Ich entwickle eine Software in Python, die an die Kunden meines Arbeitgebers verteilt wird. Mein Arbeitgeber möchte die Nutzung der Software durch eine zeitlich begrenzte Lizenzdatei einschränken.

Wenn wir die .py-Dateien oder sogar .pyc-Dateien verteilen, ist es einfach, den Code, der die Lizenzdatei überprüft, zu dekompilieren und zu entfernen.

Ein weiterer Aspekt ist, dass mein Arbeitgeber nicht möchte, dass der Code von unseren Kunden gelesen wird, weil er befürchtet, dass der Code gestohlen wird oder zumindest die "neuartigen Ideen".

Gibt es eine gute Möglichkeit, dieses Problem zu lösen? Vorzugsweise mit einer Standardlösung.

Die Software wird auf Linux-Systemen ausgeführt (daher glaube ich nicht, dass py2exe den Trick macht).

Python, eine mit Bytecode kompilierte interpretierte Sprache, ist sehr schwer zu sperren. Selbst wenn Sie einen Exe-Packager wie py2exe verwenden , ist das Layout der ausführbaren Datei bekannt und die Python-Bytecodes sind gut bekannt.

In solchen Fällen müssen Sie normalerweise einen Kompromiss eingehen. Wie wichtig ist es wirklich, den Code zu schützen? Gibt es dort echte Geheimnisse (wie einen Schlüssel für die symmetrische Verschlüsselung von Banküberweisungen) oder sind Sie nur paranoid? Wählen Sie die Sprache, mit der Sie das beste Produkt am schnellsten entwickeln können, und seien Sie realistisch, wie wertvoll Ihre neuartigen Ideen sind.

Wenn Sie sich wirklich dazu entschließen, die Lizenzprüfung sicher durchzusetzen, schreiben Sie sie als kleine C-Erweiterung, damit der Code für die Lizenzprüfung besonders schwer (aber nicht unmöglich!) Zurückentwickeln kann, und belassen Sie den Großteil Ihres Codes in Python .

"Gibt es eine gute Möglichkeit, dieses Problem zu lösen?" Nein. Gegen Reverse Engineering kann nichts geschützt werden. Sogar die Firmware auf DVD-Computern wurde rückentwickelt und der AACS-Verschlüsselungsschlüssel verfügbar gemacht. Und das trotz der DMCA, die dies zu einer Straftat macht.

Da keine technische Methode Ihre Kunden daran hindern kann, Ihren Code zu lesen, müssen Sie gewöhnliche kommerzielle Methoden anwenden.

1. Lizenzen. Verträge. Geschäftsbedingungen. Dies funktioniert auch dann noch, wenn Benutzer den Code lesen können. Beachten Sie, dass für einige Ihrer Python-basierten Komponenten möglicherweise Gebühren anfallen, bevor Sie Software mit diesen Komponenten verkaufen. Einige Open-Source-Lizenzen verbieten es Ihnen außerdem, die Quelle oder den Ursprung dieser Komponente zu verbergen.

2. Bieten Sie einen signifikanten Wert. Wenn Ihre Sachen so gut sind - zu einem Preis, der schwer abzulehnen ist - gibt es keinen Anreiz, Zeit und Geld für das Reverse Engineering zu verschwenden. Reverse Engineering ist teuer. Machen Sie Ihr Produkt etwas günstiger.

3. Bieten Sie Upgrades und Verbesserungen an, die Reverse Engineering zu einer schlechten Idee machen. Wenn die nächste Version das Reverse Engineering unterbricht, macht es keinen Sinn. Dies kann zu absurden Extremen führen, aber Sie sollten neue Funktionen anbieten, die die nächste Version wertvoller machen als Reverse Engineering.

4. Bieten Sie Anpassungen zu Preisen an, die so attraktiv sind, dass Sie lieber dafür bezahlen, dass Sie die Verbesserungen erstellen und unterstützen.

5. Verwenden Sie einen Lizenzschlüssel, der abläuft. Dies ist grausam und gibt Ihnen einen schlechten Ruf, aber es führt sicherlich dazu, dass Ihre Software nicht mehr funktioniert.

6. Bieten Sie es als Webdienst an. SaaS beinhaltet keine Downloads für Kunden.

Python ist nicht das Werkzeug, das Sie brauchen

