Cython学习

1.概述

1.简述

之前遇到的很多python题目逆向都是pyc的逆向比较简单，最近遇到了很多cython的题目，但是不太清楚原理做的就很难受，这里就想梳理一下cython的原理

2.Cython的概述

这里引自官方文档：

Cython - an overview — Cython 3.1.0a0 documentation

Cython是一种编程语言，可以编写 C 扩展 对于 Python 语言来说，就像 Python 本身一样简单 它旨在成为 语言的超集，赋予它高级， 面向对象、函数式和动态编程。

主要的 Python 执行环境通常称为 CPython用 C 语言编写的。 其他主要实现使用 Java 和 Python 本身 。

它的主要特点 ：

1. 支持可选的静态类型声明，如 语言的一部分。
2. 源代码被翻译成优化的 C/C++ 代码并编译为 Python 扩展模块
3. 允许程序执行速度非常快，并且与外部 C 紧密集成 库，同时保持高生产力

3.Cython的起源

Cython 项目最初基于著名的 [Pyrex Pyrex] 已经通过源代码编译器解决了这个问题 将 Python 代码转换为等效的 C 代码

特性：

1. 保留了 Python 的原始界面源代码
2. 可以直接从 Python 代码中使用
3. 使用快速二进制模块扩展 CPython 解释器
4. 将Python 代码与外部C库连接

2.Cython环境配置

与大多数 Python 软件不同，Cython 需要在系统上存在 C 编译器

1.不同系统的配置

1.Linux

GNU C 编译器（gcc）通常存在，或通过包系统轻松获得

在 Ubuntu 或 Debian 命令：

2.Mac OS X

木有apple，所以自己官网看

https://developer.apple .com /

3.Windows

使用开源 MinGW（Windows 的 gcc 分发版）

2.安装操作

1.直接包安装

2.官网下载安装最新版本

https://cython.org/

解压缩 tarball 或 zip 文件，输入目录

再运行

3.语言特性分析

前言

1.学习

跟着无名侠仙贝学习Cython Reverse - Pandaos's blog (panda0s.top)

2.编译

1.原理

Cython 有一个个功能可以将 Python 编译成 C语言实现，再由 GCC/Clang 将 C 编译成动态库

2.build（便于对应分析）

build的源码：

annotate=True 选项可以生成一个 html 页面

==显示 Py源码与生成的C代码的对应关系==

build命令：

成功后在当前目录下找到对应的动态库与对应的 xxx.c 源文件

==直接用 python import 导入==

3.基于Hello.py 编译成的动态库分析

版本： Python 3.7.6，Cython 0.29.21

1.将这个文件改为pyx后缀

2.运行前面的build命令

3.进入文件夹中查看便于分析的html文件

4.源码

1.__pyx_string_tab

1.概述

在pyx文件编译为.c的文件时，__pyx_string_tab是一个包含代码中所有需要使用的字符串（避免重复创建相同的字符串，从而优化字符串的使用和查找）

2.查看源码

3.利用

__pyx_string_tab将字符串与PyObject联系，再调用

__Pyx_InitStrings初始化字符串对象（详解__Pyx_InitStrings使用）

C++ __Pyx_InitStrings函数代码示例 - 纯净天空 (vimsky.com)

在逆向时，可以通过这个特性快速找到对应的project

4.辨析一下__Pyx_StringTabEntry和__pyx_string_tab

我在审计的时候发现了__Pyx_StringTabEntry结构体，发现和前面的__pyx_string_tab数组有点关系分析一下

如下：

1.Pyx_StringTabEntry结构体的定义

2.举个例子

cython代码大致结构

完整的实现

在模块初始化过程中，Cython 会调用一个函数（如 __Pyx_InitStrings），使用 __pyx_string_tab 来初始化所有字符串常量，

然后这个函数遍历 __pyx_string_tab，初始化每个字符串条目，并将字符串对象的指针存储在相应的结构体字段中

2.整数常量的构造

1.概述

整数常量的构造涉及将 Python 代码中的整数常量转换为 C 代码中的相应表示形式。这包括处理各种整数类型（如短整型、整型、长整型和超长整型）以及确保在生成的 C 代码中正确初始化和使用这些常量

2.简要分析

1.整数类型转换

在cython是可以直接引用

但是转化为c代码时，类似于（简化版本）

2.处理大整数

超出 C 的基本整数类型范围的整数，Cython 使用 Python 的 PyLong 类型来表示

例如：

转换

3.源码分析

整数属于全局变量，在 __Pyx_InitGlobals 中初始化

3.函数声明

1.概述

2.源码

2.详细分析一下__pyx_pf_5hello_32test_arg和 __pyx_pf_5hello_10test_class_2test_class_hh函数

1.__pyx_pf_5hello_32test_arg

