Jak chronić kod Pythona?

632

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ę).

Jordfräs
źródło
25
py2exe po prostu przechowuje pliki kodu bajtowego .pyc w archiwum .zip, więc zdecydowanie nie jest to rozwiązanie. Może to jednak być przydatne w połączeniu z odpowiednim skryptem starup, aby działał pod Linuksem
Ber
To jest najbardziej wyczerpująca odpowiedź na twoje pytanie: wiki.python.org/moin/Asking%20for%20Help/…
Mike

Odpowiedzi:

378

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 .

Ned Batchelder
źródło
157
Nawet jeśli kod sprawdzający licencję był trudny do odtworzenia, ponieważ jest napisany w C, czy nadal nie byłoby stosunkowo łatwo usunąć wywołania kodu sprawdzającego licencję?
Blair Conrad,
59
Tak, w zależności od tego, gdzie przeprowadzana jest kontrola licencji. Jeśli istnieje wiele połączeń z tym numerem wewnętrznym, usunięcie może być trudne. Możesz też przenieść inną istotną część aplikacji do kontroli licencji, aby usunięcie połączenia z numerem wewnętrznym spowodowało uszkodzenie aplikacji.
Ned Batchelder,
103
Naprawdę, cała ta praca nie polega na zapobieganiu modyfikacjom, ale na zwiększaniu trudności, aby nie było już tego warte. Wszystko może być poddane inżynierii wstecznej i modyfikowane, jeśli jest wystarczająca korzyść.
Ned Batchelder,
11
@Blair Conrad: Nie, jeśli kod sprawdzający licencję również ukrywa funkcjonalność. Np.mylicensedfunction(licenseblob liblob, int foo, int bar, std::string bash)
Brian,
8
W rzeczywistości widziałem komercyjny kod Pythona wysyłany jako osadzony python w bibliotece C. Zamiast konwertować niektóre części kodu do C, ukrywają cały kod Pythona w ochronnej warstwie C. Następnie, jeśli chcą modułu do importowania przez Python, piszą cienkie rozszerzenie Pythona na C. Otwarte źródło jest znacznie łatwiejszym sposobem na życie.
Mike McKerns
454

„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.

S.Lott
źródło
7
Punkt 2 jest jeszcze ważniejszy. Jeśli jest to tańszy zakup niż inżynieria wsteczna plus coroczne aktualizacje, nikt nie będzie próbował, a nawet jeśli tak, nikt nie zapłaci hakerowi zamiast dostawcy oprogramowania.
m3nda
To prawda. Inżynieria wsteczna jest wykonalna, ale w większości sytuacji droga. @ S.ott, uważam, że punkt 6 ma większe znaczenie w zależności od pytania. Jeśli kod źródłowy naprawdę wymaga ochrony, powinien być zdalny od użytkownika końcowego.
Delali,
7
Pytanie: „Czy istnieje dobry sposób na ochronę mojej rodziny i mnie przed zamordowaniem przez intruzów podczas snu?” Internet: „Nie. Do każdego można się dostać i żadne mieszkanie nie jest nigdy w 100% nieprzeniknione. Śmiertelna ludzka rodzina jest niewłaściwym narzędziem do tego zadania”.
Prosty algorytm
Punktu 5 nie można zastosować przy takim samym założeniu, że można go poddać inżynierii wstecznej i złamać.
jjmontes
313

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 ...

e-satis
źródło
16
Python nie jest narzędziem, którego potrzebujesz. Malbolge jest. :)
johndodo
8
Dobra odpowiedź, ale „przypadkowy problem prawny”? Naprawdę? Gdzie mieszkasz, że masz przypadkowe problemy prawne?
Mark E. Haase,
1
Wydaje mi się, że jeśli mamy częstotliwość - jak często włamany jest kosztowny zaciemniony kod - moglibyśmy powiedzieć o praktyczności wykorzystania Pythona i zaciemnionego kodu.
sergzach,
Jeśli twój kod ma ciekawe funkcje, ten, kto był w stanie go niewłaściwie wykorzystać, rozpowszechniłby go @Macke
Delali,
1
Jak na świecie „łatwo odkryłbyś, że ktoś to robi”?
Make42
145

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.