Sie müssen das richtige Werkzeug verwenden, um das Richtige zu tun, und Python wurde nicht entwickelt, um verschleiert zu werden. Es ist das Gegenteil; In Python ist alles offen oder leicht zu enthüllen oder zu ändern, da dies die Philosophie der Sprache ist.

Wenn Sie etwas wollen, das Sie nicht durchschauen können, suchen Sie nach einem anderen Werkzeug. Dies ist keine schlechte Sache, es ist wichtig, dass mehrere unterschiedliche Tools für unterschiedliche Verwendungen vorhanden sind.

Die Verschleierung ist wirklich schwer

Sogar kompilierte Programme können rückentwickelt werden. Denken Sie also nicht, dass Sie Code vollständig schützen können. Sie können verschleiertes PHP analysieren, den Flash-Verschlüsselungsschlüssel beschädigen usw. Neuere Windows-Versionen werden jedes Mal geknackt.

Eine gesetzliche Anforderung zu haben, ist ein guter Weg

Sie können nicht verhindern, dass jemand Ihren Code missbraucht, aber Sie können leicht feststellen, ob dies jemand tut. Daher ist es nur eine zufällige rechtliche Frage.

Der Codeschutz wird überbewertet

Heutzutage tendieren Geschäftsmodelle dazu, Dienstleistungen anstelle von Produkten zu verkaufen. Sie können einen Dienst nicht kopieren, raubkopieren oder stehlen. Vielleicht ist es an der Zeit, darüber nachzudenken, mit dem Fluss zu gehen ...

Kompilieren Sie Python und verteilen Sie Binärdateien!

Sinnvolle Idee:

Verwenden Sie Cython , Nuitka , Shed Skin oder ähnliches, um Python in C-Code zu kompilieren, und verteilen Sie Ihre App stattdessen als Python-Binärbibliotheken (pyd).

Auf diese Weise bleibt kein Python-Code (Byte-Code) übrig, und Sie haben eine angemessene Menge an Verschleierung vorgenommen, die jeder (dh Ihr Arbeitgeber) von regulärem Code erwarten kann, denke ich. (.NET oder Java sind weniger sicher als dieser Fall, da dieser Bytecode nicht verschleiert ist und relativ leicht in eine vernünftige Quelle dekompiliert werden kann.)

Cython wird immer kompatibler mit CPython, daher denke ich, dass es funktionieren sollte. (Ich erwäge dies tatsächlich für unser Produkt. Wir erstellen bereits einige Bibliotheken von Drittanbietern als pyd / dlls, daher ist es für uns kein allzu großer Schritt, unseren eigenen Python-Code als Binärdateien zu versenden.)

In diesem Blog-Beitrag (nicht von mir) finden Sie ein Tutorial dazu. (Danke @hithwen)

Verrückte Idee:

Sie könnten Cython wahrscheinlich dazu bringen, die C-Dateien für jedes Modul separat zu speichern, sie dann einfach alle zu verketten und sie mit starkem Inlining zu erstellen. Auf diese Weise ist Ihr Python-Modul ziemlich monolithisch und mit gängigen Tools nur schwer zu bearbeiten.

Jenseits von verrückt:

Möglicherweise können Sie eine einzelne ausführbare Datei erstellen, wenn Sie die Python-Laufzeit und alle Bibliotheken (DLLs) statisch verknüpfen (und damit optimieren) können. Auf diese Weise ist es sicher schwierig, Aufrufe von / zu Python und den von Ihnen verwendeten Framework-Bibliotheken abzufangen. Dies ist jedoch nicht möglich, wenn Sie LGPL-Code verwenden.

Ich verstehe, dass Sie möchten, dass Ihre Kunden die Leistung von Python nutzen, aber den Quellcode nicht verfügbar machen möchten.

Hier sind meine Vorschläge:

(a) Schreiben Sie die kritischen Teile des Codes als C- oder C ++ - Bibliotheken und verwenden Sie dann SIP oder swig , um die C / C ++ - APIs dem Python-Namespace auszusetzen.

(b) Verwenden Sie Cython anstelle von Python

(c) Sowohl in (a) als auch in (b) sollte es möglich sein, die Bibliotheken als lizenzierte Binärdatei mit einer Python-Schnittstelle zu verteilen.

