Cython程序分析_1

字数统计: 8k字   |   阅读时长≈ 40分

隔了几个月，新年第一个blog。重新整整最恶俗的cython逆向。

Cython程序分析_1

好久没有系统化的研究一个项目了。这次准备从python入手，先从最麻烦的cython编译文件来进行分析。

cython编译后的pyd，so文件非常复杂，cython编译器向其中添加了很多冗余代码，难度会非常大。

这次准备通过举例的方法，将几种常见的python语法类型都试一遍，看看其特征。

测试版本

1
2
Cython version 0.29.24
Python 3.7.9

编译方法

第4篇:Cython编译细节详解 - 知乎 (zhihu.com)

setup.py编译（推荐）

setup.py

1
2
3
4
5
6
7
from setuptools import setup
from Cython.Build import cythonize

setup(
    name="print",
    ext_modules=cythonize("./print.py", annotate=True),
)

命令行

1
python3 setup.py build_ext --inplace

这样会得到一个c文件，一个注释过的html文件，以及build文件夹中编译好的pyd或so文件。

1
2
def print_msg():
    print("Hello Cython")

查看html注释后发现

1
2
3
+1: def print_msg():
+2:     print("Hello Cython")
  if (__Pyx_PrintOne(0, __pyx_kp_s_Hello_Cython) < 0) __PYX_ERR(0, 2, __pyx_L1_error)

print()函数调用的是__Pyx_PrintOne()API。

C文件分析

字符串声明

再看看c文件，发现里面一大堆标准的胶水代码。搜索print_msg字符串。

在第1000多行左右会遇到第一个相关字符串。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/* Implementation of 'print' */
static const char __pyx_k_end[] = "end";
static const char __pyx_k_file[] = "file";
static const char __pyx_k_main[] = "__main__";
static const char __pyx_k_name[] = "__name__";
static const char __pyx_k_test[] = "__test__";
static const char __pyx_k_print[] = "print";
static const char __pyx_k_print_py[] = "print.py";
static const char __pyx_k_print_msg[] = "print_msg";
static const char __pyx_k_Hello_Cython[] = "Hello Cython";
static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
static PyObject *__pyx_kp_s_Hello_Cython;
static PyObject *__pyx_n_s_cline_in_traceback;
static PyObject *__pyx_n_s_end;
static PyObject *__pyx_n_s_file;
static PyObject *__pyx_n_s_main;
static PyObject *__pyx_n_s_name;
static PyObject *__pyx_n_s_print;
static PyObject *__pyx_n_s_print_msg;
static PyObject *__pyx_kp_s_print_py;
static PyObject *__pyx_n_s_test;
static PyObject *__pyx_pf_5print_print_msg(CYTHON_UNUSED PyObject *__pyx_self); /* proto */
static PyObject *__pyx_codeobj_;

1000行及以上的都是无关胶水代码。

这里声明了模块里的字符串，其中有函数名称，被打印的字符串，还有一些编译器生成的字符串。

紧接着就是PyObject，这是Cython里面一个比较重要的对象，这是实现面向对象思想的一个重要体现。

python源码剖析之PyObject详解 | w3c笔记 (w3cschool.cn)

Common Object Structures — Python 3.8.0 文档 (hubwiz.com)

根据参考文章，Cython的所有数据元素都是对象，也就是可以通过PyObject*指针进行引用的。

命名规则

根据已知，说一下命名规则（在Linux上编so的情况下，会保留符号表，Windows上pyd就不一定了）

  1. kC风格字符串
  2. kp字符串指针，PyObject*类型
  3. n是对象指针，PyObject*类型
  4. pf是函数，PyObject*类型
  5. pw是Wrapper（封装）函数，将pf函数包裹了一下

有几个后面还有有s，可能是静态（static）的意思，也有可能是字符串的意思。

kp_s和n_s的区别待定，因为最后都被用于初始化Python字符串对象了。

封装函数

下面是第一行代码，也就是函数声明那行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/* Late includes */

/* "print.py":1
 * def print_msg():             # <<<<<<<<<<<<<<
 *     print("Hello Cython")
 */

/* Python wrapper */
static PyObject *__pyx_pw_5print_1print_msg(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyMethodDef __pyx_mdef_5print_1print_msg = {"print_msg", (PyCFunction)__pyx_pw_5print_1print_msg, METH_NOARGS, 0};
static PyObject *__pyx_pw_5print_1print_msg(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("print_msg (wrapper)", 0);
  __pyx_r = __pyx_pf_5print_print_msg(__pyx_self);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_5print_print_msg(CYTHON_UNUSED PyObject *__pyx_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("print_msg", 0);
    
   	// 括号还未闭合，下面就是第二行代码。

由/* Python wrapper */注释可以得知，首先定义了一个wrapper函数__pyx_pw_5print_1print_msg()对真正的函数进行了一个简单的封装。

第一行是声明了原型/*proto*/，

紧接着进行了PyMethodDef声明了此对象的一些元信息：

  1. 方法名（函数名）
  2. wrapper函数指针（名称中含有pw的便是Python Wrapper的缩写，也就是封装函数）
  3. METH_NOARGS（疑似是无参声明）
  4. 0（参数数量？）

然后定义了封装函数的一些操作。可以大致了解一下里面进行的内容，这样逆向过程中可以通过这些特征来快速识别函数块。

首先定义了一个PyObject*，在__Pyx_RefNannySetupContext()之后，便获得了子函数指针并进行了调用。然后就是默认的退出代码__Pyx_RefNannyFinishContext()。

__Pyx_RefNannySetupContext()是一个宏函数：

1
2
3
4
5
6
7
8
9
10
11
12
#ifdef WITH_THREAD
  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
          if (acquire_gil) {\
              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
              PyGILState_Release(__pyx_gilstate_save);\
          } else {\
              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
          }
#else
  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)

这里有有关多线程以及GIL的东西，暂时不管。核心就是

1
__Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);

这里可以作为一个特征码，其字符串大抵可以用于判别函数的名称。（前提是需要#define CYTHON_REFNANNY

接下来把完整的子函数代码贴上来。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
static PyObject *__pyx_pf_5print_print_msg(CYTHON_UNUSED PyObject *__pyx_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("print_msg", 0);

  /* "print.py":2
 * def print_msg():
 *     print("Hello Cython")             # <<<<<<<<<<<<<<
 */
  if (__Pyx_PrintOne(0, __pyx_kp_s_Hello_Cython) < 0) __PYX_ERR(0, 2, __pyx_L1_error)

  /* "print.py":1
 * def print_msg():             # <<<<<<<<<<<<<<
 *     print("Hello Cython")
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("print.print_msg", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

前半段定义了一些数据对象。

  1. PyObject *__pyx_r作为返回值返回
  2. int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0;这三个都是在出现错误的时候被调用的

然后有一个SetupContext()。

核心代码

if (__Pyx_PrintOne(0, __pyx_kp_s_Hello_Cython) < 0) __PYX_ERR(0, 2, __pyx_L1_error)是核心代码

__Pyx_PrintOne

是一般的print()函数，大抵是没有任何传参和格式化操作下的API。

值得注意的是，为了安全性，该函数被一个if包裹。若返回值小于0就会调用错误异常处理，跳转到AddTraceback()那里去。

其他

__pyx_string_tab

1
2
3
4
5
6
7
8
9
10
11
12
13
static __Pyx_StringTabEntry __pyx_string_tab[] = {
  {&__pyx_kp_s_Hello_Cython, __pyx_k_Hello_Cython, sizeof(__pyx_k_Hello_Cython), 0, 0, 1, 0},
  {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
  {&__pyx_n_s_end, __pyx_k_end, sizeof(__pyx_k_end), 0, 0, 1, 1},
  {&__pyx_n_s_file, __pyx_k_file, sizeof(__pyx_k_file), 0, 0, 1, 1},
  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
  {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
  {&__pyx_n_s_print, __pyx_k_print, sizeof(__pyx_k_print), 0, 0, 1, 1},
  {&__pyx_n_s_print_msg, __pyx_k_print_msg, sizeof(__pyx_k_print_msg), 0, 0, 1, 1},
  {&__pyx_kp_s_print_py, __pyx_k_print_py, sizeof(__pyx_k_print_py), 0, 0, 1, 0},
  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
  {0, 0, 0, 0, 0, 0, 0}
};

这一块结构体，在逆向上会有帮助，即通过寻找字符串即可找到PyObject*指针，通过交叉引用找到相应代码。

往上翻可以找到__Pyx_StringTabEntry结构体的定义

__Pyx_StringTabEntry

1
2
3
4
5
6
7
8
9
10
typedef struct {
	PyObject **p; 	// 8
	const char *s; 	// 8
	const Py_ssize_t n; // 8
	const char* encoding;	// 8
	const char is_unicode; // 1
	const char is_str; 	// 1
	const char intern;  // 1
    // _BYTE[5] _padding;
} __Pyx_StringTabEntry;

__Pyx_PyCode_New

继续往下翻，能发现一个与Cython的Small Code有关的代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);

  /* "print.py":1
 * def print_msg():             # <<<<<<<<<<<<<<
 *     print("Hello Cython")
 */
  __pyx_codeobj_ = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_print_py, __pyx_n_s_print_msg, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj_)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_RefNannyFinishContext();
  return 0;
  __pyx_L1_error:;
  __Pyx_RefNannyFinishContext();
  return -1;
}

