Wie schütze ich Python-Code?

https://stackoverflow.com/questions/261638

06-07-2019
|

Frage

Ich bin ein Stück Software in Python zu entwickeln, die zu meinem Arbeitgeber der Kunden verteilt werden. Mein Arbeitgeber will die Nutzung der Software mit einer Zeit eingeschränkte Lizenzdatei begrenzen.

Wenn wir die Py-Dateien oder sogar .pyc Dateien verteilen wird es einfach sein zu (dekompilieren und), um den Code zu entfernen, die die Lizenzdatei überprüft.

Ein weiterer Aspekt ist, dass mein Arbeitgeber will nicht der Code von unseren Kunden zu lesen, aus Angst, dass der Code gestohlen werden kann, oder zumindest die „neuen Ideen“.

Gibt es einen guten Weg, um dieses Problem zu umgehen? Vorzugsweise mit einer Off-the-shelf Lösung.

Die Software wird auf Linux-Systemen läuft (so glaube ich nicht py2exe den Trick).

Lösung

Python, wobei ein Byte-Code kompiliert interpretierte Sprache, ist sehr schwer zu sperren. Selbst wenn Sie einen exe-Verpacker wie py2exe , das Layout der ausführbaren Datei ist gut bekannt, und der Python-Byte-Codes sind gut verstanden.

In der Regel in Fällen wie diesen, müssen Sie einen Kompromiss machen. Wie wichtig ist es wirklich um den Code zu schützen? Gibt es wirkliche Geheimnisse dort (wie ein Schlüssel für die symmetrische Verschlüsselung von Banküberweisungen), oder bist du nur paranoid? Wählen Sie die Sprache, die Ihnen das beste Produkt am schnellsten lässt entwickeln und realistisch sein, wie wertvoll Ihre neue Ideen sind.

Wenn Sie sich entscheiden, Sie wirklich die Lizenzprüfung sicher erzwingen müssen, schreiben Sie es als eine kleine C-Erweiterung, so dass die Lizenzprüfung Code extrahart sein kann (aber nicht unmöglich!) Reverse Engineering, und lassen Sie den Großteil Ihrer Code in Python.

Andere Tipps

„Gibt es einen guten Weg, um dieses Problem zu umgehen?“ Nein. Nichts kann gegen Reverse Engineering geschützt werden. Auch die Firmware auf DVD-Maschinen wurde Reverse Engineering und AACS Chiffrierschlüssel ausgesetzt. Und das ist trotz der DMCA, dass eine Straftat zu machen.

Da keine technische Methode, um Ihre Kunden beim Lesen Sie den Code stoppen, müssen Sie handelsüblichen Methoden anwenden.

Lizenzen. Verträge. Geschäftsbedingungen. Dies funktioniert auch dann, wenn die Leute den Code lesen können. Beachten Sie, dass einige Ihrer Python-basierten Komponenten erfordern, dass Sie Gebühren zahlen, bevor Sie Software unter Verwendung dieser Komponenten zu verkaufen. Auch einige Open-Source-Lizenzen verbieten Sie von Verschleierung der Quelle oder Ursprung dieser Komponente.
signifikanten Wert anbieten. zu einem Preis, zu verweigern schwer ist - - Wenn Sie Ihre Sachen so gut ist, gibt es keinen Anreiz, Zeit und Geld zu verschwenden umkehren etwas erfinden. Reverse Engineering ist teuer. Machen Sie Ihr Produkt etwas weniger teuer.
Angebot Upgrades und Erweiterungen, die jede Reverse Engineering eine schlechte Idee zu machen. Wenn die nächste Version ihrer Reverse Engineering bricht, gibt es keinen Punkt. Dies kann ad absurdum geführt werden, aber Sie sollten neue Funktionen bieten, die die nächste Version wertvoller als Reverse Engineering zu machen.
Angebot Anpassung bei Raten so attraktiv, dass sie lieber zahlen würden Sie bauen und die Erweiterungen unterstützen.
einen Lizenzschlüssel verwenden, die abläuft. Das ist grausam, und gibt Ihnen einen schlechten Ruf, aber es macht sicherlich die Software nicht mehr funktioniert.
Bieten Sie es als Web-Service. SaaS beinhaltet keine Downloads an die Kunden.

