一文打通DES算法以及在ctf中的运用！【附2024NepCTF simpleDES巨细题解~】_ctf des(1)

于 2024-04-28 23:28:06 发布
阅读量405 收藏 12
点赞数 8
分类专栏： 程序员 文章标签： 算法 网络 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84264536/article/details/138294915
版权

那么如何知道我们爆破的结果是正确的呢？就需要根据CTF题目中的部分已知明文进行判断

然后回到主体流程中 f 函数利用密钥继续加密

image-20230818181758830

式子：B1B2…B8 = K + E®

输出：P(S1(B1)S2(B2)…S8(B8)

其中E函数功能：32bits的输入转化为48bits输出

image-20230818182059318

其含义就是根据给出的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盒举例

image-20230818183218327

其中行编号是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盒实例：

image-20230818184310863

我们暂时把经过S盒处理的32bits排列称为L

则P(L)的输出格式和P盒相同

输出的第一位 就是根据P盒第一位获得的数值16 提取L中第16位的数值

到此回顾整个加密流程就解释清楚了

image-20230818184647717

基本解密流程

因为是对称密码体系，所以在解密的过程中一定要始终保持对称的思想，充分借鉴加密的流程，从上面的output反推回input

相当于现在已知R16L16

然后进行反向解密

Rn-1 = Ln

Ln-1 = Rn ^ f(Ln,Kn) = Rn ^ f(Rn-1,Kn)

同时注意子密钥一定要反着传

这里看概念比较抽象，下面跟着这道优秀的题目好好感受一下DES的魅力吧~

参考优质论文：DES

simple_des

image-20230813185606868
在下面的代码中可以关注一下注释 做出了比较细的解释~
题目源码：

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

出题师傅的思路：

image-20230813201601281

解第一段（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]

__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
]



tt=[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]
t = tt[:64]
t = ''.join(str(i) for i in t)
t= int(t,2)
t = long_to_bytes(t)  #转为字节作为密文

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]

#512-1=511 每次-1 直到129
for i in range(2\*\*9-1,2\*\*7,-1):
    #指定0作为填充字符 前导0 转为列表
    tmp =  list(bin(i)[2:].rjust(9,'0'))
    #补充i=0
    L = LL + [ int(u) for u in tmp]
    R = Rr
    combined = L+R
    sub_key = PC_2(combined)
    try_des(t, sub_key)
    
#[0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 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, 0] b'NepCTF{N'

第二段解密（i=1,2时）：

通过上次记录的C1和D1进行右移1位得到C0和D0

然后逆PC1盒获得不完整的KEY 因为需要和上次的明文异或 所以随意补充KEY为64bits即可

然后根据异或的结果生成所有子密钥

最后进行des解密即可 和第一段相同 也是逆序传入所有的子密钥

from itertools import product
from typing import List
from operator import add
from functools import reduce
from gmpy2 import \*
from Crypto.Util.number import \*

#现在获取的是第一轮的子密钥 想要获得原始KEY 对C1D1进行还原C0D0 即右移一位
guess_8bit = list(product(range(2), repeat=8))
combined = [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 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, 0]
C0D0 = combined[-2:-1] + combined[:-1]

__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
]
def PC\_1(key: List[int]) -> List[int]:
    return [key[x] for x in __pc1]
#逆一下P1盒就行56bit -> 64bit 八位爆破
not_in_PC1 = []
for i in range(64):
    if not i in __pc1:
        not_in_PC1.append(i)
# print(not\_in\_PC1) #[7, 15, 23, 31, 39, 47, 55, 63]


def re\_PC1(sbkey):
    # 56-bit -> 64-bit
    res = ['\*']\*64  #这样不确定的位置更明确一点
    for i in range(len(sbkey)):
        res[__pc1[i]] = sbkey[i]
    #sbkey的长度只有48 所以存在8bit不确定的位置
    return res # ok

def guess(C0D0, t):
    res = re_PC1(C0D0)
    for i in range(8):
        res[not_in_PC1[i]] = guess_8bit[t][i]
    return res # ok

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)]

__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对照表
def PC\_2(key: List[int]) -> List[int]:
    return [key[x] for x in __pc2]
ROTATIONS = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1]

#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]


## 写在最后

**在结束之际，我想重申的是，学习并非如攀登险峻高峰，而是如滴水穿石般的持久累积。尤其当我们步入工作岗位之后，持之以恒的学习变得愈发不易，如同在茫茫大海中独自划舟，稍有松懈便可能被巨浪吞噬。然而，对于我们程序员而言，学习是生存之本，是我们在激烈市场竞争中立于不败之地的关键。一旦停止学习，我们便如同逆水行舟，不进则退，终将被时代的洪流所淘汰。因此，不断汲取新知识，不仅是对自己的提升，更是对自己的一份珍贵投资。让我们不断磨砺自己，与时代共同进步，书写属于我们的辉煌篇章。**


需要完整版PDF学习资源私我



