[原创]KCTF2026 第二题注入dll并利用自省机制对python进程的堆栈调用解析-CTF对抗-看雪安全社区

## 解包pyinstaller的产物并反编译可疑的pyc文件
 ![图片描述](upload/attach/202608/999385_YS9ZCHTDAVKR58E.webp)
 ![图片描述](upload/attach/202608/999385_9MED6T4BPN7JHWA.webp)
这里防守方对pyinstaller加载做了修改，需要找出被修改模块，
后面对整个解包的文件进行字符串常量扫描，也没有取得有用信息。
## 采用dll注入方式进行分析
使用的dll工具为 `PyInjector`,仓库地址为<mark class="encrypted">042K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6e0N6r3q4F1K9i4y4D9j5i4k6Q4x3X3c8b7L8%4k6G2L8r3!0@1M7$3E0&6i4K6u0r3f1s2W2u0L8X3A6W2j5%4c8G2M7W2!0q4x3#2)9^5x3q4)9^5x3R3`.`.</mark>
该工具的方式为 
1. 要执行的python代码写进 与dll同目录的code.py文件
2. 通过dll注入器，将PyInjector_x64.dll注入到目标进程，然后code.py就会被执行。
 ![图片描述](upload/attach/202608/999385_J3XHGU5TXT7YRDZ.webp)

