W Pythonie opracowuję oprogramowanie, które będzie dystrybuowane do klientów mojego pracodawcy. Mój pracodawca chce ograniczyć korzystanie z oprogramowania za pomocą pliku licencji ograniczonego czasowo.

Jeśli dystrybuujemy pliki .py, a nawet pliki .pyc, łatwo będzie (dekompilować i) usunąć kod sprawdzający plik licencji.

Innym aspektem jest to, że mój pracodawca nie chce, aby kod był czytany przez naszych klientów, obawiając się, że kod może zostać skradziony lub przynajmniej „nowatorskie pomysły”.

Czy istnieje dobry sposób na poradzenie sobie z tym problemem? Najlepiej z gotowego rozwiązania.

Oprogramowanie będzie działać na systemach Linux (więc nie sądzę, że py2exe załatwi sprawę).

Python, będący językiem interpretowanym na podstawie kodu bajtowego, jest bardzo trudny do zablokowania. Nawet jeśli używasz exe-packagera, takiego jak py2exe , układ pliku wykonywalnego jest dobrze znany, a kody bajtów Pythona są dobrze zrozumiane.

Zwykle w takich przypadkach musisz dokonać kompromisu. Jak ważna jest naprawdę ochrona kodu? Czy są w tym prawdziwe sekrety (takie jak klucz do symetrycznego szyfrowania przelewów bankowych), czy po prostu jesteś paranoikiem? Wybierz język, który pozwoli Ci jak najszybciej opracować najlepszy produkt, i realistycznie oceniaj, jak cenne są Twoje nowatorskie pomysły.

Jeśli zdecydujesz, że naprawdę musisz bezpiecznie egzekwować kontrolę licencji, napisz ją jako małe rozszerzenie C, aby kod kontroli licencji mógł być bardzo trudny (ale nie niemożliwy!) Do inżynierii wstecznej i pozostaw większość kodu w Pythonie .

„Czy istnieje dobry sposób na rozwiązanie tego problemu?” Nie. Nic nie można zabezpieczyć przed inżynierią wsteczną. Nawet oprogramowanie układowe na urządzeniach DVD zostało poddane inżynierii wstecznej i ujawniono klucz szyfrowania AACS . I to pomimo tego, że DMCA czyni z tego przestępstwo.

Ponieważ żadna metoda techniczna nie powstrzyma klientów przed odczytaniem kodu, musisz zastosować zwykłe metody komercyjne.

1. Licencje Kontrakty. Zasady i warunki. To nadal działa, nawet gdy ludzie mogą odczytać kod. Pamiętaj, że niektóre komponenty oparte na języku Python mogą wymagać uiszczenia opłat przed sprzedażą oprogramowania przy użyciu tych komponentów. Ponadto niektóre licencje typu open source zabraniają ukrywania źródła lub pochodzenia tego komponentu.

2. Oferuj znaczącą wartość. Jeśli twoje rzeczy są tak dobre - w cenie, której trudno odmówić - nie ma powodu, by marnować czas i pieniądze na cokolwiek inżynierii wstecznej. Inżynieria wsteczna jest droga. Spraw, by Twój produkt był nieco tańszy.

3. Oferuj ulepszenia i ulepszenia, które sprawiają, że inżynieria odwrotna jest złym pomysłem. Kiedy kolejne wydanie zrywa z inżynierią wsteczną, nie ma sensu. Można to doprowadzić do absurdalnych ekstremów, ale powinieneś zaoferować nowe funkcje, dzięki którym kolejne wydanie będzie bardziej wartościowe niż inżynieria wsteczna.

4. Oferuj dostosowywanie po stawkach tak atrakcyjnych, że wolą płacić za tworzenie i obsługę ulepszeń.

5. Użyj klucza licencyjnego, który wygasa. Jest to okrutne i przyniesie ci złą reputację, ale z pewnością sprawi, że twoje oprogramowanie przestanie działać.

6. Zaoferuj jako usługę internetową. SaaS nie wymaga pobierania plików od klientów.