Ist Ihrem Arbeitgeber bewusst, dass er Ideen, die andere Personen aus Ihrem Code erhalten, "zurücknehmen" kann? Ich meine, wenn sie deine Arbeit lesen können, kannst du auch ihre. Vielleicht würde ein Blick darauf, wie Sie von der Situation profitieren können, eine bessere Rendite Ihrer Investition bringen, als zu befürchten, wie viel Sie verlieren könnten.

[EDIT] Antwort auf Nicks Kommentar:

Nichts gewonnen und nichts verloren. Der Kunde hat, was er will (und hat dafür bezahlt, seit er die Änderung selbst vorgenommen hat). Da er die Änderung nicht veröffentlicht, ist es so, als ob es nicht für alle anderen passiert wäre.

Wenn der Kunde die Software verkauft, muss er den Copyright-Hinweis ändern (was illegal ist, damit Sie klagen können und gewinnen -> einfacher Fall).

Wenn sie den Copyright-Hinweis nicht ändern, werden die Kunden der zweiten Ebene feststellen, dass die Software von Ihrem Original stammt, und sich fragen, was los ist. Es besteht die Möglichkeit, dass sie sich mit Ihnen in Verbindung setzen und Sie mehr über den Weiterverkauf Ihrer Arbeit erfahren.

Wieder haben wir zwei Fälle: Der ursprüngliche Kunde hat nur wenige Exemplare verkauft. Das heißt, sie haben sowieso nicht viel Geld verdient, warum also die Mühe machen? Oder sie verkauften in Volumen. Das bedeutet bessere Chancen für Sie, zu erfahren, was sie tun, und etwas dagegen zu tun.

Aber am Ende versuchen die meisten Unternehmen, sich an das Gesetz zu halten (sobald ihr Ruf ruiniert ist, ist es viel schwieriger, Geschäfte zu machen). Sie werden also Ihre Arbeit nicht stehlen, sondern mit Ihnen zusammenarbeiten, um sie zu verbessern. Wenn Sie also die Quelle angeben (mit einer Lizenz, die Sie vor einfachem Weiterverkauf schützt), werden sie wahrscheinlich die vorgenommenen Änderungen einfach zurückschieben, da dadurch sichergestellt wird, dass die Änderung in der nächsten Version enthalten ist und sie nicht gewartet werden muss . Das ist Win-Win: Sie erhalten Änderungen und sie können die Änderung selbst vornehmen, wenn sie sie wirklich dringend benötigen, auch wenn Sie nicht bereit sind, sie in die offizielle Version aufzunehmen.

Haben Sie sich Pyminifier angesehen ? Python-Code wird minimiert, verschleiert und komprimiert. Der Beispielcode sieht für gelegentliches Reverse Engineering ziemlich unangenehm aus.

$ 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 festgestellt haben, bietet es nur sehr begrenzten Schutz. UPDATE: Hier ist ein Link zu Papier, das verschleierten Python-Code in Dropbox rückgängig gemacht hat. Der Ansatz - Opcode-Remapping ist eine gute Barriere, kann aber eindeutig besiegt werden.

Stattdessen machen es, wie viele Plakate erwähnt haben:

• Keine Reverse Engineering-Zeit wert (Ihre Software ist so gut, dass es sinnvoll ist, dafür zu zahlen)
• Lassen Sie sie einen Vertrag unterzeichnen und führen Sie nach Möglichkeit ein Lizenzaudit durch.

Alternativ, wie es die Python IDE WingIDE tut: Verschenken Sie den Code . Das ist richtig, geben Sie den Code weg und lassen Sie die Leute zurückkommen, um Upgrades und Support zu erhalten.

Verwenden Sie Cython . Es kompiliert Ihre Module zu leistungsstarken C-Dateien, die dann zu nativen Binärbibliotheken kompiliert werden können. Dies ist im Vergleich zum .pyc-Bytecode grundsätzlich nicht umkehrbar!

Ich habe einen ausführlichen Artikel darüber geschrieben, wie man Cython für ein Python-Projekt einrichtet.

Schutz von Python-Quellen mit Cython

