Verschleierndes „Hallo Welt!' auf Python verschleiern

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,
            _ 



<p>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.<br>
Erste Schritte</p>

<p>Da wir print nicht verwenden können, können wir in das stdout-Dateiobjekt schreiben:<br>
</p>

<pre class="brush:php;toolbar:false">import sys
sys.stdout.write("Hello world!\n")

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

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

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

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

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]

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

„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

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'

Umschreiben in einer Zeile mit Lambda:

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

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'

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'

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

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,
            _ 



<p>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:<br>
</p>

<pre class="brush:php;toolbar:false">import sys
sys.stdout.write("Hello world!\n")

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

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

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

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

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]

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

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

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'

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

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'

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'

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

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,
            _ 



<p>Nur ​​noch zwei Dinge sind übrig. Wir beginnen mit der einfachen: 256. 256=28</p>

<p>, also können wir es wie folgt umschreiben: 1 

</p><p>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 >) in Python, beides sind Ablenkungsmanöver, die andere Arten der I/O-Durchführung beinhalten.</p>

<p>Die Zahl kann auf verschiedene Arten zerlegt werden; Keine Methode ist korrekt (schließlich könnten wir sie einfach in (1 
</p>

<pre class="brush:php;toolbar:false">import sys
sys.stdout.write("Hello world!\n")

Die Grundidee hierbei ist, dass wir verschiedene Zahlenkombinationen in einem bestimmten Bereich testen, bis wir zwei Zahlen finden, Basis und Verschiebung, sodass Basis

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 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,
            _ 



<p>Wenn wir nun „convert(802616035175250124568770929992)“ aufrufen, erhalten wir eine schöne Zerlegung:<br>
</p>

<pre class="brush:php;toolbar:false">import sys
sys.stdout.write("Hello world!\n")

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

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

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

Hier ist die vollständige Python 3-Version:

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

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!