Python nie jest narzędziem, którego potrzebujesz

Musisz użyć odpowiedniego narzędzia, aby zrobić właściwą rzecz, a Python nie został zaprojektowany do zaciemniania. Jest wręcz przeciwnie; wszystko jest otwarte lub łatwe do ujawnienia lub modyfikacji w Pythonie, ponieważ taka jest filozofia języka.

Jeśli chcesz czegoś, czego nie widać, poszukaj innego narzędzia. To nie jest złe, ważne jest, że istnieje kilka różnych narzędzi do różnych zastosowań.

Zaciemnienie jest naprawdę trudne

Nawet skompilowane programy mogą być poddane inżynierii wstecznej, więc nie myśl, że możesz w pełni chronić dowolny kod. Możesz analizować zaciemniony PHP, złamać klucz szyfrowania flash itp. Za każdym razem nowsze wersje systemu Windows są łamane.

Posiadanie wymogów prawnych jest dobrym rozwiązaniem

Nie możesz zapobiec, aby ktoś niewłaściwie używał twojego kodu, ale możesz łatwo odkryć, czy ktoś to zrobił. Dlatego jest to zwykły problem prawny.

Ochrona kodu jest przereklamowana

W dzisiejszych czasach modele biznesowe zwykle sprzedają usługi zamiast produktów. Nie możesz skopiować usługi, pirata ani ukraść jej. Może czas zastanowić się nad pójściem z prądem ...

Kompiluj pytona i rozpowszechniaj pliki binarne!

Rozsądny pomysł:

Użyj Cython , Nuitka , Shed Skin lub czegoś podobnego do skompilowania Pythona do kodu C, a następnie rozpowszechnij aplikację jako binarne biblioteki python (pyd).

W ten sposób nie pozostanie żaden kod (bajtowy) w języku Python, a Ty dokonałeś rozsądnej ilości zaciemnienia, którego każdy (np. Twój pracodawca) mógłby oczekiwać od zwykłego kodu, tak myślę. (.NET lub Java mniej bezpieczne niż ten przypadek, ponieważ ten kod bajtowy nie jest zaciemniony i można go stosunkowo łatwo zdekompilować do rozsądnego źródła).

Cython staje się coraz bardziej kompatybilny z CPython, więc myślę, że powinien działać. (Właściwie zastanawiam się nad tym w naszym produkcie. Już teraz budujemy biblioteki stron trzecich jako pyd / dll, więc wysyłanie własnego kodu python jako plików binarnych nie jest dla nas zbyt dużym krokiem.)

Zobacz ten post na blogu (nie przeze mnie), aby zapoznać się z samouczkiem, jak to zrobić. (thx @hithwen)

Szalony pomysł:

Prawdopodobnie możesz skłonić Cython do przechowywania plików C osobno dla każdego modułu, a następnie po prostu połącz je wszystkie i zbuduj z dużym wbudowaniem. W ten sposób moduł Pythona jest dość monolityczny i trudny do złamania przy użyciu zwykłych narzędzi.

Poza szaleństwem:

Możesz być w stanie zbudować jeden plik wykonywalny, jeśli możesz połączyć się (i optymalizować) ze środowiskiem wykonawczym Pythona i wszystkimi bibliotekami (bibliotekami DLL) statycznie. W ten sposób z pewnością trudno będzie przechwycić wywołania do / z Pythona i dowolnych bibliotek frameworkowych, których używasz. Nie można tego zrobić, jeśli używasz kodu LGPL.

Rozumiem, że chcesz, aby Twoi klienci korzystali z mocy Pythona, ale nie chcesz ujawniać kodu źródłowego.

Oto moje sugestie:

(a) Napisz krytyczne fragmenty kodu jako biblioteki C lub C ++, a następnie użyj SIP lub swig, aby udostępnić interfejsy API C / C ++ w przestrzeni nazw Python.

(b) Użyj cytonu zamiast Pythona

(c) W obu (a) i (b) powinna istnieć możliwość dystrybucji bibliotek jako licencjonowanych plików binarnych z interfejsem Python.

