To wątek złodziei. Wątek gliniarzy jest tutaj .
Wyzwanie polega na pobraniu nieprzetartego zgłoszenia z wątku gliniarzy i znalezieniu, dla jakich danych wejściowych lub wejściowych program wydrukuje Hello, World!i nowy wiersz. Wielkie litery, odstępy i znaki interpunkcyjne muszą być dokładne.
Skomentuj przesłanie gliniarza, gdy złamiesz jego kod.
Odpowiedzi:
Oryginalny kod:
[[ ! "${1////x}" =~ [[:alnum:]] ]]&&[[ $# = 1 ]]&&bash -c "$1"
Wejście:
__=; (( __++, __-- ));
(( ___ = __, ___++));
(( ____ = ___, ____++));
(( _____ = ____, _____++));
(( ______ = _____, ______++));
(( _______ = ______, _______++));
(( ________ = _______, ________++));
(( _________ = ________, _________++));
${!__##-} <<<\$\'\\$___$______$_______\\$___$______$_____\\$___$_______$__\\$___$_______$_________\'\ \$\'\\$___$___$__\\$___$______$_______\\$___$_______$______\\$___$_______$______\\$___$_______$_________,\ \\$___$____$_________\\$___$_______$_________\\$___$________$____\\$___$_______$______\\$___$______$______\\$__$______$___\'
Wyjaśnienie:
To koduje „echo Witaj, świecie!” jako ósemkowe sekwencje specjalne (\ xxx).
Tyle że nie możesz także używać liczb, więc pierwsza część tworzy zmienne dla liczb 0-7. Możesz użyć ich do zbudowania łańcucha z sekwencjami ósemkowymi, które będą oceniać, aby dać ci właściwe polecenie.
Ale evaljest również alfanumeryczny. Więc zamiast tego, te potoki ciąg znaków jako dane wejściowe do innego wystąpienia bash. $0zawiera nazwę polecenia użytego do wywołania Bash, który zwykle jest po prostu bash(lub -bashdla powłoki logowania), jeśli uruchamiasz go normalnie (przez TIO lub wklejając go w terminalu). (Nawiasem mówiąc, oznacza to, że jeśli spróbujesz uruchomić to poprzez wklejenie go do skryptu, wszystko pójdzie okropnie źle, gdy będzie próbowało się rozwidlić kilka razy).
Ale i tak nie można powiedzieć $0wprost. Zamiast tego, $__zawiera nazwę z $0( „0”), i można użyć ekspansję pośredni do niego dostęp ( ${!__}odnosi się do zawartości $0).
I to w końcu daje ci wszystko, czego potrzebujesz.
•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"
Gjest wbudowany w małe litery alfabetu. Kod sprawdza równość z tym.
〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ
sLƽ$Xṙ5O½Ọ
Oryginalny kod można wyjaśnić jako taki:
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
Więc weź „Witaj, świecie!” i zdobądź punkty kodowe, wyrównaj je, rzuć z powrotem do punktów kodowych, obróć w prawo 5 razy, a następnie wyrównaj i spłaszcz wynik.
Nie jestem pewien, czy jest to właściwe rozwiązanie (w TIO drukuje \00postać), ale w mojej octave-clipowłoce wygląda to tak:
Również w oryginalnym wyzwaniu napisano, że nie drukuj nic (lub znaku zerowego) , więc jeśli nic nie jest takie samo, \00to powinno być dobrze.
[72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33, 0]0a 10).
Hello, World!i przełamane.” jest dokładnym cytatem z wyzwania. I rzeczywiście czyni to odpowiedź banalną.
print("Hello, World!") or __import__('sys').exit(0)
Zapobiegaj błędom, wychodząc wcześniej.
{length:1, charCodeAt:()=>(e='Hello, World!', String.fromCharCode=()=>'')}
To było całkiem łatwe.
Zauważyłem, że żadne wejściowe ciągi znaków nie byłyby możliwe do wyprowadzenia, Hello, World!ponieważ całość wewnątrz String.fromCharCodezwróci tylko wielokrotności 4 i !ma kod char 33. Tak więc wyraźnie musimy po prostu zhakować cały program. Hakowanie wbudowanych skryptów w JavaScript jest banalne, jeśli nie próbuje się ich zatrzymać (a nawet jeśli tak się dzieje, zwykle jest wiele obejść ...).
Proste proxy, które zwraca poszukiwaną postać tylko co 3 razy, gdy zostanie wywołana.
var i = 0;
var string = "Hello, World!";
var proxy = new Proxy([], {
get: function(target, property) {
if (!(++i%3)) {
return string[property];
}
return [1];
}
});
Magiczny wkład to: 1767707618171221 30191World!
1767707618171221jest liczbą pierwszą, a zapisano ją w bazie 36 "hello". Po pisaniu wielkimi literami tworzy to "Hello", które jest drukowane za pomocą$><<$><<", #$'"if/30191/szuka liczby 30191na wejściu i zapisuje, aby stdout ciąg złożony z przecinka, spacji i wszystkiego, co znajduje się na wejściu po 30191(za pomocą $POSTMATCH, do którego odnosi się tutaj jego krótki wariant $').Podaj to jako pierwszy argument:
C=("").char;_G[C(112,114,105,110,116)](C(72,101,108,108,111,44,32,87,111,114,108,100,33))Zakładając, że oryginalny kod znajduje się w pliku tehtmi.lua, uruchom (w bash lub podobnej powłoce):
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))'Działa również na Lua 5.3, z czego korzysta TIO, więc dlaczego nie wypróbować go online ? Nie testowałem na implementacji wykorzystującej rdzeń „PUC-Rio's Lua 5.1” (ponieważ tak naprawdę nie mogę znaleźć żadnych informacji), ale moje rozwiązanie prawdopodobnie tam również działa.
Uruchamia pierwszy argument jako kod, ale tylko jeśli zawiera mniej niż 5 małych liter.
Sztuką jest ucieczka print("Hello, World!"). Innym sposobem, w jaki można to uruchomić, jest użycie _G["print"]("Hello, World!"), które wykorzystuje tylko ciągi znaków.
Ale nie możemy użyć łańcucha bezpośrednio ze względu na ograniczenie małych liter, jednak możesz uruchomić, ("").charaby uzyskać funkcję string.char, która może konwertować z serii bajtów na ciąg. Przypisałem ją do zmiennej wielkiej litery (abyśmy nie osiągnęli limitu), abyśmy mogli użyć jej do skonstruowania zarówno ciągów znaków, jak printi Hello, World!ciągów, których można używać jak wyżej.
nextzamiast tego, charktóry nie działa na Lua 5.3 z powodu losowości kolejności iteracji.
Dane wejściowe muszą być ciągiem zawierającym:
e(
`\
_\
=\
>\
"\
H\
e\
l\
l\
o\
,\
\
W\
o\
r\
l\
d\
!\
"\
+\
\`
\`
`)
Spróbuj użyć tego:
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))Jeśli nie przejmujesz się końcowymi wymaganiami nowego wiersza dla danych wyjściowych, możesz zamiast tego zastąpić ostatnie 6 wierszy:
!"
`)
Ograniczenia na wejściu są takie, że jest to ciąg znaków, każda linia ma dwa bajty długości lub mniej i że całkowita długość wynosi 80 bajtów lub mniej. Moja pierwsza próba po zrozumieniu, że poprawnie:
_
=>
`\
H\
e\
l\
l\
o\
,\
\
W\
o\
r\
l\
d\
!
`
Uwaga: \s mają zignorować znaki nowej linii w ciągu wejściowym. Jest to niezwykle ważne dla odpowiedzi i nie mogę uwierzyć, że natknąłem się na nią przez przypadek. (Znałem to wcześniej, ale o tym zapomniałem)
Ale to nie zadziałało, ponieważ =>musi być na tej samej linii co argumenty. Na szczęście wpadłem na pomysł, aby zawinąć coś podobnego w ciąg i umieścić eval w moich danych wejściowych, aby zredukować to do jednej linii, co daje moją ostateczną odpowiedź. Po wystąpieniu ewaluacji na wejściu generowany jest następujący ciąg znaków (który jest następnie ewaluowany do funkcji, a następnie uruchamiany):
_=>"Hello, World!"+`
`
To było naprawdę trudne do złamania, ale w końcu mi się udało.
Również pierwszy crack w historii!
Wyobrażam sobie, że to zawsze jest niebezpieczne, ale myślę, że mam crack, w oczekiwaniu na to, że mam rację, ponieważ w tłumaczu jest błąd (który właśnie skompilowałem).
Mój wkład
0 1 0 1 0 1 0 1 1 0 1 0 0
Wyjście jest Hello, World!\n\n\n\n\n\n\n\n\n\n.....z niekończącymi się nowymi liniami.
Ale zauważyłem ostatnią sekcję kodu:
:1/1+1$(@6)7
0x0Aw przerażający sposób ustawia notatnik (nowa linia), odczytuje dane wejściowe na twarzy 7 (strona wejściowa), a następnie drukuje kilkakrotnie twarz 6 (strona notatnika), aż 7 twarz wyniesie zero. Jeśli ustawisz twarz 7 na zero, powinieneś otrzymać tylko jedną nową linię. Jednak otrzymałem nieskończone nowe wiersze, a moje 13. wejście było zerowe i mogę zweryfikować, czy 7 twarzy jest zawsze zerowe, wstawiając w pętli „numer wydruku z 7 twarzy”:
:1/1+1$(@6%7)7
następnie drukuje niekończące się \n0pary.
Patrzę na specyfikacje na sześciennej stronie github i to zachowanie wygląda okropnie jak błąd. Zmiana ostatniego znaku oryginalnego programu z a 7na 0powoduje oczekiwane zachowanie. Interpreter TIO wykazuje to samo nieprawidłowe zachowanie.
q5/:i:c
00072001010010800108001110004400032000870011100114001080010000033
q - Take input (string)
5/ - split into chunks of five
:i - cast to integers
:c - cast to characters
Rozwiązanie, które znalazłem, w znacznym stopniu wykorzystuje znaki niedrukowalne, więc próba wklejenia go tutaj nie działała dobrze. Wartości bajtów dla danych wejściowych to:
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
Lub wersja ciągu jest dostępna w polu wejściowym łącza TIO.
Oryginalny program pobierałby różne znaki na wejściu, a następnie odwrócił dane wejściowe i pomnożył elementy dwóch list. W ten sposób utworzyłem ciąg 26 znaków, w którym pierwsze 13 znaków było odrębnych, wszystkie 13 ostatnich znaków pojawiło się również w pierwszych 13 znakach, a każda para indeksów [i, 26-i]pomnożona przez wartość bajtu i-tego znaku w Hello, World!.
n[>n]<[8+o<]
2 25 92 100 106 103 79 24 36 103 100 100 93 64
Wypróbuj tutaj (chociaż strona nie wyświetla nowej linii).
npobiera dane wejściowe, próbuje podzielić na spacje i rzutować na int, te zostają umieszczone na stosie. odrukuje punkty porządkowe i 8+robi to, co można by pomyśleć. Zatem dane wejściowe muszą być o 8 mniejsze niż punkty kodowe w odwrotnej kolejności podzielone przez spacje.
2to zadziała - czy to tylko strona herokuapp go nie renderuje?
Oryginalny kod:
#define O(c)(((char**)v)+c)
#define W(c)*(O(c)-**O(2)+x)
main(x,v){puts(W(42));}
Argumenty:
"Hello, World!" ","
Wyjaśnienie:
W(c)oblicza adres ciągu znaków z listy argumentów do wydrukowania. Zaczyna się od adresu c-tego argumentu ( O(c)), który w tym przypadku jest 42-tym argumentem, a następnie odejmuje pierwszy znak drugiego argumentu ( **O(2)) jako przesunięcie liczby całkowitej, a następnie dodaje x, czyli liczbę argumentów.
W(c)używa drugiego argumentu, więc wiesz, że musi być co najmniej 3 z nich (0, 1, 2). Następnie „Witaj, świecie!” może przejść do pierwszego argumentu, a następnie, aby rozwiązać ten argument, potrzebujesz znaku, którego wartość ASCII mieści się w równaniu „42-x + 3 = 1”. Tak się składa, że jest „,”.
Zastępuję metody valueOf()i toString()przeanalizowanych obiektów, aby przymus nie powiódł się za pomocą TypeError.
{"valueOf": 7, "toString": 7}
Prawidłowa odpowiedź to 52768,23
Wyjaśnienie jest nieco związane.
00 c0 ;load address
20 fd ae jsr $aefd ; checks for comma
20 eb b7 jsr $b7eb ; reads arguments
Kod najpierw sprawdza przecinek (konieczność składni), a następnie odczytuje dwa argumenty, z których pierwszy jest WORD, przechowywany little-endian w pamięci 0014 i 0015, ten ostatni jest przechowywany w rejestrze 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
To całkiem sprytne, używając naszego wkładu do przepisania programu. W końcu przepisuje licznik pętli wyjściowej na końcu programu.
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
Nadchodzi przebiegłość:
8e 18 d0 STX $d018 ; stores the original second argument in d018
na C64, d018 jest bardzo ważnym bajtem. Przechowuje punkty odniesienia dla rzeczy związanych z wyjściem ekranu. Zobacz tutaj, aby uzyskać więcej informacji. Jeśli otrzyma niepoprawną wartość, spowoduje awarię C64. Aby wydrukować wymagane mieszane wielkie i małe litery, musi to być 17 USD.
Teraz zaczynamy naszą pętlę wyjściową:
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
Ta stała została zapisana wcześniej. Wyraźnie określa, jak długo działa pętla. Zdarza się, że ma już prawidłową wartość, ale musimy ponownie wcisnąć 0e.
d0 f6 bne *-8 ; jump back 8 bytes if y and that constant weren't equal
60 rts ; ends the program
Reszta to tylko informacja, którą musimy wydrukować, zaczynając od adresu pamięci c025.
Więc po prostu podąża za matematyką.
$FFto, ale potem postanowiłem to zostawić.
Poprawna odpowiedź to
8bitsareenough
Kod jest raczej skomplikowany i wymaga wielu samodzielnych modyfikacji. Więc zamiast całkowicie go odwrócić, możesz go po prostu wykorzystać do złamania się.
Oto nieco bardziej pomocny demontaż kodu, aby pomóc zrozumieć, co się stało. Składnia dotyczy 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
Oznaczenie go w ten sposób wystarczyło, aby zobaczyć, że kod XOR zawiera kilka stałych, które są ukryte, aby wydrukować to, czego potrzebujemy. Ponieważ XOR jest odwracalny, jeśli wprowadzisz pożądane wyjście, powie ci, co to jest klucz.
Więc zmieniłem ostatnią linię
/*from sta $d018
to*/ jsr $ffd2
więc wypisze ostatnie wymagane dane wejściowe zamiast awarii na złym wejściu.
I to jest to!
Jeśli jest jakieś zainteresowanie, będę więcej łamać kod.
vice. Ale cokolwiek, to właściwe rozwiązanie.
drops A in mystery+1, over the constant” <- tak naprawdę jest mystery+4z twoją wytwórnią. Offsety są w bajtach :) i FWIW, auto-modyfikacja jest dość powszechna nawet w poważnym kodzie 6502, o ile kod działa z RAM.
@_?&4_-j>5&f^~c>&6\|4>7
Rh / qi?, Wcr + du
Oryginalny kod:
œ?“¥ĊɲṢŻ;^»œ?@€⁸ḊFmṪ⁷
Wejście:
1 2586391,2949273,3312154,3312154,1134001,362881,2223505,766081,1134001,1497601,3312154,1860601,140
Wyjaśnienie:
Przede wszystkim należy zrozumieć, co robi kod. Pierwszą rzeczą, jaką robi, jest ciąg
"!,Word Hel"(ze wszystkimi potrzebnymi znakami oprócz nowej linii) i tworzy ich kombinację. Dane wejściowe określają liczby permutacji, a każda para permutacji z danych wejściowych jest stosowana do łańcucha, z wyłączeniem par, w których pierwsza permutacja jest stosowana jako pierwsza. Zasadniczo P2 (P1 (S)), P2 (P2 (S), P2 (P3 (S)), ..., P2 (PN (S)), P3 (P1 (S)), ..., P3 (PN (S)), ... ..., PN (P1 (S)), ..., PN (PN (S)). Wszystkie są łączone razem. Następnie ostatnie wejście jest ponownie wykorzystywane do pobrania każdej PNth znak z tego dużego ciągu. Więc biorę PN = len (S) * N = 10 * N. Oznacza to, że weźmiemy pierwszy znak P2 (P1 (S)), pierwszy znak P3 (P1 (S )), aż do pierwszego znaku PN (P1 (S)). Aby uprościć, pozwalam P1 = 1, który jest permutacją tożsamości. Następnie wystarczy wybrać dowolne P2, które permutuje „H” do pierwszego pozycja, P3, który pozwala „e” na pierwszą pozycję i tak dalej. Na szczęście małe liczby permutacji, takie jak ta wybrana już dla PN, nie wpływają na wcześniejsze znaki w ciągu, więc PN pozostawia „!” na początku łańcucha. (Gdyby to nie było prawdą, nadal można byłoby rozwiązać, wybierając inny P1.)
4195875
Próbuje wydrukować drugi argument jako ciąg znaków, który jest wskaźnikiem, który możemy określić na wejściu. Zdarza się tak, że w pamięci lokalizacji 4195875zaczyna się "Hello, World!\n"ciąg.
Liczba została określona przez dodanie print("%p", "Hello, World!");przed printf, konwersję liczby szesnastkowej na dziesiętną i wypróbowanie jej na oryginalnym TIO. Jednak pokazał mi printfciąg formatu. Sprawdzając niektóre liczby, dowiedziałem się, że ciąg znajduje się przed ciągiem formatu.
Tak więc w pamięci wyglądałoby to tak (jako ciąg C):
Hello, World!\n\0%2$s\0
Oznacza to również, że każda aktualizacja kompilatora może uszkodzić rozwiązanie.
['Hello, World!','','','','','','','','','','','','']
[1, "HH", 1, "eellloo", 1, ",,", 1, " WWoo", 1, "rr", 1, "ll", 1, "dd", 1, "!!"]
Wyjaśnienie za chwilę ...
var i = 0;
var string = `"${t}"`;
var answer = "i++?0:q=string";
console.log( f(answer) );
PDO,FETCH_CLASSTYPE
(TIO nie ma zdefiniowanej klasy PDO, więc powyższa wersja demonstracyjna używa takiego kodu)
Inne rozwiązanie:
ReflectionFunction,IS_DEPRECATED
Biorąc pod uwagę limit 81 znaków, prawdopodobnie nie jest to zamierzone rozwiązanie
global.g = ()=>"Hello, World!";
var str = "g";