Macke
źródło
Czy kompilacja z cytonem działałaby z aplikacją Python 3.4 Django, czy też mogłaby działać bez większego wysiłku?
Daniel
@Daniel: Nie jestem pewien. Nie próbowałem na Django. Napisz nowe pytanie na ten temat.
Macke,
4
@mlvljr FWIW, kompilacja IMHO do plików binarnych jest dobrym kompromisem między sprzedażą wszystkich twoich tajemnic a próbą ochrony przed inżynierią odwrotną klasy NSA. Zwłaszcza jeśli masz dużą bazę kodu Pythona i powody, by być paranoikiem. ;)
Macke
2
POST hithwen jest teraz nieważny.
qg_java_17137
58

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.

bhadra
źródło
1
Inne możliwości w tym samym stylu: Shed Skin code.google.com/p/shedskin i Nuitka kayhayen24x7.homelinux.org/blog/nuitka-a-python-compiler
TryPyPy
Właśnie rzuciłem okiem na Shed Skin, jak sugeruje TyPyPy, i wydaje się, że to naprawdę dobre rzeczy!
Filipe
34

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.

Aaron Digulla
źródło
Co się stanie, jeśli udostępnią oprogramowanie klientom, a klient zmodyfikuje je wewnętrznie bez ponownego wydania?
Nick T
@Nick: W żaden sposób nie zmienia sytuacji. Zobacz moje zmiany.
Aaron Digulla,
6
+1 za kradzież pomysłów z powrotem. Po co ograniczać moc obsługi klienta do własnych rozwiązań, skoro można zobaczyć, jak inni ulepszają twoje rozwiązanie i odpowiednio ulepszają własny produkt? „Jeśli masz jabłko, a ja mam jabłko, a my je wymienimy, wtedy ty i ja nadal będziemy mieli jedno jabłko. Ale jeśli masz pomysł, a ja mam pomysł i wymieniamy te pomysły, to każdy z nas będzie miał dwa pomysły ”.
Jordan
Co, jeśli jeden z Twoich klientów ponownie wyda Twój kod lub pomysły za darmo i anonimowo? Nie możesz powiedzieć, kto to zrobił i pozwać ich, a ponieważ nie dostali z tego korzyści, nie zrobisz tego. Zrujnuje to twoją pracę, a jeden z was klientów zapłacił za nią tylko podstawową cenę. (oczywiście działa tylko, jeśli masz więcej niż jednego klienta dla swojego rozwiązania)
Skandix
1
@ Skandix Jak dokładnie by to działało? Przesyłanie swojej pracy przez Internet nie szkodzi Ci. Zacznie cię to krzywdzić, jeśli znajdzie go wiele osób ORAZ ci ludzie płacą klientom zamiast tego. Kradzież kodu to mit. „Moja wiedza jest za darmo, mój czas jest drogi” (nie jestem pewien, kto to powiedział).
Aaron Digulla
34

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)
Lmwangi
źródło
6
Zaletą tego jest demoralizacja każdego, kto próbuje dekodować funkcjonalność. Połącz to z Cython i dodatkową kryptą za pośrednictwem modułów lub połączeń internetowych, a prawdopodobnie dostaniesz nagrodę.
m3nda
Jedyną rzeczą, którą udało się osiągnąć temu pakietowi, jest oszukiwanie „obfuscatora”, że kod jest zaciemniony.
markroxor
robiłem błędy, kiedy próbowałem. myślę, że źle zarządzał danymi i nie w pełni je przekonwertował.
Vicrobot
nie działa dla całego projektu lub silnika szablonów, ponieważ potrzebuje nazwy zmiennej do wyświetlenia w szablonie
TomSawyer
Ta biblioteka nie wydaje się być utrzymywana i daje mi błędy wcięcia. Używam Python 3.7
PV
25

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.

Konradowie
źródło
1
Jak ten ekstremalny pomysł. Dostaje się tam w ogromnym stopniu i ma ogromny udział w rynku, a następnie masz bardzo dużą bazę klientów do wsparcia i dodatków. Zmagałem się również z tym pytaniem i wszystkie odpowiedzi na „licencjonowanie” są w zasadzie bzdurne, ponieważ nie chronią przed rozpowszechnionym kopiowaniem, ale nie dają żadnej przewagi rynkowej.
Thomas Browne,
Ale ulepszenia to również rozdawanie ... więc jak by za to pobierać? Czy nie byłoby to tylko wsparcie?
Make42
W odniesieniu do modelu biznesowego WingIDE: Wsparcie to usługa, oprogramowanie to produkt. Skala produktów, usługa nie. Wsparcie jest dobrym modelem biznesowym tylko wtedy, gdy nie ma innego modelu biznesowego - co oznacza, że ​​jeśli nikt nie kupiłby twojego produktu (z jakiegokolwiek powodu), oddajesz produkt, dzięki czemu masz bazę klientów, która przynajmniej kupuje twoją usługę.
Make42
20

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

