Comment protéger le code Python?

Question

Je développe un logiciel en Python qui sera distribué aux clients de mon employeur. Mon employeur souhaite limiter l'utilisation du logiciel avec un fichier de licence à durée limitée.

Si nous distribuons les fichiers .py ou même les fichiers .pyc, il sera facile de (décompiler et) supprimer le code qui vérifie le fichier de licence.

Un autre aspect est que mon employeur ne veut pas que le code soit lu par nos clients, craignant que le code ne soit volé ou du moins les "nouvelles idées".

Existe-t-il un bon moyen de gérer ce problème? De préférence avec une solution prête à l'emploi.

Le logiciel fonctionnera sur les systèmes Linux (je ne pense donc pas que py2exe fera l'affaire).

Answer 1

Python, étant un langage interprété compilé par code octet, est très difficile à verrouiller. Même si vous utilisez un programme de compression exe tel que py2exe , la structure de l'exécutable est connue et les codes d'octets Python sont bien compris.

Habituellement, dans de tels cas, vous devez faire un compromis. Quelle est l’importance de protéger le code? Y at-il de véritables secrets (comme une clé pour le cryptage symétrique des virements bancaires) ou êtes-vous simplement paranoïaque? Choisissez la langue qui vous permet de développer rapidement le meilleur produit et soyez réaliste quant à la valeur de vos idées originales.

Si vous décidez que vous devez réellement appliquer la vérification de licence de manière sécurisée, écrivez-la sous la forme d'une petite extension C, de sorte que le code de vérification de la licence puisse être extrêmement dur (mais pas impossible!) pour procéder à une ingénierie inverse, et laissez le gros de vos tâches. code en Python.

Answer 2

"Existe-t-il un bon moyen de gérer ce problème?" Non, rien ne peut être protégé contre l'ingénierie inverse. Même le micrologiciel sur les machines DVD a été mis au point et clé de cryptage AACS . Et ce malgré le fait que le DMCA en fasse une infraction pénale.

Etant donné qu'aucune méthode technique ne peut empêcher vos clients de lire votre code, vous devez appliquer les méthodes commerciales habituelles.

1. Licences. Contrats Termes et conditions. Cela fonctionne toujours même lorsque les gens peuvent lire le code. Notez que certains de vos composants basés sur Python peuvent nécessiter que vous payiez des frais avant de vendre un logiciel utilisant ces composants. En outre, certaines licences open source vous empêchent de dissimuler la source ou les origines de ce composant.

2. Offrez une valeur significative. Si vos affaires sont si bonnes - à un prix difficile à refuser - rien ne vous incite à perdre du temps et de l'argent en ingénierie inverse. L'ingénierie inverse coûte cher. Rendre votre produit légèrement moins cher.

3. Proposez des mises à niveau et des améliorations qui rendent toute ingénierie inverse une mauvaise idée. Lorsque la prochaine version annule leur ingénierie inverse, cela ne sert à rien. Cela peut être porté à des extrêmes absurdes, mais vous devriez proposer de nouvelles fonctionnalités qui rendent la prochaine version plus précieuse que l’ingénierie inverse.

4. Proposez des options de personnalisation à des tarifs si attrayants qu’ils préféreraient vous payer pour construire et prendre en charge les améliorations.

5. Utilisez une clé de licence qui expire. Ceci est cruel et vous donnera une mauvaise réputation, mais votre logiciel ne fonctionnera certainement plus.

6. Proposez-le en tant que service Web. SaaS n'implique aucun téléchargement pour les clients.

Answer 3

Python n’est pas l’outil dont vous avez besoin

Vous devez utiliser le bon outil pour bien faire les choses, et Python n’a pas été conçu pour être obscurci. C'est le contraire; tout est ouvert ou facile à révéler ou à modifier en Python car c'est la philosophie du langage.

Si vous voulez quelque chose que vous ne pouvez pas voir à travers, cherchez un autre outil. Ce n’est pas une mauvaise chose, il est important que plusieurs outils existent pour différents usages.

La confusion est vraiment difficile

Même les programmes compilés peuvent être désossés, alors ne pensez pas que vous pouvez protéger complètement le code. Vous pouvez analyser PHP obfusqué, casser la clé de chiffrement flash, etc. Les versions les plus récentes de Windows sont craquées à chaque fois.

Avoir une obligation légale est un bon choix

Vous ne pouvez pas empêcher quelqu'un d'abuser de votre code, mais vous pouvez facilement savoir si quelqu'un le fait. Par conséquent, il ne s'agit que d'une question juridique occasionnelle.

La protection du code est surchargée

De nos jours, les modèles d’entreprise préfèrent vendre des services plutôt que des produits. Vous ne pouvez pas copier un service, pirater ou le voler. Peut-être qu'il est temps d'envisager de suivre le courant ...

Answer 4

Compilez python et distribuez les fichiers binaires!

Idée sensible:

Utilisez Cython , Nuitka , Shed Skin ou quelque chose de similaire pour compiler du code python en C, puis distribuez votre application en tant que fichier binaire python bibliothèques (pyd) à la place.

De cette façon, il ne reste plus de code Python (octet) et vous avez effectué une obscurification raisonnable à laquelle quiconque (à savoir votre employeur) pouvait s’attendre de la part du Code habituel, je pense. (.NET ou Java moins sûr que ce cas, car ce bytecode n’est pas obscurci et peut relativement facilement être décompilé en une source raisonnable.)

Cython devient de plus en plus compatible avec CPython, je pense donc que cela devrait fonctionner. (J'envisage en fait cela pour notre produit. Nous sommes déjà en train de créer des bibliothèques tierces en tant que pyd / dlls, ce qui fait que l'envoi de notre propre code python sous forme de fichiers binaires n'est pas une étape trop importante pour nous.)

Voir Cet article de blog (pas par moi) pour un tutoriel sur la façon de le faire. (merci @hithwen)

Idée folle:

Vous pourriez probablement demander à Cython de stocker les fichiers C séparément pour chaque module, puis de les concaténer tous et de les construire avec une lourdeur en ligne. De cette façon, votre module Python est assez monolithique et difficile à manipuler avec des outils communs.

Au-delà de la folie:

Vous pourrez peut-être créer un seul exécutable si vous pouvez créer un lien vers (et optimiser avec) le runtime Python et toutes les bibliothèques (dll) de manière statique. De cette façon, il serait difficile d’intercepter les appels de / vers python et les bibliothèques de framework que vous utilisez. Cela ne peut cependant pas être fait si vous utilisez du code LGPL.

Answer 5

Je comprends que vous voulez que vos clients utilisent la puissance de Python mais ne souhaitez pas exposer le code source.

Voici mes suggestions:

(a) Ecrivez les éléments critiques du code sous forme de bibliothèques C ou C ++, puis utilisez SIP ou swig pour exposer les API C / C ++ à l'espace de noms Python.

(b) Utilisez cython au lieu de Python

(c) Dans (a) et (b), il devrait être possible de distribuer les bibliothèques sous forme de licence binaire avec une interface Python.

Answer 6

Votre employeur sait-il qu'il peut & voler; & voler; " avez-vous des idées que d'autres personnes ont trouvées dans votre code? Je veux dire, s'ils peuvent lire votre travail, vous aussi, vous pouvez le faire. Peut-être qu'explorer comment vous pouvez tirer profit de la situation rapporterait plus pour votre investissement que de craindre combien vous pourriez perdre.

[EDIT] Réponse au commentaire de Nick:

Rien n'a été gagné et rien n'a été perdu. Le client a ce qu'il veut (et l'a payé puisqu'il a fait le changement lui-même). Comme il ne publie pas le changement, c'est comme si cela ne s'était pas produit pour tout le monde.

Maintenant, si le client vend le logiciel, il doit modifier la notification de copyright (ce qui est illégal, vous pouvez donc poursuivre et gagner - > affaire simple).

S'ils ne modifient pas les droits d'auteur, les clients du deuxième niveau remarqueront que le logiciel provient de votre logiciel d'origine et se demanderont ce qui se passe. Il y a des chances qu'ils vous contactent et vous en apprendrez plus sur la revente de votre travail.

Encore une fois, nous avons deux cas: le client d'origine n'a vendu que quelques exemplaires. Cela signifie qu'ils ne gagnent pas beaucoup d'argent de toute façon, alors pourquoi s'embêter. Ou ils ont vendu en volume. Cela signifie que vous aurez plus de chances d’apprendre ce qu’ils font et de faire quelque chose à ce sujet.

Mais au bout du compte, la plupart des entreprises tentent de se conformer à la loi (une fois que leur réputation est ruinée, il est beaucoup plus difficile de faire des affaires). Ils ne vous voleront donc pas votre travail, mais travailleront avec vous pour l’améliorer. Donc, si vous incluez le source (avec une licence qui vous protège de la simple revente), il y a de fortes chances qu'ils repoussent simplement les modifications qu'ils ont apportées, car ils garantiront que les modifications figurent dans la prochaine version et ne doivent pas être conservées. . C'est gagnant-gagnant: vous obtenez des changements et ils peuvent le faire eux-mêmes s'ils en ont vraiment besoin désespérément, même si vous ne souhaitez pas l'inclure dans la version officielle.

Answer 7

Avez-vous consulté pyminifier ? Cela minimise, obscurcit et compresse le code Python. L'exemple de code est plutôt méchant pour l'ingénierie inverse occasionnelle.

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

Answer 8

Ne comptez pas sur l’obscurcissement. Comme vous l'avez bien conclu, il offre une protection très limitée. MISE À JOUR: Voici un lien vers du papier qui est traité de manière inverse. code python obfusqué dans Dropbox. L’approche - le remappage des opcode est une bonne barrière, mais il est évident qu’elle peut être vaincue.

Au lieu de cela, comme de nombreuses affiches l'ont mentionné,

• Ne vaut pas le temps d'ingénierie inverse (votre logiciel est tellement bon qu'il est logique de payer)
• Faites-leur signer un contrat et effectuez un audit de la licence si possible.

Autrement, comme le fait l'édifice IDE WingIDE Python, qui donne un bon coup de fouet: Donner le code . C’est vrai, donnez le code et invitez les gens à revenir pour des mises à jour et une assistance.

Answer 9

La livraison des fichiers .pyc a ses problèmes: ils ne sont compatibles avec aucune autre version de Python que celle avec laquelle ils ont été créés, ce qui signifie que vous devez savoir quelle version de Python est exécutée sur les systèmes sur lesquels le produit sera exécuté. C'est un facteur très limitant.

Answer 10

Dans certaines circonstances, il peut être possible de déplacer le logiciel (en tout ou en partie, vers un élément clé) vers un service Web hébergé par votre organisation.

Ainsi, les contrôles de licence peuvent être effectués en toute sécurité dans votre propre salle de serveurs.

Answer 11

Bien qu'il n'y ait pas de solution parfaite, vous pouvez effectuer les opérations suivantes:

1. Déplacez un élément critique du code de démarrage dans une bibliothèque native.
2. Appliquez le contrôle de licence dans la bibliothèque native.

Si l'appel du code natif devait être supprimé, le programme ne commencerait pas de toute façon. Si elle n'est pas supprimée, la licence sera appliquée.

Bien qu'il ne s'agisse pas d'une solution multiplate-forme ni d'une solution purement Python, cela fonctionnera.

Answer 12

Le seul moyen fiable de protéger le code consiste à l'exécuter sur un serveur que vous contrôlez et à fournir à vos clients un client qui s'interface avec ce serveur.

Answer 13

Je pense qu’il existe une méthode supplémentaire pour protéger votre code Python; partie de la méthode d'obfuscation. Je crois qu'il y avait un jeu comme Mount and Blade ou quelque chose qui modifiait et recompilait son propre interpréteur python (l'interpréteur original que je crois être open source) et qui venait de changer les codes OP dans la table de codes OP afin qu'ils soient différents de l'OP standard python. codes.

Ainsi, la source python n’a pas été modifiée, mais les extensions de fichier des fichiers * .pyc sont différentes et les codes op ne correspondent pas à l’interpréteur python.exe public. Si vous avez coché les fichiers de données du jeu, toutes les données étaient au format source Python.

Toutes sortes d’astuces peuvent être faites pour gâcher les pirates immatures de cette façon. Arrêter un groupe de pirates informatiques inexpérimentés est facile. Ce sont les pirates professionnels que vous ne battrez probablement pas. Mais la plupart des entreprises ne gardent pas longtemps les pirates professionnels au sein de leur personnel (probablement parce que les choses se piratent). Mais les pirates immatures sont partout (lire comme un personnel informatique curieux).

Vous pouvez par exemple, dans un interpréteur modifié, lui permettre de rechercher certains commentaires ou certaines chaînes de documentation dans votre source. Vous pourriez avoir des codes OP spéciaux pour de telles lignes de code. Par exemple:

OP 234 est pour la ligne source "# Copyright j'ai écrit ceci". ou compilez cette ligne en codes opération équivalents à " si False: " si " # Copyright " est manquant. Désactiver fondamentalement tout un bloc de code pour ce qui semble être une raison obscure.

Un cas d'utilisation où la recompilation d'un interprète modifié peut être réalisable est celui où vous n'avez pas écrit l'application, l'application est volumineuse, mais vous êtes payé pour la protéger, par exemple lorsque vous êtes un administrateur de serveur dédié doté d'une fonction financière. app.

Je trouve un peu contradictoire de laisser la source ou les opcodes ouverts pour les globes oculaires, mais d'utiliser SSL pour le trafic réseau. SSL n'est pas sûr à 100% non plus. Mais il est utilisé pour empêcher la plupart des yeux de le lire. Une petite précaution est judicieuse.

En outre, si suffisamment de personnes jugent que la source et les opcodes Python sont trop visibles, il est probable que quelqu'un finira par développer au moins un simple outil de protection. Ainsi, plus de personnes demandent comment protéger l’application Python " ne fait que promouvoir ce développement.

Answer 14

En fonction du client, un mécanisme de protection simple, associé à un contrat de licence judicieux, sera de loin plus efficace que tout système complexe de licence / cryptage / obfuscation.

La meilleure solution serait de vendre le code en tant que service, par exemple en hébergeant le service, ou en offrant une assistance - bien que cela ne soit pas toujours pratique.

En envoyant le code sous forme de fichiers .pyc , vous empêcherez que votre protection soit gâchée par quelques # , mais cette protection anti-piratage est peu efficace (comme si elle existait déjà). une technologie) et, au bout du compte, aucun accord de licence décent avec l’entreprise ne devrait être obtenu.

Concentrez-vous à rendre votre code aussi agréable que possible. Si vous avez des clients satisfaits, votre entreprise gagnera bien plus d'argent que de prévenir le piratage théorique.

Answer 15

Utilisez Cython . Il compilera vos modules dans des fichiers C très performants, qui pourront ensuite être compilés dans des bibliothèques binaires natives. Ceci est fondamentalement irréversible, comparé au bytecode .pyc!

J'ai écrit un article détaillé sur la configuration de Cython pour un projet Python. Découvrez-le:

Protection des sources Python avec Cython

Answer 16

Une autre tentative pour rendre votre code plus difficile à voler consiste à utiliser jython, puis à utiliser obfuscateur java .

Cela devrait fonctionner plutôt bien lorsque jythonc convertit le code python en java, puis que java est compilé en bytecode. Donc, pour obscurcir les classes, il sera très difficile de comprendre ce qui se passe après la décompilation, sans parler de la récupération du code réel.

Le seul problème avec jython est que vous ne pouvez pas utiliser les modules python écrits en c.

Answer 17

Qu'en est-il de la signature de votre code avec des schémas de chiffrement standard en hachant et en signant des fichiers importants et en le vérifiant à l'aide de méthodes à clé publique?

De cette manière, vous pouvez émettre un fichier de licence avec une clé publique pour chaque client.

De plus, vous pouvez utiliser un obfuscateur python tel que celui-ci (seulement googlé il).

Answer 18

Vous devriez jeter un coup d'œil à la façon dont les employés de getdropbox.com le font pour leur logiciel client, y compris Linux. C'est assez délicat à craquer et nécessite un désassemblage assez créatif pour dépasser les mécanismes de protection.

Answer 19

J'ai été surpris de ne pas voir pyconcrete dans aucune réponse. Peut-être parce que c'est plus récent que la question?

Cela pourrait être exactement ce dont vous avez besoin.

Au lieu d'obscurcir le code, il le chiffre et le déchiffre au moment du chargement.

De la page pypi :

  

Protéger le flux de travail du script python

     

  
• votre_script.py importer pyconcrete
  
• pyconcrete accrochera le module d'importation
  
• lorsque votre script importe MODULE ,   Le point d'ancrage pyconcrete import tentera de trouver MODULE.pye en premier, puis   déchiffrer MODULE.pye via _pyconcrete.pyd et exécuter les données déchiffrées (comme   contenu .pyc)
  
• chiffrer & amp; déchiffrer l'enregistrement de clé secrète dans _pyconcrete.pyd   (comme DLL ou SO), la clé secrète serait masquée dans un code binaire, vous ne pouvez pas & # 8217; t   voyez-le directement dans la vue HEX
  

Answer 20

Le mieux que vous puissiez faire avec Python est d’obscurcir les choses.

• Supprimez toutes les docstrings
• Ne distribuez que les fichiers compilés .pyc.
• le congeler
• Obscurez vos constantes dans une classe / un module afin que l'aide (config) ne montre pas tout

Vous pourrez peut-être ajouter de l’obscurité en chiffrant une partie de celle-ci, en la déchiffrant à la volée et en la passant à eval (). Mais peu importe ce que vous faites, quelqu'un peut le casser.

Rien de tout cela n'empêchera un attaquant déterminé de désassembler le bytecode ou de fouiller dans votre API avec de l'aide, des répertoires, etc.

.

Answer 21

L'idée d'avoir une licence limitée dans le temps et de la vérifier dans les programmes installés localement ne fonctionnera pas. Même avec un obscurcissement parfait, le contrôle de licence peut être supprimé. Toutefois, si vous vérifiez la licence sur le système distant et exécutez une partie importante du programme sur votre système distant fermé, vous pourrez protéger votre IP.

Pour empêcher les concurrents d’utiliser le code source ou d’écrire leur version inspirée du même code, l’un des moyens de le protéger consiste à ajouter des signatures à la logique de votre programme (secrets permettant de prouver que le code vous a été volé). et obscurcir le code source de Python, il est donc difficile à lire et à utiliser.

Une bonne dissimulation ajoute fondamentalement la même protection à votre code, que de le compiler en exécutable (et en supprimant le binaire). Comprendre le fonctionnement d'un code complexe obscurci peut s'avérer encore plus difficile que d'écrire votre propre implémentation.

Cela n’empêchera pas le piratage de votre programme. Même avec le code de dissimulation, la licence sera déchirée et le programme peut être modifié pour avoir un comportement légèrement différent (de la même manière que compiler du code en binaire ne permet pas de protéger les programmes natifs).

En plus de l’obscurcissement des symboles, il peut être judicieux de supprimer le refonte du code, ce qui rend tout encore plus confus si, par exemple. Les graphes d'appel pointent vers de nombreux endroits différents, même si en réalité ces endroits différents finissent par avoir la même chose.

Signature logique dans un code obscurci (par exemple, vous pouvez créer un tableau de valeurs utilisé par la logique du programme, mais également utilisé en tant que signature), qui peut être utilisé pour déterminer que le code provient de vous. Si quelqu'un décide d'utiliser votre module de code masqué dans le cadre de son propre produit (même après l'avoir réactivé pour le rendre différent), vous pouvez montrer que ce code est volé avec votre signature secrète.

Answer 22

J'ai examiné la protection des logiciels en général pour mes propres projets et la philosophie générale est qu'une protection complète est impossible. La seule chose que vous pouvez espérer réaliser est d’ajouter une protection qui coûterait plus cher à votre client que d’acheter une autre licence.

Cela dit, je vérifiais que Google était obsédé par Python et que je ne rapportais pas grand-chose. Dans une solution .Net, l'obsolescence serait une première approche de votre problème sur une plate-forme Windows, mais je ne suis pas sûr que quiconque ait des solutions sous Linux qui fonctionnent avec Mono.

La prochaine chose à faire serait d’écrire votre code dans un langage compilé, ou si vous voulez vraiment aller jusqu'au bout, puis en assembleur. Un exécutable dépouillé serait beaucoup plus difficile à décompiler qu'un langage interprété.

Tout se résume à des compromis. D'un côté, vous avez la facilité de développement de logiciels en python, dans lesquels il est également très difficile de cacher des secrets. À l’autre extrémité, vous avez un logiciel écrit en assembleur qui est beaucoup plus difficile à écrire, mais il est beaucoup plus facile de cacher des secrets.

Votre patron doit choisir un point quelque part dans le continuum qui répond à ses besoins. Et ensuite, il doit vous donner les outils et le temps pour que vous puissiez construire ce qu'il veut. Cependant, mon pari est qu'il s'opposera aux coûts de développement réels par rapport aux pertes financières potentielles.

Answer 23

Il est possible d’avoir le code octet py2exe dans une ressource cryptée pour un programme de lancement C qui le charge et l’exécute en mémoire. Quelques idées ici et ici .

Certains ont également pensé à un programme à modification automatique pour inverser ingénierie coûteuse.

Vous pouvez également rechercher des tutoriels pour empêcher les débogueurs , de faire échouer le désassembleur, de définir de faux points d'arrêt du débogueur et protégez votre code avec des sommes de contrôle. Rechercher [" code crypté " exécutez "en mémoire"] pour plus de liens.

Mais comme d’autres l’ont déjà dit, si votre code en vaut la peine, les ingénieurs de l’ingénierie inverse réussiront à la fin.

Answer 24

Longue histoire courte:

1. Cryptez votre code source
2. Écrivez votre propre chargeur de modules python pour déchiffrer votre code lors de l'importation
3. Implémentez le chargeur de module en C / C ++
4. Vous pouvez ajouter davantage de fonctionnalités au chargeur de modules, par exemple un anti-débogueur, un contrôle de licence, une liaison d'empreinte digitale matérielle, etc.

Pour plus de détails, consultez cette réponse .

Si le sujet vous intéresse, ce projet vous aidera - pyprotect .

Answer 25

Si nous nous concentrons sur les licences logicielles, je vous conseillerais de jeter un coup d'œil à une autre réponse au débordement de pile que j'ai écrite ici pour inspirez-vous de la manière dont un système de vérification de clé de licence peut être construit.

GitHub , une bibliothèque à code source ouvert peut vous aider à vérifier la licence. bit.

Vous pouvez l'installer avec licence d'installation pip , puis ajouter le code suivant:

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

Pour en savoir plus sur la configuration de la clé publique RSA, etc., cliquez ici .

Answer 26

utiliser cxfreeze (py2exe pour linux) fera l'affaire.

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

il est disponible dans les référentiels Ubuntu

Answer 27

Utilisez le même procédé pour protéger le fichier binaire de c / c ++, c’est-à-dire obscurcissez chaque corps de fonction dans un fichier binaire exécutable ou de bibliothèque, insérez une instruction "saut". au début de chaque entrée de fonction, passez à une fonction spéciale pour restaurer le code obfusqué. Le code d'octet est le code binaire du script Python.

• Compilez d'abord le script python pour coder l'objet
• Puis itérez chaque objet de code, masquer le co_code de chaque objet de code comme suit

    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

• Enregistrer un objet de code obscurci en tant que fichier .pyc ou .pyo

Ces fichiers obfusqués (.pyc ou .pyo) peuvent être utilisés par un interpréteur python normal lorsque cet objet code est appelé pour la première fois

• La première opération est JUMP_ABSOLUTE, elle passera au décalage n

• Au décalage n, l'instruction consiste à appeler une fonction PyCFunction. Cette fonction restaure le bytecode masqué entre l'offset 3 et n et place le code d'octet d'origine à l'offset 0. Le code obfusqué peut être obtenu à l'aide du code suivant

      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)
  

• Après le retour de cette fonction, la dernière instruction est de sauter à offset 0. Le code vraiment byte est maintenant exécuté.

Il existe un outil Pyarmor pour masquer les scripts python de cette manière.