Comment protéger le code Python?
Je développe un logiciel en Python qui sera distribué aux clients de mon employeur. Mon employeur veut limiter l'utilisation du logiciel avec un fichier de licence limité dans le temps.
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 "idées nouvelles".
Y at-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 (donc je ne pense pas que py2exe fera l'affaire).
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 présentation 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 afin que le code de vérification de licence puisse être extrêmement dur (mais pas impossible!) Pour procéder à l'ingénierie inverse, et laissez l'essentiel de votre code en Python. .
"Y a-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 par reverse engineering et AACS Encryption key exposure. Et cela malgré le fait que le DMCA ait érigé cela en infraction pénale.
Comme aucune méthode technique ne peut empêcher vos clients de lire votre code, vous devez appliquer les méthodes commerciales habituelles.
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 des logiciels utilisant ces composants. En outre, certaines licences open source vous empêchent de dissimuler la source ou les origines de ce composant.
Offrir 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. Rendez votre produit un peu moins cher.
Proposez des mises à niveau et des améliorations qui rendent toute ingénierie inverse une mauvaise idée. Lorsque la prochaine version annulera 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 le reverse engineering.
Proposez des options de personnalisation à des taux si intéressants qu’ils préféreraient vous payer pour construire et prendre en charge les améliorations.
Utilisez une clé de licence qui expire. Ceci est cruel et vous donnera une mauvaise réputation, mais votre logiciel ne fonctionnera certainement plus.
Offrez-le comme un service Web. SaaS n'implique aucun téléchargement pour les clients.
Python n'est pas l'outil dont vous avez besoin
Vous devez utiliser le bon outil pour faire le bon choix, 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 différents existent pour différents usages.
L'obfuscation est vraiment difficile
Même les programmes compilés peuvent être désossés, alors ne pensez pas que vous pouvez protéger totalement le code. Vous pouvez analyser PHP obfusqué, casser la clé de chiffrement flash, etc. Les nouvelles versions de Windows sont fissurées à chaque fois.
Avoir une obligation légale est un bon chemin à parcourir
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 surfaite
De nos jours, les modèles commerciaux ont tendance à privilégier la vente de services plutôt que de produits. Vous ne pouvez pas copier un service, pirater ou le voler. Peut-être qu'il est temps d'envisager de suivre le courant ...
Compilez python et distribuez les 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 sous forme de bibliothèques binaires python (pyd).
De cette façon, il ne reste plus de code (octet) Python et vous avez dissimulé une quantité raisonnable d'obscurcissements à laquelle tout le monde (votre employeur) pouvait s'attendre du code habituel, je pense. (.NET ou Java moins sûr que ce cas, étant donné que 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 construire des bibliothèques tierces en tant que pyd/dlls, alors expédier 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 fou:
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 pas être fait si vous utilisez du code LGPL.
Je comprends que vous souhaitiez que vos clients utilisent la puissance de Python mais ne souhaitiez 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) En (a) et en (b), il devrait être possible de distribuer les bibliothèques sous forme de licence binaire avec une interface Python.
Votre employeur sait-il qu'il peut "récupérer" des idées que d'autres personnes ont récupéré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 un meilleur retour sur 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 libère 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 changer la notification de copyright (ce qui est illégal, vous pouvez donc poursuivre et gagner -> affaire simple).
S'ils ne modifient pas la notification de copyright, 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 de meilleures chances pour vous d’apprendre ce qu’ils font et de faire quelque chose.
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 est probable qu'ils repousseront simplement les modifications qu'ils ont apportées, car ils feront en sorte 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.
Avez-vous jeté un œil à pyminifier ? Cela minimise, obscurcit et compresse le code Python. L'exemple de code semble assez 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)
Ne comptez pas sur l'obscurcissement. Comme vous l'avez correctement conclu, il offre une protection très limitée . MISE À JOUR: Voici un lien vers le papier qui code du code python obfuscé en reverse engineering dans Dropbox. L'approche - le remappage d'opcode est une bonne barrière, mais il est évident qu'elle peut être vaincue.
Comme le signalent de nombreuses affiches,
- Ne vaut pas le temps d'ingénierie inverse (votre logiciel est si bon qu'il est logique de payer)
- Leur faire signer un contrat et faire un audit de licence si possible.
Alternativement, comme le fait Python IDE, kickIDE, WingIDE: Donne le code. C’est vrai, donnez le code et demandez aux gens de revenir pour des mises à jour et du support.
L'expédition de 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 s'exécute sur les systèmes sur lesquels le produit sera exécuté. C'est un facteur très limitant.
Dans certaines circonstances, il peut être possible de déplacer (tout ou au moins une partie clé) du logiciel 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.
Bien qu'il n'y ait pas de solution parfaite, voici ce qui peut être fait:
- Déplacez un élément critique du code de démarrage dans une bibliothèque native.
- Appliquez le contrôle de licence dans la bibliothèque native.
Si l'appel au code natif devait être supprimé, le programme ne commencerait pas de toute façon. Si ce n'est pas supprimé alors la licence sera appliquée.
Bien que ce ne soit pas une solution multiplate-forme ou pure-Python, cela fonctionnera.
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 venait de changer les codes OP dans la table de codes OP pour qu'ils soient différents du OP standard 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 de 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:
L'OP 234 est pour la ligne source "# Copyright j'ai écrit ceci" Ou compilez cette ligne en codes opérations équivalents à "if 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é pour une application financière.
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 raisonnable.
En outre, si suffisamment de personnes considèrent 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 font que promouvoir ce développement.
Le seul moyen fiable de protéger le code est de l'exécuter sur un serveur que vous contrôlez et de fournir à vos clients un client qui s'interface avec ce serveur.
Selon le client, un mécanisme de protection simple, associé à un contrat de licence raisonnable, sera de loin plus efficace que n’importe quel système complexe de licence/cryptage/obscurcissement.
La meilleure solution serait de vendre le code en tant que service, en hébergeant le service ou en offrant une assistance - même si cela n’est pas toujours pratique.
Envoyer le code sous forme de fichiers .pyc empêchera votre protection d'être déjouée de quelques #s, mais ce n'est pas une protection anti-piratage efficace (comme s'il existait une telle technologie), et en fin de compte, elle ne devrait rien obtenir un accord de licence décent avec la société sera.
Faites en sorte que votre code soit aussi simple d'utilisation que possible - avoir des clients satisfaits rapportera à votre entreprise bien plus d'argent que d'empêcher le piratage théorique.
Une autre tentative pour rendre votre code plus difficile à voler consiste à utiliser jython, puis à utiliser Java obfuscator .
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.
Vous devriez jeter un coup d'œil à la façon dont les gars 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.
Pourquoi ne pas signer 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 en python comme celui-ci (juste le googler).
Utilisez Cython . Il compilera vos modules en fichiers C très performants, qui pourront ensuite être compilés en bibliothèques binaires natives. Ceci est fondamentalement irréversible, comparant au bytecode .pyc!
J'ai écrit un article détaillé sur la configuration de Cython pour un projet Python, consultez-le:
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 (ed).
Au lieu d'obscurcir le code, il le chiffre et le déchiffre au moment du chargement.
De pypi page :
Protéger le flux de travail du script python
- votre_script.py
import pyconcrete- pyconcrete va accrocher le module d'importation
- lorsque votre script importe
MODULE, pyconcrete import hook essaiera de trouverMODULE.pyeen premier, puis déchiffrerMODULE.pyevia_pyconcrete.pydet exécuter des données déchiffrées (en tant que contenu- chiffrer et déchiffrer l'enregistrement de clé secrète dans
_pyconcrete.pyd(comme DLL ou SO), la clé secrète serait cachée dans du code binaire, ne peut pas voir directement en vue HEX
L'idée d'avoir une licence limitée dans le temps et de la vérifier dans un programme installé localement ne fonctionnera pas. Même avec un obscurcissement parfait, le contrôle de licence peut être supprimé. Cependant, 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 comme leur propre nom ou d’écrire leur version inspirée du même code, une façon de le protéger consiste à ajouter des signatures à la logique de votre programme (certains secrets permettant de prouver que le code vous a été volé) et à masquer la Le code source python est donc difficile à lire et à utiliser.
Une bonne dissimulation ajoute fondamentalement la même protection à votre code que la compilation en exécutable (et en supprimant les binaires). 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, les licences seront fissurées 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 s’avérer judicieux de supprimer le code, ce qui rendrait 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 différents endroits font finalement 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é comme 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 obscurci 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.
Le mieux que vous puissiez faire avec Python est d’obscurcir les choses.
- Supprimer tous les docstrings
- Distribuez uniquement les fichiers compilés .pyc.
- le congeler
- Obscurcissez vos constantes dans une classe/un module afin que help (config) ne montre pas tout
Vous pourrez peut-être ajouter de l'obscurité supplémentaire en cryptant 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 creuser dans votre API avec de l'aide, des dir, etc.
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 puissiez espérer réaliser est d’ajouter une protection d’un niveau qui coûterait plus cher à votre client que d’acheter une autre licence.
Cela dit, je vérifiais que Google était obsédé par le python et que je ne rapportais pas grand chose. Dans une solution .Net, l'observation 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 ce 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.
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 auto-modificateur pour rendre l’ingénierie inverse coûteuse.
Vous pouvez également trouver des tutoriels pour empêcher les débogueurs , faire échouer le désassembleur, définir des points d'arrêt de débogueur faux et protéger votre code avec des sommes de contrôle. Recherchez ["code crypté" exécuter "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 en rétro-informatique réussiront à la fin.
Longue histoire courte:
- Cryptez votre code source
- Ecrivez votre propre chargeur de modules python pour déchiffrer votre code lors de l'importation
- Implémenter le chargeur de module en C/C++
- Vous pouvez ajouter plus de fonctionnalités au chargeur de module, par exemple un anti-débogueur, un contrôle de licence, une liaison d'empreinte digitale matérielle, etc.
Pour plus de détails, regardez cette réponse .
Si le sujet vous intéresse, ce projet vous aidera - pyprotect .
utiliser cxfreeze (py2exe pour linux) fera le travail.
http://cx-freeze.sourceforge.net/
il est disponible dans les dépôts d'ubuntu
Utilisez la même méthode 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 "jump" au début de chaque entrée de fonction, passez à une fonction spéciale pour restaurer le code obscurci. Le code d'octet est le code binaire du script Python.
- Premier script python à coder 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 ... ... Ici c'est du bytecode obscurci ... n LOAD_GLOBAL? (__pyarmor __) n + 3 CALL_FUNCTION 0 n + 6 POP_TOP n + 7 JUMP_ABSOLUTE 0
- Enregistrer un objet de code masqué en tant que fichier .pyc ou .pyo
Ce fichier obscurci (.pyc ou .pyo) peut être utilisé 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 obfusqué 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 consiste à accéder à Offset 0. Le véritable code d'octet est maintenant exécuté.
Il existe un outil Pyarmor pour obscurcir les scripts python de cette façon.
Si nous nous concentrons sur les licences logicielles, je vous conseillerais de jeter un coup d'œil à une autre réponse de Stack Overflow que j'ai écrite ici / afin de vous inspirer sur la manière de construire un système de vérification de clé de licence.
Il existe une bibliothèque open-source sur GitHub qui peut vous aider avec le bit de vérification de licence.
Vous pouvez l'installer par pip install licensing 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")
Vous pouvez en savoir plus sur la configuration de la clé publique RSA, etc. ici .