[原创]Pyd原理以及逆向实战（二）变量与实战-逆向工程-看雪安全社区

# 一、前言
最近在分析一个国外某个体育游戏，热度最高的外挂样本。发现使用的是Python脚本并且Pyd编译后的，中间存在部分名称混淆以及反调试，且Pyd的编译后巨大，故而研究了一下Pyd逆向用来高效逆向这类样本。顺便记录一下方便后面查阅。这一期主要是我如何定位分析这个样本爆破它的登陆，并且简单讲一下Pyd成员的原理。一些对于函数处理和Pyd函数是怎么实现的可以看我上一篇。（感谢版主支持hh）
# 二、变量
先说一个前提我认为：对于变量和成员变量来说，静态分析不是一个很好的办法，原因是：RTTI类的这种信息比较散，需要一点点处理太麻烦了，不如运行起来再解释器层进行处理。
这里主要抛出几个问题：
1.Python成员和变量如何转换成pyd
2.解释器如何感知变量和成员变量
3.解释器以及native层如何访问这些变量
## 问题1.Python成员和变量如何转换成pyd
全局变量:
这里我编译了一个Pyd，通过编译选项让他产生中间文件.c，通过来窥探一下全局变量是如何实现的（pyd怎么生成中间文件就不展示以了）：
demo代码：
```python
# 全局变量
g_count = 100
g_name = "global_test"

def calculate(a, b):
    """局部变量示例"""
    x = a + 10
    y = b * 2
    result = x + y
    return result

class Player:
    """类成员示例"""
    # 类变量
    max_level = 99

def __init__(self, name):
        # 实例成员
        self.name = name
        self.health = 100
        self.level = 1

def take_damage(self, amount):
        self.health -= amount
        if self.health < 0:
            self.health = 0    
        return self.health

```
这里生成了一个 example.c ，大概有 8630行非常巨大（也就是为什么pyd难以逆向的原因）
这里画了一个图整理了一下：
 ![图片描述](upload/attach/202602/992284_KXETG83HJEVFJME.webp)
对照生成出来的 example.c 讲解一下：
1.全局变量的字符串名称如何存储？
首先字符串会存储在一个字符串索引表里面,可以看到这里就有我们需要的g_count：
 ![图片描述](upload/attach/202602/992284_RD3QN4ZMENXY99C.webp)
```c
const char* const bytes = "?example.py\347\261\273\346\210\220\345\221\230\347\244\272\344\276\213PlayerPlayer.__init__Player.take_damage__Pyx_PyDict_NextRefaamountasyncio.coroutinesbcalculatecline_in_traceback__doc__example__func__g_countg_nameglobal_testhealth__init___is_coroutineitemslevel__main__max_level__metaclass____module__name__name__pop__prepare____qualname__resultself__set_name__setdefaulttake_damage__test__valuesxy\200\001\340\004\010\210\002\210\"\210A\330\004\010\210\002\210\"\210A\330\004\r\210R\210r\220\021\330\004\013\2101\200A\340\010\014\210H\220A\330\010\014\210J\220a\330\010\014\210I\220Q\200A\330\010\014\210K\220q\330\010\013\2104\210x\220r\230\021\330\014\020\220\n\230!\330\010\017\210t\2201";
```
在文件中定义了一些来表示字符串在字符串数组中的位置：
 ![图片描述](upload/attach/202602/992284_CZDPBBDQEY47WX5.webp)
字符串数组是存储在一个结构体中 __pyx_mstatetype：
 ![图片描述](upload/attach/202602/992284_Y4RC6N65Y5KDRBQ.webp)
当程序运行起来的时候，就会访问，并且动态创建这些全局变量，最后吧这些注入到我们的dict里面去给解释器使用。
对象成员有所不同：
创建一个demo
```python
class Player:
    # 类变量
    max_level = 99
    game_name = "RPG"

def __init__(self, name, hp):
        # 实例成员
        self.name = name
        self.hp = hp
        self.level = 1
        self.items = []

def take_damage(self, amount):
        self.hp -= amount
        return self.hp

def level_up(self):
        if self.level < Player.max_level:
            self.level += 1

```
编译一下，8500行：
 ![图片描述](upload/attach/202601/992284_U4PGB4665K3QBF7.webp)
