Este es el hilo de los ladrones. El hilo de la policía está aquí .
Su desafío es tomar una presentación sin descifrar del hilo de la policía y encontrar, para qué entrada o entradas, el programa se imprimirá Hello, World!y una nueva línea. La capitalización, el espaciado y la puntuación deben ser exactos.
Comenta sobre el envío del policía cuando hayas descifrado su código.
Respuestas:
Código original:
[[ ! "${1////x}" =~ [[:alnum:]] ]]&&[[ $# = 1 ]]&&bash -c "$1"
Entrada:
__=; (( __++, __-- ));
(( ___ = __, ___++));
(( ____ = ___, ____++));
(( _____ = ____, _____++));
(( ______ = _____, ______++));
(( _______ = ______, _______++));
(( ________ = _______, ________++));
(( _________ = ________, _________++));
${!__##-} <<<\$\'\\$___$______$_______\\$___$______$_____\\$___$_______$__\\$___$_______$_________\'\ \$\'\\$___$___$__\\$___$______$_______\\$___$_______$______\\$___$_______$______\\$___$_______$_________,\ \\$___$____$_________\\$___$_______$_________\\$___$________$____\\$___$_______$______\\$___$______$______\\$__$______$___\'
Explicación:
Esto codifica "echo Hello, World!" como secuencias de escape octal (\ xxx).
Excepto que tampoco puede usar números, por lo que la primera parte acumula variables para los números 0-7. Puede usarlos para construir una cadena con secuencias octales que evaluarán para darle el comando real.
Pero evaltambién es alfanumérico. Entonces, en cambio, esto canaliza esa cadena como entrada a otra instancia de bash. $0contiene el nombre del comando utilizado para invocar Bash, que generalmente es solo bash(o -bashpara un shell de inicio de sesión) si lo está ejecutando normalmente (a través de TIO o pegándolo en un terminal). (Esto, por cierto, significa que si intentas ejecutar esto pegándolo en un script, las cosas saldrán terriblemente mal, ya que intenta bifurcarse varias veces).
Pero de todos modos, no se puede decir $0directamente. En su lugar, $__contiene el nombre de $0("0"), y puede utilizar la expansión indirecta para acceder a él (se ${!__}refiere al contenido de $0).
Y eso, finalmente, te da todas las piezas que necesitas.
•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"
Ges el incorporado para el alfabeto en minúsculas. El código verifica la igualdad contra eso.
〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ
sLƽ$Xṙ5O½Ọ
El código original se puede explicar como tal:
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
Entonces, solo toma "¡Hola, mundo!" y obtener puntos de código, cuadrarlos, volver a los puntos de código, rotar a la derecha 5 veces, y luego cuadrar y aplanar el resultado.
No estoy seguro de si esta es la solución correcta (en TIO imprime el \00personaje), pero en mi octave-clishell se ve así:
También en el desafío original dice que no imprima nada (o el carácter nulo) , por lo que si nada es lo mismo, \00entonces debería estar bien.
[72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33, 0]0con a 10).
Hello, World!y una nueva línea". Es una cita exacta del desafío. Y de hecho, eso hace que la respuesta sea trivial.
print("Hello, World!") or __import__('sys').exit(0)
Prevenga cualquier error saliendo temprano.
{length:1, charCodeAt:()=>(e='Hello, World!', String.fromCharCode=()=>'')}
Eso fue bastante fácil.
Me di cuenta de que no sería posible generar ninguna entrada de cadena Hello, World!porque todo lo que está dentro String.fromCharCodesolo devolverá múltiplos de 4 y !tiene un código char de 33. Así que claramente solo tenemos que hackear todo el programa. Hackear los elementos integrados en JavaScript es trivial si uno no trata de detenerlos (e incluso si lo hace, generalmente hay muchas soluciones alternativas ...).
Proxy simple que solo devuelve el carácter deseado cada 3 veces que se llama.
var i = 0;
var string = "Hello, World!";
var proxy = new Proxy([], {
get: function(target, property) {
if (!(++i%3)) {
return string[property];
}
return [1];
}
});
La entrada mágica es: 1767707618171221 30191World!
1767707618171221es primo y, escrito en base 36, lo es "hello". Cuando se escribe con mayúscula, esto produce "Hello", que se imprime usando$><<$><<", #$'"if/30191/busca el número 30191en la entrada y escribe en stdout una cadena compuesta por una coma, un espacio y cualquier cosa que esté en la entrada después de 30191(usando el $POSTMATCH, que se refiere aquí por su variante corta $').Pase esto como el primer argumento:
C=("").char;_G[C(112,114,105,110,116)](C(72,101,108,108,111,44,32,87,111,114,108,100,33))Suponiendo que el código original está en un archivo tehtmi.lua, ejecute (en bash o un shell similar):
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))'También funciona en Lua 5.3, que es lo que usa TIO, entonces, ¿por qué no lo prueba en línea ? No he probado en una implementación que utiliza el núcleo "PUC-Rio's Lua 5.1" (porque realmente no puedo encontrar ninguna información), pero mi solución probablemente también funcione allí.
Ejecuta el primer argumento como código, pero solo si contiene menos de 5 caracteres en minúscula.
El truco es correr print("Hello, World!"). Otra forma de ejecutar esto es mediante el uso _G["print"]("Hello, World!"), que solo utiliza cadenas.
Pero no podemos usar la cadena directamente debido a la restricción de recuento en minúsculas, sin embargo, puede ejecutar ("").charpara obtener la función string.char, que puede convertir de una serie de bytes a una cadena. Lo asigné a una variable en mayúscula (para que no lleguemos al límite) para que podamos usarlo para construir tanto printlas Hello, World!cadenas como las que se pueden usar como se indica arriba.
nextlugar de charlo que no funciona en Lua 5.3 debido a la aleatorización del orden de iteración.
La entrada debe ser una cadena que contenga esto:
e(
`\
_\
=\
>\
"\
H\
e\
l\
l\
o\
,\
\
W\
o\
r\
l\
d\
!\
"\
+\
\`
\`
`)
Pruébalo usando esto:
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))Si no le importa el requisito de nueva línea final para la salida, puede reemplazar las últimas 6 líneas con esto en su lugar:
!"
`)
Las restricciones en la entrada son que es una cadena, cada línea tiene dos bytes de longitud o menos, y que la longitud total es de 80 bytes o menos. Mi primer intento después de entender eso correctamente fue este:
_
=>
`\
H\
e\
l\
l\
o\
,\
\
W\
o\
r\
l\
d\
!
`
Nota: los \s deben ignorar las nuevas líneas en la cadena en la entrada. Esto es increíblemente crucial para la respuesta, y no puedo creer que me topé con él por accidente. (Estaba familiarizado con eso antes pero lo olvidé)
Pero esto no funcionó, ya que =>tiene que estar en la misma línea que los argumentos. Afortunadamente, tuve la idea de envolver algo similar en una cadena y poner una evaluación en mi entrada para reducirlo a una línea, lo que resultó en mi respuesta final. Después de que ocurre la evaluación en la entrada, se genera lo siguiente como una cadena (que luego se evalúa en una función y luego se ejecuta):
_=>"Hello, World!"+`
`
Esto fue realmente difícil de descifrar, pero al final tuve éxito.
Además, ¡el primer crack!
Me imagino que esto siempre es peligroso, pero creo que tengo una grieta, a la espera de que tenga razón en que hay un error en el intérprete (que acabo de compilar).
Mi entrada
0 1 0 1 0 1 0 1 1 0 1 0 0
La salida es Hello, World!\n\n\n\n\n\n\n\n\n\n.....con nuevas líneas interminables.
Pero noté la última sección del código:
:1/1+1$(@6)7
configura el bloc de notas en 0x0A(nueva línea) de forma aterradora, lee la entrada en la cara 7 (la cara de entrada) y luego imprime la cara 6 (cara del bloc de notas) repetidamente hasta que la cara 7 sea cero. Si establece la cara 7 en cero, solo debería obtener una nueva línea. Sin embargo, obtuve nuevas líneas infinitas y mi 13a entrada fue un cero, y puedo verificar que la 7 cara siempre es cero insertando un "número de impresión de 7 caras" en el bucle:
:1/1+1$(@6%7)7
luego imprime \n0pares interminables .
Estoy mirando las especificaciones en la página cúbicamente github y este comportamiento se parece mucho a un error. Cambiar el último carácter del programa original de 7a a 0resulta en el comportamiento esperado. El intérprete de TIO exhibe el mismo comportamiento incorrecto.
q5/:i:c
00072001010010800108001110004400032000870011100114001080010000033
q - Take input (string)
5/ - split into chunks of five
:i - cast to integers
:c - cast to characters
La solución que encontré hace un uso muy sustancial de caracteres no imprimibles, por lo que intentar pegarlo aquí no funcionó bien. Los valores de bytes para la entrada son:
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
O la versión de cadena está disponible en el campo de entrada del enlace TIO.
El programa original tomaría los caracteres distintos en la entrada, luego invertiría la entrada y multiplicaría los elementos de las dos listas. Por lo tanto, creé una cadena de 26 caracteres de longitud donde los primeros 13 caracteres eran distintos, los últimos 13 caracteres también aparecieron en los primeros 13 y cada par de índices se [i, 26-i]multiplicó al valor de byte del i-ésimo carácter en Hello, World!.
n[>n]<[8+o<]
2 25 92 100 106 103 79 24 36 103 100 100 93 64
Pruébelo aquí (aunque la página no muestra la nueva línea).
ntoma entrada, intenta dividirse en espacios y lanzar a ints, estos se ponen en la pila. oimprime puntos ordinales y 8+hace lo que uno pensaría. Por lo tanto, la entrada debe ser 8 menos que los puntos de código en orden inverso divididos por espacios.
2que funcionaría, ¿es solo la página de herokuapp que no lo muestra?
Código original:
#define O(c)(((char**)v)+c)
#define W(c)*(O(c)-**O(2)+x)
main(x,v){puts(W(42));}
Argumentos:
"Hello, World!" ","
Explicación:
W(c)está calculando la dirección de una cadena de la lista de argumentos para imprimir. Comienza con la dirección del argumento cth ( O(c)), que es el argumento 42 en este caso, y luego resta el primer carácter del segundo argumento ( **O(2)) como un desplazamiento de enteros, y luego suma x, que es el número de argumentos.
W(c)utiliza el segundo argumento, por lo que sabe que debe haber al menos 3 de ellos (0, 1, 2). Entonces "¡Hola, mundo!" puede ir en el primer argumento, y luego para abordar ese argumento necesita un carácter cuyo valor ASCII se ajuste a la ecuación "42-x + 3 = 1". Eso pasa a ser ",".
Anulo los métodos valueOf()y toString()de los objetos analizados para que la coerción falle con a TypeError.
{"valueOf": 7, "toString": 7}
La respuesta correcta es 52768,23
La explicación está un poco involucrada.
00 c0 ;load address
20 fd ae jsr $aefd ; checks for comma
20 eb b7 jsr $b7eb ; reads arguments
El código primero busca una coma (necesidad de sintaxis) y luego lee dos argumentos, el primero de los cuales es una PALABRA, almacenado little-endian en la ubicación de memoria 0014 y 0015, el último de los cuales se almacena en el 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
Eso es bastante inteligente, usando nuestra entrada para reescribir el programa. Eventualmente reescribe el contador para el bucle de salida al final del programa.
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
Aquí viene la parte tortuosa:
8e 18 d0 STX $d018 ; stores the original second argument in d018
en el C64, d018 es un byte muy importante. Almacena los puntos de referencia para cosas que involucran la salida de la pantalla. Ver aquí para más información. Si esto obtiene un valor incorrecto, bloqueará su C64. Para imprimir las letras mayúsculas y minúsculas mixtas requeridas, esto debe ser $ 17.
Ahora comenzamos nuestro ciclo de salida:
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
Esa constante es lo que se escribió antes. Determina claramente cuánto dura el ciclo. Resulta que ya es el valor correcto, pero necesitamos mantener 0e allí nuevamente.
d0 f6 bne *-8 ; jump back 8 bytes if y and that constant weren't equal
60 rts ; ends the program
El resto es solo la información que necesitamos imprimir, comenzando en la dirección de memoria c025.
Entonces solo sigue las matemáticas desde allí.
$FFallí, pero luego decidí dejarlo.
La respuesta correcta es
8bitsareenough
El código es bastante complicado e implica una gran cantidad de auto modificación. Entonces, en lugar de aplicarle ingeniería inversa, puedes usarlo para descifrarlo.
Aquí hay un desmontaje un poco más útil del código, para ayudar a comprender lo que sucedió. La sintaxis es para 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
Etiquetarlo de esta manera fue suficiente para mí para ver que el código XOR contiene un montón de constantes que se ocultan para imprimir lo que necesitamos. Como XOR es reversible, si ingresa la salida deseada, le dirá cuál es la clave.
Entonces cambié la última línea
/*from sta $d018
to*/ jsr $ffd2
por lo que imprimiría la última entrada requerida en lugar de bloquearse en una entrada incorrecta.
¡Y eso es eso!
Si hay algún interés, descifraré el código más.
vice. Pero lo que sea, es la solución correcta.
drops A in mystery+1, over the constant" <- eso es realmente mystery+4con tu etiqueta. Las compensaciones están en bytes :) y FWIW, la auto-modificación es bastante común incluso en el código 6502 serio , siempre que el código se ejecute desde la RAM.
@_?&4_-j>5&f^~c>&6\|4>7
Rh / qi?, Wcr + du
Código original:
œ?“¥ĊɲṢŻ;^»œ?@€⁸ḊFmṪ⁷
Entrada:
1.2586391,2949273,3312154,3312154,1134001,362881,2223505,766081,1134001,1497601,3312154,1860601,140
Explicación:
Principalmente, es necesario entender lo que hace el código. Lo primero que hace es tomar la cuerda
"!,Word Hel"(con todos los caracteres necesarios excepto la nueva línea) y crea un montón de permutaciones de ellos. Las entradas especifican números de permutación, y cada par de permutaciones de la entrada se aplica a la cadena, excluyendo los pares donde se aplica primero la primera permutación. Básicamente, P2 (P1 (S)), P2 (P2 (S), P2 (P3 (S)), ..., P2 (PN (S)), P3 (P1 (S)), ..., P3 (PN (S)), ... ..., PN (P1 (S)), ..., PN (PN (S)). Todos se concatenan juntos. Luego, la última entrada se reutiliza para tomar cada PNth carácter de esta gran cadena. Entonces, tomo PN = len (S) * N = 10 * N. Esto significa que tomaremos el primer carácter de P2 (P1 (S)), el primer carácter de P3 (P1 (S )), todo el camino hasta el primer carácter de PN (P1 (S)). Para simplificar aún más, dejo que P1 = 1, que es la permutación de identidad. Entonces es suficiente elegir cualquier P2 que permuta "H" en el primer posición, un P3 que permuta "e" en la primera posición y así sucesivamente. Afortunadamente, los números de permutación pequeños como el que ya se eligió para PN no afectan a los caracteres anteriores de la cadena, por lo que PN deja "!" Al principio de la cuerda. (Si esto no fuera cierto, aún sería posible resolverlo eligiendo un P1 diferente).
4195875
Intenta imprimir el segundo argumento como una cadena, que es un puntero que podemos determinar en la entrada. Sucede que en la memoria de ubicación 4195875comienza la "Hello, World!\n"cadena.
El número se determinó sumando print("%p", "Hello, World!");antes del printf, convirtiendo el número hexadecimal a decimal y probándolo en el TIO original. Sin embargo, me mostró la printfcadena de formato. Al probar algunos números, descubrí que la cadena se encuentra antes de la cadena de formato.
Entonces, en la memoria, se vería así (como una cadena C):
Hello, World!\n\0%2$s\0
Esto también significa que cualquier actualización del compilador podría romper la solución.
['Hello, World!','','','','','','','','','','','','']
[1, "HH", 1, "eellloo", 1, ",,", 1, " WWoo", 1, "rr", 1, "ll", 1, "dd", 1, "!!"]
La explicación viene un poco ...
var i = 0;
var string = `"${t}"`;
var answer = "i++?0:q=string";
console.log( f(answer) );
PDO,FETCH_CLASSTYPE
(TIO no tiene la clase PDO definida, por lo que la demostración anterior usa un teclado que sí)
Otra solución:
ReflectionFunction,IS_DEPRECATED
Dado el límite de 81 caracteres, esta probablemente no sea la solución prevista
global.g = ()=>"Hello, World!";
var str = "g";