Der Versand von .pyc-Dateien hat seine Probleme - sie sind mit keiner anderen Python-Version als der Python-Version kompatibel, mit der sie erstellt wurden. Dies bedeutet, dass Sie wissen müssen, welche Python-Version auf den Systemen ausgeführt wird, auf denen das Produkt ausgeführt wird. Das ist ein sehr begrenzender Faktor.

Unter bestimmten Umständen kann es möglich sein, die gesamte Software (oder zumindest einen wichtigen Teil) in einen von Ihrer Organisation gehosteten Webdienst zu verschieben.

Auf diese Weise können die Lizenzprüfungen in der Sicherheit Ihres eigenen Serverraums durchgeführt werden.

Obwohl es keine perfekte Lösung gibt, kann Folgendes getan werden:

1. Verschieben Sie einen kritischen Teil des Startcodes in eine native Bibliothek.
2. Erzwingen Sie die Lizenzprüfung in der nativen Bibliothek.

Wenn der Aufruf des nativen Codes entfernt würde, würde das Programm sowieso nicht gestartet. Wenn es nicht entfernt wird, wird die Lizenz erzwungen.

Dies ist zwar keine plattformübergreifende oder reine Python-Lösung, funktioniert jedoch.

Ich denke, es gibt noch eine Methode, um Ihren Python-Code zu schützen. Teil der Verschleierungsmethode. Ich glaube, es gab ein Spiel wie Mount and Blade oder etwas, das seinen eigenen Python-Interpreter (den ursprünglichen Interpreter, von dem ich glaube, dass er Open Source ist) geändert und neu kompiliert hat und nur die OP-Codes in der OP-Codetabelle so geändert hat, dass sie sich vom Standard-Python-OP unterscheiden Codes.

Die Python-Quelle ist also unverändert, aber die Dateierweiterungen der * .pyc-Dateien sind unterschiedlich und die Op-Codes stimmen nicht mit dem öffentlichen Interpreter python.exe überein. Wenn Sie die Spieledatendateien überprüft haben, waren alle Daten im Python-Quellformat.

Auf diese Weise können alle möglichen bösen Tricks ausgeführt werden, um sich mit unreifen Hackern anzulegen. Es ist einfach, ein paar unerfahrene Hacker aufzuhalten. Es sind die professionellen Hacker, die Sie wahrscheinlich nicht schlagen werden. Aber die meisten Unternehmen halten professionelle Hacker nicht lange im Personal, wie ich mir vorstellen kann (wahrscheinlich, weil Dinge gehackt werden). Aber unreife Hacker sind überall (als neugierige IT-Mitarbeiter gelesen).

Sie können beispielsweise in einem geänderten Interpreter zulassen, dass in Ihrer Quelle nach bestimmten Kommentaren oder Dokumentzeichenfolgen gesucht wird. Sie könnten spezielle OP-Codes für solche Codezeilen haben. Zum Beispiel:

OP 234 ist für die Quellzeile "# Copyright I write this" oder kompilieren Sie diese Zeile in Op-Codes, die "if False:" entsprechen, wenn "# Copyright" fehlt. Grundsätzlich wird ein ganzer Codeblock aus einem scheinbar unklaren Grund deaktiviert.

Ein Anwendungsfall, in dem ein Neukompilieren eines modifizierten Interpreters möglich ist, besteht darin, dass Sie die App nicht geschrieben haben. Die App ist groß, aber Sie werden dafür bezahlt, sie zu schützen, z. B. wenn Sie ein dedizierter Serveradministrator für eine Finanz-App sind.

Ich finde es ein wenig widersprüchlich, die Quelle oder die Opcodes für Augäpfel offen zu lassen, aber SSL für den Netzwerkverkehr zu verwenden. SSL ist auch nicht 100% sicher. Aber es wird verwendet, um die meisten Augen davon abzuhalten, es zu lesen. Eine kleine Vorsichtsmaßnahme ist sinnvoll.

Wenn genügend Leute der Meinung sind, dass Python-Quelle und Opcodes zu sichtbar sind, wird wahrscheinlich irgendwann jemand zumindest ein einfaches Schutzwerkzeug dafür entwickeln. Je mehr Leute fragen, wie man die Python-App schützt, desto mehr wird diese Entwicklung gefördert.

Der zuverlässige einzige Weg, Code zu schützen, besteht darin, ihn auf einem von Ihnen gesteuerten Server auszuführen und Ihren Clients einen Client bereitzustellen, der mit diesem Server verbunden ist.