实际上生成的字符串也是存在字符串缓存表里面
 ![图片描述](upload/attach/202601/992284_FKDGMKB9M756MNY.webp)
```
const char* const cstring = "BZh91AY&SY(\311\237\341\000\000\017\377\343A\\\300\000 \001$\000\245\341p\000\277\357\377\340@@@@\000@@\0000\001\0316\301*\236\247\24514\323\t\215LI\201\001\201\203R\rF\204\3654OQ\2102\031\006M214\323@i\244F\200\232d\320\006\200\0004i\247\251\225/\374\217(\367)\t$\r\363\334\222\241\366=\204=\273\010\023\355\211m\205DC\245\314B^@^\312\235~\261\266\267\\\2567b\211\030e\"9\024`\021\005)1A\003\024$x\017\301\342\014^C7`i\014S\314\362E<j\037\023(\332c\305\020\252\232\363|\326\217C=r\310\013a\"\331uj\306\223 \243\rz\256\013H\231n\230\222P\311\257\247\325-\026\362S \004$N\200jx\020.`:f\271\246i\017\232P\260\240A\036\215k\016ao\r\020\020\352\232\201M\"\263d\301q\210o:f\224SC\002W\206g\n\250\2064\235\314'\224\320\020\260\223Uk\2429D\247\233\237\252^tB \221\204M\201l\251B\205OW\371\376x\365\206\031Y\3337\036\377\\\357oeE\0253\374]\311\024\341B@\243&\177\204";
```
这里验证了从静态层面是无法分析处于内存地址与变量关系。所以纯ida极难分析。
## 问题2.解释器如何感知变量和成员变量
再讲之前我们需要了解一下存储这些成员变量的结构：
__pyx_mstatetype 
```cpp
typedef struct {
    // ===== 模块核心 =====
    PyObject *__pyx_d;                  // 模块字典 (__dict__)
    PyObject *__pyx_b;                  // builtins 模块
    PyObject *__pyx_cython_runtime;     // cython_runtime 模块
    
    // ===== 空对象缓存 =====
    PyObject *__pyx_empty_tuple;        // 空元组 ()
    PyObject *__pyx_empty_bytes;        // 空字节 b""
    PyObject *__pyx_empty_unicode;      // 空字符串 ""
    
    // ===== 方法缓存 =====
    __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_items;   // dict.items
    __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_pop;     // dict.pop
    __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_values;  // dict.values
    
    // ===== 常量表 =====
    PyObject *__pyx_codeobj_tab[3];     // 代码对象表 (函数)
    PyObject *__pyx_string_tab[45];     // 字符串表 ("g_count", "g_name"...)
    PyObject *__pyx_number_tab[6];      // 数值表 (0, 1, 2, 10, 99, 100)
    
    // ===== 类型对象 =====
    PyTypeObject *__pyx_CommonTypesMetaclassType;  // 元类
    PyTypeObject *__pyx_CyFunctionType;            // Cython 函数类型
    
    // ===== 代码缓存 =====
    struct __Pyx_CodeObjectCache __pyx_code_cache;
    
} __pyx_mstatetype;
```
几乎是所有想要的都在这里了，如果我们想对解释层动手就需要找到它。
这里详细讲一下，动态创建的流程：
首先Pyd入口实际上是 __pyx_pymod_exec_example （今天从源码生成角度解析一下）
slot的数组的第二个就是入(ida逆向查找看昨天的文章)
 ![图片描述](upload/attach/202602/992284_UMK9DX68R5CUTK9.webp)
__pyx_pymod_exec_example 中就调用了 __Pyx_InitConstants 来初始化整个 全局变量：
我们demo中的g_count 就是这里创建的：
这里创建了一个Long对象，也就是我们全局对象的容器，并且初始化值,这里会创建一个key，value，用来索引这个容器位置。
 ![图片描述](upload/attach/202602/992284_QNG397PKCT87KEW.webp)
在__pyx_pymod_exec_example中 容器与字符串进行绑定完成python解释器的创建：
 ![图片描述](upload/attach/202602/992284_XZTJ95PKAFNUGGT.webp)
```python
/* "example.py":4
 * 
 * #
 * g_count = 100             # <<<<<<<<<<<<<<
 * g_name = "global_test"
 * 
*/
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_g_count, __pyx_mstate_global->__pyx_int_100) < (0)) __PYX_ERR(0, 4, __pyx_L1_error)
```
这里可能看上去对不上，实际上这里全是宏（有点灾难）
最后这里走完后就会把信息存入Dict中，也就完成了注册。
 ![图片描述](upload/attach/202602/992284_Y8NE6C879GXEY6B.webp)
总结整理一下就是：
```cpp
① import example
      ↓