Python ist nicht das Werkzeug, das Sie benötigen

Sie müssen das richtige Werkzeug verwenden, das Richtige zu tun, und Python war nicht zu verschleierten gestaltet. Es ist das Gegenteil; alles ist offen oder einfach in Python zu offenbaren oder zu ändern, weil das die Philosophie der Sprache ist.

Wenn Sie etwas wollen Sie nicht sehen können, durch, suchen Sie nach einem anderen Werkzeug. Das ist keine schlechte Sache, es ist wichtig, dass mehrere verschiedene Werkzeuge für unterschiedliche Nutzungen vorhanden sind.

Obfuscation ist wirklich schwer

Auch können kompilierten Programme werden reverse-engineered denkt nicht, dass Sie in vollem Umfang von Code zu schützen. Sie können verschleierte PHP analysieren, brechen den Flash-Verschlüsselungsschlüssel usw. Neuere Versionen von Windows jedes Mal geknackt werden.

eine gesetzliche Anforderung ist eine gute Art und Weise

zu gehen

Sie können nicht jemand die aus missbräuchlicher Verwendung der Code verhindern, aber Sie können leicht herausfinden, ob jemand tut. Daher ist es nur eine gelegentliche rechtliche Frage.

Code-Schutz ist hoch genug

Heute, Geschäftsmodelle sind in der Regel für den Verkauf von Dienstleistungen statt Produkte zu gehen. Sie können einen Service, Raubkopie noch stehlen. Vielleicht ... ist es Zeit zu prüfen, mit dem Strom schwimmen

Übersetzen Python und verteilen Binaries!

Sensible Idee:

Verwenden Sie Cython , Nuitka , ähnliche Haut oder etwas Schuppen python in C-Code kompilieren, dann Ihre App als python binär verteilen Bibliotheken (PYD) statt.

Auf diese Weise kein Python (Byte) Code wird links und Sie haben eine vernünftige Menge an obscurification jemand getan (das heißt Ihr Arbeitgeber) von regelmäßigen-Code erwarten könnte, denke ich. (.NET oder Java weniger sicher als in diesem Fall, wie die Bytecode nicht verschleiert wird und relativ leicht in vernünftige Quelle dekompilierten werden kann.)

Cython wird immer mehr und mehr kompatibel mit CPython, so dass ich denke, es sollte funktionieren. (Ich erwäge tatsächlich diese für unser Produkt .. Wir sind bereits einige Drittanbieter-Libs Gebäude als pyd / dlls, so Versand unserer eigenen Python-Code als Binärdateien für uns kein allzu großer Schritt.)

Siehe Dieser Blog-Eintrag (nicht von mir) für eine Anleitung, wie man es tun. (Thx @hithwen)

Crazy Idee:

Sie könnten wahrscheinlich erhalten Cython die C-Dateien für jedes Modul separat zu speichern, dann verketten sie einfach alle und bauen sie mit schwerem inlining. Auf diese Weise Ihr Python-Modul ist ziemlich monolithisch und schwer zerspanbaren auf mit gängigen Werkzeugen.

Über verrückt:

Das könnte Sie der Lage sein, eine einzelne ausführbare Datei zu erstellen, wenn Sie verknüpfen können (und optimieren mit), um die Python-Laufzeit und alle Bibliotheken (DLLs) statisch. Auf diese Weise würde es sicher schwierig sein, Anrufe zu / von Python abzufangen und was auch immer Framework-Bibliotheken Sie verwenden. Dies kann nicht geschehen, wenn Sie obwohl LGPL-Code verwenden.

Ich verstehe, dass Sie Ihre Kunden wollen die Macht der Python verwenden, wollen aber nicht den Quellcode aus.

Hier sind meine Vorschläge:

(a) Schreiben Sie die kritischen Teile des Codes wie C oder C ++ Bibliotheken und verwenden Sie dann SIP oder swig die C / C ++ APIs Python-Namensraum zu belichten.

