Este é o fio dos ladrões. A discussão dos policiais está aqui .
Seu desafio é pegar um envio sem rachaduras do tópico da polícia e encontrar, para quais entradas ou entradas, o programa será impresso Hello, World!e uma nova linha. Letras maiúsculas, espaçamento e pontuação devem ser exatas.
Por favor, comente a submissão do policial quando você tiver decifrado o código.
Respostas:
Código original:
[[ ! "${1////x}" =~ [[:alnum:]] ]]&&[[ $# = 1 ]]&&bash -c "$1"
Entrada:
__=; (( __++, __-- ));
(( ___ = __, ___++));
(( ____ = ___, ____++));
(( _____ = ____, _____++));
(( ______ = _____, ______++));
(( _______ = ______, _______++));
(( ________ = _______, ________++));
(( _________ = ________, _________++));
${!__##-} <<<\$\'\\$___$______$_______\\$___$______$_____\\$___$_______$__\\$___$_______$_________\'\ \$\'\\$___$___$__\\$___$______$_______\\$___$_______$______\\$___$_______$______\\$___$_______$_________,\ \\$___$____$_________\\$___$_______$_________\\$___$________$____\\$___$_______$______\\$___$______$______\\$__$______$___\'
Explicação:
Isso codifica "eco Olá, mundo!" como seqüências de escape octais (\ xxx).
Exceto que você também não pode usar números, então a primeira parte cria variáveis para os números de 0 a 7. Você pode usá-los para criar uma sequência com sequências octais que serão avaliadas para fornecer o comando real.
Mas evaltambém é alfanumérico. Então, ao invés disso, isso canaliza essa string como entrada para outra instância de bash. $0contém o nome do comando usado para chamar o Bash, que normalmente é apenas bash(ou -bashpara um shell de login) se você o estiver executando normalmente (por meio do TIO ou colando-o em um terminal). (Isso significa que, se você tentar executar isso colando-o em um script, as coisas darão terrivelmente errado ao tentar se bifurcar várias vezes.)
Mas de qualquer maneira, você não pode dizer $0diretamente. Em vez disso, $__contém o nome de $0("0") e você pode usar a expansão indireta para acessá-lo ( ${!__}refere-se ao conteúdo de $0).
E isso, finalmente, fornece todas as peças necessárias.
•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é o built-in para o alfabeto em minúsculas. O código verifica a igualdade em relação a isso.
〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ
sLƽ$Xṙ5O½Ọ
O código original pode ser explicado da seguinte forma:
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
Então, basta pegar "Olá, mundo!" e obtenha pontos de código, ajuste-os ao quadrado, jogue de volta aos pontos de código, gire para a direita 5 vezes e, em seguida, aplique o quadrado e achatar o resultado.
Não tenho certeza se esta é a solução correta (no TIO ele imprime o \00personagem), mas no meu octave-clishell fica assim:
Também no desafio original, ele diz que imprima nada (ou o caractere nulo) ; portanto, se nada for o mesmo, \00então tudo ficará bem.
[72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33, 0]0por a 10).
Hello, World!e uma nova linha." é uma citação exata do desafio. E, de fato, isso torna a resposta trivial.
print("Hello, World!") or __import__('sys').exit(0)
Evite erros ao sair mais cedo.
{length:1, charCodeAt:()=>(e='Hello, World!', String.fromCharCode=()=>'')}
Isso foi bem fácil.
Eu notei que nenhuma entrada de string não seria possível produzir, Hello, World!porque a coisa toda dentro String.fromCharCoderetornará apenas múltiplos de 4 e !tem um código de caractere 33. Então, claramente, precisamos apenas hackear o programa inteiro. Hackear embutidos em JavaScript é trivial se não tentarmos impedi-los (e mesmo se o fizermos, geralmente existem muitas soluções alternativas ...).
Proxy simples que retorna o caractere desejado apenas a cada 3 vezes.
var i = 0;
var string = "Hello, World!";
var proxy = new Proxy([], {
get: function(target, property) {
if (!(++i%3)) {
return string[property];
}
return [1];
}
});
A entrada mágica é: 1767707618171221 30191World!
1767707618171221é primo e, escrito na base 36, é "hello". Quando em maiúscula, isso produz "Hello", que é impresso usando$><<$><<", #$'"if/30191/procura o número 30191na entrada e grava em stdout uma string composta por vírgula, espaço e o que estiver na entrada após a 30191(usando o $POSTMATCH, que é referido aqui por sua variante curta $').Passe isso como o primeiro argumento:
C=("").char;_G[C(112,114,105,110,116)](C(72,101,108,108,111,44,32,87,111,114,108,100,33))Supondo que o código original esteja em um arquivo tehtmi.lua, execute (no bash ou em um shell semelhante):
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))'Também funciona no Lua 5.3, que é o que o TIO usa. Por que você não tenta online ? Eu não testei em uma implementação que usa o núcleo "5.1 da Lua da PUC-Rio" (porque realmente não consigo encontrar nenhuma informação), mas minha solução provavelmente também funciona lá.
Ele executa o primeiro argumento como código, mas apenas se contiver menos de 5 caracteres em minúsculas.
O truque é correr print("Hello, World!"). Outra maneira de executar isso é usando _G["print"]("Hello, World!"), que usa apenas strings.
Mas não podemos usar a string diretamente devido à restrição de contagem em minúsculas; no entanto, você pode executar ("").charpara obter a função string.char, que pode converter de uma série de bytes em uma string. Eu o atribuai a uma variável maiúscula (para não atingirmos o limite), para que possamos usá-la para construir printas Hello, World!strings e as strings que podem ser usadas como acima.
nextvez de charque não funciona no Lua 5.3 devido à randomização da ordem de iteração.
A entrada deve ser uma sequência que contenha isso:
e(
`\
_\
=\
>\
"\
H\
e\
l\
l\
o\
,\
\
W\
o\
r\
l\
d\
!\
"\
+\
\`
\`
`)
Experimente usando o seguinte:
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 você não se importa com o requisito de nova linha à direita para a saída, substitua as últimas 6 linhas por:
!"
`)
As restrições na entrada são que é uma sequência, cada linha tem dois bytes de comprimento ou menos e que o comprimento total é de 80 bytes ou menos. Minha primeira tentativa depois de entender que foi corretamente:
_
=>
`\
H\
e\
l\
l\
o\
,\
\
W\
o\
r\
l\
d\
!
`
Nota: os \s devem ignorar as novas linhas na string na entrada. Isso é incrivelmente crucial para a resposta, e não acredito que me deparei com ela por acidente. (Eu estava familiarizado com isso antes, mas esqueci)
Mas isso não funcionou, pois =>o argumento deve estar na mesma linha. Felizmente, tive a ideia de agrupar algo semelhante em uma string e colocar uma avaliação em minha opinião para reduzi-la a uma linha, resultando em minha resposta final. Após a avaliação na entrada, o seguinte é gerado como uma sequência (que é avaliada para uma função e depois executada):
_=>"Hello, World!"+`
`
Foi realmente difícil de entender, mas eu consegui no final.
Além disso, o primeiro crack de todos os tempos!
Eu imagino que isso seja sempre perigoso, mas acho que tenho uma rachadura, enquanto estou correto, pois há um erro no intérprete (que acabei de compilar).
Minha entrada
0 1 0 1 0 1 0 1 1 0 1 0 0
A saída é Hello, World!\n\n\n\n\n\n\n\n\n\n.....com novas linhas intermináveis.
Mas notei a última seção do código:
:1/1+1$(@6)7
define o bloco de notas para 0x0A(nova linha) de forma assustadora, lê a entrada na face 7 (a face de entrada) e imprime as 6 faces (face do bloco de notas) repetidamente até que a face 7 seja zero. Se você definir a face 7 como zero, deverá receber apenas uma nova linha. No entanto, recebi novas linhas infinitas e minha 13ª entrada foi zero, e posso verificar se a face 7 é sempre zero inserindo um "número de impressão da face 7" no loop:
:1/1+1$(@6%7)7
depois imprime \n0pares intermináveis .
Eu estou olhando as especificações na página do github cubicamente e esse comportamento se parece muito com um bug. Alterar o último caractere do programa original de a 7para um 0resulta no comportamento esperado. O intérprete TIO exibe o mesmo comportamento incorreto.
q5/:i:c
00072001010010800108001110004400032000870011100114001080010000033
q - Take input (string)
5/ - split into chunks of five
:i - cast to integers
:c - cast to characters
A solução que encontrei faz uso muito substancial de caracteres não imprimíveis, portanto, tentar colá-lo aqui não funcionou bem. Os valores de bytes para a entrada são:
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
Ou a versão da sequência está disponível no campo de entrada do link TIO.
O programa original pegaria os caracteres distintos na entrada, depois reverteria a entrada e multiplicaria os elementos das duas listas. Assim, criei uma string com 26 caracteres, onde os 13 primeiros caracteres eram distintos, todos os 13 últimos também apareceram nos 13 primeiros, e cada par de índices [i, 26-i]multiplicado pelo valor de byte do i-ésimo caractere Hello, World!.
n[>n]<[8+o<]
2 25 92 100 106 103 79 24 36 103 100 100 93 64
Experimente aqui (embora a página não renderize a nova linha).
nrecebe entrada, tenta dividir em espaços e converter em entradas, essas são colocadas na pilha. oimprime pontos ordinais e 8+faz o que alguém poderia pensar. Portanto, a entrada precisa ser 8 a menos que os pontos de código na ordem inversa, dividida por espaços.
2que funcionaria - isso é apenas a página herokuapp não a processando?
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!" ","
Explicação:
W(c)está calculando o endereço de uma string da lista de argumentos a ser impressa. Começa com o endereço do césimo argumento ( O(c)), que é o 42º argumento neste caso, e subtrai o primeiro caractere do segundo argumento ( **O(2)) como um deslocamento inteiro, e depois adiciona x, que é o número de argumentos.
W(c)usa o segundo argumento, para que você saiba que precisa haver pelo menos três deles (0, 1, 2). Então "Olá, mundo!" pode ir no primeiro argumento e, para abordá-lo, você precisa de um caractere cujo valor ASCII se encaixe na equação "42-x + 3 = 1". Isso passa a ser ",".
Eu substituo os métodos valueOf()e toString()dos objetos analisados para que a coerção falhe com a TypeError.
{"valueOf": 7, "toString": 7}
A resposta correta é 52768,23
A explicação está um pouco envolvida.
00 c0 ;load address
20 fd ae jsr $aefd ; checks for comma
20 eb b7 jsr $b7eb ; reads arguments
O código primeiro verifica uma vírgula (necessidade de sintaxe) e, em seguida, lê dois argumentos, o primeiro dos quais é uma PALAVRA, armazenado little-endian nos locais de memória 0014 e 0015, o último dos quais é armazenado no 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
Isso é bastante inteligente, usando nossa entrada para reescrever o programa. Eventualmente, reescreve o contador para o loop de saída no final do 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
Aí vem a parte desonesta:
8e 18 d0 STX $d018 ; stores the original second argument in d018
no C64, o d018 é um byte muito importante. Ele armazena os pontos de referência para itens que envolvem a saída da tela. Veja aqui para mais informações. Se isso der um valor errado, ele travará o seu C64. Para imprimir as letras maiúsculas e minúsculas necessárias, é necessário US $ 17.
Agora começamos nosso loop de saída:
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
Essa constante é o que foi escrito antes. Determina claramente quanto tempo o loop é executado. Já é o valor certo, mas precisamos manter 0e lá novamente.
d0 f6 bne *-8 ; jump back 8 bytes if y and that constant weren't equal
60 rts ; ends the program
O restante é apenas a informação que precisamos imprimir, começando no endereço de memória c025.
Então, é só seguir a matemática a partir daí.
$FFlá, mas depois decidi deixá-la.
A resposta correta é
8bitsareenough
O código é bastante complicado, envolvendo muita auto-modificação. Então, em vez de fazer a engenharia totalmente reversa, você pode usá-lo para se quebrar.
Aqui está uma desmontagem do código um pouco mais útil, para ajudar a entender o que aconteceu. A sintaxe é para o 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
Rotulá-lo dessa forma foi suficiente para eu ver que o código XORs um monte de constantes que estão ocultas para imprimir o que precisamos. Como o XOR é reversível, se você inserir a saída desejada, ele informará qual é a chave.
Então eu mudei a última linha
/*from sta $d018
to*/ jsr $ffd2
para imprimir a última entrada necessária em vez de travar em uma entrada errada.
E é isso!
Se houver algum interesse, decifrarei mais o código.
vice. Mas seja como for, é a solução correta.
drops A in mystery+1, over the constant" <- esse é realmente o mystery+4seu rótulo. As ofensas estão em bytes :) e no FWIW, a auto-modificação é bastante comum mesmo no código 6502 sério , desde que o código seja executado a partir da 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
Explicação:
Principalmente, é necessário entender o que o código faz. A primeira coisa que faz é pegar a corda
"!,Word Hel"(com todos os caracteres necessários, exceto nova linha) e cria várias permutações deles. As entradas especificam números de permutação e cada par de permutações da entrada é aplicado aos strings que excluem pares onde a primeira permutação é aplicada primeiro. Basicamente, P2 (P1 (S)), P2 (P2 (S), P2 (P3 (S)), ..., P2 (PN (S)), P3 (P1 (S)), ..., P3 (PN (S)), ... ..., PN (P1 (S)), ..., PN (PN (S)) Tudo isso é concatenado, então a última entrada é reutilizada para cada PNth caractere dessa string grande. Então, eu pego PN = len (S) * N = 10 * N. Isso significa que pegaremos o primeiro caractere de P2 (P1 (S)), o primeiro caractere de P3 (P1 (S )), até o primeiro caractere de PN (P1 (S)) .Para simplificar, deixei P1 = 1, que é a permutação de identidade.Em seguida, basta escolher qualquer P2 que permita "H" no primeiro posição, um P3 que permite "e" na primeira posição e assim por diante. Felizmente, pequenos números de permutação como o já escolhido para PN não afetam os caracteres anteriores da string, portanto o PN deixa "!" no início da string. (Se isso não fosse verdade, ainda seria possível resolver escolhendo um P1 diferente.)
4195875
Ele tenta imprimir o segundo argumento como uma string, que é um ponteiro que podemos determinar na entrada. Acontece que no local a memória 4195875inicia a "Hello, World!\n"string.
O número foi determinado adicionando print("%p", "Hello, World!");antes de printf, convertendo o número hexadecimal em decimal e testando-o no TIO original. No entanto, ele me mostrou a printfstring de formato. Ao experimentar alguns números, descobri que a string está localizada antes da string de formato.
Portanto, na memória, ficaria assim (como uma string C):
Hello, World!\n\0%2$s\0
Isso também significa que qualquer atualização no compilador pode interromper a solução.
['Hello, World!','','','','','','','','','','','','']
[1, "HH", 1, "eellloo", 1, ",,", 1, " WWoo", 1, "rr", 1, "ll", 1, "dd", 1, "!!"]
Explicação em breve ...
var i = 0;
var string = `"${t}"`;
var answer = "i++?0:q=string";
console.log( f(answer) );
PDO,FETCH_CLASSTYPE
(O TIO não tem a classe PDO definida, portanto, a demonstração acima usa um teclado de código que faz)
Outra solução:
ReflectionFunction,IS_DEPRECATED
Dado o limite de 81 caracteres, essa provavelmente não é a solução pretendida
global.g = ()=>"Hello, World!";
var str = "g";