Czy Twój pracodawca jest świadomy tego, że może „ukraść” wszelkie pomysły, które inne osoby dostają od Twojego kodu? Mam na myśli to, że jeśli potrafią przeczytać twoją pracę, to ty też możesz. Być może spojrzenie na to, jak możesz skorzystać z tej sytuacji, przyniosłoby lepszy zwrot z inwestycji niż obawa, ile możesz stracić.

[EDYCJA] Odpowiedz na komentarz Nicka:

Nic nie zyskało i nic nie straciło. Klient ma to, czego chce (i zapłacił za to, ponieważ sam dokonał zmiany). Ponieważ nie wypuszcza zmiany, to tak, jakby nie zdarzyło się to dla wszystkich innych.

Teraz, jeśli klient sprzedaje oprogramowanie, musi zmienić informację o prawach autorskich (co jest nielegalne, więc możesz pozwać i wygrać -> prosta sprawa).

Jeśli nie zmienią informacji o prawach autorskich, klienci drugiego poziomu zauważą, że oprogramowanie pochodzi od Ciebie i zastanawiają się, co się dzieje. Są szanse, że skontaktują się z tobą, dzięki czemu dowiesz się o odsprzedaży swojej pracy.

Ponownie mamy dwa przypadki: pierwotny klient sprzedał tylko kilka egzemplarzy. Oznacza to, że i tak nie zarabiali dużo pieniędzy, więc po co się tym przejmować. Lub sprzedali w dużych ilościach. Oznacza to większe szanse, aby dowiedzieć się, co robią i coś z tym zrobić.

Ale w końcu większość firm stara się przestrzegać prawa (gdy ich reputacja jest zrujnowana, znacznie trudniej jest robić interesy). Więc nie ukradną twojej pracy, ale pracują z tobą, aby ją ulepszyć. Jeśli więc dołączysz źródło (z licencją, która chroni cię przed prostą odsprzedażą), są szanse, że po prostu odepchną dokonane zmiany, ponieważ upewni się, że zmiana jest w następnej wersji i nie będą musieli jej utrzymywać . To wygrana-wygrana: dostajesz zmiany i mogą sami dokonać zmiany, jeśli naprawdę, desperacko potrzebują jej, nawet jeśli nie chcesz uwzględnić jej w oficjalnej wersji.

Czy spojrzałeś na piminifier ? Robi Minify, zaciemnia i kompresuje kod Pythona. Przykładowy kod wygląda dość nieprzyjemnie dla zwykłej inżynierii wstecznej.

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

Nie polegaj na zaciemnianiu. Jak poprawnie stwierdziłeś, oferuje bardzo ograniczoną ochronę. AKTUALIZACJA: Oto link do papieru, w którym wstecznie zmodyfikowano zaciemniony kod python w Dropbox. Podejście - ponowne mapowanie opcode jest dobrą barierą, ale najwyraźniej można je pokonać.

Zamiast tego, jak wspomniało wiele plakatów, zrób to:

• Nie warto cofać czasu inżynierii (Twoje oprogramowanie jest tak dobre, że warto płacić)
• Niech podpisują umowę i przeprowadzają audyt licencji, jeśli jest to wykonalne.

Alternatywnie, jak robi to idiotyczny Python IDE WingIDE: Podaj kod . Zgadza się, rozdaj kod i niech ludzie wrócą po aktualizacje i wsparcie.

Użyj Cython . Skompiluje twoje moduły do ​​wysokowydajnych plików C, które można następnie skompilować do rodzimych bibliotek binarnych. Jest to w zasadzie nieodwracalne, w porównaniu z bajtecode .pyc!

Napisałem szczegółowy artykuł na temat konfiguracji Cython dla projektu Python, sprawdź to:

Ochrona źródeł Python za pomocą Cython

Wysyłanie plików .pyc ma swoje problemy - nie są one kompatybilne z żadną inną wersją Pythona niż wersja, w której zostały utworzone, co oznacza, że ​​musisz wiedzieć, która wersja Pythona działa w systemach, na których będzie działać produkt. To bardzo ograniczający czynnik.