(b) Verwendung cython statt Python

(c) sowohl (a) und (b), sollte es möglich sein, die Bibliotheken als lizenzierte binär mit einer Python-Schnittstelle zu verteilen.

Ist Ihr Arbeitgeber bewusst, dass er „stehlen“ kann wieder irgendwelche Ideen, die anderen Menschen aus dem Code bekommen? Ich meine, wenn sie Ihre Arbeit lesen können, so können Sie ihre. Vielleicht schauen, wie man von der Situation profitieren würde eine bessere Rendite Ihrer Investition ergibt als aus Angst, wie viel Sie verlieren.

[EDIT] Antwort auf Nicks Kommentar:

Nichts gewonnen und nichts verloren. Der Kunde hat, was er will (und dafür bezahlt, da er die Änderung tat selbst). Da er nicht die Änderung entbindet, es ist, als ob es nicht für alle anderen der Fall war.

Nun, wenn der Kunde die Software verkauft, müssen sie den Copyright-Hinweis ändern (was illegal ist, so dass Sie verklagen können und werden gewinnen -> einfacher Fall).

Wenn sie nicht der Copyright-Hinweis ändern, die 2. Ebene Kunden werden feststellen, dass die Software von Ihnen kommt original und sich fragen, was los ist. Die Chancen stehen gut, dass sie mit Ihnen in Verbindung und so werden Sie über den Wiederverkauf von Ihrer Arbeit lernen.

Auch hier haben wir zwei Fälle: Der ursprünglichen Kunden nur wenige Exemplare verkauft. Das heißt, sie haben nicht viel Geld machen sowieso, also warum die Mühe. Oder sie verkaufte im Volumen. Das bedeutet bessere Chancen für Sie zu lernen, was sie tun und etwas dagegen tun.

Aber am Ende, versuchen die meisten Unternehmen auf das Gesetz zu befolgen (einmal ihr Ruf ruiniert ist, ist es viel schwieriger, Geschäfte zu machen). So werden sie Ihre Arbeit nicht stehlen, sondern mit Ihnen zusammenarbeiten, um es zu verbessern. Also, wenn Sie die Quelle (mit einer Lizenz, die Sie von der einfachen Reselling schützt) umfassen, die Chancen sind, dass sie einfach Änderungen zurückdrängen werden sie da gemacht, dass wird die Änderung in der nächsten Version stellen Sie sicher, und sie müssen es nicht halten . Das ist ein Win-win:. Sie Änderungen erhalten, und sie können die Änderung selbst machen, wenn sie wirklich, es dringend brauchen, auch wenn Sie nicht bereit, es in der offiziellen Veröffentlichung schließen

Haben Sie haben einen Blick auf pyminifier ? Es ist Minify, verschleiert, und Python-Code komprimieren. Der Beispielcode sieht ziemlich fiese für lässigen Reverse Engineering.

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

Verlassen Sie sich nicht auf Verschleierung. Wie Sie richtig geschlossen haben, bietet es einen sehr begrenzten Schutz. UPDATE: Hier ist ein Link zu Papier das Reverse Engineering verschleierter python-Code in Dropbox. Der Ansatz -. Opcode Remapping ist eine gute Barriere, aber klar kann es besiegt werden

Stattdessen kann, wie viele Plakate erwähnt hat es:

Nicht wert Reverse Engineering Zeit (Ihre Software ist so gut, macht es Sinn, zu bezahlen)
Machen sie einen Vertrag unterschreiben und machen eine Lizenzprüfung, wenn möglich.

Alternativ kann, wie der Kick-ass Python IDE WingIDE tut: Geben Sie den Code entfernt. Das ist richtig, den Code verraten und haben die Menschen wieder für Upgrades und Support.

Versand .pyc Dateien hat seine Probleme - sie sind nicht kompatibel mit jeder anderen Python-Version als die Python-Version, die sie mit erstellt wurden, was bedeutet, Sie müssen wissen, welche Python-Version auf den Systemen läuft das Produkt zum laufen. Das ist ein sehr limitierenden Faktor dar.

