混淆Python代码？

Question

我正在寻找如何隐藏我的Python源代码.

print "Hello World!" 

我如何编码这个例子,以便它不是人类可读的？我被告知使用base64,但我不知道如何.

Answer 1

这只是一个有限的第一级混淆解决方案,但它是内置的:Python有一个字节码编译器:

python -OO -m py_compile <your program.py>

生成一个.pyo包含字节码的文件,以及删除文档字符串的.pyo文件等.您可以使用.py扩展名重命名该文件,并python <your program.py>像程序一样运行但不包含源代码.

PS:你得到的"有限"混淆程度是可以恢复代码(带有一些变量名,但没有注释和文档字符串).请参阅第一条评论,了解如何操作.但是,在某些情况下,这种混淆程度可能被认为是足够的.

PPS:如果你的程序导入了这样模糊的模块,那么你需要用.pyc后缀重命名它们(我不确定这一天不会破坏),或者你可以使用它来.pyo运行它们python -O ….pyo(导入应该工作).这将允许Python找到您的模块(否则,Python会查找.py模块).

Answer 2

所以它不是人类可读的？

我的意思是所有的文件都是编码的!! 当你打开它时你什么都听不懂..!那就是我想要的

作为最大值,您可以将源代码编译为字节码,然后只分发字节码.但即使这是可逆的.字节码可以被反编译成半可读源.

对于任何人来说,Base64都很容易解码,所以它不能作为实际保护,只能从完全的PC文盲中"隐藏"来源.此外,如果您计划以任何方式实际运行该代码,您必须将解码器包含在脚本中(或您的发行版中的另一个脚本,需要由合法用户运行),这会立即泄露您的编码/加密.

混淆技术通常涉及注释/文档剥离,名称修改,垃圾代码插入等,因此即使您反编译字节码,您也不会获得非常可读的来源.但是它们仍然是Python的源代码,Python并不擅长变得难以理解.

如果您绝对需要保护某些功能,我建议使用编译语言,如C或C++,编译和分发.so/.dll,然后使用Python绑定到受保护的代码.

Answer 3

您可以使用该base64模块对字符串进行编码以停止肩膀冲浪,但如果他们可以访问您的文件,则不会阻止某人找到您的代码.

然后,您可以使用该compile()函数和eval()函数在解码后执行代码.

>>> import base64
>>> mycode = "print 'Hello World!'"
>>> secret = base64.b64encode(mycode)
>>> secret
'cHJpbnQgJ2hlbGxvIFdvcmxkICEn'
>>> mydecode = base64.b64decode(secret)
>>> eval(compile(mydecode,'<string>','exec'))
Hello World!

所以,如果你有30行代码,你可能想要加密它,做这样的事情:

>>> f = open('myscript.py')
>>> encoded = base64.b64encode(f.read())

然后,您需要编写第二个脚本来执行该操作compile(),eval()并且可能将编码脚本包含为包含在三引号中的字符串文字.所以它看起来像这样:

import base64
myscript = """IyBUaGlzIGlzIGEgc2FtcGxlIFB5d
              GhvbiBzY3JpcHQKcHJpbnQgIkhlbG
              xvIiwKcHJpbnQgIldvcmxkISIK"""
eval(compile(base64.b64decode(myscript),'<string>','exec'))

Answer 4

赛通

似乎对此的 goto 答案是 Cython。我真的很惊讶没有其他人提到这一点吗？这是主页：https : //cython.org

简而言之，这会将您的 python 转换为 C 并对其进行编译，从而使其与任何“正常”编译的可分发 C 程序一样受到保护。

