¿Ocultando el código de Python?

Estoy buscando cómo ocultar mi código fuente de Python.

print "hello World !" 

¿Cómo puedo codificar este ejemplo para que no se pueda leer? Me han dicho que use base64 pero no estoy seguro de cómo.

Esta es solo una solución de ofuscación limitada de primer nivel, pero está integrada: Python tiene un comstackdor para el código de bytes:

 python -OO -m py_compile  

produce un archivo .pyo que contiene el código de bytes y donde se eliminan las cadenas de documentación, etc. Puede cambiar el nombre del archivo .pyo con una extensión .py , y python ejecuta como su progtwig pero no contiene su fuente código.

PD : el nivel “limitado” de ofuscación que se obtiene es tal que se puede recuperar el código (con algunos de los nombres de las variables, pero sin comentarios y cadenas de documentación). Vea el primer comentario, para saber cómo hacerlo. Sin embargo, en algunos casos, este nivel de ofuscación puede considerarse suficiente.

PPS : Si su progtwig importa módulos ofuscados de esta manera, entonces necesita cambiarles el nombre con un sufijo .pyc (no estoy seguro de que esto no se rompa un día), o puede trabajar con .pyo y ejecutarlos con python -O ….pyo (las importaciones deberían funcionar). Esto permitirá a Python encontrar sus módulos (de lo contrario, Python busca los módulos .py ).

¿Para que no sea legible por humanos?

Quiero decir que todo el archivo está codificado! cuando lo abres no puedes entender nada ..! que lo que quiero

Como máximo, puede comstackr sus fonts en bytecode y luego distribuir solo bytecode. Pero incluso esto es reversible. Bytecode puede ser descomstackdo en fonts semi-legibles.

Base64 es trivial para decodificar para cualquier persona, por lo que no puede servir como protección real y “ocultará” las fonts solo de los analfabetos de PC completos. Además, si planea ejecutar ese código por cualquier medio, tendría que incluir el descodificador directamente en el script (u otro script en su distribución, que tendría que ser ejecutado por un usuario legítimo), y eso le daría de inmediato su encoding / encriptación.

Las técnicas de ofuscación por lo general implican eliminación de comentarios / documentos, modificación de nombres, inserción de código de basura, etc., por lo que incluso si descomstack el código de bytes, obtendrá fonts poco legibles. Sin embargo, serán fonts de Python y Python no es bueno para convertirse en un desastre ilegible.

Si absolutamente necesita proteger alguna funcionalidad, sugeriría ir con lenguajes comstackdos, como C o C ++, comstackr y distribuir .so / .dll, y luego usar enlaces de Python para proteger el código.

Puede usar el módulo base64 para codificar cadenas para detener la navegación por los hombros , pero no va a impedir que alguien encuentre su código si tiene acceso a sus archivos.

Luego puede usar la función compile() y la función eval() para ejecutar su código una vez que lo haya descodificado.

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

Entonces, si tiene 30 líneas de código, probablemente querrá cifrarlo haciendo algo como esto:

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

Luego necesitaría escribir un segundo script que compile() y eval() que probablemente incluiría el script codificado como una cadena literal encerrada entre comillas triples . Así se vería algo así:

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

Podría insertar su código y comstackr / ejecutar desde un progtwig C / C ++. Incrustar Python en otra aplicación

embebido.c

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

En ubuntu, debian

 $ sudo apt-get install python-dev 

En centos, redhat, fedora

 $ sudo yum install python-devel 

comstackr con

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

corre con

 $ chmod u+x ./embedded $ time ./embedded Hello world ! real 0m0.014s user 0m0.008s sys 0m0.004s 

hello_world.py:

 print('Hello World !') 

ejecutar el script de python

 $ time python hello_world.py Hello World ! real 0m0.014s user 0m0.008s sys 0m0.004s 

sin embargo, algunas cadenas del código python se pueden encontrar en el archivo .c comstackdo

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

