Ich suche nach Möglichkeiten, meinen Python-Quellcode auszublenden.

print "Hello World!" 

Wie kann ich dieses Beispiel so codieren, dass es nicht für Menschen lesbar ist? Mir wurde gesagt, dass ich base64 verwenden soll, aber ich bin mir nicht sicher, wie.

Dies ist nur eine eingeschränkte Verschleierungslösung der ersten Ebene, sie ist jedoch integriert: Python verfügt über einen Compiler für Bytecode:

python -OO -m py_compile <your program.py>

.pyoErstellt eine Datei, die Bytecode enthält und in der Dokumentzeichenfolgen entfernt werden usw. Sie können die .pyoDatei mit einer .pyErweiterung umbenennen und python <your program.py>wie Ihr Programm ausführen, jedoch nicht Ihren Quellcode.

PS : Der "begrenzte" Grad der Verschleierung, den Sie erhalten, ist so, dass man den Code wiederherstellen kann (mit einigen der Variablennamen, aber ohne Kommentare und Dokumentzeichenfolgen). Informationen dazu finden Sie im ersten Kommentar. In einigen Fällen kann dieser Grad der Verschleierung jedoch als ausreichend angesehen werden.

PPS : Wenn Ihr Programm so verschleierte Module importiert, müssen Sie sie .pycstattdessen mit einem Suffix umbenennen (ich bin nicht sicher, ob dies eines Tages nicht kaputt geht), oder Sie können mit dem arbeiten .pyound sie ausführen python -O ….pyo(die Importe sollten Arbeit). Dadurch kann Python Ihre Module finden (andernfalls sucht Python nach .pyModulen).

damit es nicht für Menschen lesbar ist?

Ich meine, die ganze Datei ist verschlüsselt !! Wenn Sie es öffnen, können Sie nichts verstehen ..! das ist was ich will

Maximal können Sie Ihre Quellen in Bytecode kompilieren und dann nur Bytecode verteilen. Aber auch das ist reversibel. Bytecode kann in halb lesbare Quellen zerlegt werden.

Base64 ist für jedermann trivial zu dekodieren, kann also nicht als tatsächlicher Schutz dienen und "verbirgt" Quellen nur vor vollständigen PC-Analphabeten. Wenn Sie vorhaben, diesen Code tatsächlich auf irgendeine Weise auszuführen, müssten Sie außerdem den Decoder direkt in das Skript (oder ein anderes Skript in Ihrer Distribution, das von einem legitimen Benutzer ausgeführt werden müsste) aufnehmen, und das würde Ihren sofort verraten Kodierung / Verschlüsselung.

Verschleierungstechniken umfassen normalerweise das Entfernen von Kommentaren / Dokumenten, das Verwöhnen von Namen, das Einfügen von Papierkorbcode usw. Selbst wenn Sie Bytecode dekompilieren, erhalten Sie nicht sehr gut lesbare Quellen. Aber sie werden trotzdem Python-Quellen sein und Python ist nicht gut darin, unlesbares Chaos zu werden.

Wenn Sie unbedingt einige Funktionen schützen müssen, empfehlen wir Ihnen, kompilierte Sprachen wie C oder C ++ zu verwenden, .so / .dll zu kompilieren und zu verteilen und dann Python-Bindungen für geschützten Code zu verwenden.

Sie können das base64Modul zum Codieren von Zeichenfolgen verwenden, um das Surfen auf der Schulter zu stoppen. Es wird jedoch nicht verhindern, dass jemand Ihren Code findet, wenn er Zugriff auf Ihre Dateien hat.

Sie können dann die compile()Funktion und die eval()Funktion verwenden , um Ihren Code auszuführen, sobald Sie ihn dekodiert haben.

>>> import base64
>>> mycode = "print 'Hello World!'"
>>> secret = base64.b64encode(mycode)
>>> secret
'cHJpbnQgJ2hlbGxvIFdvcmxkICEn'
>>> mydecode = base64.b64decode(secret)
>>> eval(compile(mydecode,'<string>','exec'))
Hello World!

Wenn Sie also 30 Codezeilen haben, möchten Sie diese wahrscheinlich wie folgt verschlüsseln:

>>> f = open('myscript.py')
>>> encoded = base64.b64encode(f.read())

Sie müssten dann ein zweites Skript schreiben, das das compile()und eval()wahrscheinlich das codierte Skript als Zeichenfolgenliteral in dreifachen Anführungszeichen enthält . Es würde also ungefähr so ​​aussehen:

import base64
myscript = """IyBUaGlzIGlzIGEgc2FtcGxlIFB5d
              GhvbiBzY3JpcHQKcHJpbnQgIkhlbG
              xvIiwKcHJpbnQgIldvcmxkISIK"""
eval(compile(base64.b64decode(myscript),'<string>','exec'))

Sie können Ihren Code einbetten und aus einem C / C ++ - Programm kompilieren / ausführen. Einbetten von Python in eine andere Anwendung

embedded.c

#include <Python.h>

int
main(int argc, char *argv[])
{
  Py_SetProgramName(argv[0]);  /* optional but recommended */
  Py_Initialize();
  PyRun_SimpleString("print('Hello world !')");
  Py_Finalize();
  return 0;
}

In Ubuntu Debian

$ sudo apt-get install python-dev

In Centos, Redhat, Fedora

$ sudo yum install python-devel

kompilieren mit

$ gcc -o embedded -fPIC -I/usr/include/python2.7 -lpython2.7 embedded.c

laufen mit

$ chmod u+x ./embedded
$ time ./embedded
Hello world !

real  0m0.014s
user  0m0.008s
sys 0m0.004s

hello_world.py:

print('Hello World !')

Führen Sie das Python-Skript aus

$ time python hello_world.py
Hello World !

real  0m0.014s
user  0m0.008s
sys 0m0.004s

Einige Zeichenfolgen des Python-Codes befinden sich jedoch möglicherweise in der kompilierten C-Datei

$ grep "Hello" ./embedded
Binary file ./embedded matches

$ grep "Hello World" ./embedded
$

Wenn Sie zusätzliche Sicherheit wünschen, können Sie base64 für Ihren Code verwenden

...
PyRun_SimpleString("import base64\n"
                  "base64_code = 'your python code in base64'\n"
                  "code = base64.b64decode(base64_code)\n"
                  "exec(code)");
...

z.B:

Erstellen Sie die 64-Zeichenfolge Ihres Codes

$ base64 hello_world.py
cHJpbnQoJ0hlbGxvIFdvcmxkICEnKQoK

embedded_base64.c

#include <Python.h>

int
main(int argc, char *argv[])
{
  Py_SetProgramName(argv[0]);  /* optional but recommended */
  Py_Initialize();
  PyRun_SimpleString("import base64\n"
                    "base64_code = 'cHJpbnQoJ0hlbGxvIFdvcmxkICEnKQoK'\n"
                    "code = base64.b64decode(base64_code)\n"
                    "exec(code)\n");
  Py_Finalize();
  return 0;
}

alle Befehle

$ gcc -o embedded_base64 -fPIC -I/usr/include/python2.7 -lpython2.7 ./embedded_base64.c
$ chmod u+x ./embedded_base64

$ time ./embedded_base64
Hello World !

real  0m0.014s
user  0m0.008s
sys 0m0.004s

$ grep "Hello" ./embedded_base64
$

Cython

Es scheint, dass die Antwort darauf Cython ist. Ich bin wirklich überrascht, dass dies noch niemand erwähnt hat. Hier ist die Homepage: https://cython.org

Kurz gesagt, dies wandelt Ihre Python in C um und kompiliert sie, wodurch sie genauso gut geschützt ist wie jedes "normale" kompilierte verteilbare C-Programm.

