Python逆向及相关知识

已于 2023-08-25 11:56:48 修改
阅读量2.6k 收藏 16
点赞数 5
分类专栏： re知识点积累 文章标签： python bytecode pyc花指令与混淆
于 2023-03-18 22:06:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61154173/article/details/129593923
版权

今天第二次看见python字节码的逆向题，然后发现了一个介绍Python逆向的文章，所以把文章里的内容简单整理记录一下。

文章参考：https://www.cnblogs.com/blili/p/11799398.html  奇安信攻防社区-浅谈ctf中的python逆向https://www.cnblogs.com/blili/p/11799398.html

PYC逆向及混淆手法 - 在逆向的边缘反复横跳

Python运行原理：

一.什么是Python

Python 是一种解释型、面向对象、动态数据类型的高级程序设计语言。

二.解释性语言和编译型语言的区别

我们编程都是用的高级语言，计算机不能直接理解高级语言，只能理解和运行机器语言，所以必须要把高级语言翻译成机器语言，计算机才能运行高级语言所编写的程序。翻译的方式有两种，一个是编译，一个是解释。

用编译型语言写的程序执行之前，需要一个专门的编译过程，通过编译系统（不仅仅只是通过编译器，编译器只是编译系统的一部分）把高级语言翻译成机器语言，把源高级程序编译成为机器语言文件。

解释型语言没有严格编译汇编过程，由解释器将代码块按需要变运行边翻译给机器执行。因此解释型语言一度存在运行效率底，重复解释的问题。但是通过对解释器的优化!可以提高解释型语言的运行效率。Python就属于这一种编程语言。

三.Python运行原理概述

Python没有严格意义上的编译和汇编过程。一般可以认为编写好的python源文件，由python解释器翻译成以.pyc为结尾的字节码文件。pyc文件是二进制文件，可以由python虚拟机直接运行。

注：有的朋友可能会问，为什么我运行python，有时候生成pyc文件，有时候没有呢？Python在执行import语句时，将会到已设定的path中寻找对应的模块。并且把对应的模块编译成相应的PyCodeObject（python中的一个类）中间结果，然后创建pyc文件，并将中间结果写入该文件。然后，Python会import这个pyc文件，实际上也就是将pyc文件中的PyCodeObject重新复制到内存中。而被直接运行的python代码一般不会生成pyc文件。

加载模块时，如果同时存在.py和.pyc，Python会尝试使用.pyc，如果.pyc的编译时间早于.py的修改时间，则重新编译.py并更新.pyc。

四.综述

Python源码->python解释器->.pyc文件->python虚拟机运行

Python的pyc文件结构

Python代码的编译结果就是PyCodeObject对象。PyCodeObject对象可以由虚拟机加载后直接运行，而pyc文件就是PyCodeObject对象在硬盘上的保存形式。因此我们先分析PyCodeObject对象的结构，随后再涉及pyc文件的二进制结构。

一.PyCodeObject对象结构

 二.pyc文件生成：

python中使用marshal.dump的方法将PyCodeObject对象转化为对应的二进制文件结构。每个字段在二进制文件中的结构如下图：

pyc文件结构主要包括两部分：pyc文件头部表示和PyCodeObject对象部分。上面对PyCodeObject对象的二进制部分已经有了了解，pyc文件头部比较简单，在python2中只占用4个字节包含两个字段magic和mtime，完整的pyc文件结构见下图： 

python字节码反编译

经过编译的python文件可以提高程序的运行速度，一定程度上也对源代码起到了保护作用。然而如果我们只有编译过的python字节码文件，就给我们审查源码造成了一定的困难，这就引出了python字节码反编译的需求。

根据python的编译原理我们知道PyCodeObjectData是python源文件作为一个实例化的类，通过python内置库函数marshal.dumps生成的二进制数据段，因此通过marshal.loads(PyCodeObjectData) ，我们可以得到PyCodeObjectData反序列化的对象。

使用python内置模块dis可以对PyCodeObject进行反编译，从而获取到python二进制字节码代码段的“汇编形式”。这样可以便于对字节码进行阅读。

Python字节码解读

字节码结构如下：
源码行号 | 跳转注释符 | 指令在函数中的偏移 | 指令符号（助记符） | 指令参数 | 实际参数值