En caso de que desee un poco más de seguridad, puede usar base64 en su código

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

p.ej:

Crea la cadena base 64 de tu código

 $ base64 hello_world.py cHJpbnQoJ0hlbGxvIFdvcmxkICEnKQoK 

embedded_base64.c

 #include  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; } 

todos los comandos

 $ 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 $ 

Tal vez usted puede probar en pyconcrete

.pye a .pye y descifre cuando lo importe

Cifrar y descifrar por la biblioteca OpenAES

Uso

Cifrado completo

  • convierte todo tu .py a *.pye

     $ pyconcrete-admin.py compile --source={your py script} --pye $ pyconcrete-admin.py compile --source={your py module dir} --pye 
  • eliminar *.py *.pyc o copiar *.pye a otra carpeta

  • .py encriptado como .pye principal , no puede ser ejecutado por python normal. Debe usar pyconcrete para procesar el script principal .pye. pyconcrete ( exe ) se instalará en la ruta de su sistema (por ejemplo: / usr / local / bin)

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

Cifrado parcial (pyconcrete como lib)

  • descargue la fuente de pyconcrete e instale por setup.py

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

  • diseño de proyecto de recomendación

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

Bueno, si quieres hacer un código semi-ofuscado, debes hacer un código como este:

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

y haz un archivo como este (usando el código anterior):

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

archivo “algo.py”:

 code = '789CE352008282A2CCBC120DA592D4E212203B3FBD28315749930B215394581E9F9957500A5463A7A0A4A90900ADFB0FF9' 

simplemente importe “something.py” y ejecute run(something.code) para ejecutar el código en el archivo.

Un truco es hacer que el código sea difícil de leer por diseño: nunca documente nada, si es necesario, solo dé el resultado de una función, no cómo funciona. Haga nombres de variables muy amplios, referencias de películas u opuestos ejemplo: btmnsfavclr = 16777215 donde ” btmnsfavclr ” significa “Color favorito de Batman” y el valor es 16777215 o la forma decimal de ” ffffff ” o blanco. Recuerde mezclar diferentes estilos de nombres para mantener a esas personas molestas de su código. Además, use consejos en este sitio: Los 11 consejos principales para desarrollar un código que no se puede mantener .

Yo enmascararía el código así:

 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(); 

Borrar texto:

 import os; os.system("whoami") 

Codificado:

 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); 

Recientemente me topé con este blogpost: Ofthuscation de Python Source usando ASTs, donde el autor habla sobre la ofuscación de archivos de source de Python usando el módulo AST integrado. El binario comstackdo debía usarse para el HitB CTF y, como tal, tenía estrictos requisitos de ofuscación.

Dado que obtiene acceso a nodos AST individuales, el uso de este enfoque le permite realizar modificaciones arbitrarias en el archivo fuente. Dependiendo de las transformaciones que realice, el binario resultante podría / no comportarse exactamente como la fuente no ofuscada.

Tal vez debería considerar el uso de algo simple, como un volumen truecrypt para el almacenamiento de código fuente, ya que eso parece ser una preocupación suya. Puede crear un archivo cifrado en una clave usb o simplemente cifrar todo el volumen (siempre que el código se ajuste) para que pueda llevarse la clave al final del día.

Para comstackr, puedes usar algo como PyInstaller o py2exe para crear un ejecutable independiente. Si realmente quería hacer un esfuerzo adicional, busque un compresor o una utilidad de compresión para agregar más ofuscación. Si ninguno de estos es una opción, al menos podría comstackr el script en un código de bytes para que no se pueda leer de inmediato. Tenga en cuenta que estos métodos simplemente demorarán a alguien que intenta depurar o descomstackr su progtwig.

Como han dicho otras respuestas, realmente no hay una manera que sea buena. Base64 puede ser decodificado. Bytecode puede ser descomstackdo. Python fue inicialmente interpretado, y la mayoría de los lenguajes interpretados intentan acelerar la interpretación de la máquina más que dificultar la interpretación humana.

Python fue hecho para ser legible y compartible, no confuso. Las decisiones de lenguaje sobre cómo se debe formatear el código fueron para promover la legibilidad entre diferentes autores.

La ofuscación del código de Python simplemente no encaja con el lenguaje. Vuelva a evaluar sus razones para ofuscar el código.

Prueba este ofuscador de 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() 

será traducido a

 __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 

Opio

https://github.com/QQuick/Opy

¡Opy ofuscará su extenso código fuente de Python en el mundo real y de múltiples módulos de forma gratuita! Y USTED elige por proyecto qué ofuscar y qué no, editando el archivo de configuración:

 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. 

A diferencia de algunas de las otras opciones publicadas, ¡ esto funciona tanto para Python 2 como para 3 ! También es gratis / de código abierto, y no es una herramienta solo en línea (a menos que usted pague) como algunas otras.

Debo admitir que todavía estoy evaluando esto, pero todas las pruebas iniciales funcionaron perfectamente. ¡Parece que esto es exactamente lo que estaba buscando!

La versión oficial se ejecuta como una utilidad independiente, con el diseño original previsto para que coloque un script en la raíz del directorio que desea ofuscar, junto con un archivo de configuración para definir los detalles / opciones que desea emplear. No estaba enamorado de ese plan, así que agregué un fork del proyecto, lo que te permite importar y utilizar la herramienta desde una biblioteca. De esta forma, puede convertir esto directamente en un script de empaquetado más amplio. (Por supuesto, podría envolver múltiples scripts py en bash / batch, pero creo que una solución de python pura es ideal). Solicité que mi bifurcación se fusionara con el trabajo original, pero en caso de que eso nunca suceda, aquí está la url de mi versión revisada:

https://github.com/BuvinJT/Opy

Cython

Parece que la respuesta goto para esto es Cython. Estoy realmente sorprendido de que nadie haya mencionado esto todavía? Aquí está la página de inicio: https://cython.org/

En pocas palabras, esto transforma tu python en C y lo comstack, lo que lo hace tan protegido como cualquier progtwig de C distribuible “normal” comstackdo.

Aunque hay limitaciones. No los he explorado en profundidad, porque cuando comencé a leer sobre ellos, abandoné la idea para mis propios propósitos. Pero aún podría funcionar para el tuyo. Esencialmente, no puedes usar Python al máximo, con la genialidad dinámica que ofrece. Un problema importante que me llamó la atención fue que los parámetros de palabras clave no son utilizables 🙁 Debes escribir llamadas de función usando solo parámetros posicionales. No lo confirmé, pero dudo que puedas usar importaciones condicionales o evals. No estoy seguro de cómo se maneja el polymorphism …

De todos modos, si no está intentando ofuscar una base de código enorme después del hecho, o idealmente si tiene en mente el uso de Cython, esta es una opción muy notable.

Escribiré mi respuesta de manera didáctica …

Primero escribe en tu intérprete de Python:

 import this 

luego, vaya y eche un vistazo al archivo this.py en su directorio Lib dentro de su distribución de Python y trate de entender lo que hace.

Después de eso, eche un vistazo a la función eval en la documentación:

 help(eval) 

Ahora deberías haber encontrado una forma divertida de proteger tu código. ¡Pero cuidado, porque eso solo funciona para las personas que son menos inteligentes que tú! (Y no estoy tratando de ser ofensivo, cualquiera lo suficientemente inteligente como para entender lo que hiciste podría revertirlo).

Hay múltiples formas de ofuscar el código. Aquí hay un ejemplo:

 (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 _, __, ___, ____, _____, ______, _______, ________: _ ) ) ) 

Intente pegar el código de python de hello world en el siguiente sitio:

http://enscryption.com/encrypt-and-obfuscate-scripts.html

Producirá un script encriptado y ofuscado complejo, pero completamente funcional para usted. Vea si puede descifrar el script y revelar el código real. O vea si el nivel de complejidad que proporciona satisface su necesidad de tranquilidad.

El script encriptado que se produce para usted a través de este sitio debería funcionar en cualquier sistema Unix que tenga instalado Python.

Si desea cifrar de otra manera, le sugiero que escriba su propio algoritmo de cifrado / ofuscación (si la seguridad es tan importante para usted) . De esa manera, nadie puede descubrir cómo funciona, excepto usted. Pero, para que esto realmente funcione, tienes que dedicarle una gran cantidad de tiempo para asegurarte de que no haya lagunas legales que alguien que tenga mucho tiempo en sus manos pueda explotar. Y asegúrese de usar herramientas que ya son naturales para el sistema Unix … es decir, openssl o base64. De esa manera, su script encriptado es más portátil.

Hay 2 formas de ofuscar scripts de python

  • Ofuscar el código de bytes de cada objeto de código
  • Ofuscar todo el código objeto del módulo python

Ofuscar los guiones de Python

  • Comstackr el archivo fuente de Python para codificar el objeto

     char * filename = "xxx.py"; char * source = read_file( filename ); PyObject *co = Py_CompileString( source, filename, Py_file_input ); 
  • Iterar el objeto de código, envolver el código de bytes de cada objeto de código como el siguiente formato

     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 
  • Serializar el objeto de código y ofuscarlo

     char *original_code = marshal.dumps( co ); char *obfuscated_code = obfuscate_algorithm( original_code ); 
  • Crear script de envoltura “xxx.py”, $ {obfuscated_code} representa la constante de cadena generada en el paso anterior.

     __pyarmor__(__name__, b'${obfuscated_code}') 

Ejecutar o importar scripts de Python ofuscados

Cuando importe o ejecute este script contenedor, la primera statement es llamar a 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 ); } 

Esta función acepta 2 parámetros: nombre del módulo y código ofuscado, luego

  • Restaura el código ofuscado
  • Crear un objeto de código por código original
  • Importar módulo original (esto resultará en un marco duplicado en Traceback)

Ejecutar o importar Bytecode ofuscado

Después del módulo importado, cuando se llama por primera vez a cualquier objeto de código en este módulo, a partir del código de bytes envuelto descrito en la sección anterior, lo sabemos

  • La primera operación es JUMP_ABSOLUTE, saltará para compensar n

  • En el offset n, la instrucción es llamar a un PyCFunction. Esta función restaurará los bytecode ofuscados entre el offset 3 y n, y colocará el bytecode original en el offset 0

  • Después de la llamada a la función, la última instrucción es saltar al desplazamiento 0. El código de bytes realmente ahora se ejecuta.

Consulte a Pyarmor

La mejor manera de hacer esto es primero generar un archivo de CA y luego
Compílalo con tcc a. Archivo pyd
Nota: Es un arreglo solo para windows.
Requerimientos
1.tcc (Se puede descargar desde aquí )
2.pyobfuscate (Se puede descargar desde aquí )
3.Cython
Para instalar esta escritura

 pip install cython 

Para ofuscar su archivo .py use pyobfuscate.
Ejecutando esto en cmd.

 pyobfuscate.py myfile.py > obfuscated.py 

Ahora pasa al siguiente paso
Para generar un archivo .c siga los pasos
1.Agregue una función de inicio a su archivo .py.

2. Ejecute el comando siguiente en cmd reemplazando los parámetros

 cython --embed  

3. Ahora descargue el tcc.
4. Copia de python incluye a tcc incluye.
Ejecute el comando que se muestra a continuación

 tcc .c -o .pyd -shared -I -L 

5.Thats tiene un archivo .pyd que puede importar en su aplicación.
6. El archivo pyd es muy difícil de hacer ingeniería inversa.
7.Usted puede hacer un archivo pyd de todas sus funciones importantes y luego importarlo en su aplicación.
8. Simplemente importe el archivo pyd y haga un archivo .exe de su aplicación.
9. has terminado