Это нить грабителей. Нить полицейских здесь .
Ваша задача состоит в том, чтобы взять непроверенную заявку из потока полицейских и найти, для какого ввода или ввода программа напечатает Hello, World!и новую строку. Прописная буква, пробел и пунктуация должны быть точными.
Пожалуйста, прокомментируйте представление полицейского, когда вы взломали его код.
Ответы:
Оригинальный код:
[[ ! "${1////x}" =~ [[:alnum:]] ]]&&[[ $# = 1 ]]&&bash -c "$1"
Входные данные:
__=; (( __++, __-- ));
(( ___ = __, ___++));
(( ____ = ___, ____++));
(( _____ = ____, _____++));
(( ______ = _____, ______++));
(( _______ = ______, _______++));
(( ________ = _______, ________++));
(( _________ = ________, _________++));
${!__##-} <<<\$\'\\$___$______$_______\\$___$______$_____\\$___$_______$__\\$___$_______$_________\'\ \$\'\\$___$___$__\\$___$______$_______\\$___$_______$______\\$___$_______$______\\$___$_______$_________,\ \\$___$____$_________\\$___$_______$_________\\$___$________$____\\$___$_______$______\\$___$______$______\\$__$______$___\'
Объяснение:
Это кодирует "эхо Привет, мир!" как восьмеричные escape-последовательности (\ xxx).
За исключением того, что вы также не можете использовать числа, поэтому первая часть создает переменные для чисел 0-7. Вы можете использовать их для построения строки с восьмеричными последовательностями, которые будут вычислять, чтобы дать вам фактическую команду.
Но evalэто также буквенно-цифровой. Таким образом, вместо этого эта строка передается в качестве входных данных для другого экземпляра bash. $0содержит имя команды, используемой для вызова Bash, которая обычно просто bash(или-bash для оболочки входа в систему), если вы запускаете ее нормально (через TIO или вставляя ее в терминал). (Это случайно означает, что если вы попытаетесь выполнить это, вставив его в сценарий, все пойдет ужасно неправильно, так как он будет пытаться раскошелиться несколько раз.)
Но в любом случае, вы не можете сказать $0прямо. Вместо этого, $__содержит имя из $0( «0»), и вы можете использовать косвенное расширение для доступа к нему ( ${!__}относится к содержанию$0 ).
И это, наконец, дает вам все части, которые вам нужны.
•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является встроенным для строчного алфавита. Код проверяет равенство против этого.
〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ
sLƽ$Xṙ5O½Ọ
Исходный код можно объяснить так:
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
Итак, просто возьмите "Привет, мир!" и получить кодовые точки, возвести их в квадрат, привести обратно к кодовым точкам, повернуть вправо 5 раз, а затем выровнять и выровнять результат.
Не уверен, что это правильное решение (на TIO он печатает \00символ), но в моей octave-cliоболочке это выглядит так:
Также в исходном вызове написано « ничего не печатать» (или нулевой символ) , поэтому, если ничто не совпадает с \00этим, это должно быть хорошо.
[72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33, 0]0на a 10).
Hello, World!и символ новой строки.» точная цитата из задачи. И действительно, это делает ответ тривиальным.
print("Hello, World!") or __import__('sys').exit(0)
Предотвратите любые ошибки, выходя рано.
{length:1, charCodeAt:()=>(e='Hello, World!', String.fromCharCode=()=>'')}
Это было довольно легко.
Я заметил, что любые строковые входные данные невозможно будет вывести, Hello, World!потому что все внутри String.fromCharCodeбудет возвращать только кратные 4, и !имеет код символа 33. Очевидно, что нам просто нужно взломать всю программу. Взломать встроенные в JavaScript тривиальны, если не пытаться их остановить (и даже если они это делают, обычно есть много обходных путей ...).
Простой прокси, который возвращает нужный символ только каждый третий раз, когда он вызывается.
var i = 0;
var string = "Hello, World!";
var proxy = new Proxy([], {
get: function(target, property) {
if (!(++i%3)) {
return string[property];
}
return [1];
}
});
Волшебный вклад: 1767707618171221 30191World!
1767707618171221простое, и, записанное в базе 36, оно есть "hello". При использовании заглавных букв получается "Hello", что печатается с использованием$><<$><<", #$'"if/30191/ищет число 30191во входных данных и записывает в стандартный вывод строку, состоящую из запятой, пробела и того, что находится на входе после 30191(с использованием $POSTMATCHоператора, который здесь обозначен его коротким вариантом, $').Передайте это как первый аргумент:
C=("").char;_G[C(112,114,105,110,116)](C(72,101,108,108,111,44,32,87,111,114,108,100,33))Если исходный код находится в файле tehtmi.lua, запустите (в bash или аналогичной оболочке):
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))'Он также работает на Lua 5.3, который использует TIO, так что почему бы не попробовать его в Интернете? ? Я не тестировал реализацию, которая использует ядро "PUC-Rio's Lua 5.1" (потому что я не могу найти какую-либо информацию), но мое решение, вероятно, также работает там.
Первый аргумент запускается как код, но только если он содержит менее 5 строчных символов.
Хитрость в том, чтобы бежать print("Hello, World!"). Другой способ запустить это - использовать_G["print"]("Hello, World!") только строки.
Но мы не можем использовать строку напрямую из-за ограничения количества строчных букв, однако вы можете запустить ("").charфункцию string.char, которая может преобразовывать серию байтов в строку. Я назначил его переменной верхнего регистра (чтобы мы не достигли предела), чтобы мы могли использовать его для создания строк printи, и Hello, World!строк, которые можно использовать, как описано выше.
nextвместо charкоторого не работает на Lua 5.3 из-за рандомизации порядка итерации.
Входные данные должны быть строкой, содержащей это:
e(
`\
_\
=\
>\
"\
H\
e\
l\
l\
o\
,\
\
W\
o\
r\
l\
d\
!\
"\
+\
\`
\`
`)
Попробуйте, используя это:
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))Если вас не интересует конечный символ новой строки для выходных данных, вы можете заменить последние 6 строк следующим:
!"
`)
Ограничения на входные данные состоят в том, что это строка, каждая строка имеет длину два байта или менее, а общая длина составляет 80 байтов или менее. Моя первая попытка после понимания того, что правильно было так:
_
=>
`\
H\
e\
l\
l\
o\
,\
\
W\
o\
r\
l\
d\
!
`
Примечание: \s должны игнорировать символы новой строки в строке ввода. Это невероятно важно для ответа, и я не могу поверить, что наткнулся на него случайно. (Я был знаком с этим раньше, но забыл об этом)
Но это не сработало, поскольку =>они должны быть в одной строке с аргументами. К счастью, у меня была идея обернуть что-то похожее в строку и вставить eval в свой ввод, чтобы уменьшить его до одной строки, что привело к моему окончательному ответу. После того, как происходит eval во входных данных, в виде строки генерируется следующее (которое затем передается в функцию, а затем запускается):
_=>"Hello, World!"+`
`
Это было действительно трудно взломать, но я преуспел в конце.
Кроме того, первая трещина в мире!
Я предполагаю, что это всегда опасно, но я думаю, что у меня есть ошибка, ожидающая, что я прав в том, что есть ошибка в интерпретаторе (который я только что скомпилировал).
Мой вклад
0 1 0 1 0 1 0 1 1 0 1 0 0
Вывод Hello, World!\n\n\n\n\n\n\n\n\n\n.....с бесконечными переводами строки.
Но я заметил последний раздел кода:
:1/1+1$(@6)7
0x0Aстрашно устанавливает блокнот на (новую строку), считывает ввод на грань 7 (грань ввода), а затем несколько раз печатает грань 6 (грань блокнота), пока грань 7 не станет равной нулю. Если вы установите лицо 7 на ноль, вы должны получить только одну новую строку. Тем не менее, я получил бесконечные переводы строк, и мой 13-й вход был равен нулю, и я могу убедиться, что 7-грань всегда равна нулю, вставив в цикл «печатное число из 7-гранной»:
:1/1+1$(@6%7)7
то печатает бесконечное \n0 пары.
Я смотрю на спецификации на кубической странице GitHub, и это поведение очень похоже на ошибку. Изменение последнего символа исходной программы с a 7на 0результат ожидаемого поведения. Интерпретатор TIO демонстрирует такое же некорректное поведение.
q5/:i:c
00072001010010800108001110004400032000870011100114001080010000033
q - Take input (string)
5/ - split into chunks of five
:i - cast to integers
:c - cast to characters
Решение, которое я нашел, очень широко использует непечатаемые символы, поэтому попытка вставить его сюда не сработала. Значения байтов для ввода:
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
Или версия строки доступна в поле ввода ссылки TIO.
Исходная программа будет принимать различные символы на входе, затем реверсировать вход и умножать элементы двух списков. Таким образом, я создал строку длиной 26 символов, в которой первые 13 символов были различны, последние 13 символов также появились в первых 13, и каждая пара индексов [i, 26-i]умножалась на значение байта i-го символа в Hello, World!.
n[>n]<[8+o<]
2 25 92 100 106 103 79 24 36 103 100 100 93 64
Попробуйте это здесь (хотя страница не отображает перевод строки).
nпринимает входные данные, пытается разделить на пробелы и привести к целым числам, они помещаются в стек. oпечатает порядковые точки и 8+делает то, что думаешь. Таким образом, ввод должен быть на 8 меньше, чем кодовые точки в обратном порядке, разделенные пробелами.
2что это сработает - разве это просто страница с HeroKapp, не отображающая ее?
Оригинальный код:
#define O(c)(((char**)v)+c)
#define W(c)*(O(c)-**O(2)+x)
main(x,v){puts(W(42));}
Аргументы:
"Hello, World!" ","
Объяснение:
W(c)вычисляет адрес строки из списка аргументов для распечатки. Он начинается с адреса аргумента cth ( O(c)), который в данном случае является 42-м аргументом, а затем вычитает первый символ второго аргумента ( **O(2)) как целочисленное смещение, а затем добавляетx , что является количеством аргументов.
W(c)использует второй аргумент, поэтому вы должны знать, что их должно быть как минимум 3 (0, 1, 2). Тогда "Привет, мир!" можете перейти к первому аргументу, а затем для адресации этого аргумента вам нужен символ, значение ASCII которого соответствует уравнению «42-x + 3 = 1». Это случается ",".
Я отменяю valueOf() и toString()методы анализируемых объектов, так что приведение не удается с помощью TypeError.
{"valueOf": 7, "toString": 7}
Правильный ответ, 52768,23
Объяснение немного запутано.
00 c0 ;load address
20 fd ae jsr $aefd ; checks for comma
20 eb b7 jsr $b7eb ; reads arguments
Код сначала проверяет запятую (необходимость в синтаксисе), а затем считывает два аргумента, первый из которых - WORD, хранится с прямым порядком байтов в ячейках памяти 0014 и 0015, последний из которых хранится в регистре 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
Это довольно умно, используя наш ввод, чтобы переписать программу. В конце концов он переписывает счетчик для цикла вывода в конце программы.
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
Здесь начинается хитрая часть:
8e 18 d0 STX $d018 ; stores the original second argument in d018
на C64 d018 - очень важный байт. Он хранит контрольные точки для вещей, связанных с выводом на экран. Смотрите здесь для получения дополнительной информации. Если это получит неправильное значение, это приведет к краху вашего C64. Чтобы напечатать необходимые смешанные прописные и строчные буквы, это должно быть $ 17.
Теперь мы начинаем наш цикл вывода:
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
Эта константа - то, что было переписано ранее. Он четко определяет продолжительность цикла. Это уже правильное значение, но нам нужно снова вставить 0e.
d0 f6 bne *-8 ; jump back 8 bytes if y and that constant weren't equal
60 rts ; ends the program
Остальное - это просто информация, которую нам нужно распечатать, начиная с адреса памяти c025.
Так что оттуда просто следую математике.
$FF там, но затем решил оставить его.
Правильный ответ
8bitsareenough
Код довольно сложный, включающий много самоизменения. Таким образом, вместо того, чтобы полностью реконструировать его, вы можете просто использовать его для взлома.
Вот немного более полезная разборка кода, чтобы помочь понять, что произошло. Синтаксис для 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
Я назвал это так, что мне было достаточно увидеть, что код XOR содержит кучу констант, которые скрыты вокруг, чтобы распечатать то, что нам нужно. Поскольку XOR является обратимым, если вы введете желаемый результат, он скажет вам, что это за ключ.
Поэтому я переключил последнюю строку
/*from sta $d018
to*/ jsr $ffd2
таким образом, он напечатал бы последний требуемый ввод вместо сбоя на неправильном вводе.
И это все!
Если есть интерес, я взломаю код больше.
vice. Но как бы то ни было, это правильное решение.
drops A in mystery+1, over the constant" <- это на самом деле mystery+4с вашим лейблом. Отклонения в байтах :) и FWIW, автоматическое изменение довольно распространено даже в серьезном коде 6502, если код запускается из ОЗУ.
@_?&4_-j>5&f^~c>&6\|4>7
Rh / й?, Wcr + ие
Оригинальный код:
œ?“¥ĊɲṢŻ;^»œ?@€⁸ḊFmṪ⁷
Входные данные:
1,2586391,2949273,3312154,3312154,1134001,362881,2223505,766081,1134001,1497601,3312154,1860601,140
Объяснение:
Главным образом, необходимо понимать, что делает код. Первое, что он делает, это берет строку
"!,Word Hel"(со всеми необходимыми символами, кроме новой строки) и создает кучу их перестановок. Входные данные указывают числа перестановок, и каждая пара перестановок из входных данных применяется к строке, исключая пары, где первая перестановка применяется первой. В основном, P2 (P1 (S)), P2 (P2 (S), P2 (P3 (S)), ..., P2 (PN (S)), P3 (P1 (S)), ..., P3 (PN (S)), ... ..., PN (P1 (S)), ..., PN (PN (S)). Все они соединены вместе. Затем последний вход повторно используется для получения каждого PNth символ из этой большой строки. Итак, я беру PN = len (S) * N = 10 * N. Это означает, что мы возьмем первый символ P2 (P1 (S)), первый символ P3 (P1 (S )), вплоть до первого символа PN (P1 (S)). Чтобы упростить дальнейшее, я позволю P1 = 1, который является тождественной перестановкой. Тогда достаточно выбрать любой P2, который переставляет "H" в первый позиция, P3, который переставляет «е» в первую позицию и так далее. К счастью, небольшие числа перестановок, такие как уже выбранное для PN, не влияют на более ранние символы в строке, поэтому PN оставляет "!" в начале строки. (Если бы это было не так, все равно можно было бы решить, выбрав другой P1.)
4195875
Он пытается напечатать второй аргумент в виде строки, которая является указателем, который мы можем определить на входе. Так уж сложилось, что в памяти места 4195875начинается "Hello, World!\n"строка.
Число было определено путем добавления print("%p", "Hello, World!");перед printf, преобразования шестнадцатеричного числа в десятичное и опробовано на исходном TIO. Тем не менее, он показал мне printfформат строки. Опробовав несколько чисел, я обнаружил, что строка находится перед строкой форматирования.
Таким образом, в памяти это будет выглядеть так (как строка C):
Hello, World!\n\0%2$s\0
Это также означает, что любое обновление компилятора может нарушить решение.
['Hello, World!','','','','','','','','','','','','']
[1, "HH", 1, "eellloo", 1, ",,", 1, " WWoo", 1, "rr", 1, "ll", 1, "dd", 1, "!!"]
Объяснение немного позже ...
var i = 0;
var string = `"${t}"`;
var answer = "i++?0:q=string";
console.log( f(answer) );
PDO,FETCH_CLASSTYPE
(TIO не имеет определенного класса PDO, поэтому в приведенной выше демонстрации используется кодовая панель, которая это делает)
Другое решение:
ReflectionFunction,IS_DEPRECATED
Учитывая ограничение в 81 символ, это, вероятно, не предполагаемое решение
global.g = ()=>"Hello, World!";
var str = "g";