Ich war überrascht, dass ich in keiner Antwort Pyconcrete sah . Vielleicht, weil es neuer ist als die Frage?

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

Anstatt den Code zu verschleiern, verschlüsselt er ihn und entschlüsselt ihn beim Laden.

Von der Pypi-Seite :

Schützen Sie den Python-Skript-Workflow

• your_script.py import pyconcrete
• pyconcrete hakt das Importmodul
• wenn Ihr Skript Import tun MODULE, wird pyconcrete Import Haken versuchen zu finden MODULE.pyeund dann zu entschlüsseln MODULE.pyeüber _pyconcrete.pydund führen Sie entschlüsselten Daten (wie .pyc Inhalt)
• Verschlüsseln und Entschlüsseln des geheimen Schlüsseldatensatzes in _pyconcrete.pyd (wie DLL oder SO) Der geheime Schlüssel wird im Binärcode ausgeblendet und kann nicht direkt in der HEX-Ansicht angezeigt werden

Je nachdem, wer der Client ist, ist ein einfacher Schutzmechanismus in Kombination mit einer vernünftigen Lizenzvereinbarung weitaus effektiver als jedes komplexe Lizenzierungs- / Verschlüsselungs- / Verschleierungssystem.

Die beste Lösung wäre, den Code als Service zu verkaufen, beispielsweise durch Hosten des Service oder durch Anbieten von Support - obwohl dies nicht immer praktikabel ist.

Wenn Sie den Code als .pycDateien versenden, wird verhindert, dass Ihr Schutz um einige Sekunden vereitelt wird #, aber es ist kaum ein wirksamer Schutz gegen Piraterie (als ob es eine solche Technologie gäbe), und am Ende des Tages sollte er nichts erreichen, was a anständige Lizenzvereinbarung mit dem Unternehmen wird.

Konzentrieren Sie sich darauf, Ihren Code so benutzerfreundlich wie möglich zu gestalten. Wenn Sie zufriedene Kunden haben, wird Ihr Unternehmen weitaus mehr Geld verdienen, als theoretische Piraterie zu verhindern.

Ein weiterer Versuch, das Stehlen Ihres Codes zu erschweren, besteht darin, Jython und anschließend Java Obfuscator zu verwenden .

Dies sollte ziemlich gut funktionieren, da jythonc Python-Code in Java übersetzt und Java dann in Bytecode kompiliert wird. Wenn Sie also die Klassen verschleiern, wird es wirklich schwer zu verstehen sein, was nach der Dekompilierung vor sich geht, ganz zu schweigen von der Wiederherstellung des eigentlichen Codes.

Das einzige Problem mit jython ist, dass Sie keine in c geschriebenen Python-Module verwenden können.

Was ist mit dem Signieren Ihres Codes mit Standardverschlüsselungsschemata, indem Sie wichtige Dateien hashen, signieren und mit Methoden des öffentlichen Schlüssels überprüfen?

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

Zusätzlich können Sie einen Python-Obfuscator wie diesen verwenden (nur gegoogelt).

Sie sollten sich ansehen, wie die Jungs von getdropbox.com dies für ihre Client-Software, einschließlich Linux, tun. Es ist ziemlich schwierig zu knacken und erfordert eine ziemlich kreative Demontage, um die Schutzmechanismen zu überwinden.

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

• Entfernen Sie alle Dokumentzeichenfolgen
• Verteilen Sie nur die kompilierten .pyc-Dateien.
• friere es ein
• Verschleiern Sie Ihre Konstanten innerhalb einer Klasse / eines Moduls, damit help (config) nicht alles anzeigt

Möglicherweise können Sie zusätzliche Unklarheiten hinzufügen, indem Sie einen Teil davon verschlüsseln, im laufenden Betrieb entschlüsseln und an eval () übergeben. Aber egal was Sie tun, jemand kann es brechen.

Nichts davon hindert einen entschlossenen Angreifer daran, den Bytecode zu zerlegen oder mit Hilfe, Verzeichnis usw. durch Ihre API zu graben.