不过也有限制。我自己并没有深入探索它们，因为当我开始阅读它们时，我出于自己的目的放弃了这个想法。但它可能仍然对你有用。从本质上讲，您不能充分利用 Python，因为它提供了动态超棒的功能。我突然想到的一个主要问题是关键字参数不可用:(您必须仅使用位置参数编写函数调用。我没有确认这一点，但我怀疑您是否可以使用条件导入或评估。我是不确定如何处理多态性...

无论如何，如果您不想事后混淆庞大的代码库，或者理想情况下如果您一开始就考虑使用 Cython，这是一个非常值得注意的选择。

Answer 5

您可以嵌入代码并从C/C++程序编译/运行. 在另一个应用程序中嵌入Python

embedded.c

#include <Python.h>

int
main(int argc, char *argv[])
{
  Py_SetProgramName(argv[0]);  /* optional but recommended */
  Py_Initialize();
  PyRun_SimpleString("print('Hello world !')");
  Py_Finalize();
  return 0;
}

在ubuntu,debian

$ sudo apt-get install python-dev

在centos,redhat,fedora

$ sudo yum install python-devel

编译

$ gcc -o embedded -fPIC -I/usr/include/python2.7 -lpython2.7 embedded.c

跟着跑

$ chmod u+x ./embedded
$ time ./embedded
Hello world !

real  0m0.014s
user  0m0.008s
sys 0m0.004s

hello_world.py:

print('Hello World !')

运行python脚本

$ time python hello_world.py
Hello World !

real  0m0.014s
user  0m0.008s
sys 0m0.004s

但是,可以在编译的.c文件中找到python代码的某些字符串

$ grep "Hello" ./embedded
Binary file ./embedded matches

$ grep "Hello World" ./embedded
$

如果您想要额外的安全性,可以在代码上使用base64

...
PyRun_SimpleString("import base64\n"
                  "base64_code = 'your python code in base64'\n"
                  "code = base64.b64decode(base64_code)\n"
                  "exec(code)");
...

例如:

创建代码的base 64字符串

$ base64 hello_world.py
cHJpbnQoJ0hlbGxvIFdvcmxkICEnKQoK

embedded_base64.c

#include <Python.h>

int
main(int argc, char *argv[])
{
  Py_SetProgramName(argv[0]);  /* optional but recommended */
  Py_Initialize();
  PyRun_SimpleString("import base64\n"
                    "base64_code = 'cHJpbnQoJ0hlbGxvIFdvcmxkICEnKQoK'\n"
                    "code = base64.b64decode(base64_code)\n"
                    "exec(code)\n");
  Py_Finalize();
  return 0;
}

所有命令

$ gcc -o embedded_base64 -fPIC -I/usr/include/python2.7 -lpython2.7 ./embedded_base64.c
$ chmod u+x ./embedded_base64

$ time ./embedded_base64
Hello World !

real  0m0.014s
user  0m0.008s
sys 0m0.004s

$ grep "Hello" ./embedded_base64
$

Answer 6

好吧,如果你想制作一个半混淆的代码,你可以像这样编写代码:

import base64
import zlib
def run(code): exec(zlib.decompress(base64.b16decode(code)))
def enc(code): return base64.b16encode(zlib.compress(code))

并制作这样的文件(使用上面的代码):

f = open('something.py','w')
f.write("code=" + enc("""
print("test program")
print(raw_input("> "))"""))
f.close()

文件"something.py":

code = '789CE352008282A2CCBC120DA592D4E212203B3FBD28315749930B215394581E9F9957500A5463A7A0A4A90900ADFB0FF9'

只需导入"something.py"并运行run(something.code)以运行文件中的代码.

一个技巧是使代码难以通过设计阅读:永远不记录任何内容,如果必须,只需提供函数的输出,而不是它的工作方式.使变量名称非常广泛,电影参考或对立的例子:btmnsfavclr = 16777215其中" btmnsfavclr"表示"蝙蝠侠最喜欢的颜色",值为16777215或ffffff"或"的十进制形式.请记住混合不同风格的命名,以保持代码中那些讨厌的人.此外,使用本网站上的提示:开发不可维护代码的十大提示.

Answer 7

查看这些用于混淆和缩小python 代码的工具：

• pyarmor，https : //pypi.org/project/pyarmor/ - 十六进制编码的完全混淆；显然不允许只对变量/函数名称进行部分混淆
• python-minifier，https ://pypi.org/project/python-minifier/ - 缩小代码并混淆函数/变量名称（虽然不像下面的 pyminifier 那样强烈）
• pyminifier，https : //pypi.org/project/pyminifier/ - 在混淆函数、变量、文字的名称方面做得很好；也可以执行类似于 pyarmor 的十六进制编码（压缩）。问题：混淆后的代码可能包含语法错误并且无法运行。

使用 --obfuscate 和 --gzip 运行时 pyminifier 的示例 .py 输出：

$ pyminifier --obfuscate --gzip /tmp/tumult.py

#!/usr/bin/env python3
import zlib, base64
exec(zlib.decompress(base64.b64decode('eJx1kcFOwzAMhu95ClMO66apu0/KAQEbE5eJC+IUpa27haVJ5Ljb+vakLYJx4JAoiT/7/+3c3626SKvSuBW6M4Sej96Jq9y1wRM/E3kSexnIOBZObrSNKI7Sl59YsWDq1wLMiEKNrenoYCqB1woDwzXF9nn2rskZd1jDh+9mhOD8DVvAQ8WdtrZfwg74aNwp7ZpnMXHUaltk878ybR/ZNKbSjP8JPWk6wdn72ntodQ8lQucIrdGlxaHgq3QgKqtjhCY/zlN6jQ0oZZxhpfKItlkuNB3icrE4XYbDwEBICRP6NjG1rri3YyzK356CtsGwZuNd/o0kYitvrBd18qgmj3kcwoTckYPtJPAyCVzSKPCMNErs85+rMINdp1tUSspMqVYbp1Q2DWKTJpcGURRDr9DIJs8wJFlKq+qzZRaQ4lAnVRuJgjFynj36Ol7SX/iQXr8ANfezCw==')))
# Created by pyminifier.py (https://github.com/liftoff/pyminifier)

这个输出对应于40行的原始输入脚本如图这里。

Answer 8

也许你可以试试pyconcrete

加密.pyc到.pye解密进口它的时候

通过库OpenAES加密和解密

用法

完全加密

• 把你所有的转换.py成*.pye

  $ pyconcrete-admin.py compile --source={your py script}  --pye
  $ pyconcrete-admin.py compile --source={your py module dir} --pye
  

• 删除*.py *.pyc或复制*.pye到其他文件夹

• main .py加密为主 .pye,无法正常执行python.您必须使用pyconcrete来处理主 .pye脚本. pyconcrete(exe)将安装在您的系统路径中(例如:/ usr/local/bin)

  pyconcrete main.pye
  src/*.pye  # your libs
  

部分加密(pyconcrete as lib)

• 下载pyconcrete源并通过setup.py安装

  $ python setup.py install \
    --install-lib={your project path} \
    --install-scripts={where you want to execute pyconcrete-admin.py and pyconcrete(exe)}
  

• 在主脚本中导入pyconcrete

• 推荐项目布局

  main.py       # import pyconcrete and your lib
  pyconcrete/*  # put pyconcrete lib in project root, keep it as original files
  src/*.pye     # your libs
  

Answer 9

有多种方法可以混淆代码。这里只是一个例子：

(lambda _, __, ___, ____, _____, ______, _______, ________:
    getattr(
        __import__(True.__class__.__name__[_] + [].__class__.__name__[__]),
        ().__class__.__eq__.__class__.__name__[:__] +
        ().__iter__().__class__.__name__[_____:________]
    )(
        _, (lambda _, __, ___: _(_, __, ___))(
            lambda _, __, ___:
                chr(___ % __) + _(_, __, ___ // __) if ___ else
                (lambda: _).func_code.co_lnotab,
            _ << ________,
            (((_____ << ____) + _) << ((___ << _____) - ___)) + (((((___ << __)
            - _) << ___) + _) << ((_____ << ____) + (_ << _))) + (((_______ <<
            __) - _) << (((((_ << ___) + _)) << ___) + (_ << _))) + (((_______
            << ___) + _) << ((_ << ______) + _)) + (((_______ << ____) - _) <<
            ((_______ << ___))) + (((_ << ____) - _) << ((((___ << __) + _) <<
            __) - _)) - (_______ << ((((___ << __) - _) << __) + _)) + (_______
            << (((((_ << ___) + _)) << __))) - ((((((_ << ___) + _)) << __) +
            _) << ((((___ << __) + _) << _))) + (((_______ << __) - _) <<
            (((((_ << ___) + _)) << _))) + (((___ << ___) + _) << ((_____ <<
            _))) + (_____ << ______) + (_ << ___)
        )
    )
)(
    *(lambda _, __, ___: _(_, __, ___))(
        (lambda _, __, ___:
            [__(___[(lambda: _).func_code.co_nlocals])] +
            _(_, __, ___[(lambda _: _).func_code.co_nlocals:]) if ___ else []
        ),
        lambda _: _.func_code.co_argcount,
        (
            lambda _: _,
            lambda _, __: _,
            lambda _, __, ___: _,
            lambda _, __, ___, ____: _,
            lambda _, __, ___, ____, _____: _,
            lambda _, __, ___, ____, _____, ______: _,
            lambda _, __, ___, ____, _____, ______, _______: _,
            lambda _, __, ___, ____, _____, ______, _______, ________: _
        )
    )
)

Answer 10

我会像这样掩盖代码:

def MakeSC():
    c = raw_input(" Encode: ")
    sc = "\\x" + "\\x".join("{0:x}".format(ord(c)) for c in c)
    print "\n shellcode =('" + sc + "'); exec(shellcode)"; MakeSC();

明文:

import os; os.system("whoami")

编码:

Payload = ('\x69\x6d\x70\x6f\x72\x74\x20\x6f\x73\x3b\x20\x6f\x73\x2e\x73\x79\x73\x74\x65\x6d\x28\x22\x77\x68\x6f\x61\x6d\x69\x22\x29'); exec(Payload);

Answer 11

试试这个 python 混淆器：

pyob.oxyry.com pyob.oxyry.c

__all__ = ['foo']

a = 'a'
_b = 'b'

def foo():
    print(a)

def bar():
    print(_b)

def _baz():
    print(a + _b)

foo()
bar()
_baz()

将翻译为

__all__ =['foo']#line:1
OO00OO0OO0O00O0OO ='a'#line:3
_O00OO0000OO0O0O0O ='b'#line:4
def foo ():#line:6
    print (OO00OO0OO0O00O0OO )#line:7
def O0000000OOOO00OO0 ():#line:9
    print (_O00OO0000OO0O0O0O )#line:10
def _OOO00000O000O0OOO ():#line:12
    print (OO00OO0OO0O00O0OO +_O00OO0000OO0O0O0O )#line:13
foo ()#line:15
O0000000OOOO00OO0 ()#line:16
_OOO00000O000O0OOO ()#line:17

Answer 12

最好的方法是先生成一个 .c 文件，然后用 tcc 编译成 .pyd 文件
注意：仅限 Windows

要求

1. tcc
2. 混淆
3. 赛通

安装：

sudo pip install -U cython

混淆你的 .py 文件：

pyobfuscate.py myfile.py >obfuscated.py

要生成 .c 文件，

1. init<filename>()向您的 .py 文件添加一个函数可选

2. cython --embed file.py

3. cp Python.h tcc\include

4. tcc file.c -o file.pyd -shared -I\path\to\Python\include -L\path\to\Python\lib

5. 将 .pyd 文件导入 app.exe

Answer 13

我知道这是一个老问题。只是想添加我有趣的混淆“Hello world！” 在 Python 3 和一些技巧;)

#//'written in c++'

#include <iostream.h>
#define true false
import os
n = int(input())
_STACK_CALS=  [ ];
_i_CountCals__= (0x00)
while os.urandom(0x00 >> 0x01) or (1 & True):
  _i_CountCals__+= 0o0;break;# call shell command echo "hello world" > text.txt
""#print'hello'
__cal__= getattr( __builtins__  ,'c_DATATYPE_hFILE_radnom'[ 0x00 ]+'.h'[-1]+'getRndint'[3].lower() )
_o0wiXSysRdrct   =eval (  __cal__(0x63) + __cal__(104) + 'r_RUN_CALLER'[0] );
_i1CLS_NATIVE=  getattr (__builtins__ ,__cal__(101)+__cal__(118  )+_o0wiXSysRdrct ( 0b1100001 )+'LINE 2'[0].lower( ))#line 2 kernel call
__executeMAIN_0x07453320abef  =_i1CLS_NATIVE ( 'map');
def _Main():
    raise 0x06;return 0 # exit program with exit code 0
def _0o7af():_i1CLS_NATIVE('_int'.replace('_', 'programMain'[:2]))(''.join(  __executeMAIN_0x07453320abef( _o0wiXSysRdrct ,_STACK_CALS)));return;_Main()
for _INCREAMENT in [0]*1024:
    _STACK_CALS= [0x000 >> 0x001 ,True&False&True&False ,'c++', 'h', 'e', 'l', 'o',' ', 'w', 'o', 'r', 'l', 'd']
   
#if
for _INCREAMENT in [0]*1024:
    _STACK_CALS= [40, 111, 41, 46, 46] * n
    
""""""#print'word'
while True:
    break;
_0o7af();
while os.urandom(0x00 >> 0xfa) or (1 & True): # print "Hello, world!"
  _i_CountCals__-= 0o0;break;
  while os.urandom(0x00 >> 0x01) or (1 & True):
      _i_CountCals__ += 0o0;
      break;

可以手动完成，我的提示是：

• 使用eval和/或exec加密字符串

• 使用[ord(i) for i in s]/''.join(map(chr, [list of chars goes here]))作为简单的加密/解密

• 使用晦涩的变量名

• 让它不可读

• 不要只写 1 或 True，写1&True&0x00000001;)

• 使用不同的数字系统

• 在第 10 行添加诸如“第 2 行”或在 while 循环中“它返回 0”等令人困惑的注释。

• 用 __builtins__

• 使用getattr和setattr

Answer 14

努伊特卡

我真的会推荐Nuitka 而不是 Cython。Nuitka 还将 Python 编译为本地平台代码，提供与编译的 C 代码类似的混淆级别。

python -m pip install nuitka
python -m nuitka --follow-imports --include-package urllib3.util.ssl_ myprogram.py
./myprogram.bin

• --follow-imports 在包含所有导入的模块方面做得很好。
• --include-package 如果某些导入被隐藏并且在启动编译程序时丢失，传递额外的包会很有帮助。

添加标志--onefile或者-standalone这是否适用于获取要分发的包。

我也在pyarmor这里使用了referenced，但是作为核心的pytransform.soorpytransform.dll共享对象pyarmor是闭源的，这在我的项目中是一个障碍。

Answer 15

也许您应该考虑使用诸如truecrypt卷之类的简单内容进行源代码存储，因为这似乎是您的关注点。您可以在USB密钥上创建加密文件，也可以仅加密整个卷（前提是代码适合），因此您可以在一天结束时随身携带密钥。

为了进行编译，您可以使用PyInstaller或py2exe之类的东西来创建独立的可执行文件。如果您真的想加倍努力，请查看打包程序或压缩实用程序，以增加更多的混淆。如果这些都不是选项，那么您至少可以将脚本编译为字节码，以使其无法立即读取。请记住，这些方法只会减慢尝试调试或反编译程序的人员的速度。

Answer 16

我最近偶然发现了此博文：使用AST进行Python源混淆，作者在其中讨论了使用内置AST模块进行python源文件混淆。编译后的二进制文件将用于HitB CTF，因此具有严格的混淆要求。

由于您可以访问单个AST节点，因此使用此方法可以对源文件执行任意修改。根据您执行的转换，所生成的二进制文件可能/可能不会与未混淆的源代码完全不同。

Answer 17

欧派

https://github.com/QQuick/Opy

Opy 将免费混淆您广泛的、真实的、多模块的 Python 源代码！您可以通过编辑配置文件来为每个项目选择要混淆的内容和不混淆的内容：

You can recursively exclude all identifiers of certain modules from obfuscation.
You can exclude human readable configuration files containing Python code.
You can use getattr, setattr, exec and eval by excluding the identifiers they use.
You can even obfuscate module file names and string literals.
You can run your obfuscated code from any platform.

与发布的其他一些选项不同，这适用于 Python 2 和 3！它也是免费/开源的，并且它不像其他一些工具那样仅是在线工具（除非您付费）。

诚然，我自己仍在评估这一点，但它的所有初始测试都运行良好。看来这正是我要找的！

官方版本作为一个独立的实用程序运行，最初的设计是将脚本放入要混淆的目录的根目录中，以及一个用于定义要使用的详细信息/选项的配置文件。我不喜欢那个计划，所以我从项目中添加了一个分支，允许您从库中导入和使用该工具。这样，您可以将其直接滚动到更全面的打包脚本中。（您当然可以在 bash/batch 中包装多个 py 脚本，但我认为纯 python 解决方案是理想的）。我要求将我的 fork 合并到原始作品中，但万一没有发生，这里是我修改后的版本的 url：

https://github.com/BuvinJT/Opy