## 利用自省机制 对堆栈调用进行解析
`自省机制（Introspection）`是指程序在运行时能够检查自身结构、获取对象类型、属性和方法的能力。
这意味我们可以在运行时时期，对python进程中全局变量、局部变量进行访问。
```python
import sys

def native_print(msg):
    sys.stdout.write(str(msg) + "\n")
    sys.stdout.flush()

native_print("\n" + "="*20 + " 静默堆栈自省读取器 " + "="*20)

orig_input = sys.modules['builtins'].input

def silent_stack_reader(prompt=""):
    native_print(f"[+] 捕获到输入请求！正在静默回溯调用栈...")
    
    # 获取当前的执行帧（Frame）
    # _getframe(0) 是当前函数，_getframe(1) 就是调用 input 的那个神秘上级！
    try:
        frame = sys._getframe(1)
        depth = 1
        while frame:
            co = frame.f_code
            native_print(f"\n[★★★★★] 成功回溯第 {depth} 层调用源：")
            native_print(f"    [-] 文件名 (co_filename): {co.co_filename}")
            native_print(f"    [-] 函数名 (co_name): {co.co_name}")
            native_print(f"    [-] 当前执行行号 (f_lineno): {frame.f_lineno}")
            native_print(f"    [-] 当前层局部变量 (f_locals): {list(frame.f_locals.keys())}")
            
            # 顺便把这一层的全局空间变量名打印出来，看看是不是我们苦苦寻找的代码
            native_print(f"    [-] 当前层全局变量 (f_globals): {list(frame.f_globals.keys())}")
            
            # 向下追溯更外层的调用
            frame = frame.f_back
            depth += 1
    except Exception as e:
        native_print(f"[-] 回溯失败: {str(e)}")
        
    # 为了不让程序死循环，我们随便返回一个 6 位字符串打破僵局
    return "123456"

sys.modules['builtins'].input = silent_stack_reader
native_print("[+] 静默回溯器挂载成功！请在 exe 窗口敲击回车。")
native_print("="*40 + "\n")
```
将上面代码注入python进程，可得到如下效果
```
def my_function():
        print("恭喜成功！")
请输入key还原代码（请输入6个字符）
[+] 捕获到输入请求！正在静默回溯调用栈...

[★★★★★] 成功回溯第 1 层调用源：
    [-] 文件名 (co_filename): <frozen os>
    [-] 函数名 (co_name): <module>
    [-] 当前执行行号 (f_lineno): 1206
    [-] 当前层局部变量 (f_locals): ['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__builtins__', 'abc', 'sys', 'st', '_check_methods', 'GenericAlias', '__all__', '_exists', '_get_exports_list', 'name', 'linesep', 'stat', 'access', 'chdir', 'chmod', 'fchmod', 'lchmod', 'getcwd', 
......
, 'x', 'my_function', 'buffer', 'w', 'i', 'b', 'key', 'b_key', 'c', 'buf', 'my', 'succ']

[★★★★★] 成功回溯第 2 层调用源：
[★★★★★] 成功回溯第 3 层调用源：
......
```
上面输出的 回溯第 1 层调用源中，可以观察到一些明显线索 `'my_function', 'buffer', 'w', 'i', 'b', 'key', 'b_key', 'c', 'buf', 'my', 'succ'`
### 获取可疑的变量值
```python
import sys

def native_print(msg):
    sys.stdout.write(str(msg) + "\n")
    sys.stdout.flush()

native_print("\n" + "="*20 + " 跨层命名空间数据强制脱壳 " + "="*20)

orig_input = sys.modules['builtins'].input

def dump_hidden_locals(prompt=""):
    native_print(f"[+] 再次成功拦截 input()。正在跨层强行抓取隐藏变量值...")
    
    try:
        # 获取第一层也就是那个被魔改的 <frozen os> 环境
        frame = sys._getframe(1)
        hidden_vars = frame.f_locals
        
        native_print(f"[*] 成功锁定目标 Frame，内部包含 {len(hidden_vars)} 个关键变量。")
        
        # 1. 重点捞取我们看到的那些奇怪变量
        target_keys = ['x', 'buffer', 'w', 'i', 'b', 'key', 'b_key', 'c', 'buf', 'my', 'succ']
        
        for k in target_keys:
            if k in hidden_vars:
                val = hidden_vars[k]
                # 打印变量的类型和具体的值（如果是字符串/字节/数字，直接现形）
                native_print(f"    [★] 隐藏变量 -> {k} (类型: {type(val)}): {repr(val)}")
                
        # 2. 如果 my_function 也在里面，直接把它彻底还原打印出来
        if 'my_function' in hidden_vars:
            func = hidden_vars['my_function']
            native_print(f"    [★] 发现目标函数 my_function！")
            if hasattr(func, '__code__'):
                native_print(f"        [-] 常量表 (co_consts): {list(func.__code__.co_consts)}")
                native_print(f"        [-] 变量名 (co_names): {list(func.__code__.co_names)}")
                native_print(f"        [-] 原始字节码 hex: {func.__code__.co_code.hex()}")

# 3. 广撒网：看看有没有其他遗漏的、名字里带 flag 的隐藏变量
        for k, v in hidden_vars.items():
            if 'flag' in str(k).lower() or 'flag' in str(v).lower():
                native_print(f"    [★★★★★] 撞大运发现 Flag 关联变量 -> {k} = {v}")

except Exception as e:
        native_print(f"[-] 变量抓取失败: {str(e)}")
        
    return "123456"

sys.modules['builtins'].input = dump_hidden_locals
native_print("[+] 脱壳器挂载成功！请在 exe 窗口中随意输入并回车触发。")
native_print("="*40 + "\n")

```
然后得到如下输出
```
提示，需要还原的代码
def my_function():
        print("恭喜成功！")
请输入key还原代码（请输入6个字符）
[+] 再次成功拦截 input()。正在跨层强行抓取隐藏变量值...
[*] 成功锁定目标 Frame，内部包含 175 个关键变量。
    [★] 隐藏变量 -> x (类型: <class 'int'>): 20
    [★] 隐藏变量 -> buffer (类型: <class 'bytes'>): b"\xb3\xda\xc5\xb2\xf1\xef\xba\xe9\xd9\xbc\xc9\xd5\xbd\xf3\xd4\xbd\xea\xcd\xb0\xdb\xca\xb2\xcf\xd1\xb1\xee\xf6\xb2\xf5\xd4X_103u8,\n3 ;6!<:;}|oX_\\%'<;!}w\xb3\xd4\xf8\xb0\xc3\xc9\xb3\xdd\xc5\xb0\xdf\xca\xba\xe9\xd4w|X_\xbd\xfa\xe2\xbd\xeb\xc6\xb0\xd0\xf0>0,\xbd\xea\xcd\xb0\xdb\xca\xb1\xee\xf6\xb2\xf5\xd4\xba\xe9\xdd\xbd\xfa\xe2\xbd\xeb\xc6\xb0\xd0\xf0c\xb1\xed\xff\xb0\xf8\xc2\xb2\xf9\xf3\xba\xe9\xdc"
    [★] 隐藏变量 -> w (类型: <class 'bytes'>): b'\xe6\x8f\x90\xe7\xa4\xba\xef\xbc\x8c\xe9\x9c\x80\xe8\xa6\x81\xe8\xbf\x98\xe5\x8e\x9f\xe7\x9a\x84\xe4\xbb\xa3\xe7\xa0\x81\r\ndef my_function():\r\n\tprint("\xe6\x81\xad\xe5\x96\x9c\xe6\x88\x90\xe5\x8a\x9f\xef\xbc\x81")\r\n\xe8\xaf\xb7\xe8\xbe\x93\xe5\x85\xa5key\xe8\xbf\x98\xe5\x8e\x9f\xe4\xbb\xa3\xe7\xa0\x81\xef\xbc\x88\xe8\xaf\xb7\xe8\xbe\x93\xe5\x85\xa56\xe4\xb8\xaa\xe5\xad\x97\xe7\xac\xa6\xef\xbc\x89'
    [★] 隐藏变量 -> i (类型: <class 'int'>): 220
    [★] 隐藏变量 -> b (类型: <class 'int'>): 137
    [★] 隐藏变量 -> key (类型: <class 'str'>): '123456'
    [★] 隐藏变量 -> b_key (类型: <class 'bytes'>): b'123456'
    [★] 隐藏变量 -> c (类型: <class 'bytes'>): b'\xecbmucryb6tcr*c\x03ucryb6tCr\x1eb'
    [★] 隐藏变量 -> buf (类型: <class 'bytes'>): b'\xae\xd1\xa8\xa5\xc0\xd8\xae\xd8\x95\xa5\xdc\xdb\xa7\xec\x84'
    [★] 隐藏变量 -> my (类型: <class 'code'>): <code object my_function at 0x0000023464EA46C0, file "<frozen os>", line 1188>
    [★] 隐藏变量 -> succ (类型: <class 'bytes'>): b'\x9f\xe3\x9b\x91\xf5\xee\x9f\xea\xa6\x91\xe9\xed\x96\xde\xb7'
    [★] 发现目标函数 my_function！
        [-] 常量表 (co_consts): [None, 666]
        [-] 变量名 (co_names): ['print']
        [-] 原始字节码 hex: 95005b0100000000000000005301350100000000000020006700
```
## 这部分内容直接扔给ai进行分析
对抓出的隐藏变量进行两两比对：

