¿Cómo protejo el código Python?

https://stackoverflow.com/questions/261638

06-07-2019
|

Pregunta

Estoy desarrollando un software en Python que se distribuirá a los clientes de mi empleador. Mi empleador quiere limitar el uso del software con un archivo de licencia de tiempo restringido.

Si distribuimos los archivos .py o incluso los archivos .pyc, será fácil (descompilar y) eliminar el código que verifica el archivo de licencia.

Otro aspecto es que mi empleador no quiere que nuestros clientes lean el código, por temor a que el código pueda ser robado o al menos las "ideas nuevas".

¿Hay una buena manera de manejar este problema? Preferiblemente con una solución lista para usar.

El software se ejecutará en sistemas Linux (así que no creo que py2exe haga el truco).

Solución

Python, al ser un lenguaje interpretado compilado por código de bytes, es muy difícil de bloquear. Incluso si utiliza un paquete exe como py2exe , el diseño del ejecutable es bien conocido y los códigos de bytes de Python son bien entendidos.

Por lo general, en casos como este, debe hacer una compensación. ¿Qué tan importante es realmente proteger el código? ¿Hay secretos reales allí (como una clave para el cifrado simétrico de transferencias bancarias) o simplemente estás siendo paranoico? Elija el lenguaje que le permita desarrollar el mejor producto más rápido y sea realista sobre lo valiosas que son sus nuevas ideas.

Si decide que realmente necesita aplicar la verificación de licencia de forma segura, escríbala como una pequeña extensión C para que el código de verificación de licencia pueda ser muy difícil (¡pero no imposible!) para realizar ingeniería inversa y dejar la mayor parte de su código en Python.

Otros consejos

" ¿Hay una buena manera de manejar este problema? " No. Nada puede protegerse contra la ingeniería inversa. Incluso el firmware en las máquinas de DVD ha sido modificado y clave de cifrado AACS expuesta. Y eso a pesar de que la DMCA lo convirtió en un delito penal.

Dado que ningún método técnico puede impedir que sus clientes lean su código, debe aplicar métodos comerciales comunes.

Licencias. Contratos Términos y Condiciones. Esto todavía funciona incluso cuando las personas pueden leer el código. Tenga en cuenta que algunos de sus componentes basados ??en Python pueden requerir que pague tarifas antes de vender el software que usa esos componentes. Además, algunas licencias de código abierto le prohíben ocultar el origen o los orígenes de ese componente.
Ofrecer un valor significativo. Si sus cosas son tan buenas, a un precio difícil de rechazar, no hay incentivo para perder tiempo y dinero en ingeniería inversa. La ingeniería inversa es costosa. Haga que su producto sea un poco menos costoso.
Ofrece actualizaciones y mejoras que hacen que cualquier ingeniería inversa sea una mala idea. Cuando el próximo lanzamiento rompa su ingeniería inversa, no tiene sentido. Esto puede llevarse a extremos absurdos, pero debe ofrecer nuevas características que hagan que la próxima versión sea más valiosa que la ingeniería inversa.
Ofrezca personalización a precios tan atractivos que preferirían pagarle a usted para construir y soportar las mejoras.
Use una clave de licencia que caduque. Esto es cruel y le dará una mala reputación, pero ciertamente hace que su software deje de funcionar.
Ofrézcalo como un servicio web. SaaS no implica descargas a los clientes.

Python no es la herramienta que necesita

Debe usar la herramienta correcta para hacer lo correcto, y Python no fue diseñado para ofuscarse. Es lo contrario; todo es abierto o fácil de revelar o modificar en Python porque esa es la filosofía del lenguaje.

Si quieres algo que no puedes ver, busca otra herramienta. Esto no es malo, es importante que existan varias herramientas diferentes para diferentes usos.

La ofuscación es realmente difícil

Incluso los programas compilados pueden tener ingeniería inversa, así que no piense que puede proteger completamente cualquier código. Puede analizar PHP ofuscado, romper la clave de cifrado flash, etc. Las versiones más nuevas de Windows se descifran cada vez.

Tener un requisito legal es un buen camino a seguir

No puede evitar que alguien haga un mal uso de su código, pero puede descubrir fácilmente si alguien lo hace. Por lo tanto, es solo un problema legal casual.