这个函数对应于 Python 定义的函数 test_arg(x, y, z)，它在 Cython 中被编译成如下形式：

在 Cython 编译过程中，这个 Python 函数被转换为 C 函数，形式如下：

1.__pyx_pf_5hello_32test_arg是C 函数的名称

• 前缀 __pyx_pf_是 Cython 生成的函数前缀
• 5hello`表示模块名
• 32test_arg` 表示函数名

2.CYTHON_UNUSED PyObject *__pyx_self 是第一个参数

通常在 Cython 中用作占位符，因为函数没有 self`参数

3.PyObject *__pyx_v_x, PyObject *__pyx_v_y, PyObject *__pyx_v_z 参数

对应于 Python 函数参数 x, y, z`的 C 对象

2.__pyx_pf_5hello_10test_class_2test_class_hh

这个函数对应于一个类方法 test_class.test_class_hh，其 Python 定义如下：

在 Cython 编译过程中，这个类方法被转换为 C 函数，形式如下：

1.__pyx_pf_5hello_10test_class_2test_class_hh 是 C 函数的名称

• pyx_pf 是 Cython 生成的函数前缀
• 5hello 表示模块名
• 10test_class表示类名
• 2test_class_hh表示方法名

2.CYTHON_UNUSED PyObject *__pyx_self是第一个参数

通常在 Cython 中用作占位符，因为方法没有 self参数

3.PyObject *__pyx_v_self参数

对应于 Python 方法中的 self参数的 C 对象

4.myfunc1() 分析

1.源码

字符串常量

字符串常量 __pyx_kp_s_This_is_myfunc1被初始化为 "This is myfunc1."

创建元组

创建包含该字符串的元组：

• PyTuple_Pack(1, __pyx_kp_s_This_is_myfunc1)：创建一个包含一个元素的元组，该元素是字符串 __pyx_kp_s_This_is_myfunc1
• if (unlikely(!_pyx_tuple)) __PYX_ERR(0, 5, __pyx_L1_error)：==检查元组创建是否成功==，如果失败，则跳转到错误处理代码
• __Pyx_GOTREF(_pyx_tuple)：==记录元组对象 pyx_tuple 的引用==，防止垃圾回收
• __Pyx_GIVEREF(_pyx_tuple)：告诉==垃圾回收器这个对象已经被引用了==

2.分析printf的实现

print("This is myfunc1.")
  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* … */
  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_This_is_myfunc1); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 5, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple_);
  __Pyx_GIVEREF(__pyx_tuple_);

__pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_print, _pyx_tuple, NULL);
if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

• __pyx_t_1：存储函数调用的返回值
• __Pyx_PyObject_Call(__pyx_builtin_print, _pyx_tuple, NULL)：==调用 print 函数==，参数是 _pyx_tuple（即==包含字符串 "This is myfunc1." 的元组==），没有关键字参数
• ==检查 print 调用是否成功==，如果失败，则跳转到错误处理代码
• __Pyx_GOTREF(__pyx_t_1)：==记录 __pyx_t_1 的引用==
• __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0：==减少== __pyx_t_1 的引用计数，并将其设置为 0，==防止后续使用无效指针==

3.回收站

前面我们提到了回收站机制，这里详细解释cython中严格处理的回收站的机制

1.基本原理

引用计数：

• 每个对象维护一个引用计数，当有新的引用指向该对象时，引用计数增加；当引用被删除时，引用计数减少
• 当对象的引用计数降为零时，说明没有任何地方引用该对象，可以安全地回收其占用的内存

标记-清除（Mark and Sweep）：

• 垃圾回收器定期扫描所有对象，标记可达的（仍在使用的）对象
• 然后清除所有未标记的对象（即不再使用的对象），释放它们占用的内存

2.cython中的调用处理

__Pyx_GOTREF(__pyx_t_1);//增加 __pyx_t_1 的引用计数，表示当前代码块持有这个对象的引用
__Pyx_DECREF(__pyx_t_1); //减少 __pyx_t_1 的引用计数，当引用计数为零时，内存会被回收
__pyx_t_1 = 0;//__pyx_t_1 = 0;：将指针设置为 0，防止悬空指针

3.实现的大致代码框架

# 定义一个 Cython 类 MyClass
cdef class MyClass:
    cdef int value  # 类的成员变量，类型为 int

    # 类的构造函数，用于初始化对象
    def __cinit__(self, int value):
        self.value = value  # 将传入的值赋给成员变量 value

    # 类的析构函数，当对象被垃圾回收时调用
    def __dealloc__(self):
        print("Deallocating MyClass with value:", self.value)  # 打印对象被回收时的消息

    # 一个方法，用于获取对象的 value 值
    def get_value(self):
        return self.value