In einigen Fällen kann es möglich sein, sich zu bewegen (alle oder zumindest ein wesentlicher Teil) der Software in eine Web-Service, der Ihre Organisation Hosts.

Auf diese Weise können die Lizenzüberprüfungen der Sicherheit der eigenen Serverraum durchgeführt werden.

Obwohl es keine perfekte Lösung ist, kann folgendes geschehen:

Bewegen Sie einige kritische Stück Startup-Code in eine native Bibliothek.
Erzwingen die Lizenzprüfung in der nativen Bibliothek.

Wenn der Anruf an den nativen Code zu entfernen, würde das Programm ohnehin nicht starten. Wenn es nicht entfernt ist, dann wird die Lizenz geltend gemacht werden.

Obwohl dies nicht eine Cross-Plattform ist oder eine reine Python-Lösung, wird es funktionieren.

Die zuverlässige einzige Möglichkeit, Code zu schützen, ist es auf einem Server, den Sie steuern laufen und Ihre Kunden mit einem Client, der mit dieser Server-Schnittstellen zur Verfügung stellen.

Ich denke, es ist eine weitere Methode, um Ihren Python-Code zu schützen; Teil des Verfahrens Verschleierung. Ich glaube, dass es ein Spiel wie Mount and Blade oder etwas war, die ihr eigenes Python-Interpreter verändert und neu kompilierte (das Original-Interpreter, den ich glaube, dass Open Source) und veränderte nur den OP-Codes in der OP-Code-Tabelle, anders zu sein dann der Standard-Python-OP Codes.

So ist der Python-Source unmodifizierten ist aber die Dateierweiterungen der * .pyc Dateien sind unterschiedlich und der Op-Codes für die Öffentlichkeit nicht python.exe Dolmetscher entspricht. Wenn Sie die Spiele-Datendateien werden alle Daten wurden in Python-Source-Format überprüft.

Alle Arten von fiesen Tricks können mit unreifem Hacker auf diese Weise zu verwirren erfolgen. ein paar unerfahrene Hacker zu stoppen ist einfach. Es ist die professionelle Hacker, dass Sie nicht wahrscheinlich höher schlagen. Aber die meisten Unternehmen nicht halten Pro Hacker auf Personal lange denke ich (wahrscheinlich, weil die Dinge gehackt). Aber unreife Hacker sind alle über den Ort (wie neugierig IT-Mitarbeiter lesen).

Sie können beispielsweise in einem modifizierten Interpreter, lassen Sie es für bestimmte Kommentare oder doc-Strings in Ihrer Quelle zu überprüfen. Sie könnten für eine solche Zeilen Code spezielle OP-Codes haben. Zum Beispiel:

OP 234 ist für Quellenleitung „# Urheberrecht Ich schrieb dieses“ oder diese Zeile in op-Codes erstellen, die gleichwertig sind „wenn falsch:“ if „# Urheberrecht“ fehlt. Im Grunde genommen einen ganzen Block von Code zur Deaktivierung der scheinbar unerfindlichen Gründen sein.

Ein Anwendungsfall, wo ein modifizierte Interpreter neu zu kompilieren kann machbar ist, wo Sie die App nicht geschrieben haben, die App ist groß, aber Sie werden es schützen bezahlt, wie wenn Sie ein dedizierter Server Admin für eine Finanz sind App.

Ich finde es ein wenig widersprüchlich die Quelle oder Opcodes offen für Augäpfel zu verlassen, aber SSL für den Netzwerkverkehr nutzen. SSL ist nicht 100% sicher auch nicht. Aber es wird benutzt, um MOST Augen es beim Lesen zu stoppen. Ein bisschen Vorsicht ist sinnvoll.

Auch, wenn genug Leute halten, dass Python Quelle und OP-Codes zu sehen ist, ist es wahrscheinlich, jemand wird schließlich zumindest ein einfaches Schutzwerkzeug für sie entwickeln. Je mehr Leute zu fragen, „wie Python App zu schützen“ fördert nur die Entwicklung.