La protección del código está sobrevalorada

Hoy en día, los modelos de negocio tienden a vender servicios en lugar de productos. No puede copiar un servicio, piratearlo ni robarlo. Tal vez es hora de considerar seguir la corriente ...

¡Compila python y distribuye binarios!

Idea sensata:

Use Cython , Nuitka , Shed Skin o algo similar para compilar python en código C, luego distribuya su aplicación como python binary bibliotecas (pyd) en su lugar.

De esa manera, no queda ningún código de Python (byte) y ha hecho cualquier cantidad razonable de ocultación que cualquiera (es decir, su empleador) podría esperar del Código normal, creo. (.NET o Java son menos seguros que este caso, ya que ese bytecode no se ofusca y se puede descompilar con relativa facilidad en una fuente razonable).

Cython se está volviendo cada vez más compatible con CPython, así que creo que debería funcionar. (De hecho, estoy considerando esto para nuestro producto. Ya estamos construyendo algunas librerías de terceros como pyd / dlls, por lo que enviar nuestro propio código de Python como binarios no es un paso demasiado grande para nosotros).

Ver Esta publicación de blog (no para mí) para obtener un tutorial sobre cómo hacerlo. (thx @hithwen)

Idea loca:

Probablemente podría hacer que Cython almacene los archivos C por separado para cada módulo, luego simplemente concatenelos todos y compílelos con una gran línea. De esa manera, su módulo Python es bastante monolítico y difícil de usar con herramientas comunes.

Más allá de la locura:

Es posible que pueda construir un solo ejecutable si puede vincular (y optimizar con) el tiempo de ejecución de Python y todas las bibliotecas (dlls) estáticamente. De esa manera, seguramente sería difícil interceptar llamadas a / desde python y cualquier biblioteca de framework que use. Sin embargo, esto no se puede hacer si está utilizando el código LGPL.

Entiendo que desea que sus clientes utilicen el poder de Python, pero no desea exponer el código fuente.

Aquí están mis sugerencias:

(a) Escriba las partes críticas del código como bibliotecas C o C ++ y luego use SIP o swig para exponer las API de C / C ++ al espacio de nombres de Python.

(b) Use cython en lugar de Python

(c) En ambos (a) y (b), debería ser posible distribuir las bibliotecas como binarios con licencia con una interfaz Python.

¿Sabe su empleador que puede "robar"? ¿alguna idea que otras personas obtienen de tu código? Quiero decir, si ellos pueden leer tu trabajo, tú también puedes leer el suyo. Tal vez ver cómo puede beneficiarse de la situación generaría un mejor retorno de su inversión que temer cuánto podría perder.

[EDITAR] Respuesta al comentario de Nick:

Nada ganado y nada perdido. El cliente tiene lo que quiere (y lo pagó desde que él mismo hizo el cambio). Como no publica el cambio, es como si no hubiera sucedido para todos los demás.

Ahora, si el cliente vende el software, tiene que cambiar el aviso de derechos de autor (que es ilegal, por lo que puede demandar y ganará - > caso simple).

Si no cambian el aviso de derechos de autor, los clientes de segundo nivel notarán que el software proviene de usted original y se preguntarán qué está pasando. Lo más probable es que se pongan en contacto con usted, por lo que aprenderá sobre la reventa de su trabajo.

Nuevamente tenemos dos casos: el cliente original vendió solo unas pocas copias. Eso significa que no hicieron mucho dinero de todos modos, entonces, ¿por qué molestarse? O se vendieron en volumen. Eso significa mejores oportunidades para que usted aprenda sobre lo que hacen y hagan algo al respecto.

Pero al final, la mayoría de las empresas intentan cumplir con la ley (una vez que se arruina su reputación, es mucho más difícil hacer negocios). Entonces no le robarán su trabajo, sino que trabajarán con usted para mejorarlo. Entonces, si incluye la fuente (con una licencia que lo protege de la simple reventa), es probable que simplemente rechacen los cambios que hicieron, ya que eso garantizará que el cambio esté en la próxima versión y no tengan que mantenerlo . Eso es ganar-ganar: obtienes cambios y ellos pueden hacer el cambio ellos mismos si realmente lo necesitan desesperadamente, incluso si no estás dispuesto a incluirlo en el lanzamiento oficial.