**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化资料的朋友，可以点击这里获取](https://bbs.csdn.net/topics/618540462)**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
2401_84264536
关注
  • 8
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CTF之常见密码学攻击手法和实现.md
10-24
CTF-crypto-入门-密码学
一文打通DES算法以及在ctf中的运用！【附2023NepCTF simpleDES巨细题解~】
jayq1的博客
08-19 950
跟随文章的脚步一起到原始论文中探索DES的奥秘，同时还可以在真实的完美例题中感受DES知识的运用，文章看完，成就满满~
[ACTF新生赛2020]crypto-des（考点：DES）
MikeCoke的博客
02-18 1879
题目：给了三个文件，附件1和附件2，以及加密的 easydes.zip 压缩包，通过解密附件1,2以获取解密 zip 的 key 附件1 encryptedkey.txt 72143238992041641000000.000000, 77135357178006504000000000000000.000000, 1125868345616435400000000.000000, 67378029765916820000000.000000, 7555348609218470300000000000
CTF-Crypto 第二天-DES加密算法原理学习
Sciurdae的博客
10-25 417
数据加密标准（Data Encryption Standard，缩写DES）是一种对称加密算法，也是一种分组加密算法。对称加密指的是在加密和机密时使用同一个密钥的加密算法，加密算法可以被公开，发送和接收双方要事先得到同一个密钥。常见的对称加密算法有AES、ChaCha20、3DES、Salsa20、DES、Blowfish、IDEA、RC5、RC6、Camellia以及我国的SM1。分组加密指的是该算法将明文分成多个等长的模块（block），使用确定的算法和对称密钥对每组分别加密解密。
网络安全CTF竞赛模式、题目类别、所用工具小结
晓梦林的博客
09-25 7630
在开启CTF竞赛学习之路前，我们要熟悉CTF的三大竞赛模式，了解简单的CTF竞赛中涉及的题目类别，最后就是我们用哪些工具拿到Flag。本文主要是起开宗明义作用，为日后的CTF做题提供基本的理论指导。
ctf-tools-linux-master_ctf工具_ctf工具_CTFtools_CTF_Tools_
10-01
CTF常用小工具你值得拥有那个。。。。111
青少年ctf擂台挑战赛 2024 #round 1
最新发布
04-16
青少年ctf擂台挑战赛 2024 #round 1
NullCTF:一个Discord机器人，它提供ctf工具在Discord服务器中进行协作！
05-05
一个机器人专注于提供用于在Discord服务器中进行协作的CTF工具（ctftime.org命令，团队设置+ ctfd集成，实用程序等）！ 如果您有功能请求，请将其发布为GitHub或使用> request“ x”命令。请让我知道链接是否有任何...
ctf脚本_ctfpy脚本_ctf跑脚本_ctf_ctf脚本密码_
09-30
ctf 密码学 脚本 合集 非常 nice
轩禹CTF_RSA工具3.6.1.zip
01-29
CTF常用工具集
2022.3.21密码学des对称密码与rsa非对称密码【网络攻防CTF】（保姆级图文）
MZH
03-23 7515
2022.3.21密码学对称密码【网络攻防CTF】（保姆级图文）
CTF（二）DES中的S盒
发现新世界的博客
06-06 8086
如图 若输入101100，则输出0111
DES子密钥计算具体步骤
qq_45102119的博客
06-19 6203
DES子密钥计算步骤？ 1.输入原密钥 例如：K=12345679ABCDEF 2.输出他的二进制K=0001 0010 … 3.根据给出的换位表 例如（7位*8=56位）置换表1 （57 49 41 33 25 17 9） … … 注意(每八位是一个奇数偶数校验位，不参与运算） 例如第一位是输入密钥第57位上的数据，第二位是第49位上的数据，以此类推。 4.可以得到56位的新密钥 K+=1111000 0110011 … 5.将其分成左右两部分，分别是28位， C0=。。。 D0=。。。 6.对于C0，D
DES加密算法详解
m0_69416620的博客
12-25 1653
DES加密算法，案例详解
软考-des题目案例
weixin_42075643的博客
10-23 613
des题目解答
基于Python实现的CTF Crypto加密解密工具
wayne2318195236的博客
07-14 6470
基于Python实现一个能够对凯撒密码、维吉尼亚密码、栅栏密码、摩斯密码、Base64编码、Ascii编码、AES、DES、RSA、RC4的加密解密以及密文破解维吉尼亚密钥和明文的CTF Crypto工具
密码学之DES密码
weixin_43699616的博客
11-18 1740
DES密码是比较重要的对称加密算法，使用了移位、分组、置换等多种加密方法。 DES加密过程 S={P,C,K,E,D}，其中明文P，密文C是64bit的数据，密钥K是56bit的数据 1.明文首先经过一次置换（IP），置换后还是64bit。 2.将置换后的明文分为两部分：L，R，分别的32bit。然后与k作用，经过16圈的迭代。此时的k1…k16经过去除奇偶校验位等后变成48bit。其通用公式为...
【日常】DES加密算法python实现_以密码编码学与网络安全——原理与实践（第六版）课后习题3.11为例
热门推荐
一只热爱奔跑的程序猿
09-26 1万+
序言 为了加深对DES加密算法的理解，lvchen很贴心地布置了一道手算DES加密结果的题，从昨晚回寝算到今天中午才写完，主要是花时间把代码逻辑实现了一遍，加深记忆也便于后续重复使用。 笔者参考了经典的DES算法详解这篇博客的解析，博主翻译得通俗易懂，内容详实，应该算是能找到的DES讲解中说得最明白的一个版本了。 本文主要是以密码编码学与网络安全——原理与实践_第6版的课后习题3.11为例，实现DES加密算法中的 56位密钥选取算法：PC1置换 48位子密钥生成算法：PC2置换 28位半密钥的循环左移算法
Des加密算法举例
m0_51088812的博客
04-25 2503
Des算法 输入明文 64位 00000001 00100011 01000101 01100111 10001001 10101011 11001101 11101111 输入密钥 64位 00010011 00110100 01010111 01111001 10011011 10111100 11011
bugku ctf sqli-0x1题解
03-23
bugku ctf是一个CTF（Capture The Flag）比赛平台，提供各种类型的安全挑战题目供参赛者解答。sqli-0x1是其中一个SQL注入题目，下面是该题目的解题思路： 1. 题目描述：sqli-0x1是一个简单的SQL注入题目，要求获取...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值