上图表示：

  • 该字节码指令在源码中对应59行
  • 此处是跳转的目的地址
  • 82该字节指令的字节码偏移
  • 操作指令对应的助记符为LOAD_GLOBAL
  • 操作参数为6
  • 操作参数对应的实际值为disassemble

常见字节码解读

1.常量

加载常量只有一行LOAD_CONST，对应源码第1行，字节码偏移地址0字节，常量数组中索引0，实际常量值‘123 ’

2.局部变量

加载局部变量a：LOAD_CONST加载常量1，调用STORE_NAME（参数a），并将变量a存储为1
同理加载局部变量b

3.全局变量

加载全局变量a，与加载局部变量不同的是通过STORE_GLOBAL在存储变量

4.数据类型list

先将所有的list元素加载，调用BUILD_LIST方法生成list于内存中，通过STORE_NAME将堆栈中的list存储于局部变量a中

5.数据类型dict

BUILD_MAP声明字典元素数量，通过两次LOAD_CONST后，调用STORE_MAP生成键值对存于堆栈，最终通过STORE_NAME将堆栈中长度为2的两个键值对最为字典数据类型存储在a中

6.数学运算

字节码中显示先对局部变量a、b赋值，通过LOAD_NAME加载局部变量，调用加法BINARY_ADD，生成结果存储与堆栈中，使用STORE_NAME将堆栈中的计算结果存储与局部变量c
加减乘除的运算字节码相似，不不再赘述，读者可以自行分析，如下图：

上图中为对a、b做加减乘除的字节码，因为没有存储计算结果，所以每次运算完没有使用STORE_NAME方法存储，解释器默认调用POP_TOP方法将计算结果从堆栈顶部弹出，以保证堆栈平衡。

7.for循环

上图显示一个FOR循环的过程。SETUP_LOOP表明循环开始，参数说明此循环知道字节码偏移28字节的指令结束（也就是28字节开始不是循环）。调用range方法生成generator存于堆栈。FOR_ITER调用堆栈，声明generator作用到字节码偏移位置27字节。从第16字节起到27为generator迭代作用域。其中为一个print函数。

8.if判断

以一个简单的IF判断为例，先加载需要比较的常量，调用COMPARE_OP指令对堆栈中两个常量进行比较，将结果存入堆栈。调用POP_JUMP_IF_FALSE指令，判断栈顶值来决定程序运行顺序实现判断功能。 

补充：

Python 字节码与字节码混淆 - 灰信网（软件开发博客聚合）

PythonCodeObject补充

在 Python 解释器目录下 ./lib/python3.7/importlib/_bootstrap-external.py 中有明确的版本号记录

对于 pyc 文件整体的 C 结构体，可以在 ./include/python2.7/code.h 或不同版本类似的文件中找到

对于字节码opcode对应的二进制数可在./Python38/include/opcode.h查看

pyc反编译工具

（1）uncompyle6   使用：uncompyle6 ./xx.pyc

（2）pycdc             使用：./pycdc ./xxx.pyc

