Questo è il filo dei ladri. Il thread della polizia è qui .
La tua sfida è quella di prendere una presentazione non crackata dal thread della polizia e trovare, per quale input o input, il programma stamperà Hello, World!e una nuova riga. Le maiuscole, la spaziatura e la punteggiatura devono essere esatte.
Si prega di commentare l'invio del poliziotto dopo aver decifrato il loro codice.
Risposte:
Codice originale:
[[ ! "${1////x}" =~ [[:alnum:]] ]]&&[[ $# = 1 ]]&&bash -c "$1"
Ingresso:
__=; (( __++, __-- ));
(( ___ = __, ___++));
(( ____ = ___, ____++));
(( _____ = ____, _____++));
(( ______ = _____, ______++));
(( _______ = ______, _______++));
(( ________ = _______, ________++));
(( _________ = ________, _________++));
${!__##-} <<<\$\'\\$___$______$_______\\$___$______$_____\\$___$_______$__\\$___$_______$_________\'\ \$\'\\$___$___$__\\$___$______$_______\\$___$_______$______\\$___$_______$______\\$___$_______$_________,\ \\$___$____$_________\\$___$_______$_________\\$___$________$____\\$___$_______$______\\$___$______$______\\$__$______$___\'
Spiegazione:
Questo codifica "echo Hello, World!" come sequenze di fuga ottale (\ xxx).
Tranne il fatto che non puoi usare i numeri, quindi la prima parte costruisce variabili per i numeri 0-7. Puoi usarli per costruire una stringa con sequenze ottali che valuteranno per darti il comando effettivo.
Ma evalè anche alfanumerico. Quindi invece questa pipe quella stringa come input per un'altra istanza di bash. $0contiene il nome del comando usato per invocare Bash, che di solito è solo bash(o -bashper una shell di login) se lo stai eseguendo normalmente (tramite TIO o incollandolo in un terminale). (Questo per inciso significa che se provi a eseguirlo incollandolo in una sceneggiatura, le cose andranno terribilmente male mentre provano a sborsare un sacco di volte.)
Ma comunque, non puoi dirlo $0direttamente. Invece, $__contiene il nome di $0("0") e puoi usare l'espansione indiretta per accedervi (si ${!__}riferisce al contenuto di $0).
E questo, infine, ti dà tutti i pezzi di cui hai bisogno.
•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"
Gè il built-in per l'alfabeto minuscolo. Il codice verifica l'uguaglianza contro questo.
〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ
sLƽ$Xṙ5O½Ọ
Il codice originale può essere spiegato come tale:
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
Quindi, basta prendere "Ciao, mondo!" e ottenere punti di codice, quadrati, cast di nuovo a punti di codice, ruotare a destra 5 volte, quindi quadrare e appiattire il risultato.
Non sono sicuro che questa sia la soluzione corretta (su TIO stampa il \00personaggio), ma nella mia octave-clishell sembra così:
Anche nella sfida originale dice che non stampa nulla (o il carattere null) , quindi se nulla è uguale a \00questo dovrebbe andare bene.
[72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33, 0]0con a 10).
Hello, World!e un ritorno a capo." è una citazione esatta della sfida. E infatti, ciò rende la risposta banale.
print("Hello, World!") or __import__('sys').exit(0)
Prevenire eventuali errori uscendo presto.
{length:1, charCodeAt:()=>(e='Hello, World!', String.fromCharCode=()=>'')}
È stato abbastanza facile.
Ho notato che qualsiasi input di stringa non sarebbe possibile produrre Hello, World!perché l'intera cosa al suo interno String.fromCharCoderestituirà solo multipli di 4 e !ha un codice char di 33. Quindi chiaramente dobbiamo solo hackerare l'intero programma. L'hacking dei built-in in JavaScript è banale se non si cerca di fermarli (e anche se lo si fa, di solito ci sono un sacco di soluzioni alternative ...).
Proxy semplice che restituisce il carattere desiderato solo ogni terza volta che viene chiamato.
var i = 0;
var string = "Hello, World!";
var proxy = new Proxy([], {
get: function(target, property) {
if (!(++i%3)) {
return string[property];
}
return [1];
}
});
L'input magico è: 1767707618171221 30191World!
1767707618171221è un numero primo e, scritto nella base 36, lo è "hello". Se maiuscolo, questo produce "Hello", che viene stampato utilizzando$><<$><<", #$'"if/30191/cerca il numero 30191nell'input e scrive per stdout una stringa composta da una virgola, uno spazio e tutto ciò che è nell'input dopo il 30191(usando il $POSTMATCH, che è indicato qui dalla sua breve variante $').Passa questo come primo argomento:
C=("").char;_G[C(112,114,105,110,116)](C(72,101,108,108,111,44,32,87,111,114,108,100,33))Supponendo che il codice originale sia in un file tehtmi.lua, esegui (in bash o una shell simile):
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))'Funziona anche su Lua 5.3, che è ciò che utilizza TIO, quindi perché non provarlo online ? Non ho testato un'implementazione che utilizza il core "PUC-Rio's Lua 5.1" (perché non riesco davvero a trovare alcuna informazione), ma probabilmente la mia soluzione funziona anche lì.
Esegue il primo argomento come codice, ma solo se contiene meno di 5 caratteri minuscoli.
Il trucco è correre print("Hello, World!"). Un altro modo in cui questo può essere eseguito è l'utilizzo_G["print"]("Hello, World!") , che utilizza solo stringhe.
Ma non possiamo usare la stringa direttamente a causa della limitazione del conteggio in minuscolo, tuttavia, puoi eseguire ("").charper ottenere la funzione string.char, che può convertire da una serie di byte a una stringa. L'ho assegnato a una variabile maiuscola (quindi non raggiungiamo il limite) in modo che possiamo usarlo per costruire sia printle Hello, World!stringhe che le stringhe che possono essere usate come sopra.
nextposto del charquale non funziona su Lua 5.3 a causa della randomizzazione dell'ordine di iterazione.
L'input deve essere una stringa contenente questo:
e(
`\
_\
=\
>\
"\
H\
e\
l\
l\
o\
,\
\
W\
o\
r\
l\
d\
!\
"\
+\
\`
\`
`)
Provalo usando questo:
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))Se non ti interessa il requisito di nuova riga finale per l'output, puoi invece sostituire le ultime 6 righe con questo:
!"
`)
Le restrizioni sull'input sono che è una stringa, ogni riga è lunga o meno di due byte e che la lunghezza totale è di 80 byte o meno. Il mio primo tentativo dopo aver capito che era correttamente questo:
_
=>
`\
H\
e\
l\
l\
o\
,\
\
W\
o\
r\
l\
d\
!
`
Nota: gli \s devono ignorare le nuove righe nella stringa nell'input. Questo è incredibilmente cruciale per la risposta, e non posso credere di essermi imbattuto in un incidente. (Lo conoscevo prima ma me ne ero dimenticato)
Ma questo non ha funzionato, dal momento che =>deve essere sulla stessa linea degli argomenti. Per fortuna, ho avuto l'idea di avvolgere qualcosa di simile in una stringa e di inserire una valutazione nel mio input per ridurla a una riga, ottenendo la mia risposta finale. Dopo che si verifica l'eval nell'input, viene generato come stringa una stringa (che viene quindi valutata in una funzione e quindi eseguita):
_=>"Hello, World!"+`
`
Questo è stato davvero difficile da decifrare, ma alla fine ci sono riuscito.
Inoltre, il primo crack di sempre!
Immagino che questo sia sempre pericoloso, ma penso di avere una crepa, in attesa di essere corretto in quanto c'è un bug nell'interprete (che ho appena compilato).
Il mio contributo
0 1 0 1 0 1 0 1 1 0 1 0 0
L'output è Hello, World!\n\n\n\n\n\n\n\n\n\n.....con nuove righe senza fine.
Ma ho notato l'ultima sezione del codice:
:1/1+1$(@6)7
imposta il blocco note su 0x0A(newline) in modo spaventoso, legge l'input sulla faccia 7 (la faccia di input), quindi stampa ripetutamente la 6 faccia (faccia del blocco note) fino a quando la 7 faccia è zero. Se imposti la faccia 7 su zero, dovresti ottenere solo una nuova riga. Tuttavia, ho ottenuto infiniti newline e il mio 13 ° input ERA uno zero e posso verificare che la 7 faccia sia sempre zero inserendo un "numero di stampa da 7 faccia" nel ciclo:
:1/1+1$(@6%7)7
quindi stampa \n0coppie infinite .
Sto guardando le specifiche sulla pagina cubica di github e questo comportamento assomiglia moltissimo a un bug. La modifica dell'ultimo carattere del programma originale da 7a a 0comporta il comportamento previsto. L'interprete TIO mostra lo stesso comportamento errato.
q5/:i:c
00072001010010800108001110004400032000870011100114001080010000033
q - Take input (string)
5/ - split into chunks of five
:i - cast to integers
:c - cast to characters
La soluzione che ho trovato fa un uso molto sostanziale di caratteri non stampabili, quindi il tentativo di incollarlo qui non ha funzionato bene. I valori byte per l'ingresso sono:
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
Oppure la versione stringa è disponibile nel campo di input del collegamento TIO.
Il programma originale prendeva i caratteri distinti nell'input, quindi invertiva l'input e moltiplicava gli elementi delle due liste. Così ho creato una stringa lunga 26 caratteri in cui i primi 13 caratteri erano distinti, anche gli ultimi 13 caratteri apparivano tutti nei primi 13 e ogni coppia di indici si [i, 26-i]moltiplicava per il valore in byte dell'i-esimo carattere in Hello, World!.
n[>n]<[8+o<]
2 25 92 100 106 103 79 24 36 103 100 100 93 64
Provalo qui (sebbene la pagina non visualizzi la nuova riga).
nprende input, trys per dividere gli spazi e cast in ints, questi vengono messi in pila. ostampa punti ordinali e 8+fa ciò che si potrebbe pensare. Quindi l'input deve essere 8 in meno rispetto ai punti di codice in ordine inverso diviso per spazi.
2avrebbe funzionato - è solo la pagina di herokuapp a non renderla?
Codice originale:
#define O(c)(((char**)v)+c)
#define W(c)*(O(c)-**O(2)+x)
main(x,v){puts(W(42));}
Argomenti:
"Hello, World!" ","
Spiegazione:
W(c)sta calcolando l'indirizzo di una stringa dall'elenco degli argomenti da stampare. Inizia con l'indirizzo del cth argomento ( O(c)), che in questo caso è il 42 ° argomento, quindi sottrae il primo carattere del secondo argomento ( **O(2)) come offset intero, quindi aggiungex , che è il numero di argomenti.
W(c)usa il secondo argomento, quindi sai che devono essercene almeno 3 (0, 1, 2). Quindi "Ciao, mondo!" può andare nel primo argomento e quindi per affrontare tale argomento è necessario un carattere il cui valore ASCII si adatti all'equazione "42-x + 3 = 1". Quello sembra essere ",".
Sovrascrivo i metodi valueOf()e toString()degli oggetti analizzati in modo che la coercizione fallisca con a TypeError.
{"valueOf": 7, "toString": 7}
La risposta corretta è 52768,23
La spiegazione è leggermente coinvolta.
00 c0 ;load address
20 fd ae jsr $aefd ; checks for comma
20 eb b7 jsr $b7eb ; reads arguments
Il codice cerca prima una virgola (necessità della sintassi) e quindi legge due argomenti, il primo dei quali è una WORD, memorizzato little-endian nella posizione di memoria 0014 e 0015, l'ultimo dei quali è memorizzato nel registro X.
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
È abbastanza intelligente, usando il nostro input per riscrivere il programma. Alla fine riscrive il contatore per il loop di output alla fine del programma.
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
Ecco che arriva la parte subdola:
8e 18 d0 STX $d018 ; stores the original second argument in d018
sul C64, d018 è un byte molto importante. Memorizza i punti di riferimento per le cose che coinvolgono l'output dello schermo. Vedi qui per maggiori informazioni. Se questo ottiene un valore errato, si bloccherà il tuo C64. Per stampare le lettere miste maiuscole e minuscole richieste, questo deve essere $ 17.
Ora iniziamo il nostro ciclo di output:
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
Quella costante è ciò che è stato scritto sopra. Determina chiaramente per quanto tempo dura il ciclo. Capita già di avere il giusto valore, ma dobbiamo rimanere di nuovo lì 0e.
d0 f6 bne *-8 ; jump back 8 bytes if y and that constant weren't equal
60 rts ; ends the program
Il resto sono solo le informazioni che dobbiamo stampare, iniziando dall'indirizzo di memoria c025.
Quindi sta solo seguendo la matematica da lì.
$FFlì, ma poi ha deciso di lasciarlo.
La risposta corretta è
8bitsareenough
Il codice è piuttosto complicato, implicando molta auto-modifica. Quindi, invece di decodificarlo completamente, puoi semplicemente usarlo per rompere se stesso.
Ecco un disassemblaggio leggermente più utile del codice, per aiutare a capire cosa è successo. La sintassi è per 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
Etichettarlo in questo modo mi è bastato per vedere che il codice XOR contiene un gruppo di costanti che sono nascoste per stampare ciò di cui abbiamo bisogno. Poiché XOR è reversibile, se si immette l'output desiderato, ti dirà qual è la chiave.
Quindi ho cambiato l'ultima riga
/*from sta $d018
to*/ jsr $ffd2
quindi stamperebbe l'ultimo input richiesto invece di bloccarsi su un input errato.
E quello è quello!
Se c'è qualche interesse, creerò di più il codice.
vice. Ma qualunque sia, è la soluzione corretta.
drops A in mystery+1, over the constant" <- in realtà è mystery+4con la tua etichetta. Gli arresti sono in byte :) e FWIW, l'automodificazione è abbastanza comune anche nel serio codice 6502, purché il codice venga eseguito dalla RAM.
@_?&4_-j>5&f^~c>&6\|4>7
Rh / qi?, WCR + du
Codice originale:
œ?“¥ĊɲṢŻ;^»œ?@€⁸ḊFmṪ⁷
Ingresso:
1,2586391,2949273,3312154,3312154,1134001,362881,2223505,766081,1134001,1497601,3312154,1860601,140
Spiegazione:
Principalmente, è necessario capire cosa fa il codice. La prima cosa che fa è prendere la stringa
"!,Word Hel"(con tutti i personaggi necessari tranne newline) e crea un sacco di permutazioni. Gli input specificano i numeri di permutazione e ogni coppia di permutazioni dall'input viene applicata alle coppie che escludono la stringa in cui viene applicata per prima la prima permutazione. Fondamentalmente, P2 (P1 (S)), P2 (P2 (S), P2 (P3 (S)), ..., P2 (PN (S)), P3 (P1 (S)), ..., P3 (PN (S)), ... ..., PN (P1 (S)), ..., PN (PN (S)). Questi sono tutti concatenati insieme. Quindi l'ultimo input viene riutilizzato per prendere ogni PNth carattere di questa grande stringa. Quindi prendo PN = len (S) * N = 10 * N. Questo significa che prenderemo il primo carattere di P2 (P1 (S)), il primo carattere di P3 (P1 (S )), fino al primo carattere di PN (P1 (S)). Per semplificare ulteriormente, lascio P1 = 1 che è la permutazione dell'identità. Quindi è sufficiente scegliere qualsiasi P2 che permetta "H" nel primo posizione, una P3 che permetta "e" nella prima posizione e così via. Fortunatamente, piccoli numeri di permutazione come quello già scelto per PN non influiscono sui caratteri precedenti nella stringa, quindi PN lascia "!" all'inizio della stringa. (Se questo non fosse vero, sarebbe comunque possibile risolvere scegliendo un P1 diverso.)
4195875
Prova a stampare il secondo argomento come una stringa, che è un puntatore che possiamo determinare sull'input. Accade solo che nella memoria della posizione 4195875inizi la "Hello, World!\n"stringa.
Il numero è stato determinato aggiungendo print("%p", "Hello, World!");prima di printf, convertendo il numero esadecimale in decimale e provandolo sul TIO originale. Tuttavia, mi ha mostrato ilprintf stringa di formato. Provando alcuni numeri, ho scoperto che la stringa si trova prima della stringa di formato.
Quindi in memoria, sembrerebbe così (come una stringa C):
Hello, World!\n\0%2$s\0
Ciò significa anche che qualsiasi aggiornamento al compilatore potrebbe interrompere la soluzione.
[1, "HH", 1, "eellloo", 1, ",,", 1, " WWoo", 1, "rr", 1, "ll", 1, "dd", 1, "!!"]
La spiegazione arriva un po '...
var i = 0;
var string = `"${t}"`;
var answer = "i++?0:q=string";
console.log( f(answer) );
PDO,FETCH_CLASSTYPE
(TIO non ha la classe PDO definita, quindi la demo sopra usa un codepad che lo fa)
Un'altra soluzione:
ReflectionFunction,IS_DEPRECATED
Dato il limite di 81 caratteri, questa probabilmente non è la soluzione prevista
global.g = ()=>"Hello, World!";
var str = "g";