W niektórych okolicznościach może być możliwe przeniesienie (całość lub przynajmniej kluczowa część) oprogramowania do usługi sieciowej obsługiwanej przez organizację.

W ten sposób kontrole licencji można przeprowadzać w bezpiecznym miejscu we własnej serwerowni.

Chociaż nie ma idealnego rozwiązania, można wykonać następujące czynności:

1. Przenieś krytyczny fragment kodu startowego do biblioteki rodzimej.
2. Wymuszaj sprawdzenie licencji w bibliotece natywnej.

Jeśli wywołanie kodu natywnego zostanie usunięte, program i tak nie uruchomi się. Jeśli nie zostanie usunięty, licencja zostanie wymuszona.

Chociaż nie jest to rozwiązanie wieloplatformowe lub oparte wyłącznie na języku Python, będzie działać.

Myślę, że istnieje jeszcze jedna metoda ochrony twojego kodu Python; część metody zaciemniania. Wierzę, że istniała gra taka jak Mount and Blade lub coś, co zmieniło i ponownie skompilowało własnego interpretera Pythona (oryginalny interpreter, który moim zdaniem jest open source) i właśnie zmieniło kody OP w tabeli kodów OP na inne niż standardowe OP Pythona kody

Więc źródło Pythona jest niezmodyfikowane, ale rozszerzenia plików * .pyc są różne, a kody op nie pasują do publicznego interpretera python.exe. Jeśli sprawdziłeś pliki danych gier, wszystkie dane były w formacie źródłowym Python.

W ten sposób można robić różnego rodzaju paskudne sztuczki, aby zadzierać z niedojrzałymi hakerami. Zatrzymanie grupy niedoświadczonych hakerów jest łatwe. To profesjonalni hakerzy, których prawdopodobnie nie pokonasz. Ale większość firm nie utrzymuje profesjonalnych hakerów wśród pracowników przez długi czas, jak sądzę (prawdopodobnie z powodu hakowania). Ale niedojrzali hakerzy są wszędzie (czytaj jako ciekawi pracownicy IT).

Możesz na przykład w zmodyfikowanym interpretatorze zezwolić mu na sprawdzanie pewnych komentarzy lub ciągów dokumentów w twoim źródle. Możesz mieć specjalne kody OP dla takich linii kodu. Na przykład:

OP 234 dotyczy linii źródłowej „# Copyright Napisałem to” lub skompiluj tę linię w kody op, które są równoważne z „jeśli False:” jeśli brakuje „# Copyright”. Zasadniczo wyłącza cały blok kodu z jakiegoś niejasnego powodu.

Jednym z przypadków użycia, w których rekompilacja zmodyfikowanego interpretera może być wykonalna, jest brak aplikacji, aplikacja jest duża, ale płacisz za jej ochronę, na przykład gdy jesteś dedykowanym administratorem serwera dla aplikacji finansowej.

Trochę sprzeczne jest pozostawienie źródła lub kodów dostępu otwartych dla gałek ocznych, ale używam SSL do ruchu sieciowego. SSL również nie jest w 100% bezpieczny. Ale ma to na celu powstrzymanie WIĘKSZOŚCI oczu od czytania. Niewielka ostrożność jest rozsądna.

Ponadto, jeśli wystarczająca liczba osób uzna, że ​​źródła i kody Pythona są zbyt widoczne, prawdopodobnie ktoś w końcu opracuje dla niego przynajmniej proste narzędzie ochrony. Im więcej osób pyta „jak chronić aplikację Python”, promuje tylko ten rozwój.

Jedynym niezawodnym sposobem ochrony kodu jest uruchomienie go na kontrolowanym serwerze i udostępnienie klientom klienta, który współpracuje z tym serwerem.

Zaskoczyło mnie to, że nie widziałem w ogóle żadnej odpowiedzi z betonu . Może dlatego, że jest nowszy niż pytanie?

Może to być dokładnie to, czego potrzebujesz (red.).

