Dies ist der Faden der Räuber. Der Thread der Polizei ist hier .
Ihre Herausforderung besteht darin, eine ungerissene Einreichung aus dem Thread der Hello, World!Polizei zu nehmen und herauszufinden, für welche Eingaben oder Eingaben das Programm gedruckt wird und eine neue Zeile. Groß- und Kleinschreibung, Abstand und Zeichensetzung müssen genau sein.
Bitte kommentieren Sie die Einreichung des Polizisten, wenn Sie seinen Code geknackt haben.
Antworten:
Originalcode:
[[ ! "${1////x}" =~ [[:alnum:]] ]]&&[[ $# = 1 ]]&&bash -c "$1"
Eingang:
__=; (( __++, __-- ));
(( ___ = __, ___++));
(( ____ = ___, ____++));
(( _____ = ____, _____++));
(( ______ = _____, ______++));
(( _______ = ______, _______++));
(( ________ = _______, ________++));
(( _________ = ________, _________++));
${!__##-} <<<\$\'\\$___$______$_______\\$___$______$_____\\$___$_______$__\\$___$_______$_________\'\ \$\'\\$___$___$__\\$___$______$_______\\$___$_______$______\\$___$_______$______\\$___$_______$_________,\ \\$___$____$_________\\$___$_______$_________\\$___$________$____\\$___$_______$______\\$___$______$______\\$__$______$___\'
Erläuterung:
Dies codiert "echo Hallo Welt!" als oktale Escape-Sequenzen (\ xxx).
Außer, dass Sie auch keine Zahlen verwenden können, baut der erste Teil Variablen für die Zahlen 0-7 auf. Sie können diese verwenden, um eine Zeichenfolge mit Oktalsequenzen zu erstellen, die ausgewertet werden, um den eigentlichen Befehl zu erhalten.
Ist evalaber auch alphanumerisch. Stattdessen leitet dies diesen String als Eingabe an eine andere Instanz von weiter bash. $0enthält den Namen des Befehls, der zum Aufrufen von Bash verwendet wird. Dies ist normalerweise nur bash(oder -bashfür eine Anmeldeshell) der Fall, wenn Sie es normal ausführen (über TIO oder durch Einfügen in ein Terminal). (Dies bedeutet im Übrigen, dass, wenn Sie versuchen, dies durch Einfügen in ein Skript auszuführen, die Dinge schrecklich schief gehen, da es einige Male versucht, sich selbst zu teilen.)
Aber das kann man sowieso nicht $0direkt sagen . Stattdessen $__enthält die Namen von $0( „0“), und Sie können indirekte Erweiterung für den Zugriff verwenden es ( ${!__}bezieht sich auf den Inhalt $0).
Und das gibt Ihnen schließlich alle Teile, die Sie brauchen.
•GG∍Mñ¡÷dÖéZ•2ô¹βƵ6B
-107
•GG∍Mñ¡÷dÖéZ• - big number
2ô - split into twos (base-10-digit-wise)
¹β - to base of input
B - convert to base (using 012...ABC...abc...):
Ƶ6 - 107 (ToBase10(FromBase255(6))+101 = 6+101 = 107)
"abcdefghijklmnopqrstuvwxyz"
Gist das eingebaute Kleinbuchstaben. Der Code prüft die Gleichheit dagegen.
〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ
sLƽ$Xṙ5O½Ọ
Der ursprüngliche Code kann als solcher erklärt werden:
sLƽ$Xṙ5O½Ọ Main link; argument is z
s Split z into n slices, where n is:
$
ƽ The integer square root of
L the length of z
X Random of a list. Returns a random row of the input put into a square
ṙ5 Rotate the list left 5 times
O Get codepoints
½ Floating-point square root
Ọ From codepoints
Also nimm einfach "Hallo Welt!" und Codepunkte erhalten, quadrieren, auf Codepunkte zurückwerfen, fünfmal nach rechts drehen und dann das Ergebnis quadrieren und reduzieren.
Ich \00bin mir nicht sicher, ob dies die richtige Lösung ist (auf TIO wird das Zeichen gedruckt ), aber in meiner octave-cliShell sieht es so aus:
Auch in der ursprünglichen Herausforderung heißt es, nichts drucken (oder das Nullzeichen) . Wenn also nichts mit dem übereinstimmt, \00sollte dies in Ordnung sein.
[72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33, 0]0durch a 10).
Hello, World!und eine neue Zeile druckt." ist ein genaues Zitat aus der Herausforderung. Und das macht die Antwort trivial.
print("Hello, World!") or __import__('sys').exit(0)
Verhindern Sie Fehler, indem Sie vorzeitig beenden.
{length:1, charCodeAt:()=>(e='Hello, World!', String.fromCharCode=()=>'')}
Das war ziemlich einfach.
Mir ist aufgefallen, dass keine String-Eingaben ausgegeben werden können, Hello, World!da das Ganze String.fromCharCodenur ein Vielfaches von 4 !zurückgibt und einen Zeichencode von 33 hat. Wir müssen also eindeutig nur das gesamte Programm hacken. Das Hacken von in JavaScript integrierten Funktionen ist trivial, wenn man nicht versucht, sie zu stoppen (und selbst wenn man dies tut, gibt es normalerweise viele Problemumgehungen ...).
Einfacher Proxy, der nur bei jedem dritten Aufruf das gewünschte Zeichen zurückgibt.
var i = 0;
var string = "Hello, World!";
var proxy = new Proxy([], {
get: function(target, property) {
if (!(++i%3)) {
return string[property];
}
return [1];
}
});
Die magische Eingabe ist: 1767707618171221 30191World!
1767707618171221ist eine Primzahl und in Basis 36 geschrieben "hello". Bei Großschreibung entsteht "Hello", was mit gedruckt wird$><<$><<", #$'"if/30191/sucht nach der Zahl 30191in der Eingabe und schreibt, um eine Zeichenfolge zu stdouten, die aus einem Komma, einem Leerzeichen und allem, was in der Eingabe nach dem steht, verwendet wird 30191(unter Verwendung der $POSTMATCH, auf die hier durch ihre kurze Variante verwiesen wird $').Übergeben Sie dies als erstes Argument:
C=("").char;_G[C(112,114,105,110,116)](C(72,101,108,108,111,44,32,87,111,114,108,100,33))Angenommen, der ursprüngliche Code befindet sich in einer Datei tehtmi.lua , führen Sie ihn aus (in Bash oder einer ähnlichen Shell):
lua tehtmi.lua 'C=("").char;_G[C(112,114,105,110,116)](C(72,101,108,108,111,44,32,87,111,114,108,100,33))'Es funktioniert auch mit Lua 5.3, das von TIO verwendet wird. Warum probieren Sie es nicht online aus ? Ich habe noch keine Implementierung getestet, die den "PUC-Rios Lua 5.1" -Kern verwendet (weil ich keine Informationen finden kann), aber meine Lösung funktioniert wahrscheinlich auch dort.
Das erste Argument wird als Code ausgeführt, jedoch nur, wenn es weniger als 5 Kleinbuchstaben enthält.
Der Trick ist zu rennen print("Hello, World!"). Eine andere Möglichkeit, dies auszuführen, ist die Verwendung _G["print"]("Hello, World!"), bei der nur Zeichenfolgen verwendet werden.
Aufgrund der Einschränkung der Anzahl der Kleinbuchstaben können wir die Zeichenfolge jedoch nicht direkt verwenden. Sie können jedoch ausführen ("").char, um die Funktion string.charabzurufen, die von einer Reihe von Bytes in eine Zeichenfolge konvertiert werden kann. Ich habe es einer Großbuchstabenvariablen zugewiesen (damit wir das Limit nicht erreichen), damit wir damit sowohl die printals auch die Hello, World!Zeichenfolgen erstellen können, die wie oben verwendet werden können.
nextstattdessen charLua 5.3 zu verwenden, was aufgrund der Randomisierung der Iterationsreihenfolge nicht funktioniert.
Die Eingabe muss eine Zeichenfolge sein, die Folgendes enthält:
e(
`\
_\
=\
>\
"\
H\
e\
l\
l\
o\
,\
\
W\
o\
r\
l\
d\
!\
"\
+\
\`
\`
`)
Probieren Sie es aus:
const e=eval,p=''.split,c=''.slice,v=[].every,f=s=>(t=c.call(s),typeof s=='string'&&t.length<81&&v.call(p.call(t,`\n`),l=>l.length<3)&&e(t)(t))
input='e(\n`\\\n_\\\n=\\\n>\\\n\"\\\nH\\\ne\\\nl\\\nl\\\no\\\n,\\\n \\\nW\\\no\\\nr\\\nl\\\nd\\\n!\\\n\"\\\n+\\\n\\`\n\\`\n`)'
console.log(f(input))Wenn Sie sich nicht für die nachfolgende Newline-Anforderung für die Ausgabe interessieren, können Sie stattdessen die letzten 6 Zeilen durch folgende ersetzen:
!"
`)
Die Einschränkungen für die Eingabe bestehen darin, dass es sich um eine Zeichenfolge handelt, jede Zeile zwei Byte lang oder weniger ist und dass die Gesamtlänge 80 Byte oder weniger beträgt. Mein erster Versuch, nachdem ich das richtig verstanden hatte, war folgender:
_
=>
`\
H\
e\
l\
l\
o\
,\
\
W\
o\
r\
l\
d\
!
`
Hinweis: Die \s sollen die Zeilenumbrüche in der Zeichenfolge in der Eingabe ignorieren. Dies ist unglaublich wichtig für die Antwort, und ich kann nicht glauben, dass ich bei einem Unfall darauf gestoßen bin. (Ich war vorher damit vertraut, habe es aber vergessen)
Dies hat aber nicht funktioniert, da das =>in der gleichen Zeile wie die Argumente stehen muss. Zum Glück hatte ich die Idee, etwas Ähnliches in eine Zeichenfolge zu wickeln und eine Auswertung in meine Eingabe einzufügen, um sie auf eine Zeile zu reduzieren, was zu meiner endgültigen Antwort führte. Nachdem die Auswertung in der Eingabe erfolgt ist, wird Folgendes als Zeichenfolge generiert (die dann zu einer Funktion ausgewertet und dann ausgeführt wird):
_=>"Hello, World!"+`
`
Das war wirklich schwer zu knacken, aber am Ende war ich erfolgreich.
Auch der erste Riss überhaupt!
Ich stelle mir vor, dass dies immer gefährlich ist, aber ich denke, ich habe einen Riss, bis ich richtig bin, dass der Interpreter einen Fehler enthält (den ich gerade kompiliert habe).
Mein Input
0 1 0 1 0 1 0 1 1 0 1 0 0
Die Ausgabe erfolgt Hello, World!\n\n\n\n\n\n\n\n\n\n.....mit endlosen Zeilenumbrüchen.
Aber ich habe den letzten Codeabschnitt bemerkt:
:1/1+1$(@6)7
0x0ASetzt den Notizblock auf beängstigende Weise auf (Zeilenumbruch), liest die Eingabe auf Seite 7 (die Eingabefläche) und druckt dann die 6-Seite (Notizblockfläche) wiederholt, bis die 7-Fläche Null ist. Wenn Sie Gesicht 7 auf Null setzen, sollten Sie nur eine neue Zeile erhalten. Ich habe jedoch unendlich viele Zeilenumbrüche erhalten und meine 13. Eingabe war eine Null. Ich kann überprüfen, ob die 7-Fläche immer Null ist, indem ich eine "Drucknummer von 7-Fläche" in die Schleife einfüge:
:1/1+1$(@6%7)7
dann werden endlose \n0Paare gedruckt .
Ich schaue mir die Spezifikationen auf der kubischen Github-Seite an und dieses Verhalten sieht sehr nach einem Fehler aus. Das Ändern des letzten Zeichens des ursprünglichen Programms von a 7in a 0führt zu dem erwarteten Verhalten. Der TIO-Interpreter zeigt dasselbe falsche Verhalten.
q5/:i:c
00072001010010800108001110004400032000870011100114001080010000033
q - Take input (string)
5/ - split into chunks of five
:i - cast to integers
:c - cast to characters
Die Lösung, die ich gefunden habe, verwendet sehr stark nicht druckbare Zeichen, sodass der Versuch, sie hier einzufügen, nicht gut funktioniert hat. Die Bytewerte für die Eingabe sind:
109, 89, 4, 121, 3, 11, 8, 29, 37, 38, 27, 25, 72, 4, 4, 4, 3, 3, 3, 4, 4, 37, 3, 27, 4, 3
Oder die String-Version ist im Eingabefeld des TIO-Links verfügbar.
Das ursprüngliche Programm würde die unterschiedlichen Zeichen in der Eingabe übernehmen, dann die Eingabe umkehren und die Elemente der beiden Listen multiplizieren. So habe ich eine 26 Zeichen lange Zeichenfolge erstellt, in der die ersten 13 Zeichen unterschiedlich waren, die letzten 13 Zeichen auch in den ersten 13 Zeichen erschienen und jedes Indexpaar [i, 26-i]mit dem Bytewert des i-ten Zeichens in multipliziert wurde Hello, World!.
n[>n]<[8+o<]
2 25 92 100 106 103 79 24 36 103 100 100 93 64
Versuchen Sie es hier (obwohl die Seite den Zeilenumbruch nicht rendert).
nnimmt Eingaben entgegen, versucht, Leerzeichen aufzuteilen und in Ints umzuwandeln, diese werden auf den Stapel gelegt. odruckt Ordnungspunkte und 8+tut, was man denken würde. Die Eingabe muss also 8 weniger sein als die Codepunkte in umgekehrter Reihenfolge, geteilt durch Leerzeichen.
2dass es funktionieren würde - ist das nur die Herokuapp-Seite, die es nicht rendert?
Originalcode:
#define O(c)(((char**)v)+c)
#define W(c)*(O(c)-**O(2)+x)
main(x,v){puts(W(42));}
Argumente:
"Hello, World!" ","
Erläuterung:
W(c)berechnet die Adresse einer Zeichenfolge aus der auszudruckenden Argumentliste. Es beginnt mit der Adresse des c-ten Arguments ( O(c)), das in diesem Fall das 42. Argument ist, subtrahiert dann das erste Zeichen des zweiten Arguments ( **O(2)) als ganzzahligen Offset und addiert dann xdie Anzahl der Argumente.
W(c)verwendet das zweite Argument, sodass Sie wissen, dass mindestens drei davon vorhanden sein müssen (0, 1, 2). Dann "Hallo Welt!" kann in das erste Argument gehen, und um dieses Argument anzusprechen, benötigen Sie ein Zeichen, dessen ASCII-Wert in die Gleichung "42-x + 3 = 1" passt. Das ist zufällig ",".
Ich überschreibe die valueOf()und toString()Methoden der analysierten Objekte, so dass der Zwang mit a fehlschlägt TypeError.
{"valueOf": 7, "toString": 7}
Die richtige Antwort lautet 52768,23
Die Erklärung ist etwas kompliziert.
00 c0 ;load address
20 fd ae jsr $aefd ; checks for comma
20 eb b7 jsr $b7eb ; reads arguments
Der Code sucht zuerst nach einem Komma (Syntaxnotwendigkeit) und liest dann zwei Argumente ein, von denen das erste ein WORD ist, das im Speicher 0014 und 0015 als Little-Endian gespeichert ist, wobei das letztere im X-Register gespeichert ist.
8a TXA ;Store second argument into A (default register)
0a ASL ; bitshifts the second argument left (doubles it)
45 14 EOR $14 ; XOR that with the low byte of first argument
8d 21 c0 STA $c021 ; Drop that later in the program
Das ist ziemlich klug, wenn wir unsere Eingabe verwenden, um das Programm neu zu schreiben. Am Ende des Programms wird schließlich der Zähler für die Ausgabeschleife neu geschrieben.
45 15 EOR $15 ; XOR that with the high byte of the first argument
85 15 STA $15 ; Put the result in $15
49 e5 EOR #$e5 ; XOR that with the number $e5
85 14 STA $14 ; Put that in $14
Hier kommt der hinterhältige Teil:
8e 18 d0 STX $d018 ; stores the original second argument in d018
Auf dem C64 ist d018 ein sehr wichtiges Byte. Es speichert die Referenzpunkte für Dinge, die die Ausgabe des Bildschirms betreffen. Sehen Sie hier für weitere Informationen. Wenn dies einen falschen Wert ergibt, stürzt Ihr C64 ab. Um die erforderlichen gemischten Groß- und Kleinbuchstaben zu drucken, müssen dies 17 US-Dollar sein.
Jetzt beginnen wir unsere Ausgabeschleife:
a0 00 ldy #$00 ; zeroes out the Y register
b1 14 lda ($14),y ; puts the memory referenced by the byte
; starting at $14 (remember that byte?)
; into the default register
20 d2 ff jsr $ffd2 ; calls the kernal routine to print the char stored in A
c8 iny ; increment Y
c0 0e cpy #$0e ; test for equality with the constant $0e
Diese Konstante wurde zuvor überschrieben. Es wird klar bestimmt, wie lange die Schleife läuft. Es ist zwar schon der richtige Wert, aber wir müssen dort wieder 0e halten.
d0 f6 bne *-8 ; jump back 8 bytes if y and that constant weren't equal
60 rts ; ends the program
Der Rest sind nur die Informationen, die wir ausdrucken müssen, beginnend mit der Speicheradresse c025.
Also folgt es nur der Mathematik von dort.
$FFdort, entschied mich dann aber, ihn zu verlassen.
Die richtige Antwort ist
8 Bits sind genug
Der Code ist ziemlich kompliziert und erfordert viel Selbständerung. Anstatt es vollständig zurückzuentwickeln, können Sie es einfach verwenden, um sich selbst zu knacken.
Hier ist eine etwas hilfreichere Demontage des Codes, um zu verstehen, was passiert ist. Die Syntax ist für KickAssembler.
*=$c000 // LOAD ADDRESS
jsr $aefd //checks for a comma
jsr $ad9e /*Reads in an argument. Stores length of it into
$61, with the address of the stored arg in $62-3*/
jsr $b6a3 /*Evaluates the string, leaving the pointer on $22-3
and the length on A*/ //I think
ldy #$00
loop: lda thedata,y
cpy #$01
beq shuffle
cpy #$07
beq shuffle
cpy #$0b
beq shuffle
tricks: jsr output
iny
bne loop
output: eor ($22),y //XOR's A with the y-eth letter of our input
jmp $ffd2 //good old CHROUT, returns to tricks above
thedata: .byte $f0,$48,$fa,$a2, $1c,$6d,$72,$30
.byte $06,$a9,$03,$48,$7c,$a3
shuffle: sta $c048 //drops A in mystery+4, over the constant
lda $c026,y
sta $c045 //overwrites the low byte of mystery
lda $c027,y
sta $c046 //overwrites the high byte of mystery
ldx #$00
mystery: lda $aefd,x
eor #$23
jsr output
iny
inx
cpx #$03
bne mystery
cpy #$0e
bne loop
eor #$1a
sta $d018
rts
Das Beschriften so hat mir gereicht, um zu sehen, dass der Code XOR eine Reihe von Konstanten enthält, die versteckt sind, um auszudrucken, was wir brauchen. Da XOR reversibel ist, werden Sie bei Eingabe der gewünschten Ausgabe über den Schlüssel informiert.
Also habe ich die letzte Zeile gewechselt
/*from sta $d018
to*/ jsr $ffd2
Es würde also die letzte erforderliche Eingabe drucken, anstatt bei einer falschen Eingabe abzustürzen.
Und das ist das!
Wenn es Interesse gibt, werde ich den Code mehr knacken.
vice
drops A in mystery+1, over the constant" <- das ist eigentlich mystery+4mit deinem Label. Offests sind in Bytes :) und FWIW, Selbstmodifikation ist selbst in ernsthaftem 6502-Code ziemlich häufig , solange der Code aus dem RAM ausgeführt wird.
@_?&4_-j>5&f^~c>&6\|4>7
Rh / qi ?, Wcr + du
int puts(const char *s)
{
printf("Hello, World!%s", s);
}Originalcode:
œ?“¥ĊɲṢŻ;^»œ?@€⁸ḊFmṪ⁷
Eingang:
1,2586391,2949273,3312154,3312154,1134001,362881,2223505,766081,1134001,1497601,3312154,1860601,140
Erläuterung:
Hauptsächlich ist es notwendig zu verstehen, was der Code tut. Das erste, was es tut, ist, dass es den String nimmt
"!,Word Hel"(mit allen benötigten Zeichen außer Zeilenumbruch) und erstellt eine Reihe von Permutationen davon. Die Eingaben geben Permutationsnummern an, und jedes Permutationspaar aus der Eingabe wird auf die Zeichenfolge angewendet, die Paare ausschließt, bei denen die erste Permutation zuerst angewendet wird. Grundsätzlich P2 (P1 (S)), P2 (P2 (S), P2 (P3 (S)), ..., P2 (PN (S)), P3 (P1 (S)), ..., P3 (PN (S)), ... ..., PN (P1 (S)), ..., PN (PN (S)). Diese werden alle miteinander verkettet. Dann wird der letzte Eingang wiederverwendet, um jeden PNth aufzunehmen Zeichen aus dieser großen Zeichenkette. Also nehme ich PN = len (S) * N = 10 * N. Dies bedeutet, dass wir das erste Zeichen von P2 (P1 (S)), das erste Zeichen von P3 (P1 (S), nehmen )) bis zum ersten Zeichen von PN (P1 (S)). Zur weiteren Vereinfachung lasse ich P1 = 1, was die Identitätspermutation ist. Dann reicht es aus, jedes P2 zu wählen, das "H" in das erste permutiert Position, ein P3, der "e" in die erste Position und so weiter permutiert. Glücklicherweise wirken sich kleine Permutationszahlen wie die bereits für PN ausgewählte nicht auf die früheren Zeichen in der Zeichenfolge aus, sodass PN "!" am Anfang der Zeichenfolge. (Wenn dies nicht wahr wäre, wäre es immer noch möglich, durch Auswahl eines anderen P1 zu lösen.)
4195875
Es wird versucht, das zweite Argument als Zeichenfolge zu drucken. Dies ist ein Zeiger, den wir anhand der Eingabe bestimmen können. Es kommt einfach so vor, dass am Speicherort 4195875die "Hello, World!\n"Zeichenfolge beginnt .
Die Zahl wurde durch Addieren print("%p", "Hello, World!");vor printf, Konvertieren der Hexadezimalzahl in Dezimalzahl und Ausprobieren auf dem ursprünglichen TIO ermittelt. Es zeigte mir jedoch die printfFormatzeichenfolge. Beim Ausprobieren einiger Zahlen stellte ich fest, dass sich die Zeichenfolge vor der Formatzeichenfolge befindet.
Im Speicher würde es also so aussehen (als C-Zeichenfolge):
Hello, World!\n\0%2$s\0
Dies bedeutet auch, dass ein Update des Compilers die Lösung beschädigen kann.
['Hello, World!','','','','','','','','','','','','']
[1, "HH", 1, "eellloo", 1, ",,", 1, " WWoo", 1, "rr", 1, "ll", 1, "dd", 1, "!!"]
Erklärung kommt ein bisschen ...
var i = 0;
var string = `"${t}"`;
var answer = "i++?0:q=string";
console.log( f(answer) );
PDO,FETCH_CLASSTYPE
(In TIO ist die PDO-Klasse nicht definiert, daher verwendet die obige Demo ein Codepad, das dies tut.)
Eine andere Lösung:
ReflectionFunction,IS_DEPRECATED
Angesichts der Beschränkung auf 81 Zeichen ist dies wahrscheinlich nicht die beabsichtigte Lösung
global.g = ()=>"Hello, World!";
var str = "g";