Ceci est le fil des voleurs. Le fil des flics est ici .
Votre défi est de prendre une soumission non fissurée du fil des flics et de trouver, pour quelle entrée ou entrées, le programme imprimera Hello, World!et une nouvelle ligne. La mise en majuscule, l'espacement et la ponctuation doivent être exacts.
Veuillez commenter la soumission du policier lorsque vous avez craqué son code.
Réponses:
Code d'origine:
[[ ! "${1////x}" =~ [[:alnum:]] ]]&&[[ $# = 1 ]]&&bash -c "$1"
Contribution:
__=; (( __++, __-- ));
(( ___ = __, ___++));
(( ____ = ___, ____++));
(( _____ = ____, _____++));
(( ______ = _____, ______++));
(( _______ = ______, _______++));
(( ________ = _______, ________++));
(( _________ = ________, _________++));
${!__##-} <<<\$\'\\$___$______$_______\\$___$______$_____\\$___$_______$__\\$___$_______$_________\'\ \$\'\\$___$___$__\\$___$______$_______\\$___$_______$______\\$___$_______$______\\$___$_______$_________,\ \\$___$____$_________\\$___$_______$_________\\$___$________$____\\$___$_______$______\\$___$______$______\\$__$______$___\'
Explication:
Cela code "écho Bonjour, monde!" sous forme de séquences d'échappement octales (\ xxx).
Sauf que vous ne pouvez pas non plus utiliser de nombres, donc la première partie crée des variables pour les nombres 0-7. Vous pouvez les utiliser pour construire une chaîne avec des séquences octales qui seront évaluées pour vous donner la commande réelle.
Mais evalest également alphanumérique. Donc, à la place, cela canalise cette chaîne en entrée d'une autre instance de bash. $0contient le nom de la commande utilisée pour appeler Bash, qui est généralement juste bash(ou -bashpour un shell de connexion) si vous l'exécutez normalement (via TIO ou en le collant dans un terminal). (Cela signifie d'ailleurs que si vous essayez de l'exécuter en le collant dans un script, les choses iront horriblement mal alors qu'il essaie de se bifurquer plusieurs fois.)
Mais de toute façon, vous ne pouvez pas dire $0directement. $__Contient à la place le nom de $0("0") et vous pouvez utiliser l'expansion indirecte pour y accéder ( ${!__}fait référence au contenu de $0).
Et cela, enfin, vous donne toutes les pièces dont vous avez besoin.
•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)
〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ
sLƽ$Xṙ5O½Ọ
Le code d'origine peut être expliqué comme tel:
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
Alors, prenez simplement "Bonjour, le monde!" et obtenez des points de code, mettez-les au carré, relancez-les en points de code, faites-les pivoter 5 fois vers la droite, puis ajustez et aplatissez le résultat.
Je ne sais pas si c'est la bonne solution (sur TIO, cela imprime le \00caractère), mais dans mon octave-clishell, cela ressemble à ceci:
Dans le défi d'origine, il est également indiqué de ne rien imprimer (ou le caractère nul) , donc si rien n'est le même, \00cela devrait aller.
[72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33, 0]0par un 10).
Hello, World!et un retour à la ligne. » est une citation exacte du défi. Et en effet, cela rend la réponse triviale.
print("Hello, World!") or __import__('sys').exit(0)
Empêchez toute erreur en fermant tôt.
{length:1, charCodeAt:()=>(e='Hello, World!', String.fromCharCode=()=>'')}
C'était assez facile.
J'ai remarqué que toute entrée de chaîne ne serait pas possible de sortir Hello, World!parce que le tout à l'intérieur String.fromCharCodene renverrait que des multiples de 4, et !a un code de caractère de 33. Donc, clairement, nous devons juste pirater tout le programme. Le piratage des fonctionnalités intégrées en JavaScript est trivial si l'on n'essaye pas de les arrêter (et même si on le fait, il existe généralement de nombreuses solutions de contournement ...).
Proxy simple qui ne renvoie le caractère recherché que tous les 3 fois qu'il est appelé.
var i = 0;
var string = "Hello, World!";
var proxy = new Proxy([], {
get: function(target, property) {
if (!(++i%3)) {
return string[property];
}
return [1];
}
});
L'entrée magique est: 1767707618171221 30191World!
1767707618171221est un nombre premier et, écrit en base 36, il l'est "hello". Une fois capitalisé, cela produit "Hello", qui est imprimé en utilisant$><<$><<", #$'"if/30191/recherche le nombre 30191dans l'entrée et écrit pour stdout une chaîne composée d'une virgule, d'un espace et de tout ce qui est dans l'entrée après le 30191(en utilisant le $POSTMATCH, qui est référencé ici par sa variante courte $').Passez ceci comme premier argument:
C=("").char;_G[C(112,114,105,110,116)](C(72,101,108,108,111,44,32,87,111,114,108,100,33))En supposant que le code d'origine se trouve dans un fichier tehtmi.lua, exécutez (dans bash ou un shell similaire):
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))'Il fonctionne également sur Lua 5.3, qui est utilisé par TIO, alors pourquoi ne pas l' essayer en ligne ? Je n'ai pas testé une implémentation qui utilise le noyau "PUC-Rio's Lua 5.1" (car je ne trouve pas vraiment d'informations), mais ma solution y fonctionne probablement aussi.
Il exécute le premier argument sous forme de code, mais uniquement s'il contient moins de 5 caractères minuscules.
L'astuce est de courir print("Hello, World!"). Cela peut également être exécuté à l'aide de _G["print"]("Hello, World!"), qui utilise uniquement des chaînes.
Mais nous ne pouvons pas utiliser la chaîne directement en raison de la restriction du nombre de minuscules, cependant, vous pouvez exécuter ("").charpour obtenir la fonction string.char, qui peut convertir une série d'octets en une chaîne. Je l'ai assigné à une variable en majuscule (afin de ne pas atteindre la limite) afin que nous puissions l'utiliser pour construire à la fois printles Hello, World!chaînes et les chaînes qui peuvent être utilisées comme ci-dessus.
nextplace de charce qui ne fonctionne pas sur Lua 5.3 en raison de la randomisation de l'ordre d'itération.
L'entrée doit être une chaîne contenant ceci:
e(
`\
_\
=\
>\
"\
H\
e\
l\
l\
o\
,\
\
W\
o\
r\
l\
d\
!\
"\
+\
\`
\`
`)
Essayez-le en utilisant ceci:
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 vous ne vous souciez pas de l'exigence de retour à la ligne pour la sortie, vous pouvez remplacer les 6 dernières lignes par ceci:
!"
`)
Les restrictions sur l'entrée sont qu'il s'agit d'une chaîne, chaque ligne fait deux octets de long ou moins, et que la longueur totale est de 80 octets ou moins. Ma première tentative après avoir compris que c'était correctement ceci:
_
=>
`\
H\
e\
l\
l\
o\
,\
\
W\
o\
r\
l\
d\
!
`
Remarque: les \s doivent ignorer les sauts de ligne dans la chaîne en entrée. C'est incroyablement crucial pour la réponse, et je ne peux pas croire que je suis tombé dessus par accident. (Je le connaissais auparavant mais je l'ai oublié)
Mais cela n'a pas fonctionné, car le =>doit être sur la même ligne que les arguments. Heureusement, j'ai eu l'idée d'encapsuler quelque chose de similaire dans une chaîne et de mettre un eval dans mon entrée pour le réduire à une ligne, ce qui a abouti à ma réponse finale. Une fois que l'évaluation dans l'entrée se produit, ce qui suit est généré sous forme de chaîne (qui est ensuite évaluée par une fonction, puis exécutée):
_=>"Hello, World!"+`
`
C'était vraiment difficile à résoudre, mais j'ai finalement réussi.
De plus, le premier crack jamais!
J'imagine que c'est toujours dangereux, mais je pense que j'ai une fissure, en attendant que j'ai raison en ce qu'il y a un bug dans l'interpréteur (que je viens de compiler).
Ma contribution
0 1 0 1 0 1 0 1 1 0 1 0 0
La sortie est Hello, World!\n\n\n\n\n\n\n\n\n\n.....avec des nouvelles lignes sans fin.
Mais j'ai remarqué la dernière section de code:
:1/1+1$(@6)7
définit le bloc-notes sur 0x0A(nouvelle ligne) d'une manière effrayante, lit l'entrée sur la face 7 (la face d'entrée), puis imprime le visage 6 (face du bloc-notes) à plusieurs reprises jusqu'à ce que la face 7 soit nulle. Si vous définissez la face 7 sur zéro, vous ne devriez obtenir qu'une seule nouvelle ligne. Cependant, j'ai obtenu des sauts de ligne infinis et ma 13e entrée était un zéro, et je peux vérifier que le 7 face est toujours zéro en insérant un "numéro d'impression à partir de 7 face" dans la boucle:
:1/1+1$(@6%7)7
puis il imprime des \n0paires sans fin .
Je regarde les spécifications sur la page cubiquement github et ce comportement ressemble énormément à un bug. La modification du dernier caractère du programme d'origine de a 7à a 0entraîne le comportement attendu. L'interpréteur TIO présente le même comportement incorrect.
q5/:i:c
00072001010010800108001110004400032000870011100114001080010000033
q - Take input (string)
5/ - split into chunks of five
:i - cast to integers
:c - cast to characters
La solution que j'ai trouvée utilise très substantiellement les caractères non imprimables, donc essayer de le coller ici n'a pas bien fonctionné. Les valeurs d'octet pour l'entrée sont:
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 la version chaîne est disponible dans le champ de saisie du lien TIO.
Le programme d'origine prendrait les caractères distincts dans l'entrée, puis inverserait l'entrée et multiplierait les éléments des deux listes. J'ai donc créé une chaîne de 26 caractères où les 13 premiers caractères étaient distincts, les 13 derniers caractères sont également apparus dans les 13 premiers, et chaque paire d'index s'est [i, 26-i]multipliée jusqu'à la valeur d'octet du i-ème caractère dans Hello, World!.
n[>n]<[8+o<]
2 25 92 100 106 103 79 24 36 103 100 100 100 93 64
Essayez-le ici (bien que la page ne rende pas la nouvelle ligne).
nprend des entrées, essaie de se diviser en espaces et de lancer en pouces, ceux-ci sont mis sur la pile. oimprime les points ordinaux et 8+fait ce que l'on pourrait penser. L'entrée doit donc être inférieure de 8 aux points de code dans l'ordre inverse, divisé par des espaces.
2cela fonctionnerait - est-ce juste la page herokuapp qui ne la rend pas?
Code d'origine:
#define O(c)(((char**)v)+c)
#define W(c)*(O(c)-**O(2)+x)
main(x,v){puts(W(42));}
Arguments:
"Hello, World!" ","
Explication:
W(c)calcule l'adresse d'une chaîne à partir de la liste des arguments à imprimer. Il commence par l'adresse du cème argument ( O(c)), qui est le 42ème argument dans ce cas, puis soustrait le premier caractère du deuxième argument ( **O(2)) comme un décalage entier, puis ajoutex , qui est le nombre d'arguments.
W(c)utilise le deuxième argument, vous savez donc qu'il doit y en avoir au moins 3 (0, 1, 2). Puis "Bonjour, le monde!" peut aller dans le premier argument, puis pour répondre à cet argument, vous avez besoin d'un caractère dont la valeur ASCII correspond à l'équation "42-x + 3 = 1". Cela se trouve être ",".
Je remplace les méthodes valueOf()et toString()des objets analysés afin que la contrainte échoue avec a TypeError.
{"valueOf": 7, "toString": 7}
La bonne réponse est, 52768,23
L'explication est légèrement impliquée.
00 c0 ;load address
20 fd ae jsr $aefd ; checks for comma
20 eb b7 jsr $b7eb ; reads arguments
Le code vérifie d'abord une virgule (nécessité de syntaxe), puis lit deux arguments, dont le premier est un WORD, stocké en petit-boutien aux emplacements de mémoire 0014 et 0015, le dernier étant stocké dans le registre 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
C'est assez intelligent, en utilisant notre entrée pour réécrire le programme. Il réécrit finalement le compteur de la boucle de sortie à la fin du programme.
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
Voici la partie sournoise:
8e 18 d0 STX $d018 ; stores the original second argument in d018
sur le C64, d018 est un octet très important. Il stocke les points de référence pour les choses impliquant la sortie de l'écran. Voir ici pour plus d'informations. Si cela obtient une valeur erronée, cela fera planter votre C64. Pour imprimer les lettres mixtes majuscules et minuscules requises, cela doit être de 17 $.
Maintenant, nous commençons notre boucle de sortie:
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
Cette constante est ce qui a été écrit auparavant. Il détermine clairement la durée de la boucle. Il se trouve que c'est déjà la bonne valeur, mais nous devons encore y coller 0e.
d0 f6 bne *-8 ; jump back 8 bytes if y and that constant weren't equal
60 rts ; ends the program
Le reste n'est que les informations que nous devons imprimer, à partir de l'adresse mémoire c025.
Il s'agit donc simplement de suivre les calculs à partir de là.
$FFlà, mais a ensuite décidé de le laisser.
La bonne réponse est
8bitsareenough
Le code est assez compliqué, impliquant beaucoup d'auto-modification. Ainsi, au lieu de le désosser complètement, vous pouvez simplement l'utiliser pour se fissurer.
Voici un démontage légèrement plus utile du code, pour aider à comprendre ce qui s'est passé. La syntaxe est pour 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
L'étiqueter comme ça m'a suffi pour voir que le code XORs un tas de constantes qui sont cachées afin d'imprimer ce dont nous avons besoin. Étant donné que XOR est réversible, si vous entrez la sortie souhaitée, il vous dira quelle est la clé.
J'ai donc changé la dernière ligne
/*from sta $d018
to*/ jsr $ffd2
il imprimerait donc la dernière entrée requise au lieu de planter sur une mauvaise entrée.
Et c'est ça!
S'il y a un intérêt, je vais plus déchiffrer le code.
vice. Mais peu importe, c'est la bonne solution.
drops A in mystery+1, over the constant" <- c'est en fait mystery+4avec votre étiquette. Les offests sont en octets :) et FWIW, l'auto-modification est assez courante même dans le code 6502 sérieux , tant que le code s'exécute à partir de la RAM.
@_?&4_-j>5&f^~c>&6\|4>7
Rh / qi?, Wcr + du
Code d'origine:
œ?“¥ĊɲṢŻ;^»œ?@€⁸ḊFmṪ⁷
Contribution:
1,2586391,2949273,3312154,3312154,1134001,362881,2223505,766081,1134001,1497601,3312154,1860601,140
Explication:
Surtout, il est nécessaire de comprendre ce que fait le code. La première chose qu'il fait est qu'il prend la chaîne
"!,Word Hel"(avec tous les caractères nécessaires sauf la nouvelle ligne) et en crée un tas de permutations. Les entrées spécifient les numéros de permutation, et chaque paire de permutations de l'entrée est appliquée à la chaîne excluant les paires où la première permutation est appliquée en premier. Fondamentalement, P2 (P1 (S)), P2 (P2 (S), P2 (P3 (S)), ..., P2 (PN (S)), P3 (P1 (S)), ..., P3 (PN (S)), ... ..., PN (P1 (S)), ..., PN (PN (S)). Ils sont tous concaténés ensemble. Ensuite, la dernière entrée est réutilisée pour prendre chaque PNth de cette grosse chaîne. Donc, je prends PN = len (S) * N = 10 * N. Cela signifie que nous prendrons le premier caractère de P2 (P1 (S)), le premier caractère de P3 (P1 (S )), jusqu'au premier caractère de PN (P1 (S)). Pour simplifier davantage, je laisse P1 = 1 qui est la permutation d'identité. Il suffit ensuite de choisir tout P2 qui permute "H" dans le premier position, un P3 qui permute "e" dans la première position et ainsi de suite. Heureusement, les petits nombres de permutation comme celui déjà choisi pour PN n'affectent pas les premiers caractères de la chaîne, donc PN laisse "!" au début de la chaîne. (Si ce n'était pas vrai, il serait toujours possible de résoudre en choisissant un P1 différent.)
4195875
Il essaie d'imprimer le deuxième argument sous forme de chaîne, qui est un pointeur que nous pouvons déterminer sur l'entrée. Il se trouve que la mémoire de l'emplacement 4195875démarre la "Hello, World!\n"chaîne.
Le nombre a été déterminé en ajoutant print("%p", "Hello, World!");avant le printf, en convertissant le nombre hexadécimal en décimal et en l'essayant sur le TIO d'origine. Cependant, il m'a montré la printfchaîne de format. En essayant certains nombres, j'ai découvert que la chaîne se trouve avant la chaîne de format.
Donc, en mémoire, cela ressemblerait à ceci (comme une chaîne C):
Hello, World!\n\0%2$s\0
Cela signifie également que toute mise à jour du compilateur peut casser la solution.
['Hello, World!','','','','','','','','','','','','']
[1, "HH", 1, "eellloo", 1, ",,", 1, " WWoo", 1, "rr", 1, "ll", 1, "dd", 1, "!!"]
Explication à venir un peu ...
var i = 0;
var string = `"${t}"`;
var answer = "i++?0:q=string";
console.log( f(answer) );
PDO,FETCH_CLASSTYPE
(TIO n'a pas la classe PDO définie, donc la démo ci-dessus utilise un codepad qui le fait)
Une autre solution:
ReflectionFunction,IS_DEPRECATED
Étant donné la limite de 81 caractères, ce n'est probablement pas la solution prévue
global.g = ()=>"Hello, World!";
var str = "g";