Zamiast zaciemniać kod, szyfruje go i odszyfrowuje w czasie ładowania.

Ze strony pypi :

Chroń przepływ pracy skryptów Pythona

• twój_skrypt.py import pyconcrete
• pyconcrete podpina moduł importu
• gdy skrypt zrobić import MODULE, pyconcrete hak import będzie starał się znaleźć MODULE.pye, a potem odszyfrować MODULE.pyepoprzez_pyconcrete.pyd i wykonać odszyfrowane dane (jak .pyc treści)
• szyfruj i odszyfruj zapis tajnego klucza w _pyconcrete.pyd (jak DLL lub SO) tajny klucz byłby ukryty w kodzie binarnym, nie widzę go bezpośrednio w widoku HEX

W zależności od tego, kim jest klient, prosty mechanizm ochrony w połączeniu z rozsądną umową licencyjną będzie daleko skuteczniejszy niż jakikolwiek złożony system licencjonowania / szyfrowania / zaciemniania.

Najlepszym rozwiązaniem byłoby sprzedanie kodu jako usługi, powiedzmy przez hosting usługi lub oferowanie wsparcia - chociaż nie zawsze jest to praktyczne.

Wysyłanie kodu jako .pycplików zapobiegnie udaremnieniu ochrony przez kilka #sekund, ale nie jest to skuteczna ochrona antypiracka (tak, jakby istniała taka technologia), a na koniec nie powinna osiągnąć niczego, co przyzwoita umowa licencyjna z firmą będzie.

Skoncentruj się na tym, aby Twój kod był jak najbardziej przyjemny w użyciu - zadowoleni klienci przyniosą Twojej firmie znacznie więcej pieniędzy niż zapobieganie piractwu teoretycznemu.

Inną próbą utrudnienia kradzieży kodu jest użycie Jython, a następnie użycie jav Obfuscator .

Powinno to działać całkiem dobrze, ponieważ jythonc tłumaczy kod Pythona na java, a następnie java jest kompilowana do kodu bajtowego. Więc unoście zaciemnianie klas, naprawdę trudno będzie zrozumieć, co się dzieje po dekompilacji, nie mówiąc już o odzyskaniu rzeczywistego kodu.

Jedynym problemem związanym z Jython jest to, że nie można używać modułów Pythona napisanych w c.

Co powiesz na podpisywanie kodu za pomocą standardowych schematów szyfrowania poprzez mieszanie i podpisywanie ważnych plików oraz sprawdzanie go za pomocą metod klucza publicznego?

W ten sposób możesz wydać plik licencji z kluczem publicznym dla każdego klienta.

Dodatkowym można użyć obfuscator Pythona jak ten jeden (tylko google it).

Powinieneś rzucić okiem na to, jak faceci z getdropbox.com robią to dla swojego oprogramowania klienckiego, w tym Linuksa. Złamanie go jest dość trudne i wymaga dość kreatywnego demontażu, aby ominąć mechanizmy ochronne.

Najlepsze, co możesz zrobić z Pythonem, to ukrywanie rzeczy.

• Usuń wszystkie dokumenty
• Rozpowszechniaj tylko pliki skompilowane w formacie .pyc.
• zamroź to
• Zasłonić swoje stałe wewnątrz klasy / modułu, aby help (config) nie pokazywał wszystkiego

Możesz być w stanie dodać dodatkowe zaciemnienie, szyfrując jego część i odszyfrowując w locie i przekazując do eval (). Ale bez względu na to, co robisz, ktoś może to złamać.

Nic z tego nie powstrzyma zdeterminowanego atakującego przed dezasemblacją kodu bajtowego lub przekopaniem interfejsu użytkownika z pomocą, reż, itp.

Pomysł posiadania ograniczonej czasowo licencji i sprawdzenia jej w lokalnym programie nie będzie działać. Nawet przy idealnym zaciemnieniu kontroli licencji można usunąć. Jeśli jednak sprawdzisz licencję na zdalnym systemie i uruchomisz znaczną część programu na zamkniętym zdalnym systemie, będziesz w stanie chronić swoje IP.