¿Has echado un vistazo a pyminifier ? Hace Minify, ofusca y comprime el código Python. El código de ejemplo parece bastante desagradable para la ingeniería inversa informal.

$ pyminifier --nonlatin --replacement-length=50 /tmp/tumult.py
#!/usr/bin/env python3
ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲמּ=ImportError
ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ燱=print
ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ巡=False
ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ澨=object
try:
 import demiurgic
except ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲמּ:
 ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ燱("Warning: You're not demiurgic. Actually, I think that's normal.")
try:
 import mystificate
except ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲמּ:
 ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ燱("Warning: Dark voodoo may be unreliable.")
ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲﺬ=ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ巡
class ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ𐦚(ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ澨):
 def __init__(self,*args,**kwargs):
  pass
 def ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ클(self,dactyl):
  ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ퐐=demiurgic.palpitation(dactyl)
  ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ𠛲=mystificate.dark_voodoo(ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ퐐)
  return ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ𠛲
 def ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ𐠯(self,whatever):
  ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ燱(whatever)
if __name__=="__main__":
 ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ燱("Forming...")
 ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲﺃ=ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ𐦚("epicaricacy","perseverate")
 ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲﺃ.ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ𐠯("Codswallop")
# Created by pyminifier (https://github.com/liftoff/pyminifier)

No confíe en la ofuscación. Como ha concluido correctamente, ofrece una protección muy limitada. ACTUALIZACIÓN: Aquí hay un enlace al papel que realizó ingeniería inversa Código de Python ofuscado en Dropbox. El enfoque: la reasignación de opcode es una buena barrera, pero claramente puede ser derrotada.

En cambio, como muchos carteles han mencionado, hazlo:

No vale la pena el tiempo de ingeniería inversa (su software es tan bueno, tiene sentido pagar)
Haz que firmen un contrato y hagan una auditoría de licencia si es posible.

Alternativamente, como lo hace el increíble IDE WingIDE de Python: Regale el código . Así es, regale el código y haga que la gente regrese para actualizaciones y soporte.

El envío de archivos .pyc tiene sus problemas: no son compatibles con ninguna otra versión de Python que no sea la versión con la que se crearon, lo que significa que debe saber qué versión de Python se está ejecutando en los sistemas en los que se ejecutará el producto. Ese es un factor muy limitante.

En algunas circunstancias, es posible mover (todo, o al menos una parte clave) del software a un servicio web que aloja su organización.

De esa forma, las verificaciones de licencia se pueden realizar en la seguridad de su propia sala de servidores.

Aunque no hay una solución perfecta, se puede hacer lo siguiente:

Mueva alguna pieza crítica de código de inicio a una biblioteca nativa.
Aplicar la verificación de licencia en la biblioteca nativa.

Si se eliminara la llamada al código nativo, el programa no se iniciaría de todos modos. Si no se elimina, se aplicará la licencia.

Aunque esto no es una solución multiplataforma o pura de Python, funcionará.

La única forma confiable de proteger el código es ejecutarlo en un servidor que controlas y proporcionar a tus clientes un cliente que interactúe con ese servidor.

Creo que hay un método más para proteger su código Python; parte del método de ofuscación. Creo que hubo un juego como Mount and Blade o algo que cambió y recompiló su propio intérprete de Python (el intérprete original, que creo que es de código abierto) y simplemente cambió los códigos OP en la tabla de códigos OP para ser diferentes al OP Python estándar códigos.

Por lo tanto, la fuente de Python no se modifica, pero las extensiones de archivo de los archivos * .pyc son diferentes y los códigos operativos no coinciden con el intérprete público de python.exe. Si revisó los archivos de datos de los juegos, todos los datos estaban en formato fuente Python.

Se pueden hacer todo tipo de trucos desagradables para meterse con hackers inmaduros de esta manera. Detener a un grupo de hackers sin experiencia es fácil. Son los hackers profesionales los que probablemente no vencerás. Pero imagino que la mayoría de las empresas no mantienen a los hackers profesionales en el personal durante mucho tiempo (probablemente porque las cosas se piratean). Pero los hackers inmaduros están por todas partes (léase como personal curioso de TI).

Podría, por ejemplo, en un intérprete modificado, permitirle verificar ciertos comentarios o cadenas de documentos en su fuente. Podría tener códigos OP especiales para tales líneas de código. Por ejemplo:

OP 234 es para la línea de origen " # Copyright Escribí esto " o compile esa línea en códigos operativos que sean equivalentes a '' si es falso: '' if " # Copyright " Está perdido. Básicamente, deshabilitar todo un bloque de código por lo que parece ser una razón oscura.

Un caso de uso en el que recompilar un intérprete modificado puede ser factible es cuando no escribió la aplicación, la aplicación es grande, pero se le paga para protegerla, como cuando es un administrador de servidor dedicado aplicación.

Me parece un poco contradictorio dejar la fuente o los códigos de operación abiertos para los globos oculares, pero uso SSL para el tráfico de red. SSL tampoco es 100% seguro. Pero se usa para evitar que la mayoría de los ojos lo lean. Una pequeña precaución es sensata.

Además, si suficientes personas consideran que la fuente de Python y los códigos de operación son demasiado visibles, es probable que alguien finalmente desarrolle al menos una herramienta de protección simple para ello. Entonces, cuantas más personas pregunten "cómo proteger la aplicación Python" solo promueve ese desarrollo.

Dependiendo de quién sea el cliente, un mecanismo de protección simple, combinado con un acuerdo de licencia razonable será mucho más efectivo que cualquier sistema complejo de licencia / cifrado / ofuscación.

La mejor solución sería vender el código como un servicio, por ejemplo, alojando el servicio u ofreciendo soporte, aunque eso no siempre es práctico.

Enviar el código como archivos .pyc evitará que su protección sea frustrada por unos pocos # s, pero no es una protección efectiva contra la piratería (como si hubiera tal una tecnología), y al final del día, no debería lograr nada que un acuerdo de licencia decente con la compañía.

Concéntrese en hacer que su código sea lo más agradable posible de usar: tener clientes satisfechos hará que su empresa gane mucho más dinero que evitar alguna piratería teórica.

Utilice Cython . Compilará sus módulos en archivos C de alto rendimiento, que luego se pueden compilar en bibliotecas binarias nativas. ¡Esto es básicamente irreversible, en comparación con el bytecode .pyc!

He escrito un artículo detallado sobre cómo configurar Cython para un proyecto de Python, échale un vistazo:

Protección de fuentes de Python con Cython

Otro intento de hacer que su código sea más difícil de robar es usar jython y luego usar java obfuscator .

Esto debería funcionar bastante bien ya que jythonc traduce el código de Python a Java y luego Java se compila en bytecode. Entonces, si ofuscas las clases, será muy difícil entender lo que está sucediendo después de la descompilación, sin mencionar la recuperación del código real.

El único problema con jython es que no puede usar módulos de Python escritos en c.

¿Qué pasa con la firma de su código con esquemas de cifrado estándar mediante el hash y la firma de archivos importantes y su verificación con métodos de clave pública?

De esta forma, puede emitir un archivo de licencia con una clave pública para cada cliente.

Adicional puede usar un ofuscador de python como este (solo googleado).

Deberías echar un vistazo a cómo los chicos de getdropbox.com lo hacen por su software cliente, incluido Linux. Es bastante difícil de descifrar y requiere un desmontaje bastante creativo para superar los mecanismos de protección.

Me sorprendió no ver pyconcrete en ninguna respuesta. ¿Quizás porque es más nuevo que la pregunta?

Podría ser exactamente lo que necesita (ed).

En lugar de ofuscar el código, lo encripta y descifra en el momento de la carga.

De página de pypi :

Proteger el flujo de trabajo del script de Python


your_script.py import pyconcrete

pyconcrete enganchará el módulo de importación

cuando su script importa MODULE ,   el enlace de importación de Pyconcrete intentará encontrar MODULE.pye primero y luego   descifrar MODULE.pye a través de _pyconcrete.pyd y ejecutar datos descifrados (como   contenido .pyc)

cifrar & amp; descifrar el registro de clave secreta en _pyconcrete.pyd   (como DLL o SO) la clave secreta estaría oculta en código binario, no se puede # 8217; t   verlo directamente en la vista HEX

Lo mejor que puedes hacer con Python es ocultar las cosas.

Retire todas las cadenas de documentos
Distribuya solo los archivos compilados .pyc.
congelarlo
Obscurezca sus constantes dentro de una clase / módulo para que help (config) no muestre todo