② PyInit_example() → PyModuleDef_Init()
      ↓
③ __pyx_pymod_exec_example()
      │
      ├─→ ④ PyModule_Create()              // 创建模块对象
      │
      ├─→ ⑤ __pyx_d = PyModule_GetDict()   // 获取模块字典 (line 3275)
      │
      ├─→ ⑥ __Pyx_InitConstants()          // 初始化常量 (line 3299)
      │       │
      │       ├─→ ⑦ stringtab[16] = PyUnicode("g_count")
      │       │
      │       └─→ ⑧ numbertab[5] = PyLong(100)
      │
      ├─→ ⑨ __Pyx_InitGlobals()            // Cython 内部状态
      │
      ├─→ ⑩ PyDict_SetItem(__pyx_d, stringtab[16], numbertab[5])  // g_count=100 (line 3333)（这里就是进行注册了，最后）
```
这里需要注意的是：假设有两个100的全局变量，实际上他们都会指向同一块初始化值为100的内存，如果后续要更改实际上是重新在创建了一个long对象，所以python这里实现可以用指针来代替绑定，最后绑定的也是提前就生成好的值为100的数组。所以他和传统的cpp不一样没有一个变量对应一个内存这个概念。
### 类如何注册到dict里面
__pyx_pymod_exec_member_demo 这个函数主要负责注册类的信息：
由解释器加载的时候调用，还是存在slots字段中
 ![图片描述](upload/attach/202601/992284_UA6HJ4XCPWRF9XZ.webp)
注册到dict位置还是一样的：
 ![图片描述](upload/attach/202601/992284_3UMM688GAMMWC8T.webp)
```c
  /* "member_demo.py":3
 * # member_demo.py -
 * 
 * class Player:             # <<<<<<<<<<<<<<
 *     #
 *     max_level = 99
*/
  __pyx_t_2 = __Pyx_Py3MetaclassPrepare((PyObject *) NULL, __pyx_mstate_global->__pyx_empty_tuple, __pyx_mstate_global->__pyx_n_u_Player, __pyx_mstate_global->__pyx_n_u_Player, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_member_demo, (PyObject *) NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);

/* "member_demo.py":5
 * class Player:
 *     #
 *     max_level = 99             # <<<<<<<<<<<<<<
 *     game_name = "RPG"
 * 
*/
  if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_max_level, __pyx_mstate_global->__pyx_int_99) < (0)) __PYX_ERR(0, 5, __pyx_L1_error)

/* "member_demo.py":6
 *     #
 *     max_level = 99
 *     game_name = "RPG"             # <<<<<<<<<<<<<<
 * 
 *     def __init__(self, name, hp):
*/
  if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_game_name, __pyx_mstate_global->__pyx_n_u_RPG) < (0)) __PYX_ERR(0, 6, __pyx_L1_error)

/* "member_demo.py":8
 *     game_name = "RPG"
 * 
 *     def __init__(self, name, hp):             # <<<<<<<<<<<<<<
 *         #
 *         self.name = name
*/
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_11member_demo_6Player_1__init__, 0, __pyx_mstate_global->__pyx_n_u_Player___init, NULL, __pyx_mstate_global->__pyx_n_u_member_demo, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 8, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3);
  #endif
  if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_init, __pyx_t_3) < (0)) __PYX_ERR(0, 8, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
```

因为python一切皆对象的观念。而我们这上面成员和函数信息都会注册到一个tp_dict 元组里面去就像是这样
```python
模块字典 __pyx_d
├── "Player" → 类对象 (PyTypeObject)
│                └── tp_dict (类的属性字典)
│                      ├── "max_level" → 99
│                      ├── "game_name" → "RPG"
│                      ├── "__init__"  → <function>   ← 函数在这里
│                      ├── "take_damage" → <function>
│                      └── "level_up"  → <function>
│
└── "p" → 实例对象
```
最后上面这个类会在这里进行注册(代码比较多我单拎出来)：
```
 if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_init, __pyx_t_3) < (0)) __PYX_ERR(0, 8, __pyx_L1_error)
