Verschleierndes „Hallo Welt!' auf Python verschleiern-Python-Tutorial-php.cn

Obfuscating “Hello world!” obfuscate on Python

Erstellen Sie das seltsamste verschleierte Programm, das die Zeichenfolge „Hallo Welt!“ ausgibt. Ich beschloss, eine Erklärung darüber zu verfassen, wie zum Teufel es funktioniert. Hier ist also der Eintrag in Python 2.7:

(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 _, __, ___, ____, _____, ______, _______, ________: _
        )
    )
)

Nach dem Login kopieren

String-Literale waren nicht erlaubt, aber ich habe zum Spaß einige andere Einschränkungen festgelegt: Es musste ein einzelner Ausdruck (also keine print-Anweisung) mit minimaler integrierter Verwendung und ohne ganzzahlige Literale sein.
Erste Schritte

Da wir print nicht verwenden können, können wir in das stdout-Dateiobjekt schreiben:

import sys
sys.stdout.write("Hello world!\n")

Nach dem Login kopieren

Aber verwenden wir etwas niedrigeres: os.write(). Wir benötigen den Dateideskriptor von stdout, der 1 ist (Sie können dies mit print sys.stdout.fileno() überprüfen).

import os
os.write(1, "Hello world!\n")

Nach dem Login kopieren

Wir wollen einen einzelnen Ausdruck, also verwenden wir import():

__import__("os").write(1, "Hello world!\n")

Nach dem Login kopieren

Wir möchten auch in der Lage sein, write() zu verschleiern, also fügen wir getattr() ein:

getattr(__import__("os"), "write")(1, "Hello world!\n")

Nach dem Login kopieren

Das ist der Ausgangspunkt. Von nun an wird alles darin bestehen, die drei Strings und den Int. zu verschleiern.
Aneinanderreihen von Saiten

„os“ und „write“ sind ziemlich einfach, daher erstellen wir sie, indem wir Teile der Namen verschiedener integrierter Klassen verbinden. Es gibt viele verschiedene Möglichkeiten, dies zu tun, aber ich habe mich für folgende entschieden:

"o" from the second letter of bool: True.__class__.__name__[1]
"s" from the third letter of list: [].__class__.__name__[2]
"wr" from the first two letters of wrapper_descriptor, an implementation detail in CPython found as the type of some builtin classes’ methods (more on that here): ().__class__.__eq__.__class__.__name__[:2]
"ite" from the sixth through eighth letters of tupleiterator, the type of object returned by calling iter() on a tuple: ().__iter__().__class__.__name__[5:8]

Nach dem Login kopieren

Wir fangen an, einige Fortschritte zu machen!

getattr(
    __import__(True.__class__.__name__[1] + [].__class__.__name__[2]),
    ().__class__.__eq__.__class__.__name__[:2] +
    ().__iter__().__class__.__name__[5:8]
)(1, "Hello world!\n")

Nach dem Login kopieren

„Hallo Welt!n“ ist komplizierter. Wir werden es als große Ganzzahl kodieren, die aus dem ASCII-Code jedes Zeichens multipliziert mit 256 hoch dem Index des Zeichens in der Zeichenfolge gebildet wird. Mit anderen Worten, die folgende Summe:
∑n=0L−1cn(256n)

wo L
ist die Länge der Zeichenfolge und cn ist der ASCII-Code von n

tes Zeichen in der Zeichenfolge. So erstellen Sie die Nummer:

>>> codes = [ord(c) for c in "Hello world!\n"]
>>> num = sum(codes[i] * 256 ** i for i in xrange(len(codes)))
>>> print num
802616035175250124568770929992

Nach dem Login kopieren

Jetzt benötigen wir den Code, um diese Zahl wieder in einen String umzuwandeln. Wir verwenden einen einfachen rekursiven Algorithmus:

>>> def convert(num):
...     if num:
...         return chr(num % 256) + convert(num // 256)
...     else:
...         return ""
...
>>> convert(802616035175250124568770929992)
'Hello world!\n'

Nach dem Login kopieren

Umschreiben in einer Zeile mit Lambda:

convert = lambda num: chr(num % 256) + convert(num // 256) if num else ""

Nach dem Login kopieren

Jetzt verwenden wir eine anonyme Rekursion, um dies in einen einzigen Ausdruck umzuwandeln. Dies erfordert einen Kombinator. Beginnen Sie damit:

>>> comb = lambda f, n: f(f, n)
>>> convert = lambda f, n: chr(n % 256) + f(f, n // 256) if n else ""
>>> comb(convert, 802616035175250124568770929992)
'Hello world!\n'

Nach dem Login kopieren

Jetzt ersetzen wir einfach die beiden Definitionen in den Ausdruck und schon haben wir unsere Funktion:

>>> (lambda f, n: f(f, n))(
...     lambda f, n: chr(n % 256) + f(f, n // 256) if n else "",
...     802616035175250124568770929992)
'Hello world!\n'

Nach dem Login kopieren

Jetzt können wir dies in unseren Code von zuvor einfügen und dabei einige Variablennamen ersetzen (f → , n → _):

getattr(
    __import__(True.__class__.__name__[1] + [].__class__.__name__[2]),
    ().__class__.__eq__.__class__.__name__[:2] +
    ().__iter__().__class__.__name__[5:8]
)(
    1, (lambda _, __: _(_, __))(
        lambda _, __: chr(__ % 256) + _(_, __ // 256) if __ else "",
        802616035175250124568770929992
    )
)

Nach dem Login kopieren

Funktionsinterna

Uns bleibt ein „“ im Hauptteil unserer Konvertierungsfunktion (denken Sie daran: keine String-Literale!) und eine große Zahl, die wir irgendwie verstecken müssen. Beginnen wir mit der leeren Zeichenfolge. Wir können eine spontan erstellen, indem wir die Interna einer Zufallsfunktion untersuchen:

(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 _, __, ___, ____, _____, ______, _______, ________: _
        )
    )
)

Nach dem Login kopieren

Was wir hier eigentlich tun, ist, uns die Zeilennummerntabelle des in der Funktion enthaltenen Codeobjekts anzusehen. Da es anonym ist, gibt es keine Zeilennummern, daher ist die Zeichenfolge leer. Ersetzen Sie die 0 durch _, um es verwirrender zu machen (das spielt keine Rolle, da die Funktion nicht aufgerufen wird), und fügen Sie sie ein. Wir werden auch die 256 in ein Argument umwandeln, das an unser verschleiertes „convert()“ übergeben wird. zusammen mit der Nummer. Dazu muss dem Kombinator ein Argument hinzugefügt werden:

import sys
sys.stdout.write("Hello world!\n")

Nach dem Login kopieren

Ein Umweg

Lassen Sie uns kurz ein anderes Problem angehen. Wir möchten die Zahlen in unserem Code verschleiern, aber es wäre umständlich (und nicht besonders interessant), sie bei jeder Verwendung neu zu erstellen. Wenn wir beispielsweise range(1, 9) == [1, 2, 3, 4, 5, 6, 7, 8] implementieren können, können wir unsere aktuelle Arbeit in eine Funktion einschließen, die Variablen mit den Zahlen von verwendet 1 bis 8 und ersetzen Sie Vorkommen ganzzahliger Literale im Körper durch diese Variablen:

import os
os.write(1, "Hello world!\n")

Nach dem Login kopieren

Obwohl wir auch 256 und 802616035175250124568770929992 bilden müssen, können diese mithilfe arithmetischer Operationen auf diesen acht „grundlegenden“ Zahlen erstellt werden. Die Wahl von 1–8 ist willkürlich, scheint aber ein guter Mittelweg zu sein.

Wir können die Anzahl der Argumente, die eine Funktion benötigt, über ihr Codeobjekt ermitteln:

__import__("os").write(1, "Hello world!\n")

Nach dem Login kopieren

Erstellen Sie ein Tupel von Funktionen mit Argcounts zwischen 1 und 8:

getattr(__import__("os"), "write")(1, "Hello world!\n")

Nach dem Login kopieren

Mithilfe eines rekursiven Algorithmus können wir dies in die Ausgabe von range(1, 9) umwandeln:

"o" from the second letter of bool: True.__class__.__name__[1]
"s" from the third letter of list: [].__class__.__name__[2]
"wr" from the first two letters of wrapper_descriptor, an implementation detail in CPython found as the type of some builtin classes’ methods (more on that here): ().__class__.__eq__.__class__.__name__[:2]
"ite" from the sixth through eighth letters of tupleiterator, the type of object returned by calling iter() on a tuple: ().__iter__().__class__.__name__[5:8]

Nach dem Login kopieren

Wie zuvor wandeln wir dies in die Lambda-Form um:

getattr(
    __import__(True.__class__.__name__[1] + [].__class__.__name__[2]),
    ().__class__.__eq__.__class__.__name__[:2] +
    ().__iter__().__class__.__name__[5:8]
)(1, "Hello world!\n")

Nach dem Login kopieren

Dann in anonym-rekursiver Form:

>>> codes = [ord(c) for c in "Hello world!\n"]
>>> num = sum(codes[i] * 256 ** i for i in xrange(len(codes)))
>>> print num
802616035175250124568770929992

Nach dem Login kopieren

Zum Spaß werden wir die argcount-Operation in ein zusätzliches Funktionsargument ausgliedern und einige Variablennamen verschleiern:

>>> def convert(num):
...     if num:
...         return chr(num % 256) + convert(num // 256)
...     else:
...         return ""
...
>>> convert(802616035175250124568770929992)
'Hello world!\n'

Nach dem Login kopieren

Jetzt gibt es ein neues Problem: Wir brauchen immer noch eine Möglichkeit, 0 und 1 zu verbergen. Wir können diese erhalten, indem wir die Anzahl lokaler Variablen in beliebigen Funktionen untersuchen:

convert = lambda num: chr(num % 256) + convert(num // 256) if num else ""

Nach dem Login kopieren

Auch wenn die Funktionskörper gleich aussehen, ist _ in der ersten Funktion kein Argument und auch nicht in der Funktion definiert, sodass Python es als globale Variable interpretiert:

>>> comb = lambda f, n: f(f, n)
>>> convert = lambda f, n: chr(n % 256) + f(f, n // 256) if n else ""
>>> comb(convert, 802616035175250124568770929992)
'Hello world!\n'

Nach dem Login kopieren

Dies geschieht unabhängig davon, ob _ tatsächlich im globalen Bereich definiert ist.

Umsetzung in die Praxis:

>>> (lambda f, n: f(f, n))(
...     lambda f, n: chr(n % 256) + f(f, n // 256) if n else "",
...     802616035175250124568770929992)
'Hello world!\n'

Nach dem Login kopieren

Jetzt können wir den Wert von funcs ersetzen und dann * verwenden, um die resultierende Liste von Ganzzahlen als acht separate Variablen zu übergeben. Wir erhalten Folgendes:

getattr(
    __import__(True.__class__.__name__[1] + [].__class__.__name__[2]),
    ().__class__.__eq__.__class__.__name__[:2] +
    ().__iter__().__class__.__name__[5:8]
)(
    1, (lambda _, __: _(_, __))(
        lambda _, __: chr(__ % 256) + _(_, __ // 256) if __ else "",
        802616035175250124568770929992
    )
)

Nach dem Login kopieren

Bits verschieben

Fast geschafft! Wir ersetzen die n{1..8} Variablen durch , _, , _ usw., da dies zu Verwirrung mit den in verwendeten Variablen führt unsere inneren Funktionen. Dies verursacht keine wirklichen Probleme, da Scoping-Regeln bedeuten, dass die richtigen verwendet werden. Dies ist auch einer der Gründe, warum wir 256 dahingehend umgestaltet haben, dass sich _ auf 1 bezieht, anstatt auf unsere verschleierte Funktion „convert()“. Da es langsam lang wird, füge ich nur die erste Hälfte ein:

(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 _, __, ___, ____, _____, ______, _______, ________: _
        )
    )
)

Nach dem Login kopieren

Nur noch zwei Dinge sind übrig. Wir beginnen mit der einfachen: 256. 256=28

, also können wir es wie folgt umschreiben: 1 << 8 (mit einer Bitverschiebung nach links) oder _ << ________ mit unseren verschleierten Variablen.

Wir werden die gleiche Idee mit 802616035175250124568770929992 verwenden. Ein einfacher Divide-and-Conquer-Algorithmus kann es in Summen von Zahlen aufteilen, die wiederum Summen von Zahlen sind, die zusammengeschoben werden, und so weiter. Wenn wir zum Beispiel 112 hätten, könnten wir es in 96 16 und dann (3 << 5) (2 << 3) aufteilen. Ich verwende gerne Bitverschiebungen, weil das << erinnert mich an std::cout << „foo“ in C oder print chevron (print >>) in Python, beides sind Ablenkungsmanöver, die andere Arten der I/O-Durchführung beinhalten.

Die Zahl kann auf verschiedene Arten zerlegt werden; Keine Methode ist korrekt (schließlich könnten wir sie einfach in (1 << 0) (1 << 0) ... aufteilen, aber das ist nicht interessant). Wir sollten eine beträchtliche Menge an Verschachtelungen haben, aber dennoch die meisten unserer numerischen Variablen verwenden. Offensichtlich macht es keinen Spaß, dies von Hand zu tun, also entwickeln wir einen Algorithmus. Im Pseudocode:

import sys
sys.stdout.write("Hello world!\n")

Nach dem Login kopieren

Die Grundidee hierbei ist, dass wir verschiedene Zahlenkombinationen in einem bestimmten Bereich testen, bis wir zwei Zahlen finden, Basis und Verschiebung, sodass Basis << Die Verschiebung kommt num so nahe wie möglich (d. h. wir minimieren ihre absolute Differenz, diff). Anschließend verwenden wir unseren Divide-and-Conquer-Algorithmus, um best_base und best_shift aufzuteilen, und wiederholen dann den Vorgang für diff, bis er Null erreicht, wobei wir dabei die Terme summieren.

Das Argument span() für range() stellt die Breite des Suchraums dar. Dies darf nicht zu groß sein, sonst erhalten wir am Ende num als unsere Basis und 0 als unsere Verschiebung (weil diff Null ist), und da die Basis nicht als einzelne Variable dargestellt werden kann, wird sie endlos rekursiv wiederholt . Wenn es zu klein ist, erhalten wir so etwas wie das oben erwähnte (1 << 0) (1 << 0) .... In der Praxis möchten wir, dass die Spanne mit zunehmender Rekursionstiefe kleiner wird. Durch Versuch und Irrtum habe ich herausgefunden, dass diese Gleichung gut funktioniert:
span=⌈log1.5|num|⌉ ⌊24−Tiefe⌋

Wenn wir den Pseudocode in Python übersetzen und einige Optimierungen vornehmen (Unterstützung für das Tiefenargument und einige Vorbehalte im Zusammenhang mit negativen Zahlen), erhalten wir Folgendes:

(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 _, __, ___, ____, _____, ______, _______, ________: _
        )
    )
)

Nach dem Login kopieren

Wenn wir nun „convert(802616035175250124568770929992)“ aufrufen, erhalten wir eine schöne Zerlegung:

import sys
sys.stdout.write("Hello world!\n")

Nach dem Login kopieren

Kleben Sie dies als Ersatz für 802616035175250124568770929992 ein und setzen Sie alle Teile zusammen:

import os
os.write(1, "Hello world!\n")

Nach dem Login kopieren

Und da haben Sie es.
Nachtrag: Python 3-Unterstützung

Seit ich diesen Beitrag geschrieben habe, haben mehrere Leute nach der Python 3-Unterstützung gefragt. Daran habe ich damals noch nicht gedacht, aber da Python 3 immer mehr an Bedeutung gewinnt (und vielen Dank dafür!), ist ein Update dieses Beitrags eindeutig längst überfällig.

Glücklicherweise erfordert Python 3 (zum Zeitpunkt des Schreibens 3.6) keine großen Änderungen:

__import__("os").write(1, "Hello world!\n")

Nach dem Login kopieren

Hier ist die vollständige Python 3-Version:

getattr(__import__("os"), "write")(1, "Hello world!\n")

Nach dem Login kopieren

Vielen Dank fürs Lesen! Ich bin immer wieder erstaunt über die Beliebtheit dieses Beitrags.

Das obige ist der detaillierte Inhalt vonVerschleierndes „Hallo Welt!' auf Python verschleiern. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!