Es posible que pueda agregar algo de oscuridad adicional encriptando parte de él y descifrándolo sobre la marcha y pasándolo a eval (). Pero no importa lo que hagas, alguien puede romperlo.

Nada de esto impedirá que un atacante determinado desarme el bytecode o busque en su API con ayuda, dir, etc.

La idea de tener una licencia de tiempo restringido y verificarla en el programa instalado localmente no funcionará. Incluso con una ofuscación perfecta, se puede eliminar la verificación de licencia. Sin embargo, si verifica la licencia en el sistema remoto y ejecuta una parte importante del programa en su sistema remoto cerrado, podrá proteger su IP.

Evitando que los competidores usen el código fuente como propio o escriban su versión inspirada del mismo código, una forma de proteger es agregar firmas a la lógica de su programa (algunos secretos para poder probar que le robaron el código) y ofuscar el código fuente de Python, por lo que es difícil de leer y utilizar.

Una buena ofuscación agrega básicamente la misma protección a su código, que compilarlo en ejecutable (y eliminar binario). Descubrir cómo funciona el código complejo ofuscado puede ser aún más difícil que escribir su propia implementación.

Esto no ayudará a evitar la piratería de su programa. Incluso con el código de ofuscación, las cosas de la licencia se descifrarán y el programa puede modificarse para tener un comportamiento ligeramente diferente (de la misma manera que compilar código en binario no ayuda a la protección de los programas nativos).

Además de la ofuscación de símbolos, puede ser una buena idea no modificar el código, lo que hace que todo sea aún más confuso si, p. los gráficos de llamadas apuntan a muchos lugares diferentes, incluso si en realidad esos lugares diferentes hacen lo mismo.

Firma lógica dentro del código ofuscado (por ejemplo, puede crear una tabla de valores que la lógica del programa usa, pero también se usa como firma), que se puede usar para determinar que el código se originó en usted. Si alguien decide usar su módulo de código ofuscado como parte de su propio producto (incluso después de volverlo a poner para que parezca diferente), puede mostrar que ese código es robado con su firma secreta.

He analizado la protección de software en general para mis propios proyectos y la filosofía general es que la protección completa es imposible. Lo único que puede lograr es agregar protección a un nivel que le cueste más a su cliente evitar que comprar otra licencia.

Dicho esto, solo estaba revisando google para ver si hay obstrucción de Python y no aparecía mucho. En una solución .Net, la obstrucción sería un primer acercamiento a su problema en una plataforma Windows, pero no estoy seguro de si alguien tiene soluciones en Linux que funcionen con Mono.

Lo siguiente sería escribir su código en un lenguaje compilado, o si realmente quiere ir hasta el final, luego en ensamblador. Un ejecutable eliminado sería mucho más difícil de descompilar que un lenguaje interpretado.

Todo se reduce a compensaciones. Por un lado, tiene facilidad de desarrollo de software en python, en el que también es muy difícil ocultar secretos. En el otro extremo, tiene un software escrito en ensamblador que es mucho más difícil de escribir, pero es mucho más fácil ocultar secretos.

Su jefe tiene que elegir un punto en algún lugar de ese continuo que respalde sus requisitos. Y luego tiene que darte las herramientas y el tiempo para que puedas construir lo que quiere. Sin embargo, mi apuesta es que se opondrá a los costos de desarrollo reales frente a las posibles pérdidas monetarias.

Es posible tener el código de bytes py2exe en un recurso encriptado para un iniciador de C que lo carga y ejecuta en la memoria. Algunas ideas aquí y aquí .

Algunos también han pensado en un programa de auto modificación para revertir ingeniería cara.

También puede encontrar tutoriales para prevenir depuradores , haga que el desensamblador falle, configure puntos de interrupción falsos del depurador y proteja su código con sumas de verificación. Busque [" código cifrado " ejecutar " en memoria "] para más enlaces.

Pero como ya han dicho otros, si su código lo vale, los ingenieros inversos tendrán éxito al final.

Larga historia corta:

Cifre su código fuente
Escriba su propio cargador de módulos de Python para descifrar su código al importar
Implemente el cargador de módulos en C / C ++
Puede agregar más funciones al cargador de módulos, por ejemplo, anti-depurador, control de licencias, encuadernación de huellas digitales de hardware, etc.