Je, wer der Kunde ist, ein einfacher Schutzmechanismus, kombinierte mit einer vernünftigen Lizenzvereinbarung wird far effektiver als jedes komplexe Lizenz / Verschlüsselung / Verschleierungssystem.

Die beste Lösung wäre, den Code als Dienstleistung verkaufen werden, etwa durch die Hosting-Service oder Unterstützung anbieten - auch wenn das nicht immer praktisch ist

Versand des Codes als .pyc Dateien Ihren Schutz verhindern, indem sie ein paar #s vereitelt werden, aber es ist kaum wirksam Anti-Piraterie-Schutz (als ob es eine solche Technologie ist), und am Ende des Tages, sollte es nicht erreicht alles, was ein anständiger Lizenzvertrag mit dem Unternehmen wird.

Konzentrieren Sie sich auf Ihren Code so schön zu verwenden wie möglich zu machen - zufriedene Kunden haben, wird Ihr Unternehmen weit mehr Geld verdienen als einige theoretische Piraterie zu verhindern ..

Verwenden Sie Cython . Es wird Ihre Module zu hochperformante C-Dateien kompiliert, die dann in den einheitlichen binären Bibliotheken kompiliert werden. Dies ist im Grunde nicht-umkehrbar, im Vergleich zu .pyc Bytecode!

Ich habe einen ausführlichen Artikel geschrieben, wie Cython für ein Python-Projekt einzurichten, check it out:

Schutz Python Quellen Mit Cython

Ein weiterer Versuch, den Code schwerer zu stehlen zu machen, ist jython zu verwenden und dann verwenden java obfuscator .

Dies sollte ziemlich gut funktionieren wie jythonc Python-Code zu Java übersetzen und dann wird Java Bytecode kompiliert. So Unze verschleiern Sie die Klassen wird es wirklich schwer zu verstehen, was nach Dekompilierungsprozeß vor sich geht, nicht den eigentlichen Code erholt zu erwähnen.

Das einzige Problem mit jython ist, dass Sie nicht Python Module geschrieben in C verwenden können.

Was ist mit Ihrem Code mit Standard-Verschlüsselungsschema Unterzeichnung durch Hashing und Signatur wichtige Dateien und es mit einem öffentlichen Schlüssel Methoden überprüfen?

Auf diese Weise können Sie die Lizenzdatei mit einem öffentlichen Schlüssel für jeden Kunden ausgeben können.

Weitere können Sie eine Python obfuscator wie diese verwenden (nur es googeln).

Sie sollten einen Blick auf, wie die Jungs bei getdropbox.com tun es für ihre Client-Software, einschließlich Linux. Es ist ziemlich schwierig zu knacken und erfordert einige recht kreative Demontage vorbei an den Schutzmechanismen zu erhalten.

Ich war überrascht, in nicht zu sehen pyconcrete in jeder Antwort. Vielleicht, weil es neuer ist als die Frage?

Es könnte genau das sein, was Sie brauchen (ed).

Statt den Code verschleiern, es verschlüsselt und entschlüsselt zur Ladezeit.

pypi :

Schützen Python-Skript Arbeitsablauf


your_script.py import pyconcrete

pyconcrete wird Import-Modul anschließen

, wenn Ihr Skript tun Import MODULE,   pyconcrete Import Haken werden versuchen MODULE.pye zuerst zu finden und dann   Entschlüsseln MODULE.pye über _pyconcrete.pyd und auszuführen entschlüsselten Daten (wie   .pyc Inhalt)

Verschlüsseln und Entschlüsseln von geheimen Schlüsselsatz in _pyconcrete.pyd   (Wie DLL oder SO) der geheime Schlüssel würde verstecken sich in Binärcode sein, kann nicht   sehen sie direkt in HEX Ansicht

Das Beste, was Sie mit Python tun können, ist, die Dinge zu verschleiern.

Strip aus allen Docstrings
Verteilen Sie nur die .pyc kompilierten Dateien.
einfrieren
Unklar Ihre Konstanten in einer Klasse / Modul, so dass Hilfe (config) nicht alles zeigen