Uniemożliwiając konkurentom używanie kodu źródłowego jako własnego lub pisanie inspirowanej wersji tego samego kodu, jednym ze sposobów ochrony jest dodanie podpisów do logiki programu (niektóre tajemnice, aby móc udowodnić, że kod został skradziony) i zaciemnienie kod źródłowy Pythona, więc trudno go odczytać i wykorzystać.

Dobre zaciemnianie dodaje zasadniczo taką samą ochronę do twojego kodu, jak kompilowanie go do pliku wykonywalnego (i usuwanie binarnego). Ustalenie, jak działa zaciemniony złożony kod, może być nawet trudniejsze niż napisanie własnej implementacji.

To nie pomoże zapobiec włamaniu się do twojego programu. Nawet z licencją na kod zaciemniający rzeczy zostaną złamane, a program może zostać zmodyfikowany w celu nieco innego zachowania (w ten sam sposób, w jaki kompilowanie kodu do pliku binarnego nie pomaga w ochronie rodzimych programów).

Oprócz zaciemniania symboli dobrym pomysłem może być odreagowanie kodu, co sprawia, że ​​wszystko jest jeszcze bardziej mylące, jeśli np. Wykresy wywołań wskazują na wiele różnych miejsc, nawet jeśli te różne miejsca ostatecznie robią to samo.

Podpis logiczny w zaciemnionym kodzie (np. Możesz utworzyć tabelę wartości, które są używane przez logikę programu, ale także jako podpis), które mogą być użyte do ustalenia, że ​​kod pochodzi od ciebie. Jeśli ktoś zdecyduje się użyć modułu zaciemnionego kodu jako części własnego produktu (nawet po ponownym przerobieniu go, aby wyglądał inaczej), możesz pokazać, że kod został skradziony za pomocą twojego tajnego podpisu.

Patrzyłem ogólnie na ochronę oprogramowania dla moich własnych projektów i ogólna filozofia jest taka, że ​​pełna ochrona jest niemożliwa. Jedyną rzeczą, którą możesz osiągnąć, jest dodanie ochrony do poziomu, który obejście kosztowałoby więcej klientów niż zakup innej licencji.

Powiedziawszy to, właśnie sprawdzałem Google pod kątem zaciemnienia Pythona i niczego nie odkryłem. W rozwiązaniu .Net zaciemnienie byłoby pierwszym podejściem do problemu na platformie Windows, ale nie jestem pewien, czy ktoś ma rozwiązania w Linuksie, które współpracują z Mono.

Następną rzeczą byłoby napisanie kodu w skompilowanym języku lub jeśli naprawdę chcesz przejść całą drogę, to w asemblerze. Wyodrębniony plik wykonywalny byłby o wiele trudniejszy do dekompilacji niż język interpretowany.

Wszystko sprowadza się do kompromisów. Z jednej strony masz łatwość tworzenia oprogramowania w Pythonie, w którym bardzo trudno jest ukryć sekrety. Z drugiej strony masz oprogramowanie napisane w asemblerze, które jest znacznie trudniejsze do napisania, ale o wiele łatwiej jest ukryć sekrety.

Twój szef musi wybrać gdzieś wzdłuż tego kontinuum punkt, który spełnia jego wymagania. A potem musi dać ci narzędzia i czas, abyś mógł zbudować to, czego chce. Jednak zakładam się, że sprzeciwi się realnym kosztom rozwoju w porównaniu z potencjalnymi stratami pieniężnymi.

Krótko mówiąc:

1. Zaszyfruj kod źródłowy
2. Napisz własny moduł ładujący moduł Pythona, aby odszyfrować kod podczas importowania
3. Zaimplementuj moduł ładujący w C / C ++
4. Możesz dodać więcej funkcji do modułu ładującego, na przykład anti-debugger, kontrolę licencji, sprzętowe wiązanie odcisków palców itp.

Aby uzyskać więcej informacji, spójrz na tę odpowiedź .