```
实际上类对象已经在初始化的时候创建好了，并且注册到解释器层了。主要就是注册函数，初始化成员变量，等各种信息。但是内存的分配实际上是创建对象实例的时候才会使用。所以核心实际上还是这个 __pyx_mstatetype。
讲一下使用的时候如何创建的：
 ![图片描述](upload/attach/202601/992284_YAM4D3K6CAXKV54.webp)
```cpp
 /* "member_demo.py":24
 * 
 * #
 * p = Player("Tom", 100)             # <<<<<<<<<<<<<<
 * p.take_damage(20)
*/
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Player); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 24, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_mstate_global->__pyx_tuple[0], NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 24, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_p, __pyx_t_3) < (0)) __PYX_ERR(0, 24, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
```
实际上创建流程我们不关心，核心就是这个对象怎么被解释器感知：
```
PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_p, __pyx_t_3)
```
![图片描述](upload/attach/202601/992284_9S7XYHYC2VAGDSV.webp)
最后还是存到了 __pyx_d，所以实际上存储的位置是一样的。
## 问题3.解释器以及native层如何访问这些变量
全局变量：
 ![图片描述](upload/attach/202601/992284_CT6V4N76EP7MCMG.webp)
实际上就是查表，因为所有对象都在那个dict，核心api
PyObject_GetAttr
__Pyx_PyDict_GetItemRef
_PyDict_GetItem_KnownHash
区别是：
下面这两个是直接查hash表
__Pyx_PyDict_GetItemRef
_PyDict_GetItem_KnownHash
这个从模块地址多一层访问 
PyObject_GetAttr
self成员变量的访问：
```c
 /* "member_demo.py":16
 * 
 *     def take_damage(self, amount):
 *         self.hp -= amount             # <<<<<<<<<<<<<<
 *         return self.hp
 * 
*/
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_hp); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 16, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyNumber_InPlaceSubtract(__pyx_t_1, __pyx_v_amount); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_hp, __pyx_t_2) < (0)) __PYX_ERR(0, 16, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
```
实际上是通过这个进行访问的：
__Pyx_PyObject_GetAttrStr
写入则是这个
__Pyx_PyObject_SetAttrStr
要注意的是写入和访问实际上参数是静态的，都是已经提前定义好的宏，所以在程序没有运行起来的时候很难静态分析：
 ![图片描述](upload/attach/202601/992284_QW4Z3TH4T4DEJ3Z.webp)
全局变量的写入也比较单一没有读写那复杂：
PyDict_SetItem
 ![图片描述](upload/attach/202601/992284_6DGS92KR9RG6KS5.webp)
# 三、函数补充
对函数稍微补充一些内容：
由于Python语法的特性问题，Python自己的一些特性迭代器，或者数组遍历。。。会进行转换，实际上他们也是函数，内部函数，并且有转换模版。
如果我们想要分析的话也需要对这些函数进行hook。我这里就举例几个演示一下：
源码位置:
```
x:\x\cython\Cython\Utility\
├── ObjectHandling.c    # 对象操作（迭代、属性访问、调用）
├── Optimize.c          # 内置方法优化（append、pop）
├── Builtins.c          # 内置函数（globals、exec、getattr）
└── TypeConversion.c    # 类型转换
```
迭代器:
for x in obj
```c

/////////////// IterNext.proto ///////////////

#define __Pyx_PyIter_Next(obj) __Pyx_PyIter_Next2(obj, NULL)
static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject *, PyObject *); /*proto*/

/////////////// IterNext ///////////////
//@requires: Exceptions.c::PyThreadStateGet
//@requires: Exceptions.c::PyErrFetchRestore
//@requires: GetBuiltinName
//@requires: IterNextPlain