（3）pydumpck   使用：pydumpck *.exe/*.pyc支持exe和pyc的反编译，支持上面两种方式反编译，具有多线程支持

（4）py4coc           使用：是一个python脚本，依赖pycdc，可直接把pyc或exe反编译成python文件。实现了pydumpck的基础功能。

（5）pyinstxtractor  使用：pyinstxtractor是支持通过pyinstaller打包成的elf或exe的解包，支持的pyinstaller的版本较全，解包效果较好

相关api 或 结构成员

（1）dis.dis函数能反编译出所有的pyc的字节码

（2）dis.opmap是dis模块中的一个字典类型成员，他记录了字节码和16进制的对应关系

（3）dis.Bytecode：它可以吧字节码更细致的打印出来，不过直接使用的话，只能打印 第一个函数的信息（一般是main函数）

bytecode = dis.Bytecode(Pyobj)
for instr in bytecode:
    print(instr)
    print(instr.opcode)         # 输出所有的opcode名字
    print(instr.offset)         # 输出所有的自解码偏移

（4）Pyobj.co_code

默认打印第一个函数（main）函数中的字节码的16进制信息

由于 python3.6 版本之后，一个python字节码大小为两字节，我们可以使用一下方式来获取字节码数量

len(Pyobj.co_code) // 2

此处以一道题为例，使用 010 editor 打开

  • 最前面的 4 个字节为 Magic Number ，其中前两个直接为解释器的版本号

    • 此处前两个字节为 62211，也就是 Python 2.7.0a0 版本的字节码解释器
    • 注意这里是小端序，就是高位在后面，所以是 0xF303

  • Magic Number 之后的四个字节为时间戳，这里是 0x5EC652B0，之后就是 Python 代码对象

  • 代码对象首先一个字节表示此处的对象类型，这里值为 TYPE_CODE，值为 0x63，

  • 此后四个字节表示参数的个数，也就是 co_argcount 的值

  • 往后四个字节是局部变量的个数 co_nlocals

  • 往后四个字节是栈空间大小 co_stacksize

  • 往后四个字节是 co_flags

  • 之后就是 co_code 了，也就是编译好的字节码的部分

    • co_code 部分首先的一个字节也是表示此处的对象类型，这里是 TYPE_STRING，为 0x73
    • 接下来四个字节表示此 co_code 对象的长度，此后就是代码对象，这里的代码长度为 0xA7
    • 也就是后方 163 个字节的长度都是代码对象
  • 此 co_code 对象的字节码内容结束后，接着是 co_consts 内容，也就是用到的常量的内容
    • 最开始是 TYPE_TUPLE，表示这是个元组类型
    • 此后四个字节是元素个数，这里是 0x23，之后每一个字节与对应的值一组，一共 0x23 组
      • 每组中第一个字节表示元素类型，比如 0x69 指 TYPE_INT，此后为对应的值
  • 后方也对应结构体中的相应内容

字节码混淆

Anti-uncompyle6

对于正常的 pyc 文件，使用 uncompyle6 插件可以正常的进行字节码逆向，得到原来的代码

如果需要使 uncompyle6 失效的话，只要在 co_code 头部加上 0x71 0x03 0x00 ，然后把记录 co_code 长度的数据加 3

  • 这段字节码指 JUMP_ABSOLUTE 3 ，也就是向后跳 3 个字节后继续执行，实际上没有改变代码逻辑
  • 但是 uncompyle6 插件的还原逻辑就没办法识别此字节码原先的意思，导致解析异常

Anti-dis

  • 上文的改法会导致 uncompyle6 插件异常，但是这个方法的实质只是增加了一句字节码
  • Python 可以借助自带的 dis 库和 marshal 库解析 pyc 二进制文件中的信息，举个例子 
    def fun1():
    enc = "Ua`|{f.4V}$l4h4Vx{s.4|``dg.;;vx{s:v}$l:wz;4h4Dxqugq4}zp}wu`q4`|q4g{afwq4ur`qf4m{af4pqf}bu`}{z"
    flag = ""
    for i in enc:
        flag += chr(ord(i) ^ 0x14)
    print flag
fun1()

    编译成 pyc 文件后，尝试加入 JUMP_ABSOLUTE 3 到代码头部

  • 橙色的字节为编辑过的

 使用 uncompyle6 发生 Parse error 异常，但是还是可以正常运行。尝试使用 marshal 模块搭配 dis 模块进行字节码解析，程序输出了完整的字节码，根据字节码还是可以顺利的还原出源代码信息

如果我们不想让 dis 顺利的导出字节码，也可以用一些指令来使得 dis 模块产生异常

  • 比如来个指令重叠，中间插一个读取数据的字节码0x71 0x04 0x00 0x64 0x71 0x08 0x00 0x00
  • 这里的 0x64 为解释器的 LOAD_CONST 指令，如果正常的话这里应该是 LOAD_CONST 0x0871
  • 那么 dis 模块就看不懂了，实际上通过前面的 0x71 0x04 0x00 会跳过此字节码，实际上是不执行的
  • 后方的0x71 0x08 0x00 是根据前面第一个 0x71 开始跳转的，所以跟的是 0x08

尝试 dis 字节码，直接抛出 IndexError 了，同时 uncompyle6 也 IndexError 了

pyc花指令

整理自PYC逆向及混淆手法 - 在逆向的边缘反复横跳

常见的python花指令形式有两种：单重叠指令和多重叠指令。

以下以python3.8为例，指令长度为2字节。

单重叠指令：

#例1 Python单重叠指令
 0 JUMP_ABSOLUTE        [71 04]     5 
 2 PRINT_ITEM           [47 --]
 4 LOAD_CONST           [64 10]     16
 6 STOP_CODE            [00 --]
#例1 实际执行
 0 JUMP_ABSOLUTE        [71 04]     5 
 4 LOAD_CONST           [64 10]     16

单重叠指令多是分支的跳转，导致一些反编译工具如pycdc、uncompyle6出错。

多重叠指令：

#例2 Python多重叠指令
 0 EXTENDED_ARG         [91 64] 
 2 EXTENDED_ARG         [91 53]
 4 JUMP_ABSOLUTE        [71 01]
#例2 实际执行
 0 EXTENDED_ARG         [91 64] 
 2 EXTENDED_ARG         [91 53]
 4 JUMP_ABSOLUTE        [71 02]
 1 LOAD_CONST           [64 91]
 3 RETURN_VALUE         [53 --]

多重叠指令是将指令的数据部分当作下一条指令的opcode部分执行，在跳转基础上进一步混淆控制流的技术手段

常见的花指令形式：

83         654 JUMP_FORWARD             0 (to 656)
        >>  656 JUMP_FORWARD             2 (to 660)
            658 NOP
        >>  660 JUMP_FORWARD             4 (to 666)

 84         662 NOP
            664 NOP
        >>  666 JUMP_FORWARD             4 (to 672)
            668 NOP

 85         670 NOP
        >>  672 JUMP_FORWARD             4 (to 678)
            674 NOP
            676 NOP
            
            
 65       412 LOAD_CONST               1 ('You Are Debug')
            414 LOAD_CONST               1 ('You Are Debug')
            416 LOAD_CONST               2 ('0b')
            418 JUMP_FORWARD             0 (to 420)

pyc解花指令

pyc去除花指令后，很大可能是不能被现有工具反编译成源码的，因为现有反编译工具对pyc要求比较严格，不能有nop以及其他junk指令

解决方法

（1）将原来花指令的地方填充其他无关指令占位

（2）修改pycdc源码，将反编译相关的限制放开

例题：花指令的单重叠指令

题目链接：题目

下载完是个.pyc文件，使用uncompyle6反编译一下

发现编译不了，并且.pyc是3.8版本的，那就在3.8版本环境下看一下字节码

 发现前面JUMP_ABSOLUTE就是单重叠，去花，在010去掉这三个指令的二进制，然后修改co_code的长度(减6)

看一下

 又因为经查看./Python38/include/opcode.h知道JUMP_ABSOLUTE对应0x71，即把下图71 04 71 06 71 02删除，然后把前面的EE 07减6即可

 修改后在用uncompyle6就可以反编译成功。

_map = [
 [
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 5, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1], [1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1], [1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1], [1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1], [1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1], [1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1], [1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1], [1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1], [1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1], [1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1], [1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1], [1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1], [1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1], [1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1], [1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1], [1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1], [1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1], [1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1], [1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1], [1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1], [1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1], [1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1], [1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1], [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1], [1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 7, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]

def maze():
    x = 1
    y = 1
    step = input()
    for i in range(len(step)):
        if step[i] == 'w':
            x -= 1
        else:
            if step[i] == 's':
                x += 1
            else:
                if step[i] == 'a':
                    y -= 1
                else:
                    if step[i] == 'd':
                        y += 1
                    else:
                        return False
        if _map[x][y] == 1:
            return False
        if x == 29 and y == 29:
            return True


def main():
    print('Welcome To VNCTF2022!!!')
    print('Hello Mr. X, this time your mission is to get out of this maze this time.(FIND THAT 7!)')
    print('you are still doing the mission alone, this tape will self-destruct in five seconds.')
    if maze():
        print('Congratulation! flag: VNCTF{md5(your input)}')
    else:
        print("Sorry, we won't acknowledge the existence of your squad.")


if __name__ == '__main__':
    main()

然后走迷宫就可以解flag

内怀童心外表成熟
关注
  • 5
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
关于pyc文件的逆向
weixin_43225801的博客
03-02 5591
关于pyc文件的逆向 最近感觉遇到的pyc文件逆向的越来越多了，所以就来总结下。//参考了大佬的blog：http://mozhucy.cn/2018/11/26/python_pyc/ 0x1 pyc的文件结构 在命令行输入 python -m filename.py的时候,便会得到一个对应的filename.pyc。 拖进hxd中看二进制。其中，开头的4个字节是magic number，相对比...
Python JS逆向爬虫作业
02-29
在这个“Python JS逆向爬虫作业”中，我们可能会涉及到以下几个关键知识点： 1. **Python 爬虫**：Python 是爬虫开发的首选语言之一，因为它有丰富的库支持，如 `requests` 用于发送HTTP请求，`BeautifulSoup` 或 `...
python逆向之实战分析
Reveone的博客
10-11 1543
Python 代码先被编译为字节码后，再由Python虚拟机来执行字节码， Python的字节码是一种类似汇编指令的中间语言， 一个Python语句会对应若干字节码指令，虚拟机一条一条执行字节码指令， 从而完成程序执行。而dis模块可以帮助我们查看Python代码的字节码，它是python中内置的一个模块。
python逆向之pyc反编译
GalaxySpaceX的博客
05-10 8506
pyc反编译
探索Python二进制解包的新纪元：PyDumpCK
最新发布
gitblog_00073的博客
05-26 286
探索Python二进制解包的新纪元：PyDumpCK 项目地址:https://gitcode.com/serfend/pydumpck 在寻找一个强大的Python二进制文件反编译工具吗？来看看PyDumpCK吧！这是一个基于pycdc和uncompyle6的多线程工具，专为了解析和反编译由Python打包的PE、ELF、PYZ和PYC文件而设计。即使面对复杂的文件结构，PyDumpCK也能游刃...
Python的pyc字节码反编译反汇编相关知识
serfend's blog
04-12 8683
常用pyc转py的工具 pycdc Decompyle++ Decompyle++旨在将编译后的Python字节码转换回有效的、人类可读的Python源代码。虽然其他项目取得了不同程度的成功，但Decompyle++的独特之处在于，它寻求支持来自任何版本的Python的字节码。 Decompyle++包含一个字节码反汇编器(pycda)和一个反编译器(pycdc)。 该工具需要手动编译，使用kali编译以后的样本：https://pan.baidu.com/s/1tAzVPMzFmhWko915yguO
python逆向入门
zgwz123456的博客
02-02 3066
python逆向基础 一..python的运行机制 （1）、把原始代码编译成字节码 编译后的字节码是特定于Python的一种表现形式，它不是二进制的机器码，需要进一步编译才能被机器执行，这也是Python代码无法运行的像C/C++ 一样快的原因。如果Python进程在机器上拥有写入权限，那么它将把程序的字节码保存为一个以.pyc 为扩展名的文件，如果Python无法在机器上写入字节码，那么字节码将会在内存中生成并在程序结束时自动丢弃。在构建程序的时候最好给Python赋上在计算机上写的权限，这样只要源代码
Python(.pyc)反编译：pycdc工具安装与使用
thisiszdy的博客
08-26 3846
python反编译工具安装与使用
原创教程 - 新手小白可以学习 - 零基础学Python逆向爬虫.pdf
04-22
后续可以直接过渡到Python逆向爬虫的学习，俗话说，无逆向不爬虫，这个教程不单单讲解爬虫知识，还涉及到了js逆向知识，当你通过js逆向真正接触到Python逆向爬虫的陆海支出！ 适用人群： 1、对Python感兴趣的新手...
Python分布式爬虫与逆向进阶实战-视频教程网盘链接提取码下载.txt
09-07
本课程从 0 到 1 构建完整的爬虫知识体系，精选 20 + 案例，可接单级项目，应用热门爬虫框架 Scrapy、Selenium、多种验证码识别技术，JS 逆向破解层层突破反爬，带你从容抓取主流网站数据，掌握爬虫工程师硬核技能。...
python爬虫小项目与web逆向
02-29
Python爬虫小项目与Web逆向是IT领域中两个紧密相关的知识点，主要涉及网络数据抓取和网站结构分析。在互联网大数据时代，爬虫技术被广泛应用于数据分析、市场研究、内容聚合等领域，而Web逆向则常用于理解复杂的网页...
使用pyinstaller逆向.pyc文件
09-18
主要介绍了使用pyinstaller逆向.pyc文件，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
编译好的64位pycdc.exe(支持python3.10和python3.11)
01-16
编译好的64位pycdc.exe,可用于将pyc文件反编译为py文件 只需要将pyc.exe和pyc文件放于同一文件夹内,在文件夹内打开cmd 使用命令:pycdc xxx.pyc即可输出对应的反编译py文件(支持python3.10和python3.11)
python逆向入门教程
01-01
1、开发环境 我们在Windows 10上开始python逆向之旅，首先开始搭建开发环境，python解释器使用最新的3.6.1，IDE使用PyCharm社区版2017.1.3，下载地址如下所示，下载完成后直接双击安装包安装即可，随后设置PyCharm的Project Interpreter为刚才安装的Python解释器就可以了。 【Python】https://www.python.org/downloads/ 【PyCharm】http://www.jetbrains.com/pycharm/download/#section=windows 2、ctypes 首先介绍一下ctypes，
Python分布式爬虫与逆向进阶实战
05-01
随着课程的深入，学员将学习到 JavaScript (JS) 逆向工程的技术，这是破解复杂网站反爬虫策略的关键。我们将一步步揭示如何分析和绕过网站的反爬机制，从而有效地抓取所需的数据。课程的实战项目不仅能够帮助学员...
pycdc配置和使用
于高山之巅，方见大河奔涌；于群峰之上，更觉长风浩荡。
12-16 1037
使用的kali2023版本安装cmake下载pycdc切换到pycdc目录cd pycdc进行cmake。
python逆向的常见思路
qq_61156124的博客
04-09 1363
Python 代码先被编译为字节码后，再由Python虚拟机来执行字节码， Python的字节码是一种类似汇编指令的中间语言， 一个Python语句会对应若干字节码指令，虚拟机一条一条执行字节码指令， 从而完成程序执行。（在我的电脑上要先删除PYTHONHOME和路径才能用，删除该路径和path后打开py2exe所在文件夹，输入python2 unpy2exe.py exe路径即可）通常情况下struct中的文件头与pyc文件缺失的文件头前16位相同，复制粘贴进去即可。（三）将pyc转换成字节码。
python逆向什么意思_Python逆向（一）—— Python运行原理
weixin_36350547的博客
02-11 474
一、什么是PythonPython 是一种解释型、面向对象、动态数据类型的高级程序设计语言。二、解释型语言和编译型语言的区别我们编程都是用的高级语言，计算机不能直接理解高级语言，只能理解和运行机器语言，所以必须要把高级语言翻译成机器语言，计算机才能运行高级语言所编写的程序。翻译的方式有两种，一个是编译，一个是解释。用编译型语言写的程序执行之前，需要一个专门的编译过程，通过编译系统(不仅仅只是通过编...
ctf python逆向
10-12
好的，您的问题是 "ctf python逆向"，这是一个比较广泛的话题，您需要具体说明您想了解哪方面的内容。 一般来说，CTF中的逆向题目主要包括以下几个方面： 1. 二进制逆向：对给定的二进制文件进行分析，找出其中的漏洞或者隐藏的信息。 2. 网络逆向：对给定的网络流量进行分析，找出其中的漏洞或者隐藏的信息。 3. 加密算法逆向：对给定的加密算法进行分析，找出其中的漏洞或者破解密文。 4. 杂项逆向：包括各种其他类型的逆向题目，如反汇编、反调试等。 如果您想学习CTF中的逆向技术，可以从以下几个方面入手： 1. 学习汇编语言和反汇编技术，了解二进制文件的结构和执行过程。 2. 学习加密算法和密码学基础知识，了解各种加密算法的原理和特点。 3. 学习网络协议和网络安全知识，了解网络流量的结构和常见的攻击方式。 4. 练习做一些逆向题目，掌握常见的逆向技巧和工具使用方法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值