Jeśli jesteś zainteresowany tematem, ten projekt pomoże ci - pyprotect .

Możliwe jest umieszczenie kodu bajtowego py2exe w zaszyfrowanym zasobie dla programu uruchamiającego C, który ładuje i wykonuje go w pamięci. Kilka pomysłów tu i tutaj .

Niektórzy zastanawiali się również nad programem do samodzielnej modyfikacji, który sprawi, że inżynieria odwrotna będzie droga.

Można również znaleźć samouczki dotyczące zapobiegania debuggerom , powodować awarie deasemblera, ustawiać punkty przerwania fałszywego debuggera i chronić swój kod za pomocą sum kontrolnych. Wyszukaj [„kod zaszyfrowany” „wykonaj” w pamięci ”], aby uzyskać więcej linków.

Ale jak już powiedzieli inni, jeśli twój kod jest tego wart, inżynierowie odwrotni odniesie w końcu sukces.

Jeśli skupimy się na licencjonowaniu oprogramowania, polecam rzucić okiem na inną odpowiedź Przepełnienie stosu, którą tutaj napisałem rzucić aby uzyskać inspirację do tego, jak można zbudować system weryfikacji klucza licencyjnego.

Na GitHub znajduje się biblioteka typu open source która może pomóc w bicie weryfikacji licencji.

Możesz go zainstalować, pip install licensinga następnie dodać następujący kod:

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

Więcej informacji na temat konfiguracji klucza publicznego RSA itp. Można znaleźć tutaj .

Użyj tego samego sposobu ochrony pliku binarnego c / c ++, tzn. Zaciemnij treść każdej funkcji w pliku binarnym pliku wykonywalnego lub biblioteki, wstaw instrukcję „przeskocz” na początku każdej pozycji funkcji, przejdź do funkcji specjalnej, aby przywrócić zaciemniony kod. Byte-code to kod binarny skryptu Python, więc

• Najpierw skompiluj skrypt Pythona do obiektu kodu
• Następnie iteruj każdy obiekt kodu, zaciemnij co_code każdego obiektu kodu w następujący sposób

    0 JUMP_ABSOLUTE n = 3 + len (kod bajtowy)

    3)
    ...
    ... Tu jest zaciemniony kod bajtowy
    ...

    n LOAD_GLOBAL? (__pyarmor__)
    n + 3 FUNKCJA WYWOŁANIA 0
    n + 6 POP_TOP
    n + 7 JUMP_ABSOLUTE 0

• Zapisz zaciemniony obiekt kodu jako plik .pyc lub .pyo

Te zaciemnione pliki (.pyc lub .pyo) mogą być używane przez normalny interpreter języka Python, gdy obiekt kodu jest wywoływany po raz pierwszy

• Pierwsza operacja to JUMP_ABSOLUTE, przeskoczy do przesunięcia n

• Przy przesunięciu n instrukcja ma wywoływać funkcję PyC. Ta funkcja przywróci zaciemniony kod bajtowy między przesunięciem 3 i n, i ustawi oryginalny bajtowy kod z przesunięciem 0. Kod zaciemniony można uzyskać za pomocą następującego kodu

      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, i obfucated_bytecode i len)
  

• Po powrocie tej funkcji ostatnia instrukcja przeskakuje do offsetu 0. Teraz wykonywany jest naprawdę bajt-kod.

Istnieje narzędzie Pyarmor do zaciemniania skryptów python w ten sposób.

użycie cxfreeze (py2exe dla systemu Linux) wykona zadanie.

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

jest dostępny w repozytoriach ubuntu

Istnieje kompleksowa odpowiedź na temat ukrywania kodu źródłowego Pythona, który można znaleźć tutaj .

Możliwe omówione techniki to:
- użycie skompilowanego kodu bajtowego ( python -m compileall)
- wykonawczych twórców (lub instalatorów takich jak PyInstaller )
- oprogramowanie jako usługa (moim zdaniem najlepsze rozwiązanie do ukrycia kodu)
- obfuscators kodu źródłowego python