Die Idee, eine zeitlich begrenzte Lizenz zu haben und diese in einem lokal installierten Programm zu überprüfen, funktioniert nicht. Selbst bei perfekter Verschleierung kann die Lizenzprüfung entfernt werden. Wenn Sie jedoch die Lizenz auf dem Remote-System überprüfen und einen wesentlichen Teil des Programms auf Ihrem geschlossenen Remote-System ausführen, können Sie Ihre IP-Adresse schützen.

Um zu verhindern, dass Konkurrenten den Quellcode als ihren eigenen verwenden oder ihre inspirierte Version desselben Codes schreiben, besteht eine Möglichkeit zum Schutz darin, Ihrer Programmlogik Signaturen hinzuzufügen (einige Geheimnisse, um zu beweisen, dass Ihnen Code gestohlen wurde) und den Code zu verschleiern Python-Quellcode ist daher schwer zu lesen und zu verwenden.

Eine gute Verschleierung bietet Ihrem Code im Grunde den gleichen Schutz wie das Kompilieren in eine ausführbare Datei (und das Entfernen von Binärdateien). Es ist möglicherweise noch schwieriger herauszufinden, wie verschleierter komplexer Code funktioniert, als Ihre eigene Implementierung zu schreiben.

Dies hilft nicht, das Hacken Ihres Programms zu verhindern. Selbst mit Verschleierungscode werden Lizenzsachen geknackt und das Programm kann so geändert werden, dass es sich geringfügig anders verhält (genauso wie das Kompilieren von Code in Binärdateien nicht zum Schutz nativer Programme beiträgt).

Zusätzlich zur Verschleierung von Symbolen kann es eine gute Idee sein, den Code zu deaktivieren, was alles noch verwirrender macht, wenn z. B. Aufrufgraphen auf viele verschiedene Orte verweisen, selbst wenn diese verschiedenen Orte letztendlich dasselbe tun.

Logische Signatur in verschleiertem Code (z. B. können Sie eine Wertetabelle erstellen, die von der Programmlogik verwendet, aber auch als Signatur verwendet wird), mit der festgestellt werden kann, dass der Code von Ihnen stammt. Wenn jemand beschließt, Ihr verschleiertes Codemodul als Teil seines eigenen Produkts zu verwenden (auch nachdem es erneut verschlüsselt wurde, um es anders erscheinen zu lassen), können Sie zeigen, dass dieser Code mit Ihrer geheimen Signatur gestohlen wurde.

Ich habe den Softwareschutz im Allgemeinen für meine eigenen Projekte betrachtet und die allgemeine Philosophie ist, dass ein vollständiger Schutz unmöglich ist. Das einzige, was Sie hoffen können, ist, den Schutz auf ein Niveau zu erhöhen, dessen Umgehung Ihren Kunden mehr kosten würde als den Kauf einer anderen Lizenz.

Nachdem dies gesagt wurde, überprüfte ich nur Google auf Python-Obsfuzation und tauchte nicht viel von irgendetwas auf. In einer .NET-Lösung wäre Obsfucation ein erster Ansatz für Ihr Problem auf einer Windows-Plattform, aber ich bin mir nicht sicher, ob jemand Lösungen unter Linux hat, die mit Mono funktionieren.

Das nächste wäre, Ihren Code in einer kompilierten Sprache zu schreiben, oder wenn Sie wirklich den ganzen Weg gehen wollen, dann in Assembler. Eine abgespeckte ausführbare Datei wäre viel schwieriger zu dekompilieren als eine interpretierte Sprache.

Es kommt alles auf Kompromisse an. Auf der einen Seite haben Sie eine einfache Softwareentwicklung in Python, in der es auch sehr schwierig ist, Geheimnisse zu verbergen. Auf der anderen Seite haben Sie Software in Assembler geschrieben, die viel schwieriger zu schreiben ist, aber Geheimnisse viel einfacher zu verbergen ist.

Ihr Chef muss irgendwo entlang dieses Kontinuums einen Punkt auswählen, der seine Anforderungen unterstützt. Und dann muss er Ihnen die Werkzeuge und die Zeit geben, damit Sie bauen können, was er will. Ich wette jedoch, dass er gegen die tatsächlichen Entwicklungskosten im Vergleich zu potenziellen Geldverlusten Einwände erheben wird.

Um es kurz zu machen:

1. Verschlüsseln Sie Ihren Quellcode
2. Schreiben Sie Ihren eigenen Python-Modul-Loader, um Ihren Code beim Importieren zu entschlüsseln
3. Implementieren Sie den Modullader in C / C ++
4. Sie können dem Modullader weitere Funktionen hinzufügen, z. B. Anti-Debugger, Lizenzsteuerung, Hardware-Fingerabdruckbindung usw.

Weitere Informationen finden Sie in dieser Antwort .

Wenn Sie sich für das Thema interessieren, hilft Ihnen dieses Projekt - Schutz .

Es ist möglich, den py2exe-Bytecode in einer verschlüsselten Ressource für einen C-Launcher zu haben, der ihn im Speicher lädt und ausführt. Einige Ideen hier und hier .

Einige haben auch an ein selbstmodifizierendes Programm gedacht , um das Reverse Engineering teuer zu machen.

Sie können auch Tutorials finden , um Debugger zu verhindern , den Disassembler zum Scheitern zu bringen, falsche Debugger-Haltepunkte festzulegen und Ihren Code mit Prüfsummen zu schützen. Suchen Sie nach ["verschlüsselter Code" ausführen "im Speicher"] für weitere Links.

Aber wie andere bereits gesagt haben, werden Reverse Engineers am Ende Erfolg haben, wenn sich Ihr Code lohnt.

Wenn wir uns auf die Softwarelizenzierung konzentrieren, würde ich empfehlen, einen Blick auf eine andere Antwort zum Stapelüberlauf zu werfen, die ich hier geschrieben habe, um mich inspirieren zu lassen, wie ein System zur Überprüfung des Lizenzschlüssels aufgebaut werden kann.

Auf GitHub gibt es eine Open-Source-Bibliothek , die Ihnen bei der Lizenzüberprüfung helfen kann.

Sie können es installieren pip install licensingund dann den folgenden Code hinzufügen:

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

Weitere Informationen zur Konfiguration des öffentlichen RSA-Schlüssels usw. finden Sie hier .

Verwenden Sie den gleichen Weg, um die Binärdatei von c / c ++ zu schützen, dh verschleiern Sie jeden Funktionskörper in einer ausführbaren Datei oder einer Bibliotheksbinärdatei, fügen Sie am Anfang jedes Funktionseintrags eine Anweisung "jump" ein und springen Sie zu einer speziellen Funktion, um verschleierten Code wiederherzustellen. Byte-Code ist also Binärcode des Python-Skripts

• Kompilieren Sie zuerst das Python-Skript, um das Objekt zu codieren
• Dann iteriere jedes Codeobjekt und verschleiere den co_code jedes Codeobjekts wie folgt

    0 JUMP_ABSOLUTE n = 3 + len (Bytecode)

    3
    ...
    ... Hier ist es verschleierter Bytecode
    ...

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

• Speichern Sie das verschleierte Codeobjekt als .pyc- oder .pyo-Datei

Diese verschleierten Dateien (.pyc oder .pyo) können vom normalen Python-Interpreter verwendet werden, wenn dieses Codeobjekt zum ersten Mal aufgerufen wird

• Die erste Operation ist JUMP_ABSOLUTE. Sie springt zum Offset n

• Bei Offset n soll eine PyCFunction aufgerufen werden. Diese Funktion stellt den verschleierten Bytecode zwischen Offset 3 und n wieder her und setzt den ursprünglichen Bytecode auf Offset 0. Der verschleierte Code kann mit dem folgenden Code abgerufen werden

      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)
  

• Nachdem diese Funktion zurückgekehrt ist, besteht die letzte Anweisung darin, zum Offset 0 zu springen. Der eigentliche Bytecode wird nun ausgeführt.

Es gibt ein Tool Pyarmor, mit dem Python-Skripte auf diese Weise verschleiert werden können.

Die Verwendung von cxfreeze (py2exe für Linux) erledigt den Job.

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

Es ist in Ubuntu-Repositories verfügbar

Es gibt eine umfassende Antwort zum Verbergen des Python-Quellcodes, die Sie hier finden .

Mögliche besprochene Techniken sind:
- Verwenden Sie kompilierten Bytecode ( python -m compileall)
- ausführbare Ersteller (oder Installationsprogramme wie PyInstaller )
- Software als Service (meiner Meinung nach die beste Lösung, um Ihren Code zu verbergen)
- Python-Quellcode-Verschleierer