CYTHON_SMALL_CODE

网上没怎么查到，我觉得这应该是用于代码优化的一个技术。

1
2
3
4
5
6
7
8
9
#ifndef CYTHON_SMALL_CODE
#if defined(__clang__)
    #define CYTHON_SMALL_CODE
#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
    #define CYTHON_SMALL_CODE __attribute__((cold))
#else
    #define CYTHON_SMALL_CODE
#endif
#endif

在GNU编译下会声明__attribute__((cold))，也就是此函数是冷门函数，可以降低将其放入高速缓存的优先级。

__Pyx_PyCode_New

1
2
3
4
5
6
7
8
9
10
11
12
13
#if PY_MAJOR_VERSION < 3
  #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
  #define __Pyx_DefaultClassType PyClass_Type
#else
  #define __Pyx_BUILTIN_MODULE_NAME "builtins"
#if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2
  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
          PyCode_New(a, 0, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
#else
  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
          PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)

__Pyx_InitGlobals

这个将用于初始化上面见过的__pyx_string_tab。

1
2
3
4
5
6
static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
  return 0;
  __pyx_L1_error:;
  return -1;
}

贴一下__Pyx_InitStrings的代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
/* InitStrings */
static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
    while (t->p) {
        #if PY_MAJOR_VERSION < 3
        if (t->is_unicode) {
            *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
        } else if (t->intern) {
            *t->p = PyString_InternFromString(t->s);
        } else {
            *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
        }
        #else
        if (t->is_unicode | t->is_str) {
            if (t->intern) {
                *t->p = PyUnicode_InternFromString(t->s);
            } else if (t->encoding) {
                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
            } else {
                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
            }
        } else {
            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
        }
        #endif
        if (!*t->p)
            return -1;
        if (PyObject_Hash(*t->p) == -1)
            return -1;
        ++t;
    }
    return 0;
}

逆向分析

下面看看Windows上pyd二进制下的样子。

导出函数

先看一下导出界面，可以发现两个函数。

1
2
PyInit_print	0000000180004520	1
DllEntryPoint	0000000180001350	[main entry]

DllEntryPoint函数可能是在Cython库函数中定义的，在编译的时候引进。c文件中没有发现其身影。可以暂时不用管它。

看一下PyInit_print函数。这个便是import后，调用print_msg函数后会引用的。

值得一提的是，如果编写的Python文件是像个一般程序一样，也就是直接就可以跑的，即对函数进行了调用，而不是像库一样，仅仅定义了一些对象与函数，但没有进行调用，那么在编译成pyd文件后，只要一import，就会立刻运行。这个例子没有这样干，不过我猜测应该是这些函数逻辑都会在Dll入口点或者在PyInit_print出体现。后面会继续研究。

PyInit_Print

IDA中

1
2
3
4
__int64 PyInit_print()
{
  return PyModuleDef_Init(&unk_180007740);
}

看看C源码的声明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#ifndef CYTHON_NO_PYINIT_EXPORT
#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
#elif PY_MAJOR_VERSION < 3
#ifdef __cplusplus
#define __Pyx_PyMODINIT_FUNC extern "C" void
#else
#define __Pyx_PyMODINIT_FUNC void
#endif
#else
#ifdef __cplusplus
#define __Pyx_PyMODINIT_FUNC extern "C" PyObject *
#else
#define __Pyx_PyMODINIT_FUNC PyObject *
#endif
#endif


#if PY_MAJOR_VERSION < 3
__Pyx_PyMODINIT_FUNC initprint(void) CYTHON_SMALL_CODE; /*proto*/
__Pyx_PyMODINIT_FUNC initprint(void)
#else
__Pyx_PyMODINIT_FUNC PyInit_print(void) CYTHON_SMALL_CODE; /*proto*/
__Pyx_PyMODINIT_FUNC PyInit_print(void)
#if CYTHON_PEP489_MULTI_PHASE_INIT
{
  return PyModuleDef_Init(&__pyx_moduledef);
}

PyModuleDef_Init是个库函数，C文件里面没有定义。

那么再看看__pyx_moduledef

__pyx_moduledef

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
static struct PyModuleDef __pyx_moduledef = {
    PyModuleDef_HEAD_INIT,
    "print",
    0, /* m_doc */
  #if CYTHON_PEP489_MULTI_PHASE_INIT
    0, /* m_size */
  #else
    -1, /* m_size */
  #endif
    __pyx_methods /* m_methods */,
  #if CYTHON_PEP489_MULTI_PHASE_INIT
    __pyx_moduledef_slots, /* m_slots */
  #else
    NULL, /* m_reload */
  #endif
    NULL, /* m_traverse */
    NULL, /* m_clear */
    NULL /* m_free */
};