static PyObject *__Pyx_PyIter_Next2Default(PyObject* defval) {
    PyObject* exc_type;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    exc_type = __Pyx_PyErr_CurrentExceptionType();
    if (unlikely(exc_type)) {
        if (!defval || unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))
            return NULL;
        __Pyx_PyErr_Clear();
        Py_INCREF(defval);
        return defval;
    }
    if (defval) {
        Py_INCREF(defval);
        return defval;
    }
    __Pyx_PyErr_SetNone(PyExc_StopIteration);
    return NULL;
}
```
索引访问:
list[i]
```cpp
/////////////// GetItemInt ///////////////
// 针对 List 和 Tuple 的优化
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, ...) {
    if (wraparound & unlikely(i < 0)) {
        wrapped_i += PyList_GET_SIZE(o);  // 负索引处理
    }
    if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) {
        return __Pyx_NewRef(PyList_GET_ITEM(o, wrapped_i));  // 直接访问内部数组
    }
    ...
}
```
还有很多需要自己耐心收集这些函数。

# 四、实战
样本是通过Gtuner软件启动的（一个游戏机的转换器作弊平台，之前有分析过相关的软件以及协议可以查阅我以往文章）
因为这个软件存在大量的名称混淆，看上去应该是一个pyqt6的程序。（给作者留点面子软件界面我就删除了hh）
验证函数分析手法如下：
## 1. 定位
软件目录：
 ![图片描述](upload/attach/202602/992284_DNGNDSDBFJJNFNY.webp)
启动界面
 ![图片描述](upload/attach/202602/992284_UFJTVPMJUUUTBD8.webp)
打开任务管理器后发现：
 ![图片描述](upload/attach/202602/992284_UD5H8BKM3QPGQ8W.webp)

发现软件不是依托于Gtuner启动的，Gtuner平台只是一个幌子，通过网络下载启动并且启动了程序。笔者当时在目录下找了很久也没发现关键的核心模块并且这个外挂作者还是使用一些假模块在目录下误导分析。
 ![图片描述](upload/attach/202602/992284_DSTE5QS4NYQKSZF.webp)
这个时候通过frida就可以完美的处理这些问题：
 ![图片描述](upload/attach/202602/992284_J2P7S9822SN7JQA.webp)
通过打印发现了异常，外挂作者吧真实的本体Pyd藏到了python的运行目录下，这样我们在本地文件无法找到的（混淆名称后这掩耳盗铃一样的hh）：
贴一下frida脚本
```js
console.log('已加载的 PYD 模块:');
console.log('='.repeat(60));
Process.enumerateModules().forEach(function(module) {
    if (module.path.toLowerCase().endsWith('.pyd')) {
        console.log('名称: ' + module.name);
        console.log('路径: ' + module.path);
        console.log('基址: ' + module.base);
        console.log('大小: ' + module.size);
        console.log('-'.repeat(60));
    }
});
```
外挂文件如下：
 ![图片描述](upload/attach/202602/992284_MPGRQEW2TGVGPC4.webp)
程序的启动入口：
 ![图片描述](upload/attach/202602/992284_PZJ4QWUEU4EGQAG.webp)
之后我打印出这个目录下所有类的导出成员信息：
 ![图片描述](upload/attach/202602/992284_XNSX45EB9T6T82D.webp)
脚本代码:
```js
// 打印 pyd 模块的成员（变量、常量、类定义等，不包括函数）

var targetDir = 'j:\\anaconda3\\envs\\py11ae\\lib\\site-packages\\xisutil'.toLowerCase();

var python = Process.getModuleByName('python311.dll');

var PyGILState_Ensure = new NativeFunction(
    python.getExportByName('PyGILState_Ensure'),
    'int', []
);

var PyGILState_Release = new NativeFunction(
    python.getExportByName('PyGILState_Release'),
    'void', ['int']
);

var PyImport_GetModuleDict = new NativeFunction(
    python.getExportByName('PyImport_GetModuleDict'),
    'pointer', []
);

var PyDict_GetItemString = new NativeFunction(
    python.getExportByName('PyDict_GetItemString'),
    'pointer', ['pointer', 'pointer']
);

var PyObject_Dir = new NativeFunction(
    python.getExportByName('PyObject_Dir'),
    'pointer', ['pointer']
);