Es gibt jedoch Einschränkungen. Ich habe sie selbst nicht eingehend untersucht, weil ich, als ich anfing, darüber zu lesen, die Idee für meine eigenen Zwecke fallen ließ. Aber es könnte immer noch für Sie funktionieren. Grundsätzlich können Sie Python nicht in vollem Umfang nutzen, da es eine dynamische Dynamik bietet. Ein Hauptproblem, das mir aufgefallen ist, war, dass Schlüsselwortparameter nicht verwendbar sind :( Sie müssen Funktionsaufrufe nur mit Positionsparametern schreiben. Ich habe dies nicht bestätigt, aber ich bezweifle, dass Sie bedingte Importe oder Auswertungen verwenden können Ich bin mir nicht sicher, wie mit Polymorphismus umgegangen wird ...

Auf jeden Fall ist dies eine sehr bemerkenswerte Option, wenn Sie nicht versuchen, eine riesige Codebasis nachträglich zu verschleiern, oder idealerweise, wenn Sie zunächst die Verwendung von Cython in Betracht ziehen.

Wenn Sie einen halbverschleierten Code erstellen möchten, erstellen Sie folgenden Code:

import base64
import zlib
def run(code): exec(zlib.decompress(base64.b16decode(code)))
def enc(code): return base64.b16encode(zlib.compress(code))

und erstellen Sie eine Datei wie diese (mit dem obigen Code):

f = open('something.py','w')
f.write("code=" + enc("""
print("test program")
print(raw_input("> "))"""))
f.close()

Datei "Something.py":

code = '789CE352008282A2CCBC120DA592D4E212203B3FBD28315749930B215394581E9F9957500A5463A7A0A4A90900ADFB0FF9'

Importieren Sie einfach "Something.py" und führen Sie es aus run(something.code), um den Code in der Datei auszuführen.

Ein Trick besteht darin, den Code durch das Design schwer lesbar zu machen: Dokumentieren Sie niemals etwas, wenn Sie müssen, geben Sie nur die Ausgabe einer Funktion an, nicht wie sie funktioniert. Machen Sie Variablennamen sehr breit, Filmreferenzen oder Gegensätze Beispiel: btmnsfavclr = 16777215wobei " btmnsfavclr" "Batmans Lieblingsfarbe" bedeutet und der Wert 16777215oder die Dezimalform " ffffff" oder Weiß ist. Denken Sie daran, verschiedene Namensstile zu mischen, um die nervigen Personen Ihres Codes zu behalten. Verwenden Sie auch die Tipps auf dieser Website: Top 11 Tipps zum Entwickeln von nicht wartbarem Code .

Vielleicht können Sie Pyconcrete anprobieren

encrypt .pyczu .pyeund Entschlüsseln beim Import

verschlüsseln und entschlüsseln mit der Bibliothek OpenAES

Verwendung

Voll verschlüsselt

• konvertiere alle deine .pyin*.pye

  $ pyconcrete-admin.py compile --source={your py script}  --pye
  $ pyconcrete-admin.py compile --source={your py module dir} --pye
  

• entfernen *.py *.pycoder *.pyein einen anderen Ordner kopieren

• main .py als main .pye verschlüsselt , kann nicht normal ausgeführt werden python. Sie müssen verwenden pyconcretedas verarbeiten Haupt .pye Skript. pyconcrete( exe ) wird in Ihrem Systempfad installiert (zB: / usr / local / bin)

  pyconcrete main.pye
  src/*.pye  # your libs
  

Teilweise verschlüsselt (pyconcrete as lib)

• Laden Sie die pyconcrete-Quelle herunter und installieren Sie sie über setup.py

  $ python setup.py install \
    --install-lib={your project path} \
    --install-scripts={where you want to execute pyconcrete-admin.py and pyconcrete(exe)}
  

• Importieren Sie Pyconcrete in Ihr Hauptskript

• Empfehlung Projektlayout

  main.py       # import pyconcrete and your lib
  pyconcrete/*  # put pyconcrete lib in project root, keep it as original files
  src/*.pye     # your libs
  

Schauen Sie sich diese Tools zur Verschleierung und Minimierung von Python-Code an:

• pyarmor, https://pypi.org/project/pyarmor/ - vollständige Verschleierung mit Hex-Codierung; erlaubt anscheinend keine teilweise Verschleierung von Variablen- / Funktionsnamen
• Python-Minifier, https://pypi.org/project/python-minifier/ - minimiert den Code und verschleiert Funktions- / Variablennamen (obwohl nicht so intensiv wie Pyminifier unten)
• pyminifier, https://pypi.org/project/pyminifier/ - macht einen guten Job bei der Verschleierung von Namen von Funktionen, Variablen, Literalen; kann auch eine Hex-Codierung (Komprimierung) ähnlich wie Pyarmor durchführen. Problem: Nach der Verschleierung kann der Code Syntaxfehler enthalten und nicht ausgeführt werden.

Beispiel .py-Ausgabe von pyminifier bei Ausführung mit --obfuscate und --gzip:

$ pyminifier --obfuscate --gzip /tmp/tumult.py

#!/usr/bin/env python3
import zlib, base64
exec(zlib.decompress(base64.b64decode('eJx1kcFOwzAMhu95ClMO66apu0/KAQEbE5eJC+IUpa27haVJ5Ljb+vakLYJx4JAoiT/7/+3c3626SKvSuBW6M4Sej96Jq9y1wRM/E3kSexnIOBZObrSNKI7Sl59YsWDq1wLMiEKNrenoYCqB1woDwzXF9nn2rskZd1jDh+9mhOD8DVvAQ8WdtrZfwg74aNwp7ZpnMXHUaltk878ybR/ZNKbSjP8JPWk6wdn72ntodQ8lQucIrdGlxaHgq3QgKqtjhCY/zlN6jQ0oZZxhpfKItlkuNB3icrE4XYbDwEBICRP6NjG1rri3YyzK356CtsGwZuNd/o0kYitvrBd18qgmj3kcwoTckYPtJPAyCVzSKPCMNErs85+rMINdp1tUSspMqVYbp1Q2DWKTJpcGURRDr9DIJs8wJFlKq+qzZRaQ4lAnVRuJgjFynj36Ol7SX/iQXr8ANfezCw==')))
# Created by pyminifier.py (https://github.com/liftoff/pyminifier)

Diese Ausgabe entspricht einem 40-zeiligen ursprünglichen Eingabeskript, wie hier gezeigt .

Vielleicht sollten Sie versuchen , etwas Einfaches wie ein TrueCrypt-Volume für die Speicherung von Quellcode zu verwenden, da dies ein Anliegen von Ihnen zu sein scheint. Sie können eine verschlüsselte Datei auf einem USB-Schlüssel erstellen oder einfach das gesamte Volume verschlüsseln (vorausgesetzt, der Code passt), damit Sie den Schlüssel am Ende des Tages einfach mitnehmen können.

Zum Kompilieren können Sie dann PyInstaller oder py2exe verwenden, um eine eigenständige ausführbare Datei zu erstellen. Wenn Sie wirklich noch einen Schritt weiter gehen möchten, schauen Sie sich einen Packer oder ein Komprimierungsprogramm an, um mehr Verschleierung hinzuzufügen. Wenn keine dieser Optionen verfügbar ist, können Sie das Skript zumindest in Bytecode kompilieren, damit es nicht sofort lesbar ist. Denken Sie daran, dass diese Methoden nur jemanden verlangsamen, der versucht, Ihr Programm zu debuggen oder zu dekompilieren.

Ich würde den Code folgendermaßen maskieren:

def MakeSC():
    c = raw_input(" Encode: ")
    sc = "\\x" + "\\x".join("{0:x}".format(ord(c)) for c in c)
    print "\n shellcode =('" + sc + "'); exec(shellcode)"; MakeSC();

Klartext:

import os; os.system("whoami")

Codiert:

Payload = ('\x69\x6d\x70\x6f\x72\x74\x20\x6f\x73\x3b\x20\x6f\x73\x2e\x73\x79\x73\x74\x65\x6d\x28\x22\x77\x68\x6f\x61\x6d\x69\x22\x29'); exec(Payload);

Ich bin kürzlich auf diesen Blogpost gestoßen: Python-Quellverschleierung mit ASTs, bei dem der Autor über die Verschleierung von Python-Quelldateien mit dem integrierten AST-Modul spricht. Die kompilierte Binärdatei sollte für die HitB-CTF verwendet werden und hatte als solche strenge Verschleierungsanforderungen.

Da Sie Zugriff auf einzelne AST-Knoten erhalten, können Sie mit diesem Ansatz beliebige Änderungen an der Quelldatei vornehmen. Abhängig davon, welche Transformationen Sie ausführen, verhält sich die resultierende Binärdatei möglicherweise nicht genau wie die nicht verschleierte Quelle.

Opy

https://github.com/QQuick/Opy

Opy wird Ihren umfangreichen, realen Python-Quellcode mit mehreren Modulen kostenlos verschleiern! Und SIE wählen pro Projekt aus, was zu verschleiern ist und was nicht, indem Sie die Konfigurationsdatei bearbeiten:

You can recursively exclude all identifiers of certain modules from obfuscation.
You can exclude human readable configuration files containing Python code.
You can use getattr, setattr, exec and eval by excluding the identifiers they use.
You can even obfuscate module file names and string literals.
You can run your obfuscated code from any platform.

Im Gegensatz zu einigen anderen Optionen funktioniert dies sowohl für Python 2 als auch für Python 3 ! Es ist auch kostenlos / OpenSource und es ist kein Online-Tool (es sei denn, Sie zahlen) wie einige der anderen da draußen.

Ich bewerte das zwar immer noch selbst, aber alle ersten Tests haben perfekt funktioniert. Es scheint, dass dies genau das ist, wonach ich gesucht habe!

Die offizielle Version wird als eigenständiges Dienstprogramm ausgeführt. Das ursprünglich vorgesehene Design besteht darin, dass Sie ein Skript zusammen mit einer Konfigurationsdatei im Stammverzeichnis des Verzeichnisses ablegen, das Sie verschleiern möchten, um die Details / Optionen zu definieren, die Sie verwenden möchten. Ich war nicht in diesen Plan verliebt, deshalb habe ich einen Fork aus dem Projekt hinzugefügt, mit dem Sie das Tool stattdessen aus einer Bibliothek importieren und verwenden können. Auf diese Weise können Sie dies direkt in ein umfassenderes Verpackungsskript umwandeln. (Sie könnten natürlich mehrere Py-Skripte in Bash / Batch verpacken, aber ich denke, eine reine Python-Lösung ist ideal). Ich habe darum gebeten, dass meine Gabel in das Originalwerk integriert wird. Falls dies jedoch nie geschieht, finden Sie hier die URL zu meiner überarbeiteten Version:

https://github.com/BuvinJT/Opy

Der beste Weg, dies zu tun, besteht darin, zuerst eine .c-Datei zu generieren und sie dann mit tcc in eine .pyd-Datei zu kompilieren.
Hinweis: Nur Windows

Bedarf

1. tcc
2. pyobfuscate
3. Cython

Installieren:

sudo pip install -U cython

So verschleiern Sie Ihre .py-Datei:

pyobfuscate.py myfile.py >obfuscated.py

Um eine .c-Datei zu generieren,

1. Hinzufügen einer init<filename>()Funktion zu Ihrer .py-Datei Optional

2. cython --embed file.py

3. cp Python.h tcc\include

4. tcc file.c -o file.pyd -shared -I\path\to\Python\include -L\path\to\Python\lib

5. .pyd-Datei in app.exe importieren

Es gibt mehrere Möglichkeiten, Code zu verschleiern. Hier ist nur ein Beispiel:

(lambda _, __, ___, ____, _____, ______, _______, ________:
    getattr(
        __import__(True.__class__.__name__[_] + [].__class__.__name__[__]),
        ().__class__.__eq__.__class__.__name__[:__] +
        ().__iter__().__class__.__name__[_____:________]
    )(
        _, (lambda _, __, ___: _(_, __, ___))(
            lambda _, __, ___:
                chr(___ % __) + _(_, __, ___ // __) if ___ else
                (lambda: _).func_code.co_lnotab,
            _ << ________,
            (((_____ << ____) + _) << ((___ << _____) - ___)) + (((((___ << __)
            - _) << ___) + _) << ((_____ << ____) + (_ << _))) + (((_______ <<
            __) - _) << (((((_ << ___) + _)) << ___) + (_ << _))) + (((_______
            << ___) + _) << ((_ << ______) + _)) + (((_______ << ____) - _) <<
            ((_______ << ___))) + (((_ << ____) - _) << ((((___ << __) + _) <<
            __) - _)) - (_______ << ((((___ << __) - _) << __) + _)) + (_______
            << (((((_ << ___) + _)) << __))) - ((((((_ << ___) + _)) << __) +
            _) << ((((___ << __) + _) << _))) + (((_______ << __) - _) <<
            (((((_ << ___) + _)) << _))) + (((___ << ___) + _) << ((_____ <<
            _))) + (_____ << ______) + (_ << ___)
        )
    )
)(
    *(lambda _, __, ___: _(_, __, ___))(
        (lambda _, __, ___:
            [__(___[(lambda: _).func_code.co_nlocals])] +
            _(_, __, ___[(lambda _: _).func_code.co_nlocals:]) if ___ else []
        ),
        lambda _: _.func_code.co_argcount,
        (
            lambda _: _,
            lambda _, __: _,
            lambda _, __, ___: _,
            lambda _, __, ___, ____: _,
            lambda _, __, ___, ____, _____: _,
            lambda _, __, ___, ____, _____, ______: _,
            lambda _, __, ___, ____, _____, ______, _______: _,
            lambda _, __, ___, ____, _____, ______, _______, ________: _
        )
    )
)

Es gibt zwei Möglichkeiten, Python-Skripte zu verschleiern

• Verschleierter Bytecode jedes Codeobjekts
• Verschleiertes gesamtes Codeobjekt des Python-Moduls

Python-Skripte verschleiern

• Kompilieren Sie die Python-Quelldatei zum Codeobjekt

  char * filename = "xxx.py";
  char * source = read_file( filename );
  PyObject *co = Py_CompileString( source, filename, Py_file_input );
  

• Iterieren Sie das Codeobjekt und wickeln Sie den Bytecode jedes Codeobjekts in das folgende Format

  0   JUMP_ABSOLUTE            n = 3 + len(bytecode)    
  3
  ...
  ... Here it's obfuscated bytecode
  ...
  
  n   LOAD_GLOBAL              ? (__armor__)
  n+3 CALL_FUNCTION            0
  n+6 POP_TOP
  n+7 JUMP_ABSOLUTE            0
  

• Serialisieren Sie das Codeobjekt und verschleiern Sie es

  char *original_code = marshal.dumps( co );
  char *obfuscated_code = obfuscate_algorithm( original_code  );
  

• Erstellen Sie das Wrapper-Skript "xxx.py". $ {Obfuscated_code} steht für die im vorherigen Schritt generierte Zeichenfolgenkonstante.

  __pyarmor__(__name__, b'${obfuscated_code}')
  

Führen Sie verschleierte Python-Skripte aus oder importieren Sie sie

Wenn Sie dieses Wrapper-Skript importieren oder ausführen, müssen Sie zunächst eine CFunction aufrufen:

int __pyarmor__(char *name, unsigned char *obfuscated_code) 
{
  char *original_code = resotre_obfuscated_code( obfuscated_code );
  PyObject *co = marshal.loads( original_code );
  PyObject *mod = PyImport_ExecCodeModule( name, co );
}

Diese Funktion akzeptiert dann zwei Parameter: Modulname und verschleierter Code

• Stellen Sie den verschleierten Code wieder her
• Erstellen Sie ein Codeobjekt mit dem Originalcode
• Originalmodul importieren (dies führt zu einem doppelten Frame in Traceback)

Führen Sie den verschleierten Bytecode aus oder importieren Sie ihn

Wenn nach dem Import eines Moduls ein Codeobjekt in diesem Modul zum ersten Mal aufgerufen wird, wissen wir aus dem im obigen Abschnitt beschriebenen umschlossenen Bytecode

• Die erste Operation JUMP_ABSOLUTEspringt zum Versatz n

• Bei Offset n soll eine PyCFunction aufgerufen werden. Diese Funktion stellt den verschleierten Bytecode zwischen Offset 3 und n wieder her und platziert den ursprünglichen Bytecode auf Offset 0

• Nach dem Funktionsaufruf springt der letzte Befehl auf Offset 0 zurück. Der echte Bytecode wird nun ausgeführt

Siehe Pyarmor

Wie andere Antworten bereits festgestellt haben, gibt es wirklich keinen guten Weg. Base64 kann dekodiert werden. Bytecode kann dekompiliert werden. Python wurde ursprünglich nur interpretiert, und die meisten interpretierten Sprachen versuchen, die maschinelle Interpretation mehr zu beschleunigen, als es für die menschliche Interpretation schwierig zu machen.

Python wurde so gemacht, dass es lesbar und gemeinsam nutzbar ist und nicht verschleiert. Die Sprachentscheidungen darüber, wie Code formatiert werden muss, sollten die Lesbarkeit zwischen verschiedenen Autoren fördern.

Das Verschleiern von Python-Code passt einfach nicht wirklich zur Sprache. Bewerten Sie Ihre Gründe für die Verschleierung des Codes neu.

Probieren Sie diesen Python-Verschleierer aus:

pyob.oxyry.com pyob.oxyry.c

__all__ = ['foo']

a = 'a'
_b = 'b'

def foo():
    print(a)

def bar():
    print(_b)

def _baz():
    print(a + _b)

foo()
bar()
_baz()

wird übersetzt in

__all__ =['foo']#line:1
OO00OO0OO0O00O0OO ='a'#line:3
_O00OO0000OO0O0O0O ='b'#line:4
def foo ():#line:6
    print (OO00OO0OO0O00O0OO )#line:7
def O0000000OOOO00OO0 ():#line:9
    print (_O00OO0000OO0O0O0O )#line:10
def _OOO00000O000O0OOO ():#line:12
    print (OO00OO0OO0O00O0OO +_O00OO0000OO0O0O0O )#line:13
foo ()#line:15
O0000000OOOO00OO0 ()#line:16
_OOO00000O000O0OOO ()#line:17

Ich werde meine Antwort didaktisch schreiben ...

Geben Sie zuerst in Ihren Python-Interpreter ein:

import this

Schauen Sie sich dann die Datei this.pyin Ihrem Lib-Verzeichnis in Ihrer Python-Distribution an und versuchen Sie zu verstehen, was sie tut.

Schauen Sie sich danach die evalFunktion in der Dokumentation an:

help(eval)

Jetzt hätten Sie einen lustigen Weg finden sollen, um Ihren Code zu schützen. Aber Vorsicht, das funktioniert nur bei Leuten, die weniger intelligent sind als Sie! (und ich versuche nicht, beleidigend zu sein, jeder, der klug genug ist, um zu verstehen, was Sie getan haben, könnte es umkehren).

Versuchen Sie, Ihren Hallo-Welt-Python-Code auf der folgenden Site einzufügen:

http://enscryption.com/encrypt-and-obfuscate-scripts.html

Es wird ein komplexes verschlüsseltes und verschleiertes, aber voll funktionsfähiges Skript für Sie erstellen. Überprüfen Sie, ob Sie das Skript knacken und den tatsächlichen Code anzeigen können. Oder prüfen Sie, ob die Komplexität Ihrem Bedürfnis nach Seelenfrieden entspricht.

Das verschlüsselte Skript, das über diese Site für Sie erstellt wird, sollte auf jedem Unix-System funktionieren, auf dem Python installiert ist.

Wenn Sie auf andere Weise verschlüsseln möchten, empfehle ich Ihnen dringend, Ihren eigenen Verschlüsselungs- / Verschleierungsalgorithmus zu schreiben (wenn Ihnen die Sicherheit so wichtig ist) . Auf diese Weise kann niemand außer Ihnen herausfinden, wie es funktioniert. Damit dies jedoch wirklich funktioniert, müssen Sie enorm viel Zeit darauf verwenden, um sicherzustellen, dass es keine Lücken gibt, die jemand ausnutzen kann, der viel Zeit zur Verfügung hat. Und stellen Sie sicher, dass Sie Tools verwenden, die für das Unix-System bereits selbstverständlich sind ... dh openssl oder base64. Auf diese Weise ist Ihr verschlüsseltes Skript portabler.