# 创建多个 MyClass 对象的函数
def create_objects(int n):
    cdef list objects = []  # 定义一个列表用于存储对象
    for i in range(n):  # 循环创建 n 个 MyClass 对象
        obj = MyClass(i)  # 创建一个 MyClass 对象，并传入当前的循环计数 i 作为参数
        objects.append(obj)  # 将创建的对象添加到列表中
    return objects  # 返回包含所有创建对象的列表

转换为cython代码

/* Deallocating MyClass with value: ... */
static void __pyx_tp_dealloc_MyClass(PyObject *o) {
    MyClass *p = (MyClass *)o;
    PyObject_GC_UnTrack(o);
    Py_TRASHCAN_SAFE_BEGIN(o)
    p->__pyx_vtab = NULL;
    __Pyx_call_destructor(p);
    PyObject_GC_Del(o);
    Py_TRASHCAN_SAFE_END(o)
}

5.test_variables()分析

这里关于def函数的定义比较冗杂，简单看看就行

1.cython生成一个test_variables包装器

static PyObject *__pyx_pw_5hello_3test_variables(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyMethodDef __pyx_mdef_5hello_3test_variables = {"test_variables", (PyCFunction)__pyx_pw_5hello_3test_variables, METH_NOARGS, 0};//定义了一个 PyMethodDef 结构体，将 test_variables 函数绑定到模块 hello 上

2.Python 包装器的实现

static PyObject *__pyx_pw_5hello_3test_variables(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
    CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
    PyObject *__pyx_r = 0;
    __Pyx_RefNannyDeclarations
    __Pyx_RefNannySetupContext("test_variables (wrapper)", 0);
    __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
    __pyx_r = __pyx_pf_5hello_2test_variables(__pyx_self);//调用实际实现函数_pyx_pf_5hello_2test_variables 并将结果赋给 __pyx_r

    /* function exit code */
    __Pyx_RefNannyFinishContext();//在函数结束时，完成引用计数管理并返回结果
    return __pyx_r;//pyx_r返回值指针，初始为 0
}

• __pyx_pw_5hello_3test_variables是Python 包装器函数，它将调用委托给实际的实现函数 __pyx_pf_5hello_2test_variables
• __Pyx_RefNannySetupContext`和 __Pyx_RefNannyFinishContext用于引用计数管理，帮助避免内存泄漏
• pyx_kwvalues处理可变参数，但这里没有用到，因为函数不接受参数

3.实现函数

static PyObject *__pyx_pf_5hello_2test_variables(CYTHON_UNUSED PyObject *__pyx_self) {//__pyx_pf_5hello_2test_variables 是实际的实现函数
    long __pyx_v_x;//__pyx_v_x是局部变量 x，类型为long
    PyObject *__pyx_v_y = NULL;//__pyx_v_y是局部变量 y，类型为 PyObject*Python 对象
    PyObject *__pyx_r = NULL;

    __pyx_v_x = 5;
    __pyx_v_y = __Pyx_PyObject_FromString("variables test.");//将y赋值为字符串 "variables test."，并进行错误检查
    if (unlikely(!__pyx_v_y)) __PYX_ERR(0, 9, __pyx_L1_error)

    __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v_x); //使用 __Pyx_PyInt_From_long将x转换为 Python 整数对象并打印
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 10, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = PyTuple_New(1); 
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 10, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_1);
    PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
    __pyx_t_1 = 0;
    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_2, NULL); 
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 10, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); 
    __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_1); 
    __pyx_t_1 = 0;

    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_v_y); 
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_1); 
    __pyx_t_1 = 0;

    __pyx_r = Py_None; //如果没有错误，返回 Py_None （Python 的 None 对象）
    __Pyx_INCREF(Py_None);
    goto __pyx_L0;
    __pyx_L1_error:;//如果有错误，进行错误处理，释放资源并添加回溯信息
    __Pyx_XDECREF(__pyx_t_1);
    __Pyx_XDECREF(__pyx_t_2);
    __Pyx_AddTraceback("hello.test_variables", __pyx_clineno, __pyx_lineno, __pyx_filename);
    __pyx_r = NULL;
    __pyx_L0:;
    __Pyx_XDECREF(__pyx_v_y);
    __Pyx_XGIVEREF(__pyx_r);
    __Pyx_RefNannyFinishContext();
    return __pyx_r;//函数结束时，释放 __pyx_v_y的引用，返回结果 __pyx_r
}

4.printf的调用

6.test_global_var() 分析

这里关于def的函数定义就不再解析了，大体差不多

主要解析这里引用字符串和调用print的函数

__builtin__是cython中的一个内置模块：

包含所有的内置对象，函数，异常，常量（提供一组标准的内置对象，会自动加载的这个模块，不会在用户处显示的导入），比如

函数：print，len，range

异常：Exception，TyprError

常量：none，true，false

7.test_numbers() 分析

查看这个地方构造元组的汇编

8.test_if() 分析

分析cython的实现

详细说明：

这个地方的4是指比较操作符的代码，gpt的解释有问题，这里在官方文档中找到关于他的使用

简单来说就是一个比较函数，返回一个布尔值（异常返回-1，结果为假0，为真返回1）

第三个参数的op为6种比较操作符之一

Py_LT（1）：小于 <
Py_LE（2）：小于等于 <=
Py_EQ（3）：等于 ==
Py_NE（4）：不等于 !=
Py_GT（5）：大于 >
Py_GE（6）：大于等于 >=

9.test_string() 分析

对照源码分析

切片访问

从一个序列（如列表、元组或字符串）中提取一个子序列

__pyx_t_2 = __Pyx_PyObject_GetSlice(__pyx_v_x, 2, 0, NULL, NULL, &__pyx_slice__4, 1, 0, 1);

cython实现

通过__Pyx_PyObject_GetSlice辅助函数

__pyx_v_x: 这是需要进行切片操作的 Python 对象

2: 这是切片操作的起始索引。即，从索引 2 开始进行切片

0: 这是切片操作的结束索引（0一般表示切片一直进行到对象的末尾）

&__pyx_slice__4代表一个包含切片信息的 PyObject，实际相当于 slice(2, None)

python中实现

start: 切片开始的索引（包括）
stop: 切片结束的索引（不包括）
step: 步长，表示从 start 到 stop 之间每隔多少个元素取一个

示例：

索引访问

索引访问只能获取单个元素，而不能获取多个元素或子序列

10.test_for()分析

源码

11.test_list()分析

对照源码分析

12.test_dict() 分析

对照源码分析

13.test_datetime () 分析

14.test_format() 分析

对照源码分析

格式化字符串的汇编实现

mov     r14, cs:___pyx_n_s_One
mov     edi, 1          ; __int64
//edi 寄存器被加载为整数值 1，表示将整数 1 转换为 Python 的长整型对象，返回值存储在 rax 寄存器中，并且被复制到 r15 寄存器中
call    _PyLong_FromLong
mov     r15, rax ; r15 = _PyLong_FromLong(1)
mov     edi, 2          ; size
//edi 寄存器被加载为 2，表示创建一个包含两个元素的元组
call    _PyTuple_New
//_PyTuple_New 是 Python/C API 中的函数，用于创建一个新的元组对象。调用此函数后，返回值存储在 rax 寄存器中，并且被复制到 rbx 寄存器中
mov     rbx, rax
mov     [rax+18h], r14 ; "One"
//[rax+18h] 和 [rax+20h] 分别将字符串 "One" 和整数 1 存储到新创建的元组对象中的对应位置
mov     [rax+20h], r15 ; 1

mov     rdi, cs:___pyx_kp_s_s_is_d ; %s is %d
//rdi 寄存器被加载为 ___pyx_kp_s_s_is_d，这是一个常量字符串，在此处表示 "%s is %d" 的格式化模板
mov     rsi, rax                   ; Tuple("One", 1)
call    _PyUnicode_Format
//_PyUnicode_Format Python/C API 中的函数，用于根据格式化模板将元组中的值格式化成一个 Unicode 字符串，返回格式化后的 Unicode 字符串对象

4.利用frida获取UTF-8 dump 信息

动态调用 Python/C API 中的函数来实现在运行时获取 PyObject 指针对应的字符串表示形式的 UTF-8 dump 信息

==根据python将对象转换为UTF-8字符串的汇编实现，编译frida的脚本==

汇编实现

.text:00007FFBC501B615 mov     rcx, rbx           ; 将 rbx 寄存器中的值（Python 对象的地址）移动到 rcx 寄存器
.text:00007FFBC501B618 call    python38_PyObject_Str ; 调用 PyObject_Str 函数，获取 Python 对象的字符串表示形式
.text:00007FFBC501B61D mov     rcx, rax           ; 将 rax 寄存器中的值（PyObject_Str 的返回值）移动到 rcx 寄存器
.text:00007FFBC501B620 call    python38_PyUnicode_AsUTF8 ; 调用 PyUnicode_AsUTF8 函数，将字符串表示形式转换为 UTF-8 编码

frida脚本

对应解析

1.将地址传递给 PyObject_Str 函数

汇编：

mov rcx, rbx

call python38_PyObject_Str

脚本：

2.将 PyObject_Str 的返回值传递给 PyUnicode_AsUTF8 函数

汇编：

mov rcx, rax

call python38_PyUnicode_AsUTF8

脚本：

3.读取并打印 UTF-8 字符串

脚本实现

[培训]《安卓高级研修班(网课)》月薪三万计划，掌握调试、分析还原ollvm、vmp的方法，定制art虚拟机自动化脱壳的方法