var PyObject_GetAttrString = new NativeFunction(
    python.getExportByName('PyObject_GetAttrString'),
    'pointer', ['pointer', 'pointer']
);

var PyObject_Repr = new NativeFunction(
    python.getExportByName('PyObject_Repr'),
    'pointer', ['pointer']
);

var PyUnicode_AsUTF8 = new NativeFunction(
    python.getExportByName('PyUnicode_AsUTF8'),
    'pointer', ['pointer']
);

var PyList_Size = new NativeFunction(
    python.getExportByName('PyList_Size'),
    'int64', ['pointer']
);

var PyList_GetItem = new NativeFunction(
    python.getExportByName('PyList_GetItem'),
    'pointer', ['pointer', 'int64']
);

var PyObject_Type = new NativeFunction(
    python.getExportByName('PyObject_Type'),
    'pointer', ['pointer']
);

function dumpMembers() {
    var gilState = PyGILState_Ensure();

try {
        console.log('目标目录: ' + targetDir);
        console.log('='.repeat(80));

var modulesDict = PyImport_GetModuleDict();

pydModules.forEach(function(pydMod) {
            console.log('\n模块: ' + pydMod.pyName);
            console.log('路径: ' + pydMod.path);
            console.log('-'.repeat(60));

var modNamePtr = Memory.allocUtf8String(pydMod.pyName);
            var module = PyDict_GetItemString(modulesDict, modNamePtr);

if (!module.isNull()) {
                var dirList = PyObject_Dir(module);
                if (!dirList.isNull()) {
                    var size = PyList_Size(dirList);

console.log('\n[常量/变量]');
                    for (var i = 0; i < size; i++) {
                        var item = PyList_GetItem(dirList, i);
                        var nameStr = PyUnicode_AsUTF8(item);
                        if (!nameStr.isNull()) {
                            var name = nameStr.readUtf8String();
                            if (name.startsWith('__') && name.endsWith('__')) continue;

// 跳过函数和类
                                        if (reprStr.indexOf('<built-in function') !== -1) continue;
                                        if (reprStr.indexOf('<class ') !== -1) continue;
                                        if (reprStr.indexOf('<module ') !== -1) continue;

// 截断过长的值
                                        if (reprStr.length > 100) {
                                            reprStr = reprStr.substring(0, 100) + '...';
                                        }
                                        var typeName = getTypeName(attr);
                                        console.log('  ' + name + ' (' + typeName + ') = ' + reprStr);
                                    }
                                }
                            }
                        }
                    }

console.log('\n[类定义]');
                    for (var i = 0; i < size; i++) {
                        var item = PyList_GetItem(dirList, i);
                        var nameStr = PyUnicode_AsUTF8(item);
                        if (!nameStr.isNull()) {
                            var name = nameStr.readUtf8String();
                            if (name.startsWith('__') && name.endsWith('__')) continue;

// 只显示属于当前 pyd 的类
                                        if (reprStr.indexOf("<class '" + pydMod.shortName + '.') !== -1) {
                                            console.log('  ' + name + ' : ' + reprStr);
                                        }
                                    }
                                }
                            }
                        }
                    }

console.log('\n[对象实例]');
                    for (var i = 0; i < size; i++) {
                        var item = PyList_GetItem(dirList, i);
                        var nameStr = PyUnicode_AsUTF8(item);
                        if (!nameStr.isNull()) {
                            var name = nameStr.readUtf8String();
                            if (name.startsWith('__') && name.endsWith('__')) continue;

// 检测对象实例 (格式: <xxx object at 0x...>)
                                        if (reprStr.indexOf(' object at 0x') !== -1) {
                                            console.log('  ' + name + ' : ' + reprStr);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

console.log('\n' + '='.repeat(80));
        });

} finally {
        PyGILState_Release(gilState);
    }
}
dumpMembers();
```
在打印一下当前目录下所有Pyd的方法信息：
结果如下：
 ![图片描述](upload/attach/202602/992284_BRR9SA3YGYCU4AN.webp)
```js
// 打印 pyd 模块的函数（内置函数 + 类方法）
// 只显示地址在 pyd 范围内的自定义函数