Witalij Gordon
źródło
19

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.

Erik Forsberg
źródło
Tak, ale nie, jeśli rozpowszechniasz tę dokładną wersję Pythona z zaciemnionym kodem.
Alex
17

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.

Dziwne
źródło
+1 (powrót do 0): wydaje się, że jest to jedyne prawdziwe rozwiązanie problemu, zakładając, że takie podejście jest praktyczne dla ustawienia.
intuicyjnie,
10
Pamiętaj, że jeśli twój serwer licencyjny przestanie działać lub dostęp do Internetu dla klientów nie będzie działał, twój klient nie będzie zadowolony, że nie będzie mógł prowadzić działalności z powodu utraty dostępu do kontroli licencji.
DevPlayer,
1
@DevPlayer Istnieją rozwiązania tego problemu. Można wdrożyć mechanizm klucza lokalnego, który umożliwia tymczasowy dostęp, gdy oprogramowanie nie może uzyskać dostępu do zdalnego serwera licencyjnego.
Jeffrey
1
@Jeffrey: Dzięki temu wracasz do miejsca, w którym zacząłeś - jak chronić ten kod. Aby być bezpieczniejszym, musisz umieścić niektóre kluczowe funkcje na własnym serwerze, więc jego wymiana wymagałaby znacznego wysiłku (w którym momencie dlaczego po prostu nie założyć konkurenta typu open source?)
Dziwne,
14

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ć.

Smi
źródło
3
Podejście do biblioteki natywnej znacznie ułatwia programistom brutalne wymuszanie systemu kluczy licencyjnych, ponieważ mogą oni używać własnego kodu i interfejsu API do sprawdzania poprawności swoich licencji.
Tom Leys,
8
Więc? Użyj RSA do podpisania licencji i pozwól im brutalnie wymusić Twój klucz prywatny, na przykład składający się z 1024 bitów. Jest to możliwe, ale zajmuje dużo czasu ... a tym samym - pieniędzy.
Abgan
12

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.

DevPlayer
źródło
11

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

Alex Coventry
źródło
10

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
mvallebr
źródło
9

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.

dbr
źródło
8

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.

Piotr Czapla
źródło
6

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

Peter Parker
źródło
1
+1 za podpisanie; -1 dla obfuscatora Możesz przynajmniej zapobiec zmianie kodu.
Ali Afshar
2
Podpisywanie nie działa w tym kontekście. Zawsze można ominąć moduł ładujący sprawdzający podpisy. Pierwszą rzeczą, której potrzebujesz do przydatnej ochrony oprogramowania, jest nieprzezroczysty mechanizm ładowania. Nie jest to coś, co ułatwia Python.
ddaa
Tak, bootstrap w trybie innym niż Python.
Ali Afshar,
Lub sprawdź poprawność licencji nie tylko przy starcie, ale w kilku innych miejscach. Może być łatwo wdrożony i może znacznie wydłużyć czas na obejście.
Abgan
6

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.

fwzgekg
źródło
8
ale fakt, że minęło, oznaczał, że ponieśli porażkę - najważniejsze jest to, że nie próbuj, ale skorzystaj z ochrony prawnej.
Chii,
Czy opublikowano jakieś informacje o tym, jak przejść przez te mechanizmy ochronne?
Mitar
6

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.

Brian C. Lane
źródło
5

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.

Mikael Lepistö
źródło
4

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.

Peter M.
źródło
4

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 .

lambda11
źródło
3

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.

Lalebarde
źródło
3

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 .

Artem
źródło
2

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.

Jondy Zhao
źródło
1

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

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

jest dostępny w repozytoriach ubuntu

Ali AlNoaimi
źródło
5
Myślę, że to po prostu łączy pliki .pyc. Cython, Shed Skin i PyPy wykraczają poza kod bajtowy.
Cees Timmerman,
1

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

Mikrofon
źródło
Link prowadzi do example.com.
Darian
@Darian dziękuję za zwrócenie na to uwagi. Zaktualizowałem link.
Mike