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

1 0 0 1 1 1 1
0 0 0 1 1 1 1

前4行作为C 后四行作为D


![image-20230818211739419](https://img-blog.csdnimg.cn/img_convert/38c505fffab93879c70e88dcc26f41d9.png)


关于C和D的迭替 依靠固定的移位表


![image-20230818181404405](https://img-blog.csdnimg.cn/img_convert/7ba5d95aed2d8e376f26c19fe431b645.png)


此时


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


![image-20230818181513587](https://img-blog.csdnimg.cn/img_convert/304986866f59f8462eb84dc93ce83015.png)


这里就可以说明Kn的第一位是CnDn 组合中的第14位


故K1 = 000110110000001011101111111111000111000001110010




---


上面我们知道了DES子密钥的生成过程


下面就去了解DES子密钥的逆推过程


前提条件：如果已知两个或者两个以上的子密钥则可以逆推出初始密钥KEY（感觉第一个子密钥就可以捏


但是根据生成的过程我们知道KEY的长度是56bits（去除8个第8位） 但是子密钥的长度是48bits 所以存在8bits未知


每一bit有0和1两种情况 8bits则一共有2^8=256中情况 所以使用暴力破解


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




---


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


![image-20230818181758830](https://img-blog.csdnimg.cn/img_convert/79f093f5aed144cf8ecd204a92405be3.png)


式子：B1B2…B8 = K + E®


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


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


![image-20230818182059318](https://img-blog.csdnimg.cn/img_convert/09f4a5a7f1d1af7d88d03dd636522dbc.png)


其含义就是根据给出的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](https://img-blog.csdnimg.cn/img_convert/db61b22978aef923dc3ebd277938f9e8.png)


其中行编号是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](https://img-blog.csdnimg.cn/img_convert/fc785f2fb18ceb49a04589f9c1ba2492.png)


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


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


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


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


![image-20230818184647717](https://img-blog.csdnimg.cn/img_convert/5ea999309cf1ecbd6fedaceaa9d522e3.png)


### 基本解密流程


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


相当于现在已知R16L16


然后进行反向解密


Rn-1 = Ln


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


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


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


参考优质论文：[DES]( )




---


### simple\_des


![image-20230813185606868](https://img-blog.csdnimg.cn/img_convert/ec02b591c07037190de243a8ac6362bc.png)  
 在下面的代码中可以关注一下注释 做出了比较细的解释~  
 题目源码：

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](https://img-blog.csdnimg.cn/img_convert/498d6ef221e3588b83c4f289a064e12e.png)


**解第一段（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© % 8 == 0
res = b’’
for i in range(0,len©,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时）：**




## 写在最后

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


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



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

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

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**