Sie können möglicherweise einige zusätzliche Unklarheit hinzuzufügen, indem ein Teil davon zu verschlüsseln und es im laufenden Betrieb zu entschlüsseln und weitergeben () eval. Aber egal, was Sie tun, jemand kann es brechen.

Nichts davon wird vom Zerlegen der Bytecode oder Graben durch Ihre api mit Hilfe, dir, etc einen entschlossenen Angreifer zu stoppen.

Idee von Zeit beschränkte Lizenz hat und in lokal installierten Programm für sie überprüfen wird nicht funktionieren. Selbst bei perfekter Verschleierung kann Lizenzprüfung entfernt werden. Allerdings, wenn Sie Lizenz auf dem Remote-System überprüfen und wesentlichen Teil des Programms auf Ihrem geschlossenes Remote-System ausführen, werden Sie in der Lage sein, Ihre IP zu schützen.

Verhindern von Konkurrenten von der Nutzung des Quellcodes als ihre eigenen oder ihre inspirierte Version des gleichen Code schreiben, ist eine Möglichkeit, zu schützen Signaturen zu Ihrer Programmlogik hinzufügen (einige Geheimnisse der Lage sein, diesen Code zu beweisen, wurde von Ihnen gestohlen) und verschleiert den python-Quellcode so, es ist schwer zu lesen und zu nutzen.

Good Verschleierungs fügt im Grunde den gleichen Schutz, um Ihren Code, dass Kompilieren es ausführbar (und Strippen binär) der Fall ist. Herauszufinden, wie verschleierte komplexer Code funktioniert vielleicht noch schwieriger, als tatsächlich ein eigene Implementierung zu schreiben.

Dies wird helfen, nicht Hacking Ihres Programms zu verhindern. Selbst mit Sachen Verschleierung Code Lizenz geknackt werden und Programm geändert wird, kann etwas unterschiedliches Verhalten hat (in der gleichen Art und Weise, dass Code in binären Kompilieren nicht Schutz der heimischen Programme hilft).

Neben Symbol Verschleierung könnte eine gute Idee sein, um den Code zu unrefactor, das alles macht noch verwirrender, wenn z.B. Graphen Punkte auf viele verschiedene Orte nennen, auch wenn tatsächlich diese verschiedenen Orten tut schließlich das Gleiche.

Logische Signatur innerhalb verschleierten Code (z können Sie Wertetabelle erstellen, die von Programmlogik verwendet werden, sondern auch als Signatur verwendet), die verwendet werden können, dass Code, um zu bestimmen, von Ihnen stammt. Wenn jemand Ihre verschleierten Code zu verwenden Modul als Teil ihres eigenen Produktes entscheidet (auch nach reobfuscating es, um es anders zu machen scheint) Sie zeigen können, dass Code mit Ihrer geheimen Signatur gestohlen.

Ich habe für meine eigenen Projekte auf Software-Schutz im Allgemeinen betrachtet und die allgemeine Philosophie ist, dass vollständiger Schutz ist nicht möglich. Das einzige, was man hoffen kann, zu erreichen, ist der Schutz auf ein Niveau hinzuzufügen, dass Ihr Kunden mehr kosten würde, zu umgehen, als wäre es eine weitere Lizenz zu erwerben.

Mit dieser sagte ich gerade überprüft Google für Python obsfucation und nicht viel etwas Aufdrehen. In einer .NET-Lösung wäre obsfucation ein erster Ansatz, um Ihr Problem auf einer Windows-Plattform, aber ich bin nicht sicher, ob jemand Lösungen auf Linux hat, die mit Mono arbeiten.

Das nächste, was wäre Ihr Code in einer kompilierten Sprache zu schreiben, oder wenn Sie wirklich den ganzen Weg gehen wollen, dann in Assembler. Ein gezupft ausführbar wäre viel schwieriger sein, eine interpretierte Sprache zu dekompilieren als.

Es kommt alles zu Kompromissen. An einem Ende haben Sie eine einfache Software-Entwicklung in Python, in dem es auch zu verbergen Geheimnisse sehr hart ist. Am anderen Ende haben Sie eine Software in Assembler geschrieben, die viel schwieriger zu schreiben, aber viel einfacher ist, Geheimnisse zu verbergen.