* key 为 '123456'（你输入的测试密码）。
* buf 的值为 b'\xae\xd1\xa8\xa5\xc0\xd8\xae\xd8\x95\xa5\xdc\xdb\xa7\xec\x84'。
* succ 的值为 b'\x9f\xe3\x9b\x91\xf5\xee\x9f\xea\xa6\x91\xe9\xed\x96\xde\xb7'（长度正好是 15 字节）。

如果我们把 buf 和 succ 进行按位异或（XOR）运算，得到的结果是：
$$\text{buf} \oplus \text{succ} = \text{b'123456123456123'}$$ 
这证明了程序的解密逻辑：它在内存里把输入密码循环展开，去和某个数据做异或。
那么核心来了：
既然密码正确时程序会打印“恭喜成功！”，而“恭喜成功！”这五个中文字符在 UTF-8 编码下正好也是 15 个字节！
我们将固定的成功提示文本 b'\xe6\x81\xad...'（恭喜成功！）与代表成功结果的内存基准密文 succ 进行直接异或回推：
$$\text{succ} \oplus \text{b'\xe6\x81\xad\xe5\x96\x9c\xe6\x88\x90\xe5\x8a\x9f\xef\xbc\x81'} = \text{b'yb6tcryb6tcryb6'}$$ 
这个结果展现出了极其完美且连续的 6 字节循环节：y b 6 t c r。

登录后可查看完整内容

冰与火的战歌：Windows内核攻防实战高级班！从零到实战，融合AI与Windows内核攻防全技术栈，打造具备自动化能力的内核开发高手。

最后于 2026-8-12 21:52 被wufake编辑，原因：修改部分错误内容

#CrackMe #Reverse

[原创]KCTF2026 第二题 注入dll并利用自省机制 对python进程的堆栈调用解析

[原创]KCTF2026 第二题注入dll并利用自省机制对python进程的堆栈调用解析