我正在寻找如何隐藏我的Python源代码。
print "hello World !"
如何对此示例进行编码，使其不具有人类可读性？我被告知使用base64，但我不确定如何。
答案 0 :(得分：55)
这只是一个有限的第一级混淆解决方案，但它是内置的：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模块）。
答案 1 :(得分：33)
所以它不是人类可读的吗？
我的意思是所有文件都已编码!!当你打开它时你什么都听不懂..！那就是我想要的
作为最大值，您可以将源代码编译为字节码，然后只分发字节码。但即使这是可逆的。字节码可以反编译成半可读源。
对于任何人来说，Base64都很容易解码，所以它不能作为实际保护，只能从完全的PC文盲中“隐藏”来源。此外，如果您计划以任何方式实际运行该代码，您必须将解码器包含在脚本中（或您的发行版中的另一个脚本，需要由合法用户运行），这会立即泄露您的编码/加密
混淆技术通常涉及注释/文档剥离，名称修改，垃圾代码插入等等，因此即使您反编译字节码，您也不会获得非常可读的来源。但是它们仍然是Python的源代码，Python并不擅长变得难以理解的混乱。
如果您绝对需要保护某些功能，我建议使用编译语言，如C或C ++，编译和分发.so / .dll，然后使用Python绑定到受保护的代码。
答案 2 :(得分：22)
您可以使用base64 module对字符串进行编码以停止shoulder surfing，但如果他们有权访问您的文件，则不会阻止某人找到您的代码。
然后，您可以在解码后使用compile() function和eval() function执行代码。
>>> 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()的第二个脚本，该脚本可能包含编码脚本作为triple quotes中包含的字符串文字。所以它看起来像这样：
import base64
myscript = """IyBUaGlzIGlzIGEgc2FtcGxlIFB5d
GhvbiBzY3JpcHQKcHJpbnQgIkhlbG
xvIiwKcHJpbnQgIldvcmxkISIK"""
eval(compile(base64.b64decode(myscript),'<string>','exec'))
答案 3 :(得分：10)
您可以嵌入代码并从C / C ++程序编译/运行。 Embedding Python in Another Application
<强> 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
但是，python代码的某些字符串可以在编译的.c文件中找到
$ 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)");
...
e.g：
创建代码的基本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
$
答案 4 :(得分：9)
也许你可以试试pyconcrete
将.pyc加密为.pye并在导入时解密
加密＆amp;由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加密为 main .pye，它不能由普通python执行。
您必须使用pyconcrete来处理主 .pye脚本。
pyconcrete（ exe ）将安装在您的系统路径中（例如：/ usr / local / bin）
pyconcrete main.pye
src/*.pye # your libs
下载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
答案 5 :(得分：8)
好吧，如果你想制作一个半混淆的代码，你可以像这样编写代码：
import zlib, base64
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()
file＆＃34; something.py＆＃34;：
code = '789CE352008282A2CCBC120DA592D4E212203B3FBD28315749930B215394581E9F9957500A5463A7A0A4A90900ADFB0FF9'
只需导入＆＃34; something.py＆＃34;并运行run(something.code)以运行文件中的代码。
一个技巧是使代码难以通过设计阅读：永远不记录任何内容，如果必须，只需提供函数的输出，而不是它的工作方式。使变量名称非常宽泛，电影参考或对立示例：btmnsfavclr = 16777215其中＆＃34; btmnsfavclr＆＃34;意味着＆＃34;蝙蝠侠最喜欢的颜色＆＃34;值为16777215或＆＃34; ffffff＆＃34;的小数形式;或白色。请记住混合不同风格的命名，以保持代码中那些讨厌的人。另外，请使用此网站上的提示：Top 11 Tips to Develop Unmaintainable Code。
答案 6 :(得分：8)
我会掩盖这样的代码：
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);
答案 7 :(得分：4)
我最近偶然发现了这篇博文：Python Source Obfuscation using ASTs，其中作者使用内置AST模块讨论了python源文件混淆。编译后的二进制文件将用于HitB CTF，因此具有严格的混淆要求。
由于您可以访问各个AST节点，因此使用此方法可以对源文件执行任意修改。根据您执行的转换，生成的二进制文件可能/可能与非模糊源完全不同。
答案 8 :(得分：3)
也许您应该考虑使用简单的truecrypt volume这样的源代码存储，因为这似乎是您的关注点。您可以在USB密钥上创建加密文件，或者只加密整个卷（只要代码适合），这样您就可以在一天结束时随身携带密钥。
要进行编译，您可以使用PyInstaller或py2exe之类的内容来创建独立的可执行文件。如果您真的想加倍努力，请查看packer or compression utility以添加更多混淆。如果这些都不是一个选项，您至少可以将脚本编译为字节码，因此不能立即读取。请记住，这些方法只会减慢试图调试或反编译程序的人的速度。
答案 9 :(得分：2)
正如其他答案所说，实际上并没有任何好处。 Base64可以解码。字节码可以反编译。 Python最初只是被解释，并且大多数解释语言试图加速机器解释而不是使人类解释变得困难。
Python被认为是可读和可共享的，而不是混淆的。关于如何格式化代码的语言决策是为了提高不同作者的可读性。
模糊python代码并不真正与语言相匹配。重新评估您混淆代码的原因。
答案 10 :(得分：2)
试试这个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
答案 11 :(得分：2)
Cython
似乎，答案是Cython。我真的很惊讶，没有人提到这个吗？这是主页：https://cython.org/
简而言之，这会将您的python转换为C并对其进行编译，从而使其与任何“常规”编译后的可分发C程序一样受到良好的保护。尽管有一些限制。我本人并没有深入探讨它们，因为当我开始阅读它们时，我出于自己的目的放弃了这个想法。但是它可能仍然对您有用。本质上，您无法充分利用Python，因为它提供了动态的功能。引起我注意的一个主要问题是关键字参数不可用:(您必须仅使用位置参数编写函数调用。我没有确认这一点，但是我怀疑您可以使用条件导入或eval。不确定如何处理多态性...
无论如何，如果您不想在事实发生后混淆庞大的代码库，或者理想情况下，如果您一开始就考虑使用Cython，这是一个非常值得注意的选择。
答案 12 :(得分：1)
我知道这是一个老问题。只想添加我有趣的，模糊的“ 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
答案 13 :(得分：1)
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 ！它也是免费的/开源的，并且它不是像其中一些其他工具那样仅用于在线的工具（除非您付费）。
我承认我自己仍然对此进行评估，但是对其进行的所有初始测试均能完美完成。看来这正是我想要的！
正式版本可作为独立实用程序运行，其最初的预期设计是将脚本放入要混淆的目录的根目录，并附带一个配置文件以定义要使用的详细信息/选项。我不喜欢那个计划，所以我从项目中添加了一个fork，让您可以从库中导入和使用该工具。这样，您可以将其直接滚动到更具包容性的打包脚本中。 （您当然可以在bash / batch中包装多个py脚本，但我认为纯Python解决方案是理想的）。我要求将叉子合并到原始作品中，但是如果万一从未发生，这是我修订版的网址：
答案 14 :(得分：1)
查看以下工具以进行python代码的混淆和最小化：
使用--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)
该输出对应于here所示的40行原始输入脚本。
答案 15 :(得分：0)
我真的会推荐 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 如果在启动编译程序时某些导入被隐藏并且丢失，则传递额外的包会很有帮助。我也使用了此处引用的 pyarmor，但是作为 pytransform.so 核心的 pytransform.dll 或 pyarmor 共享对象是闭源的，这在我的项目中是一个障碍.
答案 16 :(得分：0)
现在只需使用pyarmor库，大多数解决方案已经很老了，pyarmor是新的，在大型代码花瓶上也很简单有效..
要知道如何使用它，请访问下面的链接（只有一分钟的视频，没有比这更简单的了）
答案 17 :(得分：0)
这是我在 CircuitPython 中所做的事情的非常菜鸟方法。这是不完整的 ATM，但我认为它可能有用。诚然，它不会混淆像 cv2.imread 这样简单的东西。完成后我会更新。
代码变成这样
print("Hello World!")...变成这样的代码：
degreeIncrement = 90
durationIncrement = 0.25
def GetEditGlyphParams(self, waveform, editIndex):
segments = waveform.leftSegments
waveformFunctionCount = len(self.waveformFunctions)
totalParameterCount = 0
segmentIndex = 0
while segmentIndex < len(segments):
segment = segments[segmentIndex]
segmentParameterCount = len(self.sineFunctions)
if segment.type == "line":
segmentParameterCount = len(self.lineFunctions)
如有必要，可以省略注释。
这是执行此操作的代码：
a6 = 90 # degreeIncrement = 90
a7 = 0.25 # durationIncrement = 0.25
def a8(a9, a10, a11): # def GetEditGlyphParams(self, waveform, editIndex):
a12 = a10.leftSegments # segments = waveform.leftSegments
a13 = len(a9.a5) # waveformFunctionCount = len(self.waveformFunctions)
a14 = 0 # totalParameterCount = 0
a15 = 0 # segmentIndex = 0
while a15 < len(a12): # while segmentIndex < len(segments):
a16 = a12[a15] # segment = segments[segmentIndex]
a17 = len(a9.a3) # segmentParameterCount = len(self.sineFunctions)
if a16.a332 == "line": # if segment.type == "line":
a17 = len(a9.a4) # segmentParameterCount = len(self.lineFunctions)
答案 18 :(得分：0)
执行此操作的最佳方法是先生成一个c文件，然后
用tcc将其编译为a。 Pyd文件
注意：这是仅Windows修复程序
要求
1.tcc（可以从 here 下载）
2.pyobfuscate（可以从 here 下载）
3.Cython
要安装此内容
pip install cython
要模糊化.py文件，请使用pyobfuscate。
通过在cmd中执行
pyobfuscate.py myfile.py > obfuscated.py
现在继续下一步
要生成.c文件，请遵循以下步骤
1.将初始化函数添加到您的.py文件中。
2。在cmd上执行以下命令，替换参数
cython --embed <file.py>
3。现在下载tcc。
4.将python包含复制到tcc包含。
执行如下所示的命令
tcc <myfile>.c -o <pyd file name>.pyd -shared -I<python include> -L<python lib>
5。就是这样，您拥有一个.pyd文件，您可以将其导入到您的应用程序中。
6. pyd文件很难进行逆向工程。
7.您可以制作所有重要功能的pyd文件，然后将其导入您的应用程序中。
8.只需导入pyd文件并为您的应用程序创建一个.exe。
9.您完成了
答案 19 :(得分：0)
将python源文件编译为代码对象
char * filename = "xxx.py";
char * source = read_file( filename );
PyObject *co = Py_CompileString( source, filename, Py_file_input );
迭代代码对象，将每个代码对象的字节码包装为以下格式
0 JUMP_ABSOLUTE n = 3 + len(bytecode)
3
...
... Here it's obfuscated bytecode
...
n LOAD_GLOBAL ? (__armor__)
n+3 CALL_FUNCTION 0
n+6 POP_TOP
n+7 JUMP_ABSOLUTE 0
序列化代码对象并对其进行模糊处理
char *original_code = marshal.dumps( co );
char *obfuscated_code = obfuscate_algorithm( original_code );
创建包装脚本“xxx.py”， $ {obfuscated_code} 代表上一步中生成的字符串常量。
__pyarmor__(__name__, b'${obfuscated_code}')
导入或运行此包装脚本时，第一个语句是调用一个CFunction：
int __pyarmor__(char *name, unsigned char *obfuscated_code)
{
char *original_code = resotre_obfuscated_code( obfuscated_code );
PyObject *co = marshal.loads( original_code );
PyObject *mod = PyImport_ExecCodeModule( name, co );
}
此函数接受2个参数：模块名称和模糊代码，然后
导入模块后，调用此模块中的任何代码对象 第一次，从上面描述的包装字节码，我们 知道
第一个操作是JUMP_ABSOLUTE，它会跳转到偏移量n
在偏移量n处，指令是调用PyCFunction。这个功能 将在偏移3和n之间恢复那些混淆的字节码，并且 将原始字节码放在偏移0
函数调用后，最后一条指令是跳转到 offset 0.现在真正执行字节码。
请参阅Pyarmor
答案 20 :(得分：0)
有多种方法可以混淆代码。这只是一个例子：
(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 _, __, ___, ____, _____, ______, _______, ________: _
)
)
)
答案 21 :(得分：0)
尝试将您的hello world python代码粘贴到以下站点：
http://enscryption.com/encrypt-and-obfuscate-scripts.html
它将为您生成一个复杂的加密和混淆但功能齐全的脚本。看看你是否可以破解脚本并揭示实际代码。或者看看它提供的复杂程度是否满足您的安心需求。
通过此站点为您生成的加密脚本应该适用于安装了python的任何Unix系统。
如果您想以其他方式加密，我强烈建议您编写自己的加密/混淆算法（如果安全性对您很重要）。这样，除了你，没有人能弄清楚它是如何工作的。但是，为了真正发挥作用，你必须花费大量的时间来确保它没有任何漏洞，那些有很多时间在手上的人可以利用它。并确保使用Unix系统已经很自然的工具...即openssl或base64。这样，您的加密脚本更具可移植性。
答案 22 :(得分：0)
我会以教学方式写下我的答案......
首先输入你的Python解释器：
import this
然后，去查看Python发行版中Lib目录中的文件this.py，并尝试了解它的作用。
之后，请查看文档中的eval函数：
help(eval)
现在你应该找到一种有趣的方法来保护你的代码。但要注意，因为这只适用于那些不如你聪明的人！ （而且我不是要冒犯，任何足够聪明的人都能理解你所做的事情可以逆转它。）