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 con restricción de tiempo.

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

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

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 .

"¿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 la clave de cifrado AACS expuesta. Y eso a pesar de que la DMCA lo convirtió en un delito penal.

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

1. 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.

2. 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 su producto un poco menos costoso.

3. Ofrezca actualizaciones y mejoras que hagan 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.

4. Ofrezca personalización a precios tan atractivos que preferirían pagarle a usted por construir y admitir las mejoras.

5. 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.

6. Ofrézcalo como un servicio web. SaaS no implica descargas a los clientes.

Python no es la herramienta que necesitas

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 bibliotecas binarias python (pyd).

De esa manera, no queda ningún código de Python (byte) y creo que ha realizado 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).

Vea esta publicación de blog (no por mí) para obtener un tutorial sobre cómo hacerlo. (gracias @hithwen)

Idea loca:

Probablemente podría hacer que Cython almacene los archivos C por separado para cada módulo, luego concatene 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 locos:

Es posible que pueda crear 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 C / C ++ al espacio de nombres 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" cualquier idea que otras personas obtengan de su 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 copyright (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). Por lo tanto, 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 documento que invierte el 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: el código . Así es, regale el código y haga que la gente regrese para actualizaciones y soporte.

Utiliza 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

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 manera, 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:

1. Mueva alguna pieza crítica de código de inicio a una biblioteca nativa.
2. Haga cumplir 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 no se trata de una solución multiplataforma o de Python puro, funcionará.

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 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 de TI curioso).

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:

El OP 234 es para la línea de origen "# Copyright He escrito esto" o compile esa línea en códigos operativos que sean equivalentes a "if False:" if "# # Copyright" missing. 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 puede ser posible recompilar un intérprete modificado es donde no escribió la aplicación, la aplicación es grande, pero se le paga para protegerla, como cuando es un administrador de servidor dedicado para una aplicación financiera.

Me resulta un poco contradictorio dejar la fuente o los códigos de operación abiertos para los globos oculares, pero usar 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. Por lo tanto, cada vez más personas que preguntan "cómo proteger la aplicación Python" solo promueven ese desarrollo.

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

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 cifra y descifra en el momento de la carga.

Desde la página de pypi :

Proteger el flujo de trabajo de 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 pyconcrete intentará encontrar MODULE.pyeprimero y luego descifrar MODULE.pyemediante _pyconcrete.pydy ejecutar datos descifrados (como contenido .pyc)
• cifrar y descifrar el registro de clave secreta _pyconcrete.pyd (como DLL o SO) la clave secreta estaría oculta en código binario, no se puede ver directamente en la vista HEX

Dependiendo de quién sea el cliente, un simple mecanismo de protección, combinado con un acuerdo de licencia sensato, estará lejos 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 .pycarchivos evitará que su protección se vea frustrada por unos pocos #segundos, pero no es una protección efectiva contra la piratería (como si hubiera tal tecnología), y al final del día, no debería lograr nada que acuerdo de licencia decente con la empresa lo hará.

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 una piratería teórica.

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

Esto debería funcionar bastante bien ya que jythonc traduce el código de Python a Java y luego Java se compila a 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 puedes 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 firmando archivos importantes y verificándolo con métodos de clave pública?

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

Además, puede usar un ofuscador de pitón como este (simplemente busqué en Google).

Debes 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.

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

• Retirar todas las cadenas de documentos
• Distribuya solo los archivos compilados .pyc.
• congelarlo
• Oculte 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 código de bytes o explore 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.

Para evitar 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 tanto, es difícil de leer y utilizar.

La 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 podría 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 refactorizar el código, lo que hace que todo sea aún más confuso si, por ejemplo, los gráficos de llamadas apuntan a muchos lugares diferentes, incluso si en realidad esos diferentes lugares eventualmente hacen lo mismo.

Firma lógica dentro del código ofuscado (por ejemplo, puede crear una tabla de valores que son usados ​​por la lógica del programa, pero también usados ​​como firma), que pueden usarse 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 volver a ofuscarlo 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 esperar lograr es agregar protección a un nivel que le cueste más a su cliente eludir que comprar otra licencia.

Con eso dicho, solo estaba buscando en google para detectar la fuga de python y no aparecía mucho. En una solución .Net, el oscurecimiento sería un primer enfoque para 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, entonces 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. Por otro lado, 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.

Larga historia corta:

1. Cifra tu código fuente
2. Escriba su propio cargador de módulo de Python para descifrar su código al importar
3. Implemente el cargador de módulos en C / C ++
4. 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 más detalles, mira esta respuesta .

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

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 auto modificable para hacer que la ingeniería inversa sea costosa.

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

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

Si nos centramos en las licencias de software, recomendaría echar un vistazo a otra respuesta de desbordamiento de pila que escribí aquí para obtener alguna inspiración de 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 el bit de verificación de licencia.

Puede instalarlo pip install licensingy 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 la clave pública RSA, etc.está configurada aquí .

Use la misma manera para proteger el archivo binario de c / c ++, es decir, ofusque cada cuerpo de función en el archivo binario ejecutable o de la biblioteca, inserte una instrucción "jump" 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 del script 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_código de cada objeto de código de la siguiente manera

    0 JUMP_ABSOLUTE n = 3 + len (código de bytes)

    3
    ...
    ... Aquí está el bytecode ofuscado
    ...

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

• Guarde el 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 siguiente código puede obtenerse mediante 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 al desplazamiento 0. El código de bytes realmente se ejecuta ahora.

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

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

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

está disponible en repositorios de ubuntu

Hay una respuesta completa sobre cómo ocultar el código fuente de Python, que se puede encontrar aquí .

Las posibles técnicas discutidas son:
- usar bytecode compilado ( python -m compileall)
- creadores ejecutables (o instaladores como PyInstaller )
- software como servicio (la mejor solución para ocultar su código en mi opinión)
- ofuscadores de código fuente python