Ihr Chef hat einen Punkt irgendwo entlang dieses Kontinuums zu wählen, die seine Anforderungen unterstützt. Und dann hat er Ihnen die Werkzeuge und Zeit zu geben, so können Sie bauen, was er will. Aber meine Wette ist, dass er auf real Entwicklungskosten im Vergleich zu potenziellen finanziellen Verlusten Objekt wird.

Es ist möglich, den py2exe Byte-Code in einem verschlüsselten Ressource für einen C-Launcher, dass Lasten zu haben und führt sie im Speicher. Einige Ideen hier und hier .

haben einige auch gedacht ein selbst modifizierende Programm umgekehrt machen Engineering teuer.

Sie können auch Tutorials zur Verhinderung Debugger , machen den Disassembler fehlschlagen, stellen Sie finden false Debugger-Breakpoints und Ihren Code mit Prüfsummen schützen. Suche nach [ "crypted Code" Ausführen "im Speicher"] für mehr Links.

Aber wie andere schon gesagt, wenn Ihr Code es wert ist, Reverse Engineers am Ende erfolgreich sein wird.

Lange Rede kurzer Sinn:

Verschlüsseln Sie Ihre Source-Code
Schreiben Sie Ihre eigenen Python-Modul-Loader Code zu entschlüsseln, beim Import
Implementieren Sie die Modul-Lader in C / C ++
Sie können mehr Funktionen zum Modul-Lader hinzufügen, zum Beispiel anti-Debugger, Lizenzkontrolle, Hardware-Fingerabdruck-Bindung, etc.

Für weitere Details schauen Sie diese Antwort .

Wenn Sie das Thema interessiert sind, wird dieses Projekt Ihnen helfen - pyprotect

Wenn wir auf Software-Lizenzierung konzentrieren, würde ich empfehlen, einen Blick auf einen anderen Stack-Überlauf Antwort nehme ich hier schrieb erhalten Inspiration, wie kann ein Lizenzschlüssel Verifikationssystem aufgebaut werden.

Es ist ein Open-Source-Bibliothek auf GitHub , dass Sie mit der Lizenzüberprüfung helfen können Bit.

Sie können es durch pip install licensing installieren und fügen Sie dann den folgenden Code:

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

Sie können mehr über die Art und Weise der öffentlichen RSA-Schlüssel lesen, usw. sind so konfiguriert, hier .

mit cxfreeze (py2exe für Linux) wird die Arbeit tun.

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

Es ist in Ubuntu-Repositories verfügbar

Mit der gleichen Weise Binärdatei von c schützen / C ++, das heißt, verschleiern jede Körperfunktion in ausführbare Datei oder Bibliothek Binärdatei, legen eine Anweisung „Sprung“ Beginn eines jeden Funktionseintrag, springe zur Sonderfunktion wiederherzustellen verschleierter Code. Byte-Code ist Binärcode von Python-Skript, so

Erste Kompilierung Python-Skript-Code Objekt
iterieren dann jedes Codeobjekt, verschleiern co_code jedes Code Objekt wie das folgende

    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

Speichern verschleierten Code Objekt als .pyc oder .pyo Datei

Die verschleierte Datei (.pyc oder .pyo) kann durch normales Python-Interpreter verwendet werden, wenn derjenigediejenigedasjenige Codeobjekt ersten Aufruf

Erste op ist JUMP_ABSOLUTE, springt es zum Ausgleich n
Bei n-Offset ist der Befehl einen PyCFunction zu nennen. Diese Funktion wird diese verschleierten Bytecode wiederherstellen zwischen 3 versetzt und n und der ursprünglichen Bytecode setzt auf 0 Offset Der verschleierte Code kann durch den folgenden Code bekommen wird
```
    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)
```
Nach dieser Funktion zurückkehrt, ist der letzte Befehl zu springen Offset 0. Der wirklich Byte-Code jetzt ausgeführt wird.

Es gibt ein Tool Pyarmor Python-Skripte auf diese Weise zu verschleiern.

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow