xticks barplot python licensing obfuscation copy-protection

python - barplot - pandas plot



¿Cómo protejo el código de Python? (26)

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

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, porque temen que el código pueda ser robado o al menos las "ideas novedosas".

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

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

Python no es la herramienta que necesitas

Debe usar la herramienta correcta para hacer lo correcto, y Python no fue diseñado para ser ofuscado. 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 algo malo, es importante que existan varias herramientas diferentes para diferentes usos.

La ofuscación es muy dura

Incluso los programas compilados pueden tener ingeniería inversa, así que no creas que puedes proteger completamente cualquier código. Puede analizar PHP ofuscado, romper la clave de cifrado flash, etc. Las versiones más recientes de Windows siempre están dañadas.

Tener un requisito legal es una buena manera de ir

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

Código de protección está sobrevalorado

Hoy en día, los modelos de negocios tienden a vender servicios en lugar de productos. No puedes copiar un servicio, piratearlo ni robarlo. Tal vez es hora de considerar ir con el flujo ...

¡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 de python (pyd) en su lugar.

De esa manera, no queda ningún código Python (byte) y creo que ha hecho una cantidad razonable de oscurecimiento que cualquiera (es decir, su empleador) podría esperar del Código regular. (.NET o Java son menos seguros que este caso, ya que el código de bytes no está confuso y se puede descomponer con relativa facilidad en una fuente razonable).

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

Consulte esta publicación de blog (no realizada por mí) para ver 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 genérelos con una fuerte inclusión. De esa manera, su módulo Python es bastante monolítico y difícil de manipular con herramientas comunes.

Más allá de la locura:

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) de forma estática. De esa manera, sería difícil interceptar las llamadas a / desde python y las bibliotecas de framework que uses. Sin embargo, esto no se puede hacer si está utilizando el código LGPL.

"¿Hay una buena manera de manejar este problema?" No. Nada puede ser protegido contra la ingeniería inversa. Incluso el firmware de las máquinas de DVD ha sido diseñado por ingeniería inversa y la clave de cifrado AACS está expuesta. Y eso a pesar de que la DMCA lo convierte 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 ordinarios.

  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 exigirle que pague una tarifa antes de vender software utilizando esos componentes. Además, algunas licencias de código abierto le prohíben ocultar la fuente u orígenes de ese componente.

  2. Ofrecer valor significativo. Si tus cosas son tan buenas, a un precio que es difícil de rechazar, no hay incentivo para perder tiempo y dinero para hacer ingeniería inversa. La ingeniería inversa es costosa. Haga su producto un poco menos costoso.

  3. Ofrezca actualizaciones y mejoras que hacen que cualquier ingeniería inversa sea una mala idea. Cuando la próxima versión rompe su ingeniería inversa, no tiene sentido. Esto se puede llevar a extremos absurdos, pero debe ofrecer nuevas funciones que hagan que la próxima versión sea más valiosa que la ingeniería inversa.

  4. Ofrezca la personalización a tasas tan atractivas que preferirían pagarle para construir y admitir las mejoras.

  5. Utilice una clave de licencia que caduca. 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 para los clientes.

¿Has pyminifier un vistazo al pyminifier ? Lo hace Minificar, ofuscar y comprimir el código de Python. El código de ejemplo parece bastante desagradable para la ingeniería inversa casual.

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

¿Qué hay de firmar su código con esquemas de encriptado estándar mediante el hashing y la firma de archivos importantes y verificarlo con métodos de clave pública?

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

Adicional, puedes usar un ofuscador de pitón como este (solo lo buscó en Google).

¿Su empleador sabe 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 hacerlo. Tal vez ver cómo puede beneficiarse de la situación le daría un mejor retorno de su inversión en lugar de 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ó ya que él mismo hizo el cambio). Como él no libera 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. Es probable que se pongan en contacto con usted y así aprenderá sobre la reventa de su trabajo.

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

Pero al final, la mayoría de las compañías intentan cumplir con la ley (una vez que se arruina su reputación, es mucho más difícil hacer negocios). Así que no te robarán el trabajo, sino que trabajarán contigo para mejorarlo. Por lo tanto, si incluye la fuente (con una licencia que lo protege de una simple reventa), es probable que simplemente rechacen los cambios que hicieron, ya que se asegurarán de 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.

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. Hacer 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 esta no es una solución multiplataforma o pura de Python, funcionará.

Creo que hay un método más para proteger su código Python; parte del metodo de ofuscacion. 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 que acaba de cambiar los códigos OP en la tabla de códigos OP para ser diferente al estándar de python OP códigos

Así que la fuente de python no está modificada, pero las extensiones de los archivos pyc son diferentes y los códigos de operación no coinciden con el intérprete público de python.exe. Si verificó los archivos de datos de los juegos, todos los datos estaban en el formato fuente de Python.

Se pueden hacer todo tipo de trucos desagradables para meterse con hackers aficionados de esta manera. Detener a un grupo de hackers noob es fácil. Son los hackers profesionales a los que probablemente no vencerás. Pero la mayoría de las empresas no mantienen a los hackers profesionales en el personal por mucho tiempo (probablemente porque las cosas se piratean). Pero los piratas informáticos aficionados están por todas partes (leído como curioso personal de TI).

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

OP 234 es para la línea de origen "# Copyright escribí esto" o compilo esa línea en códigos de operación que son equivalentes a "si Falso:" si "# Copyright" falta. Básicamente, deshabilita todo un bloque de código por lo que parece ser una razón obsesiva.

Un caso de uso en el que la recompilación de 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 para una aplicación financiera.

Me parece 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. Un poco de precaución es sensato.

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

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

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 licencias / encriptación / ofuscación.

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

El envío del código como archivos .pyc evitará que su protección se vea afectada por unos pocos # s, pero no es una protección efectiva contra la piratería (como si existiera tal tecnología), y al final del día, no debería lograrse Cualquier cosa que un acuerdo de licencia decente con la empresa hará.

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

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 de python con la que fueron creados, lo que significa que debe saber qué versión de python se está ejecutando en los sistemas en los que se ejecutará el producto. Eso es un factor muy limitante.

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

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

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 lugar de Python

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

Es posible tener el código de byte py2exe en un recurso cifrado para un iniciador de C que lo carga y lo ejecuta en la memoria. Algunas ideas here y here .

Algunos también han pensado en un programa de auto-modificación para hacer costosa la ingeniería inversa.

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

Pero como ya han dicho otros, si su código vale la pena, los ingenieros de ingeniería inversa tendrán éxito al final.

He analizado la protección del 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 costaría más a su cliente eludirlo que comprar otra licencia.

Dicho esto, solo estaba revisando Google para detectar la presencia de Python y no estaba subiendo mucho de nada. En una solución .Net, la ocultación sería un primer acercamiento a su problema en una plataforma Windows, pero no estoy seguro 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 todo el camino, luego en ensamblador. Un ejecutable despojado 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, tienes un software escrito en ensamblador que es mucho más difícil de escribir, pero es mucho más fácil de 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.

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

La idea de tener una licencia de tiempo restringido y verificarla en un 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 utilicen el código fuente como propio o escriba 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 demostrar que le robaron el código) y ofuscar El código fuente de Python 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) sí lo hace. Descubrir cómo funciona el código complejo confuso puede ser incluso más difícil que escribir su propia implementación.

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

Además de la ofuscación de símbolos, puede ser una buena idea no restarle importancia al 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 lugares diferentes hacen lo mismo.

Firma lógica dentro del código ofuscado (por ejemplo, puede crear una tabla de valores que son utilizados por la lógica del programa, pero que también se usan como firma), que se pueden 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 haberlo reconstruido para que parezca diferente) puede mostrarlo, ese código es robado con su firma secreta.

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

  • Eliminar todos los docstrings
  • Distribuye solo los archivos compilados .pyc.
  • congelarlo
  • Oculte sus constantes dentro de una clase / módulo para que la ayuda (config) no muestre todo

Es posible que pueda agregar algo de oscuridad adicional al encriptar parte de él y descifrarlo sobre la marcha y pasarlo a eval (). Pero no importa lo que hagas, alguien puede romperlo.

Nada de esto impedirá que un determinado atacante desarme el código de bytes o escarbe a través de su API con ayuda, directorio, etc.

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

Podría ser exactamente lo que necesitas (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 la secuencia de comandos de Python

  • su_script.py import pyconcrete
  • Pyconcrete enganchará módulo de importación
  • cuando su secuencia de comandos importa MODULE , pyconcrete import hook intentará encontrar MODULE.pye primero y luego descifrar MODULE.pye través de _pyconcrete.pyd y ejecutar datos descifrados (como contenido .pyc)
  • cifrar y descifrar el registro de clave secreta en _pyconcrete.pyd (como DLL o SO) la clave secreta se ocultará en código binario, no se puede ver directamente en la vista HEX

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 diseñó a la inversa el código de Python ofuscado en Dropbox. El enfoque: la reasignación de opcodes es una buena barrera, pero claramente puede ser derrotado.

En cambio, como muchos carteles han mencionado, hazlo:

  • No vale la pena invertir el tiempo de ingeniería (su software es tan bueno que tiene sentido pagar)
  • Haga que firmen un contrato y haga una auditoría de licencia si es posible.

Alternativamente, como el kick-ass Python IDE WingIDE: Regala el código . Así es, regale el código y haga que la gente regrese para actualizaciones y soporte.

Otro intento de hacer que tu 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 python a java y luego java se compila a bytecode. Así que una vez que ofuscas las clases, será muy difícil entender lo que sucede después de la descompilación, por no mencionar la recuperación del código real.

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

Python, al ser un lenguaje interpretado compilado en 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 son bien conocidos.

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

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

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 código de bytes .pyc!

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

Proteger las fuentes de Python con Cython

Larga historia corta:

  1. Encripta tu código fuente
  2. Escriba su propio cargador de módulos de Python para descifrar su código al importar
  3. Implementar 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, enlace de huellas dactilares de hardware, etc.

Para más detalles, mira esta answer .

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

Utilice la misma forma de proteger el archivo binario de c / c ++, es decir, ofuscar el cuerpo de cada función en el archivo binario ejecutable o de la biblioteca, inserte una instrucción "saltar" al comienzo de cada entrada de la función, salte a la función especial para restaurar el código ofuscado. El código de bytes es un 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, ofrezca co_code de cada objeto de código como lo siguiente

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

  • Guarde el objeto de código ofuscado como un archivo .pyc o .pyo

Esos archivos ofuscados (.pyc o .pyo) pueden ser utilizados por un intérprete de Python normal, cuando se llama a ese objeto de código por primera vez

  • 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 bytecodos ofuscados entre el desplazamiento 3 y n, y colocará el byte-código original en el desplazamiento 0. El código ofuscado 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)

  • Una vez que se devuelve esta función, la última instrucción es saltar al desplazamiento 0. El código de byte real ahora se ejecuta.

Hay una herramienta Pyarmor para ofuscar scripts de python de esta manera.