static PyModuleDef_Slot __pyx_moduledef_slots[] = {
  {Py_mod_create, (void*)__pyx_pymod_create},
  {Py_mod_exec, (void*)__pyx_pymod_exec_print},
  {0, NULL}
};

使用c/c++编写python扩展（一）：定义模块函数与异常 - 知乎 (zhihu.com)

贴一下别人Cython代码编写的教程。直接写Cython真的狠人。

创建模块

定义好新的函数后，我们需要把方法放入某个模块下，这样才能使用python进行调用。为此我们需要创建一个PyModuleDef类型的静态变量。

1
2
3
4
5
6
7
static struct PyModuleDef fputsmodule = {
    PyModuleDef_HEAD_INIT,
    "fputs",
    "Python interface for the fputs C library function",
    -1,
    FputsMethods
};

PyModuleDef类型的结构体共有五个变量，PyModuleDef_HEAD_INIT是固定写法，是Python.h中定义的宏，第二个参数”fputs“是模块的名称，第三个参数则是模块的docstring。第四个参数-1是跟多解释器有关的参数，负值代表不支持多解释器，正值表示每个子解释器需要申请的内存。这已经超出了本文章的范围，具体内容可以参考https://segmentfault.com/a/1190000019229771。第五个参数便是我们刚才定义的函数结构体静态数组。

有了模块的定义，最后一步我们需要定义一个PyMODINIT_FUNC类型的函数，用来供Python解释器调用初始化我们的模块

1
2
3
PyMODINIT_FUNC PyInit_fputs(void) {
    return PyModule_Create(&fputsmodule);
}

函数只有一行，将刚才定义的fputsmodule传入PyModule_Create函数并返回即可。

再对着我们的IDA看看这个结构体，可以发现#if条件成立，于是把#else的都给删掉。

1
2
3
4
5
6
7
8
9
10
11
static struct PyModuleDef __pyx_moduledef = {
    PyModuleDef_HEAD_INIT,
    "print",
    0, /* m_doc */
    0, /* m_size */
    __pyx_methods /* m_methods */,
    __pyx_moduledef_slots, /* m_slots */
    NULL, /* m_traverse */
    NULL, /* m_clear */
    NULL /* m_free */
};

现在在64位平台上都默认整数是64位，于是我也这么处理。发现得到的结构体还挺正确的。

贴一下IDA中的结构体

1
2
3
4
5
6
7
8
9
10
11
12
13
.data:0000000180007740 qword_180007740 dq 1                    ; DATA XREF: PyInit_print↑o
.data:0000000180007748                 dq 0
.data:0000000180007750                 dq 0
.data:0000000180007758                 dq 0
.data:0000000180007760                 dq 0
.data:0000000180007768                 dq offset aPrint_3      ; "print"
.data:0000000180007770                 dq 0
.data:0000000180007778                 dq 0
.data:0000000180007780                 dq offset unk_180008468
.data:0000000180007788                 dq offset unk_180007220
.data:0000000180007790                 dq 0
.data:0000000180007798                 dq 0
.data:00000001800077A0                 dq 0

可以发现第一个元素PyModuleDef_HEAD_INIT占了5个QWORD。然后三个指针，一个指向模块的字符串，一个指向__pyx_methods结构体，一个指向__pyx_moduledef_slots结构体。

__pyx_methods

1
2
3
static PyMethodDef __pyx_methods[] = {
  {0, 0, 0, 0}
};

这个数组声明了本文件中含有的方法。这个例子里面只有一个函数，所以显然只有默认的0。

贴一下上面那个帖子中的：

1
2
3
4
5
6
7
8
static PyObject *method_fputs(PyObject *self, PyObject *args) {
 	/* ...  */
}

static PyMethodDef FputsMethods[] = {
    {"fputs", method_fputs, METH_VARARGS, "Python interface for fputs C library function"},
    {NULL, NULL, 0, NULL}
};

这样一个静态变量数组可以存放多个函数的定义，并且以NULL定义作为结尾。对于数组的每个元素，有四个成员变量。本例中第一个变量”fput”为函数名称，method_fputs为我们刚才定义的函数指针，第四个参数为函数的docstring。

第三个参数使用来指定函数参数的格式。

后记：函数也被当成该模块的方法了。在上面看Wrapper函数的时候

1
static PyMethodDef __pyx_mdef_5print_1print_msg = {"print_msg", (PyCFunction)__pyx_pw_5print_1print_msg, METH_NOARGS, 0};

便是声明了一下。这个模块声明非常有用，在Exec函数中会被用到。

IDA中：

有意思的是，IDA中这里指向了未知的内存区域。大抵是动态运行的时候会调用API再去初始化。

__pyx_moduledef_slots

1
2
3
4
5
static PyModuleDef_Slot __pyx_moduledef_slots[] = {
  {Py_mod_create, (void*)__pyx_pymod_create},
  {Py_mod_exec, (void*)__pyx_pymod_exec_print},
  {0, NULL}
};

指向了两个函数，Create和Exec。

IDA二进制中的样子：

1
2
3
4
5
6
.data:0000000180007220 qword_180007220 dq 1                    ; DATA XREF: .data:0000000180007788↓o
.data:0000000180007228                 dq offset sub_180004150
.data:0000000180007230                 dq 2
.data:0000000180007238                 dq offset sub_1800039C0
.data:0000000180007240                 dq 0
.data:0000000180007248                 dq 0

__pyx_pymod_create

根据名字，可以猜出应该是一开始被import的时候调用的函数。贴一下相关代码，同时根据版本去除了一些无用的宏定义。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
static PyObject *__pyx_m = NULL;

// 将被内联
static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
    #if PY_VERSION_HEX >= 0x030700A1
    static PY_INT64_T main_interpreter_id = -1;
    PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp);
    if (main_interpreter_id == -1) {
        main_interpreter_id = current_id;
        return (unlikely(current_id == -1)) ? -1 : 0;
    } else if (unlikely(main_interpreter_id != current_id))
    #else
    static PyInterpreterState *main_interpreter = NULL;
    PyInterpreterState *current_interpreter = PyThreadState_Get()->interp;
    if (!main_interpreter) {
        main_interpreter = current_interpreter;
    } else if (unlikely(main_interpreter != current_interpreter))
    #endif
    {
        PyErr_SetString(
            PyExc_ImportError,
            "Interpreter change detected - this module can only be loaded into one interpreter per process.");
        return -1;
    }
    return 0;
}

// 要被内联
static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) {
    PyObject *value = PyObject_GetAttrString(spec, from_name);
    int result = 0;
    if (likely(value)) {
        if (allow_none || value != Py_None) {
            result = PyDict_SetItemString(moddict, to_name, value);
        }
        Py_DECREF(value);
    } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
        PyErr_Clear();
    } else {
        result = -1;
    }
    return result;
}

static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
    #if PY_VERSION_HEX >= 0x030700A1
    static PY_INT64_T main_interpreter_id = -1;
    PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp);
    if (main_interpreter_id == -1) {
        main_interpreter_id = current_id;
        return (unlikely(current_id == -1)) ? -1 : 0;
    } else if (unlikely(main_interpreter_id != current_id))
    #else
    static PyInterpreterState *main_interpreter = NULL;
    PyInterpreterState *current_interpreter = PyThreadState_Get()->interp;
    if (!main_interpreter) {
        main_interpreter = current_interpreter;
    } else if (unlikely(main_interpreter != current_interpreter))
    #endif
    {
        PyErr_SetString(
            PyExc_ImportError,
            "Interpreter change detected - this module can only be loaded into one interpreter per process.");
        return -1;
    }
    return 0;
}

static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) {
    PyObject *module = NULL, *moddict, *modname;
    if (__Pyx_check_single_interpreter())       // 检查是不是单解释器（有可能会被内敛进来）
        return NULL;
    if (__pyx_m)    // 如果这个指向模块的PyObject指针已经指向了一个对象，那么就不需要再次create了（大概，不影响逆向过程）
        return __Pyx_NewRef(__pyx_m);
    modname = PyObject_GetAttrString(spec, "name"); // 通过传入字符串获得模块的名字特征（Attribute）（大概就是要你import的时候输对模块名）
    if (unlikely(!modname)) goto bad;
    module = PyModule_NewObject(modname);
    Py_DECREF(modname);
    if (unlikely(!module)) goto bad;
    moddict = PyModule_GetDict(module);
    if (unlikely(!moddict)) goto bad;
    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad;
    return module;
bad:
    Py_XDECREF(module);
    return NULL;
}

IDA中的样子（已经被美化过）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
QWORD *__fastcall sub_180004150(__int64 spec)
{
  __int64 pythread_state; // rax
  __int64 current_id; // rax
  int v4; // er15
  QWORD *result; // rax
  QWORD *modname; // rax
  QWORD *modname_copy; // rbx
  QWORD *module; // rax
  bool v9; // zf
  QWORD *module_cp; // rdi
  __int64 v11; // rsi
  __int64 v12; // rax
  _QWORD *v13; // rbx
  int v14; // eax
  int v15; // er14
  __int64 v16; // rax
  _QWORD *v17; // rbx
  int v18; // eax
  int v19; // er14
  __int64 v20; // rax
  _QWORD *v21; // rbx
  int v22; // eax
  int v23; // er14
  __int64 v24; // rax
  _QWORD *v25; // rbx

  pythread_state = PyThreadState_Get();
  current_id = PyInterpreterState_GetID(*(_QWORD *)(pythread_state + 16));
  v4 = 0;
  if ( main_interpreter_id == -1 )
  {
    main_interpreter_id = current_id;
    if ( current_id != -1 )
      goto LABEL_3;
    return 0i64;
  }
  if ( main_interpreter_id != current_id )
  {
    PyErr_SetString(PyExc_ImportError, aInterpreterCha);
    return 0i64;
  }
LABEL_3:                                        // 上面是__Pyx_check_single_interpreter()内联代码

  result = _pyx_m;                              // 猜测是__pyx_m
  if ( _pyx_m )
  {
    ++*_pyx_m;                                  // 宏函数__Pyx_NewRef()的实际效果
    return result;
  }

  modname = (QWORD *)PyObject_GetAttrString(spec, aName);
  modname_copy = modname;
  if ( !modname )
    return 0i64;
  module = (QWORD *)PyModule_NewObject(modname);
  v9 = (*modname_copy)-- == 1;                  // Py_DECREF()
  module_cp = module;
  if ( v9 )
    (*(void (__fastcall **)(QWORD *))(modname_copy[1] + 48))(modname_copy);
  if ( !module_cp )
    return 0i64;
  v11 = PyModule_GetDict(module_cp);
  if ( v11 )
  {
    v12 = PyObject_GetAttrString(spec, aLoader);
    v13 = (_QWORD *)v12;
    if ( v12 )
    {
      v14 = PyDict_SetItemString(v11, aLoader_0, v12);
      v9 = (*v13)-- == 1i64;
      v15 = v14;
      if ( v9 )
        (*(void (__fastcall **)(_QWORD *))(v13[1] + 48i64))(v13);
      if ( v15 < 0 )
        goto LABEL_17;
    }
    else
    {
      if ( !(unsigned int)PyErr_ExceptionMatches(PyExc_AttributeError) )
        goto LABEL_17;
      PyErr_Clear();
    }                                           // 上面为__Pyx_copy_spec_to_module()的内联
                                                // 下面同理，一共有4个
    v16 = PyObject_GetAttrString(spec, aOrigin);
    v17 = (_QWORD *)v16;
    if ( v16 )
    {
      v18 = PyDict_SetItemString(v11, aFile, v16);
      v9 = (*v17)-- == 1i64;
      v19 = v18;
      if ( v9 )
        (*(void (__fastcall **)(_QWORD *))(v17[1] + 48i64))(v17);
      if ( v19 < 0 )
        goto LABEL_17;
    }
    else
    {
      if ( !(unsigned int)PyErr_ExceptionMatches(PyExc_AttributeError) )
        goto LABEL_17;
      PyErr_Clear();
    }
    v20 = PyObject_GetAttrString(spec, aParent);
    v21 = (_QWORD *)v20;
    if ( v20 )
    {
      v22 = PyDict_SetItemString(v11, aPackage, v20);
      v9 = (*v21)-- == 1i64;
      v23 = v22;
      if ( v9 )
        (*(void (__fastcall **)(_QWORD *))(v21[1] + 48i64))(v21);
      if ( v23 < 0 )
        goto LABEL_17;
    }
    else
    {
      if ( !(unsigned int)PyErr_ExceptionMatches(PyExc_AttributeError) )
        goto LABEL_17;
      PyErr_Clear();
    }
    v24 = PyObject_GetAttrString(spec, aSubmoduleSearc);
    v25 = (_QWORD *)v24;
    if ( v24 )
    {
      if ( v24 != Py_NoneStruct )
        v4 = PyDict_SetItemString(v11, aPath, v24);
      v9 = (*v25)-- == 1i64;
      if ( v9 )
        (*(void (__fastcall **)(_QWORD *))(v25[1] + 48i64))(v25);
      if ( v4 < 0 )
        goto LABEL_17;
      return module_cp;
    }
    if ( (unsigned int)PyErr_ExceptionMatches(PyExc_AttributeError) )
    {
      PyErr_Clear();
      return module_cp;
    }
  }
LABEL_17:
  v9 = (*module_cp)-- == 1;
  if ( v9 )
    (*(void (__fastcall **)(QWORD *))(module_cp[1] + 48))(module_cp);
  return 0i64;
}

了解即可，掌握一下这个函数的大概，便于定位。

__pyx_pymod_exec_print

这个函数非常重要，保留了总的函数逻辑。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
/* CythonFunction.proto */
static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml,
                                      int flags, PyObject* qualname,
                                      PyObject *closure,
                                      PyObject *module, PyObject *globals,
                                      PyObject* code);


static CYTHON_SMALL_CODE int __pyx_pymod_exec_print(PyObject *__pyx_pyinit_module)
{
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannyDeclarations
  #if CYTHON_PEP489_MULTI_PHASE_INIT
  if (__pyx_m) {    // 禁止重新初始化
    if (__pyx_m == __pyx_pyinit_module) return 0;
    PyErr_SetString(PyExc_RuntimeError, "Module 'print' has already been imported. Re-initialisation is not supported.");
    return -1;
  }
  #elif PY_MAJOR_VERSION >= 3
  if (__pyx_m) return __Pyx_NewRef(__pyx_m);
  #endif
  #if CYTHON_REFNANNY
__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
if (!__Pyx_RefNanny) {
  PyErr_Clear();
  __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
  if (!__Pyx_RefNanny)
      Py_FatalError("failed to import 'refnanny' module");
}
#endif
  __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_print(void)", 0);
  if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #ifdef __Pxy_PyFrame_Initialize_Offsets
  __Pxy_PyFrame_Initialize_Offsets();
  #endif
  __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
  #ifdef __Pyx_CyFunction_USED      // 若干根据函数特性的初始化检测操作
  if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_FusedFunction_USED
  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_Coroutine_USED
  if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_Generator_USED
  if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_AsyncGen_USED
  if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_StopAsyncIteration_USED
  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  /*--- Library function declarations ---*/
  /*--- Threads initialization code ---*/
  #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
  PyEval_InitThreads(); // 初始化线程
  #endif
  /*--- Module creation code ---*/
  #if CYTHON_PEP489_MULTI_PHASE_INIT
  __pyx_m = __pyx_pyinit_module;
  Py_INCREF(__pyx_m);
  #else
  #if PY_MAJOR_VERSION < 3  // 初始化模块
  __pyx_m = Py_InitModule4("print", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
  #else // python3调用的API
  __pyx_m = PyModule_Create(&__pyx_moduledef);
  #endif
  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif    // 大概是维护全局变量，从模块中获取Dict元素
  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
  Py_INCREF(__pyx_d);   // 导入辅助模块
  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
  Py_INCREF(__pyx_b);
  __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
  Py_INCREF(__pyx_cython_runtime);
  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
  /*--- Initialize various global constants etc. ---*/
  if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
  if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  if (__pyx_module_is_main_print) { // 是main函数，则
    if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  }
  #if PY_MAJOR_VERSION >= 3
  {
    PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
    if (!PyDict_GetItemString(modules, "print")) {
      if (unlikely(PyDict_SetItemString(modules, "print", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
    }
  }
  #endif
  /*--- Builtin init code ---*/
  if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  /*--- Constants init code ---*/
  if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  /*--- Global type/function init code ---*/
  (void)__Pyx_modinit_global_init_code();
  (void)__Pyx_modinit_variable_export_code();
  (void)__Pyx_modinit_function_export_code();
  (void)__Pyx_modinit_type_init_code();
  (void)__Pyx_modinit_type_import_code();
  (void)__Pyx_modinit_variable_import_code();
  (void)__Pyx_modinit_function_import_code();
  /*--- Execution code ---*/
  #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
  if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif

  /* "print.py":1
 * def print_msg():             # <<<<<<<<<<<<<<
 *     print("Hello Cython")
 */
 
  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_5print_1print_msg, 0, __pyx_n_s_print_msg, NULL, __pyx_n_s_print, __pyx_d, ((PyObject *)__pyx_codeobj_)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_print_msg, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /*--- Wrapped vars code ---*/

  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  if (__pyx_m) {
    if (__pyx_d) {
      __Pyx_AddTraceback("init print", __pyx_clineno, __pyx_lineno, __pyx_filename);
    }
    Py_CLEAR(__pyx_m);
  } else if (!PyErr_Occurred()) {
    PyErr_SetString(PyExc_ImportError, "init print");
  }
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  #if CYTHON_PEP489_MULTI_PHASE_INIT
  return (__pyx_m != NULL) ? 0 : -1;
  #elif PY_MAJOR_VERSION >= 3
  return __pyx_m;
  #else
  return;
  #endif
}

其中，函数前面很大一部分都是初始化，检查用的。

核心在这里

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/* "print.py":1
 * def print_msg():             # <<<<<<<<<<<<<<
 *     print("Hello Cython")
 */
 
__pyx_t_1 = __Pyx_CyFunction_New(
      &__pyx_mdef_5print_1print_msg, 	// MethodDef指针
      0, 
      __pyx_n_s_print_msg, 	// 函数名
      NULL, 
      __pyx_n_s_print,	// 所在的模块名
      __pyx_d, 	// 全局变量字典
      ((PyObject *)__pyx_codeobj_)
); 
if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (PyDict_SetItem(__pyx_d, __pyx_n_s_print_msg, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

对这个函数的调用使得我们有机会找到大致的逻辑。

定位

通过__Pyx_PyCode_New()

尝试IDA中定位。

IDA中的代码不少内联了，再加上优化，变得很复杂。我们先通过一些特征慢慢摸索到本体。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// C文件中
py_code = __Pyx_PyCode_New(
    0,
    0,
    0,
    0,
    0,
    __pyx_empty_bytes, /*PyObject *code,*/
    __pyx_empty_tuple, /*PyObject *consts,*/
    __pyx_empty_tuple, /*PyObject *names,*/
    __pyx_empty_tuple, /*PyObject *varnames,*/
    __pyx_empty_tuple, /*PyObject *freevars,*/
    __pyx_empty_tuple, /*PyObject *cellvars,*/
    py_srcfile,   /*PyObject *filename,*/
    py_funcname,  /*PyObject *name,*/
    py_line,
    __pyx_empty_bytes  /*PyObject *lnotab*/
);
// IDA（已经重命名过）
py_code = PyCode_New(
    0i64,
    0i64,
    0i64,
    0i64,
    3,
    _pyx_empty_bytes,
    _pyx_empty_tuple,
    _pyx_empty_tuple,
    _pyx_empty_tuple,
    _pyx_empty_tuple,
    _pyx_empty_tuple,
    py_srcfile,
    py_funcname,
    1,
_pyx_empty_bytes);

这个函数是在__Pyx_CreateCodeObjectForTraceback()中的；然后又在__Pyx_AddTraceback()中被调用；然后又在Exec函数的末尾被调用。总的来说，就是内联了两层代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
/* AddTraceback */
#include "compile.h"
#include "frameobject.h"
#include "traceback.h"
static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
            const char *funcname, int c_line,
            int py_line, const char *filename) {
    PyCodeObject *py_code = 0;
    PyObject *py_srcfile = 0;
    PyObject *py_funcname = 0;
    #if PY_MAJOR_VERSION < 3
    py_srcfile = PyString_FromString(filename);
    #else
    py_srcfile = PyUnicode_FromString(filename);
    #endif
    if (!py_srcfile) goto bad;
    if (c_line) {
        #if PY_MAJOR_VERSION < 3
        py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
        #else
        py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
        #endif
    }
    else {
        #if PY_MAJOR_VERSION < 3
        py_funcname = PyString_FromString(funcname);
        #else
        py_funcname = PyUnicode_FromString(funcname);
        #endif
    }
    if (!py_funcname) goto bad;
    py_code = __Pyx_PyCode_New(
        0,
        0,
        0,
        0,
        0,
        __pyx_empty_bytes, /*PyObject *code,*/
        __pyx_empty_tuple, /*PyObject *consts,*/
        __pyx_empty_tuple, /*PyObject *names,*/
        __pyx_empty_tuple, /*PyObject *varnames,*/
        __pyx_empty_tuple, /*PyObject *freevars,*/
        __pyx_empty_tuple, /*PyObject *cellvars,*/
        py_srcfile,   /*PyObject *filename,*/
        py_funcname,  /*PyObject *name,*/
        py_line,
        __pyx_empty_bytes  /*PyObject *lnotab*/
    );
    Py_DECREF(py_srcfile);
    Py_DECREF(py_funcname);
    return py_code;
bad:
    Py_XDECREF(py_srcfile);
    Py_XDECREF(py_funcname);
    return NULL;
}

static void __Pyx_AddTraceback(const char *funcname, int c_line,
                               int py_line, const char *filename) {
    PyCodeObject *py_code = 0;
    PyFrameObject *py_frame = 0;
    PyThreadState *tstate = __Pyx_PyThreadState_Current;
    if (c_line) {
        c_line = __Pyx_CLineForTraceback(tstate, c_line);
    }
    py_code = __pyx_find_code_object(c_line ? -c_line : py_line);
    if (!py_code) {
        py_code = __Pyx_CreateCodeObjectForTraceback(
            funcname, c_line, py_line, filename);
        if (!py_code) goto bad;
        __pyx_insert_code_object(c_line ? -c_line : py_line, py_code);
    }
    py_frame = PyFrame_New(
        tstate,            /*PyThreadState *tstate,*/
        py_code,           /*PyCodeObject *code,*/
        __pyx_d,    /*PyObject *globals,*/
        0                  /*PyObject *locals*/
    );
    if (!py_frame) goto bad;
    __Pyx_PyFrame_SetLineNumber(py_frame, py_line);
    PyTraceBack_Here(py_frame);
bad:
    Py_XDECREF(py_code);
    Py_XDECREF(py_frame);
}
通过一大串初始化和PyObject_GC_Track(op)

这个函数调用在核心代码的旁边。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
static PyObject *__Pyx_CyFunction_Init(
    __pyx_CyFunctionObject *op, 
    PyMethodDef *ml, 
    int flags, 
    PyObject* qualname,
    PyObject *closure, 
    PyObject *module, 
    PyObject* globals, 
    PyObject* code
) {
    if (unlikely(op == NULL))
        return NULL;
    op->flags = flags;
    __Pyx_CyFunction_weakreflist(op) = NULL;
    op->func.m_ml = ml;
    op->func.m_self = (PyObject *) op;
    Py_XINCREF(closure);
    op->func_closure = closure;
    Py_XINCREF(module);
    op->func.m_module = module;
    op->func_dict = NULL;
    op->func_name = NULL;
    Py_INCREF(qualname);
    op->func_qualname = qualname;
    op->func_doc = NULL;
    op->func_classobj = NULL;
    op->func_globals = globals;
    Py_INCREF(op->func_globals);
    Py_XINCREF(code);
    op->func_code = code;
    op->defaults_pyobjects = 0;
    op->defaults_size = 0;
    op->defaults = NULL;
    op->defaults_tuple = NULL;
    op->defaults_kwdict = NULL;
    op->defaults_getter = NULL;
    op->func_annotations = NULL;
    return (PyObject *) op;
}


/* CythonFunction */
static PyObject *__Pyx_CyFunction_New(
    PyMethodDef *ml, 
    int flags, 
    PyObject* qualname, 
    PyObject *closure, 
    PyObject *module, 
    PyObject* globals, 
    PyObject* code
) {
    PyObject *op = __Pyx_CyFunction_Init(	// 已被内联
        PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType), 	// 不会内联
        ml, 
        flags, 
        qualname, 
        closure, 
        module, 
        globals, 
        code
    );
    if (likely(op)) {
        PyObject_GC_Track(op);	// 不会内联
    }
    return op;
}

__pyx_t_1 = __Pyx_CyFunction_New(
      &__pyx_mdef_5print_1print_msg, 	// MethodDef指针
      0, 
      __pyx_n_s_print_msg, 	// 函数名
      NULL, 
      __pyx_n_s_print,	// 所在的模块名
      __pyx_d, 	// 全局变量字典
      ((PyObject *)__pyx_codeobj_)
);

__Pyx_CyFunction_New()和__Pyx_CyFunction_Init()函数在IDA中没找着，看样子是被内联掉了。

先找到PyObject_GC_Track(op)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
if ( !py_code )
{
  v4 = 1524;
  goto LABEL_80;
}
v23 = (_QWORD *)qword_1800084C8;
v24 = (_QWORD *)qword_180008440;
v25 = (_QWORD *)py_funcname;
v26 = PyObject_GC_New(qword_1800084D8);
v27 = (QWORD *)v26;
if ( !v26 )
{
  v4 = 1542;
  goto LABEL_80;
}
*(_DWORD *)(v26 + 136) = 0;
*(_QWORD *)(v26 + 40) = 0i64;
*(_QWORD *)(v26 + 16) = &off_180007720;	// method def指针
*(_QWORD *)(v26 + 24) = v26;
*(_QWORD *)(v26 + 96) = 0i64;
if ( v24 )
  ++*v24;
*(_QWORD *)(v26 + 32) = v24;
*(_QWORD *)(v26 + 48) = 0i64;
*(_QWORD *)(v26 + 56) = 0i64;
++*v25;
*(_QWORD *)(v26 + 64) = v25;
*(_QWORD *)(v26 + 72) = 0i64;
*(_QWORD *)(v26 + 104) = 0i64;
*(_QWORD *)(v26 + 80) = v23;
++*v23;
if ( v22 )
  ++*v22;
*(_QWORD *)(v26 + 88) = v22;
*(_DWORD *)(v26 + 120) = 0;
*(_QWORD *)(v26 + 128) = 0i64;
*(_QWORD *)(v26 + 112) = 0i64;
*(_QWORD *)(v26 + 144) = 0i64;
*(_QWORD *)(v26 + 152) = 0i64;
*(_QWORD *)(v26 + 160) = 0i64;
*(_QWORD *)(v26 + 168) = 0i64;
PyObject_GC_Track(v26);

这一块和__Pyx_CyFunction_Init()函数那一串长长的初始化操作很像。可以确定就是在这里了。

找到PyMethodDef*指针
1
*(_QWORD *)(v26 + 16) = &off_180007720;	// method def指针

回顾一下上文所说的这个结构体组成。

1
2
3
4
5
6
static PyMethodDef __pyx_mdef_5print_1print_msg = {
    "print_msg", 
    (PyCFunction)__pyx_pw_5print_1print_msg, 
    METH_NOARGS, 	// 4
    0
};
1
2
3
4
5
6
.data:0000000180007720 off_180007720   dq offset aPrintMsg_0   ; DATA XREF: sub_180002920+5E↑o
.data:0000000180007720                                         ; .text:000000018000318E↑o ...
.data:0000000180007720                                         ; "print_msg"
.data:0000000180007728                 dq offset sub_1800047E0
.data:0000000180007730                 dq 4
.data:0000000180007738                 dq 0

关于METH_NOARGS枚举，可以在python/include/objectmethod.h中找到。（建议使用grep -r命令搜索）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/* Flag passed to newmethodobject */
/* #define METH_OLDARGS  0x0000   -- unsupported now */
#define METH_VARARGS  0x0001
#define METH_KEYWORDS 0x0002
/* METH_NOARGS and METH_O must not be combined with the flags above. */
#define METH_NOARGS   0x0004
#define METH_O        0x0008

/* METH_CLASS and METH_STATIC are a little different; these control
   the construction of methods for a class.  These cannot be used for
   functions in modules. */
#define METH_CLASS    0x0010
#define METH_STATIC   0x0020

/* METH_COEXIST allows a method to be entered even though a slot has
   already filled the entry.  When defined, the flag allows a separate
   method, "__contains__" for example, to coexist with a defined
   slot like sq_contains. */

#define METH_COEXIST   0x0040

#ifndef Py_LIMITED_API
#define METH_FASTCALL  0x0080
#endif

/* This bit is preserved for Stackless Python */
#ifdef STACKLESS
#define METH_STACKLESS 0x0100
#else
#define METH_STACKLESS 0x0000
#endif
定位到函数

这样我们就终于定位到了print_msg()函数了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// write access to const memory has been detected, the output may be wrong!
__int64 sub_1800047E0()
{
  _QWORD *v0; // rdi
  __int64 v1; // rax
  int v2; // ebx
  _QWORD *v3; // rax
  bool v4; // zf

  v0 = (_QWORD *)PyTuple_Pack(1i64, qword_180008498);
  if ( !v0 )
    goto LABEL_14;
  v1 = qword_1800084C0;
  if ( qword_1800084C0 || (v1 = PyObject_GetAttr(qword_180008508, qword_180008440), (qword_1800084C0 = v1) != 0) )
  {
    v3 = (_QWORD *)PyObject_Call(v1, v0, 0i64);
    if ( v3 )
    {
      v4 = (*v3)-- == 1i64;
      if ( v4 )
        (*(void (__fastcall **)(_QWORD *))(v3[1] + 48i64))(v3);
      v2 = 0;
    }
    else
    {
      v2 = -1;
    }
  }
  else
  {
    v2 = -1;
  }
  v4 = (*v0)-- == 1i64;
  if ( v4 )
    (*(void (__fastcall **)(_QWORD *))(v0[1] + 48i64))(v0);
  if ( v2 >= 0 )
    return Py_NoneStruct++;
LABEL_14:
  sub_180002010(aPrintPrintMsg, 0x492u, 2, (__int64)aPrintPy);
  return 0i64;
}
比对

对比一下C文件里的函数（封装函数和子函数可能会因为内联合并）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
static PyObject *__pyx_pw_5print_1print_msg(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("print_msg (wrapper)", 0);
  __pyx_r = __pyx_pf_5print_print_msg(__pyx_self);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_5print_print_msg(CYTHON_UNUSED PyObject *__pyx_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("print_msg", 0);

  /* "print.py":2
 * def print_msg():
 *     print("Hello Cython")             # <<<<<<<<<<<<<<
 */
  if (__Pyx_PrintOne(0, __pyx_kp_s_Hello_Cython) < 0) __PYX_ERR(0, 2, __pyx_L1_error)

  /* "print.py":1
 * def print_msg():             # <<<<<<<<<<<<<<
 *     print("Hello Cython")
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("print.print_msg", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

通过和二进制文件的对比，可以发现默认情况下，与RefNanny有关的代码都不存在。应该是这个并没有被设置。所以可以在C文件中忽视这一块代码。

首先查找PyObject_Call()在C文件中的位置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
static int __Pyx_Print(PyObject* stream, PyObject *arg_tuple, int newline) {
    PyObject* kwargs = 0;
    PyObject* result = 0;
    PyObject* end_string;
    if (unlikely(!__pyx_print)) {
        __pyx_print = PyObject_GetAttr(__pyx_b, __pyx_n_s_print);
        if (!__pyx_print)
            return -1;
    }
    if (stream) {
        kwargs = PyDict_New();
        if (unlikely(!kwargs))
            return -1;
        if (unlikely(PyDict_SetItem(kwargs, __pyx_n_s_file, stream) < 0))
            goto bad;
        if (!newline) {
            end_string = PyUnicode_FromStringAndSize(" ", 1);
            if (unlikely(!end_string))
                goto bad;
            if (PyDict_SetItem(kwargs, __pyx_n_s_end, end_string) < 0) {
                Py_DECREF(end_string);
                goto bad;
            }
            Py_DECREF(end_string);
        }
    } else if (!newline) {
        if (unlikely(!__pyx_print_kwargs)) {
            __pyx_print_kwargs = PyDict_New();
            if (unlikely(!__pyx_print_kwargs))
                return -1;
            end_string = PyUnicode_FromStringAndSize(" ", 1);
            if (unlikely(!end_string))
                return -1;
            if (PyDict_SetItem(__pyx_print_kwargs, __pyx_n_s_end, end_string) < 0) {
                Py_DECREF(end_string);
                return -1;
            }
            Py_DECREF(end_string);
        }
        kwargs = __pyx_print_kwargs;
    }
    result = PyObject_Call(__pyx_print, arg_tuple, kwargs);
    if (unlikely(kwargs) && (kwargs != __pyx_print_kwargs))
        Py_DECREF(kwargs);
    if (!result)
        return -1;
    Py_DECREF(result);
    return 0;
bad:
    if (kwargs != __pyx_print_kwargs)
        Py_XDECREF(kwargs);
    return -1;
}
#endif

只在这个Print()函数中找到。那么大概也是叠层内联了。

这个函数又在__Pyx_Print_One()中被调用

1
2
3
4
5
6
7
8
9
static int __Pyx_PrintOne(PyObject* stream, PyObject *o) {
    int res;
    PyObject* arg_tuple = PyTuple_Pack(1, o);
    if (unlikely(!arg_tuple))
        return -1;
    res = __Pyx_Print(stream, arg_tuple, 1);
    Py_DECREF(arg_tuple);
    return res;
}

可以发现，这个函数有Tuple_Pack等在二进制文件中出现的代码。

大致的进行重命名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// write access to const memory has been detected, the output may be wrong!
__int64 sub_1800047E0()
{
  _QWORD *arg_tuple; // rdi
  __int64 __pyx_print; // rax
  int v2; // ebx
  _QWORD *result; // rax
  bool v4; // zf

  arg_tuple = (_QWORD *)PyTuple_Pack(1i64, obj);
  if ( !arg_tuple )
    goto LABEL_14;
  __pyx_print = _pyx_print;
  if ( _pyx_print || (__pyx_print = PyObject_GetAttr(_pyx_b, _pyx_n_s_print), (_pyx_print = __pyx_print) != 0) )
  {
    result = (_QWORD *)PyObject_Call(__pyx_print, arg_tuple, 0i64);
    if ( result )
    {
      v4 = (*result)-- == 1i64;
      if ( v4 )
        (*(void (__fastcall **)(_QWORD *))(result[1] + 48i64))(result);
      v2 = 0;
    }
    else
    {
      v2 = -1;
    }
  }
  else
  {
    v2 = -1;
  }
  v4 = (*arg_tuple)-- == 1i64;
  if ( v4 )
    (*(void (__fastcall **)(_QWORD *))(arg_tuple[1] + 48i64))(arg_tuple);
  if ( v2 >= 0 )
    return Py_NoneStruct++;
LABEL_14:
  AddTraceback(aPrintPrintMsg, 0x492u, 2, (__int64)aPrintPy);
  return 0i64;
}
恢复大致逻辑

看上去十分离谱，这个玩意怎么能够跟print()函数串在一起。

我的想法是，根据Cython的思想，将一切都是为PyObject对象。于是乎我们观察

1
2
__pyx_print = PyObject_GetAttr(_pyx_b, _pyx_n_s_print)
result = (_QWORD *)PyObject_Call(__pyx_print, arg_tuple, 0i64);

PyObject_Call

在python/include/abstract.h中可以找到PyObject_Call的原型

1
2
3
4
5
PyAPI_FUNC(PyObject *) PyObject_Call(
    PyObject *callable,	// 对象指针
    PyObject *args, 	// 传入参数，通过PyTuple_Pack()封装的
    PyObject *kwargs	// 其余变参
);

PyObject_GetAttr

1
PyObject* PyObject_GetAttr(PyObject *o, PyObject *attr_name);

从对象o中找到特征名为attr_name的对象。

__pyx_b

此对象是通过对比C文件得到的。实战情况下不一定能分析出来，但可以了解一下。

C文件中相关操作

1
2
3
4
// 在 Exec函数中

__pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
Py_INCREF(__pyx_b);

IDA中

1
2
3
4
5
6
7
8
v11 = (_QWORD *)PyImport_AddModule(aBuiltins);
_pyx_b = (__int64)v11;
if ( !v11 )
{
    v4 = 1500;
    goto LABEL_80;
}
++*v11;

__pyx_b获得的是__builtin__模块的指针。这个内置模块拥有若干Python自带的函数等元素，比如str()，eval()，print()等不需要导入即可使用的函数。

了解此对象，可以缩小范围。

_pyx_n_s_print

在IDA中，这又是一个未初始变量。

交叉引用，找到其在data段的引用

1
2
3
4
5
6
7
8
9
10
11
12
.data:00000001800078A0                 dq offset __pyx_n_s_print
.data:00000001800078A8                 dq offset aPrint_2      ; "print"
.data:00000001800078B0                 dq 6
.data:00000001800078B8                 dq 0
.data:00000001800078C0                 db    0
.data:00000001800078C1                 db    1
.data:00000001800078C2                 db    1
.data:00000001800078C3                 db    0
.data:00000001800078C4                 db    0
.data:00000001800078C5                 db    0
.data:00000001800078C6                 db    0
.data:00000001800078C7                 db    0

联想起上文所述的__pyx_string_tab中的结构体定义

1
2
3
4
5
6
7
8
9
10
typedef struct {
	PyObject **p; 	// 8
	const char *s; 	// 8
	const Py_ssize_t n; // 8
	const char* encoding;	// 8
	const char is_unicode; // 1
	const char is_str; 	// 1
	const char intern;  // 1
    // _BYTE[5] _padding;
} __Pyx_StringTabEntry;

C文件中：

1
{&__pyx_n_s_print, __pyx_k_print, sizeof(__pyx_k_print), 0, 0, 1, 1},

由此得知，这个_pyx_n_s_print对象就是一个包裹过的print字符串的指针。

于是乎逻辑就通顺了，那便是从__builtin__模块中寻找print函数，然后PyObject_Call调用它。

打印的字符串

刚刚分析了这么久，研究出来了大致的逻辑结果，但是还没发觉到底打印了啥字符串。

重新分析一下print_msg()函数

1
v0 = (_QWORD *)PyTuple_Pack(1i64, obj);

这个便是传入的参数。

obj对象交叉引用一下，发现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
.data:00000001800077B0 off_1800077B0   dq offset obj           ; DATA XREF: sub_180001D30+6↑r
.data:00000001800077B0                                         ; Exec:loc_180003D70↑r ...
.data:00000001800077B8 off_1800077B8   dq offset aHelloCython  ; DATA XREF: sub_180001D30+14↑o
.data:00000001800077B8                                         ; Exec+3BD↑o ...
.data:00000001800077B8                                         ; "Hello Cython"
.data:00000001800077C0                 dq 0Dh
.data:00000001800077C8                 dq 0
.data:00000001800077D0                 db    0
.data:00000001800077D1                 db    1
.data:00000001800077D2                 db    0
.data:00000001800077D3                 db    0
.data:00000001800077D4                 db    0
.data:00000001800077D5                 db    0
.data:00000001800077D6                 db    0
.data:00000001800077D7                 db    0

也就是在C文件中__pyx_string_tab中的初始化。

所以得到

1
print("Hello Cython")

其他

基于错误信息定位
1
__Pyx_AddTraceback(aPrintPrintMsg, 0x492u, 2, (__int64)aPrintPy);

能够显示出函数的名称和位置。十分轻松，不需要顺藤摸瓜去苦苦搜索。

基于函数表定位

也就是wrapper函数声明后的PyMethodDef结构体。

1
2
3
4
5
6
static PyMethodDef __pyx_mdef_5print_1print_msg = {
    "print_msg", 
    (PyCFunction)__pyx_pw_5print_1print_msg, 
    METH_NOARGS, 
    0
};

上文已经讲过了，但是那是从Exec函数里面慢慢抽出来的。

其实也可以直接找函数名print_msg，然后交叉引用找到这里。相当于倒过来整理逻辑。

后记/疑问

通过上面obj对象，也就是C文件中__pyx_kp_s_Hello_Cython对象的交叉引用，可以发现另外2个和print_msg()一模一样的函数都引用了它，且都有相同的错误抛出，表明原来都是python中的同一个函数。然而只有一个是在PyModuleDef*里面注册的。

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

A junior undergraduate
studying in the college of cyber science and engineering
in Sichuan University
in Sichuan , China.
Pronouns:He/him.
A core member of 0x401 CTF team
majorly focus on Reverse Engineering chanllenges.