Para obtener más detalles, mire esta respuesta .

Si está interesado en el tema, este proyecto lo ayudará: pyprotect .

Si nos centramos en las licencias de software, recomendaría echar un vistazo a otra respuesta de Stack Overflow que escribí aquí a inspírese sobre cómo se puede construir un sistema de verificación de clave de licencia.

Hay una biblioteca de código abierto en GitHub que puede ayudarlo con la verificación de la licencia bit.

Puede instalarlo mediante licencia de instalación pip y luego agregar el siguiente código:

pubKey = "<RSAKeyValue><Modulus>sGbvxwdlDbqFXOMlVUnAF5ew0t0WpPW7rFpI5jHQOFkht/326dvh7t74RYeMpjy357NljouhpTLA3a6idnn4j6c3jmPWBkjZndGsPL4Bqm+fwE48nKpGPjkj4q/yzT4tHXBTyvaBjA8bVoCTnu+LiC4XEaLZRThGzIn5KQXKCigg6tQRy0GXE13XYFVz/x1mjFbT9/7dS8p85n8BuwlY5JvuBIQkKhuCNFfrUxBWyu87CFnXWjIupCD2VO/GbxaCvzrRjLZjAngLCMtZbYBALksqGPgTUN7ZM24XbPWyLtKPaXF2i4XRR9u6eTj5BfnLbKAU5PIVfjIS+vNYYogteQ==</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>"

res = Key.activate(token="WyIyNTU1IiwiRjdZZTB4RmtuTVcrQlNqcSszbmFMMHB3aWFJTlBsWW1Mbm9raVFyRyJd",\
                   rsa_pub_key=pubKey,\
                   product_id=3349, key="ICVLD-VVSZR-ZTICT-YKGXL", machine_code=Helpers.GetMachineCode())

if res[0] == None not Helpers.IsOnRightMachine(res[0]):
    print("An error occured: {0}".format(res[1]))
else:
    print("Success")

Puede leer más sobre la forma en que se configuran la clave pública RSA, etc., aquí .

usar cxfreeze (py2exe para linux) hará el trabajo.

http://cx-freeze.sourceforge.net/

está disponible en los repositorios de ubuntu

Use la misma manera para proteger el archivo binario de c / c ++, es decir, ofusque cada cuerpo de función en un archivo binario ejecutable o de biblioteca, inserte una instrucción "saltar". Al comienzo de cada entrada de función, salte a una función especial para restaurar el código ofuscado. El código de bytes es el código binario de la secuencia de comandos de Python, por lo que

Primero compila el script de Python para codificar el objeto
Luego itere cada objeto de código, ofusque el co_code de cada objeto de código de la siguiente manera

    0   JUMP_ABSOLUTE            n = 3 + len(bytecode)

    3
    ...
    ... Here it's obfuscated bytecode
    ...

    n   LOAD_GLOBAL              ? (__pyarmor__)
    n+3 CALL_FUNCTION            0
    n+6 POP_TOP
    n+7 JUMP_ABSOLUTE            0

Guardar objeto de código ofuscado como archivo .pyc o .pyo

Esos archivos ofuscados (.pyc o .pyo) pueden ser utilizados por el intérprete normal de Python, cuando esos objetos de código se llaman por primera vez

La primera operación es JUMP_ABSOLUTE, saltará para compensar n
En el desplazamiento n, la instrucción es llamar a PyCFunction. Esta función restaurará los códigos de bytes ofuscados entre el desplazamiento 3 yn, y colocará el código de bytes original en el desplazamiento 0. El código ofuscado se puede obtener con el siguiente código
```
    char *obfucated_bytecode;
    Py_ssize_t len;
    PyFrameObject* frame = PyEval_GetFrame();
    PyCodeObject *f_code = frame->f_code;
    PyObject *co_code = f_code->co_code;      
    PyBytes_AsStringAndSize(co_code, &obfucated_bytecode, &len)
```
Después de que esta función regrese, la última instrucción es saltar a desplazamiento 0. El código de bytes realmente ahora se ejecuta.

Existe una herramienta Pyarmor para ofuscar los scripts de Python de esta manera.

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow