22:59 <%cauchy> Dobra, to ja moze zaczne pisac o czym chcialbym dzis powiedziec
23:00 <%cauchy> tytul mowi ze ma byc o obfuskacji kodu
23:00 <%cauchy> ale nie do konca tylko o tym bedzie
23:00 <%cauchy> chcialbym dzis poruszyc wlasciwie dwa tematy
23:00 <%cauchy> sama obfuskacje kodu za pomoca zwyklych i dobrze znanych wielu
23:00 <%cauchy> junk code
23:00 <%cauchy> jak i rowniez napomknac cos pokrotce o protectorach
23:01 <@phoenix__> wtrace sie, rob bardziej adv a nie for newbies bo za duzo wiary z #cs #cp
23:01 <%cauchy> ich dzialaniu i sensu ich stosowania
23:01 <%cauchy> ty, ale adv to ja nic nie mam xD
23:01 <%cauchy> adv to kazdy sobie sam moze zrobic ;]
23:01 <%cauchy> dobra
23:01 <@phoenix__> olac, rob i nie gadaj
23:01 <%cauchy> obuskacja czyli po polsku zasmiecanie kodu ma na celu
23:02 <%cauchy> takie zasmiecenie kodu wykonywalnego programu
23:02 <%cauchy> aby osoba ktora ten kod dekompiluje
23:02 <%cauchy> disasmuje
23:02 <%cauchy> nie mogla bezposrednio zobaczyc co ten kod naprawde robi
23:02 <%cauchy> taka obfuskacja mozna zastosowac praktycznie do kazdego jezyka
23:03 <%cauchy> a raczej jego skompilowanej wersji
23:03 <%cauchy> czy mamy zwykly kod binarny
23:03 <%cauchy> czy .net
23:03 <%cauchy> da to sie oszukac
23:03 <%cauchy> oczywiscie metody zasmiecania plikow .net sa diametralnie inne i na czym innym polegaja
23:03 <%cauchy> niz zwyklych plikow PE
23:04 <%cauchy> ja tutaj bede mowil tylko i wylacznie o obfuskacji znanych nam plikow PE ;]
23:04 <%cauchy> czyli nie korzystajacych z .net, java itd
23:04 <%cauchy> ok
23:05 <%cauchy> to moze przejdzmy do pierwszego przykladu
23:05 <%cauchy> najprostrze junk codes doklepuje sie do zrodla programu ktory piszemy
23:05 <%cauchy> maja najczesciej postac makr
23:05 <%cauchy> czasami co bardziej leniwy czlowiek tworzy bloczek takich zasmiecajacych instrukcji
23:06 <%cauchy> kopiuje i wkleja ;]
23:06 <%cauchy> najprostrzym przykladem sa instrukcje jedno linijkowe
23:06 <%cauchy> ktore wykonuja sie dokladnie tak jak je widac
23:06 <%cauchy> np
23:06 <%cauchy> lea eax,[ea]
23:06 <%cauchy> mov edi,edi
23:06 <%cauchy> xchg ebx,ebx
23:07 <%cauchy> jak widac te instrukcje nic a nic nie robia
23:07 <%cauchy> ups poprawka
23:07 <%cauchy> mov edi,edi
23:07 <%cauchy> xchg ebx,ebx
23:07 <%cauchy> lea eax,[eax]
23:07 <%cauchy> syf te tagi :)
23:08 <%cauchy> ok jak widac te instrukcje nic nie robia
23:08 <%j00ru> cauchy: jeszcze raz musisz zamknac
23:08 <%cauchy> :)
23:08 <%cauchy> ich przewaga jest natomiast latwosc implementacji
23:08 <%cauchy> uzywamy poprostu kilku prostych instrukcji i wrzucamy do naszego gotowego juz kodu zrodlowego mase tego typu instrukcji
23:09 <%cauchy> ale skoro sa taki proste w implementacji to rownie prosto je usunac
23:09 <%cauchy> wystarczy ze dana osoba ktora chce sie pozbyc tego typu kodu
23:09 <%cauchy> usunie wszelkie bajty odpowiadajace tym intrukcjom z kodu
23:10 <%cauchy> (oczywiscie biorac pod uwage dlugosc opkodow, zeby nam sie calle i jmp'y nie posypaly)
23:10 <%cauchy> (usunac czyli zastapic instrukcjami 'nop
23:10 <%cauchy> nop - nie rob nic
23:10 <%cauchy> wtedy gotowy kod ma juz czytelna postac
23:11 <%cauchy> tylko ze zawiera zazwyczaj duza ilosc nopow ;]
23:11 <%cauchy> jak komus sie nudzi moze sobie napisac maszynke ktora bedzie wstawiac w dany plik wykonywalny tego typu junki
23:11 <%cauchy> ok
23:12 <%cauchy> to pierwszy najprostszy typ
23:12 <%cauchy> mimo swojej prostoty nadal czesto spotykany (przeze mnie to napewno)
23:12 <+bart^xt> a jesli te instrukcje nopy ukryte sa w instrukcjach na wyzszym poziomie czyli np. mov eax,[tu ukryta instrukcja nopa] jmp do_ukrytej
23:12 <+bart^xt> :)
23:13 <%cauchy> drugi czekaj czekaj
23:13 <%cauchy> to zaraz bedzie ;]
23:13 <%cauchy> to to juz bardziej zlozone jest ;]
23:13 <%cauchy> jakies pytania ktos ma do tego co bylo ?
23:14 <%cauchy> nie Twoje bart to bo pozniej ;]
23:14 < ReWolf> ja bym mial ;-) ale wole nie
23:14 <%cauchy> ty nie masz pytan bo ty zbyt zaawansowany jestes ;]
23:14 < Eun> a ja w ogole nie wiem ocb ;p
23:14 <@phoenix__> bart^xt: stara sie najmniej mowic, albo w ogole, chyba ze jak m zdjete
23:14 <%cauchy> hehe, dobra jedziemy dalej
23:15 <%cauchy> drugi typ jest rowniez prosty
23:15 <%cauchy> tez nie ma skakanie "w intrukcje" jak to bart pokazal
23:15 <%cauchy> przed chwileczka
23:15 <%cauchy> moment
23:15 <%cauchy> ok juz
23:16 <%cauchy> tutaj chce pokazac proste bo proste, ale nadal bardzo czesto wykorzystywane bloki instrukcji
23:16 <%cauchy> niby cos robiacych
23:16 <%cauchy> ale notabene nie majacych wplywu na dzialanie programu
23:16 <%cauchy> no to krociotki przykladzik
23:17 <%cauchy> mov eax, 36436 ; wiemy ze eax nie bedzie nam potrzebny
23:17 <%cauchy> mov ebx, eax ; ebx tez nie
23:17 <%cauchy> sub eax,47h
23:17 <%cauchy> xchg eax,ebx
23:17 <%cauchy> ipt ...
23:18 <%cauchy> to jest bardzo prosty przykladzik
23:18 <%cauchy> ma on na celu tylko pokazanie tego typu dzialan
23:18 <%cauchy> jakie to ma znaczenie
23:18 <%cauchy> no czasami jak kod taki mieszjacy ma kilka kilobajtow
23:19 <%cauchy> a w srodku takiego kodu znajduje sie tylko i wylacznie kilka dla nas waznych intrukcji
23:19 <%cauchy> to przegladanie kilkunastu stron kodu
23:19 <%cauchy> moze byc uciazliwe/nieprzyjemne
23:20 <%cauchy> ten przykladzik jest jeszcze czesciej spotykany niz poprzedni
23:20 <%cauchy> mimo swej prostoty widzialem taki kod w kilku robaczkach
23:20 <%cauchy> i nawet spelnial swoje zadanie
23:21 <%cauchy> bo dobicie sie do kodu samego robaka trwalo o wiele dluzej, gdyz potrzebne bylo przebicie sie przez ten caly "spam" :)
23:22 <%cauchy> ale tak naprawde takie zasmiecanie kodu tez mozna latwo wywalic, wystarczy sie zorientowac na czym sie opieral autor
23:22 <%cauchy> jakie rejestry chcial zachowac
23:22 <%cauchy> czy moze pomiedzy blokami takich intrukcji sa jakies standartowe intrukcje
23:22 <%cauchy> np
23:22 <%cauchy> pushad
23:22 <%cauchy> jakis tam kodzik
23:22 <%cauchy> popad
23:23 <%cauchy> wtedy latwo zauwazyc taki bloczek
23:23 <%cauchy> i go usunac ;]
23:23 <%cauchy> co prawda ktos moze powiedziec ze to zbytnie ulatwianie jest, zeby dawac np zmienne rejestry, zmienne wartosci
23:23 <%cauchy> zeby nic nie bylo stalego
23:24 <%cauchy> ale jak wszyscy wiemy nie ma totalnego przypadku, wszystko ma swoj okreslony wzor
23:24 <%cauchy> kwestia jedynie to ten wzor znalezc
23:24 <%cauchy> (co czesto gesto nie jest proste :P)
23:24 <%cauchy> ok to drugi typ byl
23:24 <%cauchy> ktos cos ?
23:24 <%cauchy> wiedzialem ;]
23:24 < ged_> serio taki chlam daja w wormach?
23:24 <%cauchy> ged_: daja
23:25 <%cauchy> zrob na cpl adv ;]
23:25 < ged_> myslalem ze na pocz. bedzie
23:25 < ged_> jmp @f
23:25 <%cauchy> ged_: teraz bedzie
23:25 <%cauchy> ;]
23:25 < ged_> db junk
23:25 < ged_> @@: ;p
23:26 <%cauchy> no ostatnio duzo gowna mi sie w robocie trafia z takimi syfami
23:26 <%cauchy> i zdziwilbys sie ile takich wlasnie prostych junkow jest
23:26 <%cauchy> ok koniec przerwy
23:27 <%cauchy> jadymy dalej
23:27 <%cauchy> ah
23:27 <%cauchy> dostalem pytanie
23:27 <%cauchy> ;]
23:27 <%cauchy> na pm ktos poprosil zebym wytlumaczyl pojecia
23:27 <%cauchy> junk i obfuskacja
23:27 <%cauchy> junk - smiec
23:27 <%cauchy> najprosciej
23:27 <%cauchy> ;]
23:28 <%cauchy> kawalek kzbednego kodu ktory ma za zadanie utrudnic sledzenie badz ogladanie zdisasmowanego kodu
23:28 <%cauchy> zbednego*
23:28 <%cauchy> kod taki nie zmienia dzialania programu
23:28 <%cauchy> zachowanie sie danego programu, zawierajacego junk code
23:29 <%cauchy> jest identyczne jak tego samego programu bez tychze junkow
23:29 <%cauchy> obfuskacja - to wg mnie (nie jestem pewien czy to ogolne pojecie bo nie pytalem nie sprawdzalem nigdzie ;])
23:29 <%cauchy> poprostu wstawianie do danego fragmentu kodu
23:30 <%cauchy> czy tez danych binarnych (jezeli mamy do czynienia z juz skompilowanym programem)
23:30 <%cauchy> okreslonych, wczesniej wspomnianych, junkow
23:30 <%cauchy> cos do tego ktos cos nie wie ?
23:30 < ayufan> ja bym powiedzial troche inaczej...
23:30 <%cauchy> :)
23:30 <%cauchy> mow mow
23:31 < ayufan> chociaz...
23:31 < ayufan> na to samo wyjdzie ;p
23:31 <%cauchy> nie ma sprzeciwow to jadymy dalej
23:31 <%cauchy> sekunda, rozrywany w domu jestem
23:31 <%cauchy> ju
23:32 <%cauchy> no to jedziemy dalej
23:32 <%cauchy> teraz powiem o czym o czym ged wspomnial
23:32 <%cauchy> junki w wyniku ktorych kod ktory sie wykonuje
23:32 <%cauchy> a kod ktory widzimy na ekranie debuggera/disasemblera jest inny
23:33 <%cauchy> no tutaj dla tych ktorzy nie mieli stycznosci z asm, z binarna reprezentacja kod moze byc ciezej juz
23:33 <%cauchy> no ale wszystko do przejscia
23:33 <%cauchy> dla osob ktore tego totalnie nie znaja, dobra lektura do pisania takich "cudeniek" moga byc manuale intela
23:34 <%cauchy> na poczatek standartowy kodzik
23:34 <%cauchy> ktory pojawia sie zawsze
23:34 <%cauchy> ilekroc jest mowa o junk :)
23:34 <%cauchy> jmp @F
23:35 <%cauchy> db XX ; tutaj dowolny wybrany bajt, ale pamietaj ze lepiej aby to byl poczatek intrukcji ktora sklada sie z wiecej niz z 1 bajtu :)
23:35 <%cauchy> @@:
23:35 <%cauchy>
23:35 <%cauchy> ok, powyzszy kod jest pisany pod masm
23:36 <%cauchy> @@, @F i @B to sa specjalne etykiety
23:36 <%cauchy> moze byc ich dowolnie wiele w kodzie
23:36 <%cauchy> @@: oznacza pewne miejsce do ktorego moze sie odwolac konkretna instrukcja
23:37 <%cauchy> ale tylko taka ktora nie znajduje sie za kolejna tego typu etykieta
23:38 <%cauchy> natomiast @F i @B oznaczaja ze odwolujemy sie do etykiety @@ ktora znajduje sie dalej (@F) albo wczesniej (@B) niz dana instrukcja
23:38 <%cauchy> moze malutki przykladzik
23:38 <%cauchy> jmp @F
23:38 <%cauchy> mov eax,ecx
23:38 <%cauchy> @@:
23:38 <%cauchy> inc eax
23:38 <%cauchy> cmp eax, 0FFh
23:38 <%cauchy> jnz @B
23:39 <%cauchy> na poczatku jest wykonywany skok do pierwszej napotkanej etykiety @@
23:39 <%cauchy> nastepnie jakies tam operacje
23:39 <%cauchy> porownywanie
23:39 <%cauchy> i nastepuje skos do NAJBLIZSZEJ POPRZEDNIEJ etykiety
23:40 <%cauchy> gdyby tam znajdowala sie jeszcze jedna etykietka typu @@ to dzialanie tego moglo by oczywiscie ulec zmianie
23:40 <%cauchy> moze troszke chaotycznie to przekazalem, ale mam nadzieje ze cos z tego zrozumieliscie :)
23:40 <%cauchy> do tego @@ ktos ma pytanie ?
23:40 < ged_> no masz racje :)
23:41 <%cauchy> nie umiem tego ladnie ubrac w slowa, tylko sens przekazac ;]
23:41 < Gretchen> a mialo byc o junkach ;)
23:41 < ged_> no trzeba bylo wyjasnic kod ;p
23:41 <%cauchy> byl na to request ;]
23:42 <%cauchy> wsio jasne ?
23:42 <%cauchy> jadziemy
23:42 <%cauchy> pamietacje jeszcze nasz wczesniejszy kod ? jak nie to scroll up ;]
23:42 <%cauchy> zalozmy ze mamy kod asmowy bez junkow taki
23:42 <%cauchy> cmp eax, ecx ; 3B C1
23:43 <%cauchy> jz _henhenblisko
23:43 <%cauchy> jego reprezentacja biarna bedzie
23:43 <%cauchy> 3B C1 74 XX
23:44 <%cauchy> gdzie XX to jakies tam bajty okreslajace odlegosc skoku
23:44 <%cauchy> no jak teraz ktos sobie wrzuci taki program do debuggera czy disasma
23:44 <%cauchy> to ma ladnie jak na raczce caly kod
23:44 <%cauchy> az sie chce sledzic normalnie
23:45 <%cauchy> to wrzucmy pomiedzy te intrukcje nasz junk
23:45 <%cauchy> wtedy przed skompilowaniem bedziemy mieli
23:45 <%cauchy> cmp eax,ecx
23:45 <%cauchy> jmp @F
23:45 <%cauchy> db EB
23:45 <%cauchy> @@:
23:45 <%cauchy> jz _henhenblisko
23:46 <%cauchy> jak na to teraz patrzymy tez normalnie wyglada
23:46 <%cauchy> ale po skompilowaniu
23:46 <%cauchy> i wrzucenie danego programu do debuggera, otrzymujemy zupelnie co innego
23:46 <%cauchy> cmp eax,ecx
23:46 <%cauchy> jmp _jakistamadres
23:47 <%cauchy> jmp _cotowogolejest
23:47 <%cauchy> jak widac kod jest zupelnie inny, dopiero podczas przechodzenia poprzez te intrukcje widac co sie dzieje
23:48 <%cauchy> no ale skoro mozemy zrobic cos tak prostego
23:48 <%cauchy> moze zrobmy cos bardziej skomplikowanego
23:48 <%cauchy> cos co nie bedzie takie piekne
23:48 <%cauchy> bo podczas gdy w poprzednim przykladnie
23:49 <%cauchy> wystarczylo non stop trzymac Step Over
23:49 <%cauchy> to w nastepnej metodzie trzeba bedzie zamiast tego przyciskac step into
23:49 <%cauchy> a jak z tym jest dobrze wiemy, nagle ciach niewiadomo w jakiej funkcji jestesmy i zonk ;]
23:49 <%cauchy> no to moze pokaze przykladzik
23:50 <%cauchy> call @F
23:50 <%cauchy> db 0Fh
23:50 <%cauchy> jmp _1
23:50 <%cauchy> @@:
23:50 <%cauchy> inc dword ptr [esp]
23:50 <%cauchy> ret
23:50 <%cauchy> _1:
23:51 <%cauchy> no tutaj juz widzimy ze cos bardziej skomplikowanego
23:51 <%cauchy> nie sa to jakies cuda majaki
23:51 <%cauchy> ale jak takiego kodu nawrzuca sie duzo, to moze sprawic on klopot :)
23:51 <%cauchy> oczywiscie w miejsce db 0F
23:52 <%cauchy> mozna wstawic dowolny bajt, ale wiadomo ze lepiej wybierac takie bajty
23:52 <%cauchy> ktore rozpoczynaja jakas "dziwna" (czyt. malo znana) intrukcje
23:52 <%cauchy> i najlepiej aby taka intrukcja skladala sie z jak najwiekszej liczby bajtow
23:53 <%cauchy> to moze pokaze jak cos takiego wylada w kodzie skompilowanym
23:53 <%cauchy> call _adres_jakis
23:53 <%cauchy> por mm0,[edi+edi*8]
23:53 <%cauchy> add al,04
23:53 <%cauchy> ret
23:54 <%cauchy> no nie wyglada on zachecajaco
23:54 <%cauchy> oczywiscie taki kod jest stosunkowo prosty, poniewaz nie zamazuje w zaden sposob intrukcji do ktorej dazymy
23:55 <%cauchy> ale oczywiscie mozna to rozwinac w taki sposob
23:55 <%cauchy> zeby zamiast db XX mozna tam bylo wsadzic cale intrukcje
23:55 <%cauchy> w tym przypadku akurat nasze mozliwosci sa ograniczane praktycznie tylko przez nasza wyobraznie
23:56 <%cauchy> ;]
23:56 <%cauchy> pytania ?
23:56 <@phoenix__> nie ;P
23:56 <@phoenix__> bo itak nie rozumiem
23:56 <%cauchy> ktos cos rozumie ?
23:56 <%cauchy> hehe
23:56 <%cauchy> dobra panowie, nie bede was jeszcze dlugo meczyl
23:57 <%cauchy> praktycznie koniec mojego gledzenia, jeszcze napomkne skromniutko o protektorach
23:57 <%cauchy> mm0 to rejestr mmx
23:57 < mikel> cauchy: my chcemy wiecej
23:57 <@phoenix__> mhm
23:57 <@phoenix__> WLASNIE
23:57 < ged_> no no cos krotko kosz ;)
23:58 <%cauchy> caly spocony jestem jak dzika swinia od tego klepania ;]]
23:58 <%cauchy> ok
23:58 <%cauchy> to teraz cos innego
23:58 <%cauchy> teraz bedziemy dla odmiany modyfikowac kod wykonywalny programu
23:59 <%cauchy> odrazu ci ktorym sie oczka swieca, niech przestana, to nie jest asprot 2.x :)
23:59 <%cauchy> zostaniemy przy starym xor :)
23:59 <%cauchy> poprzednio wymienione metody maja jedna bardzo duza wade
23:59 <%cauchy> mozna je bardzo, latwo wyrzucic
00:00 <%cauchy> wystarczy ze znajdziemy odpowiedni wzor
00:00 <%cauchy> ktorym sie rzadzi dany junk
00:00 <%cauchy> napiszemy wlasny/sciagniemy z netu gotowy program ktory nop'uje wszystkie takie smieci wedlog okreslonych patternow
00:00 <%cauchy> i juz mamy problem z glowy
00:01 <%cauchy> w nastepnym przypadku nie ma tak latwo, zeby taki kod oczyscic, czy sie chce czy nie, trzeba go najpierw zanalizowac
00:01 <%cauchy> co zajmuje drogocenny czas :)
00:02 <%cauchy> to moze pokaze przykladzik, ktory bedzie modyfikowal 4 bajty nastepujace po danej komendzie
00:02 <%cauchy> opkodzie wlasciwie
00:02 <%cauchy> call @F
00:03 <%cauchy> @@:
00:03 <%cauchy> pop edi
00:03 <%cauchy> xor [edi+dlugosc_opkodu],12345678h
00:03 <%cauchy> ~~ tutaj jakies dziwne dane :P ~~
00:03 <%cauchy> jak uruchomimy nasz przykladowy program
00:04 <%cauchy> to zobaczymy ze po tych instrukcjach sa same smiecie nic nie znaczace
00:04 <%cauchy> dopiero jak dojdziemy do naszego xor;a
00:04 <%cauchy> i przez niego przejdziemy
00:04 <%cauchy> aaa moment
00:04 <%cauchy> dla tych ktorzy nie znaja asm
00:04 <%cauchy> za dobrze :)
00:05 <%cauchy> po wejsciu w dowolna procedure
00:05 <%cauchy> na stosie jest odkladany adres powrotu funkcji
00:05 <%cauchy> czyli jak weszlismy w tym miejscu to na stosie jest odkladany adres nastepnej po call'u instrukcji
00:05 <%cauchy> dalej zrzucamy ja ze stosu do edi
00:06 <%cauchy> i teraz w EDI mamy adres wskazujacy nam na intrukcje TUZ PO CALL'u
00:06 <%cauchy> czyli nie na xor
00:06 <%cauchy> ale na pop edi
00:07 <%cauchy> teraz zeby policzyc ile trzeba dodac do edi, musimy znac dlugosc popa (1 bajt) i dlugosc calego naszego xora (nie wiem ile, nie sprawdzalem ;])
00:07 <%cauchy> tak policzona wartosc wstawiamy w miejsce ktore opisalem jako dlugosc_opkodu
00:07 <%cauchy> i wszystko bedzie smigac cacy :)
00:07 <%cauchy> no dobrze ale jak to bedzie dziala
00:07 <%cauchy> c
00:08 <%cauchy> po naszej intrukcji XOR
00:08 <%cauchy> zalozmy ze znajduje sie taki dword 36345125
00:08 <%cauchy> ktore tworzy nie mam pojecia jakie intrukcje, pisze z glowy, wybaczcie
00:09 <%cauchy> w momencie przechodzenia przez xor
00:09 <%cauchy> te bajty zostana zxorowane
00:09 <%cauchy> ze stala odpowiednio dobrana przez nas wartoscia
00:09 <%cauchy> w wyniku tej operacji, otrzymamy jakies dane
00:10 <%cauchy> ktore BEDA juz gotowym do wykonania kodem
00:10 <%cauchy> no dobrze, ale jak policzyc co xorowac jaka wartoscia
00:10 <%cauchy> wiemy ze xor jest odwracalny
00:10 <%cauchy> czyli wystarcza nam 2 skladniki zeby poznac 3
00:10 <%cauchy> podobnie jest z dodawaniem i odejmowaniem :)
00:11 <%cauchy> wiec xora mozna rownie dobrze zastapic add czy sub
00:11 <%cauchy> co kto woli :)
00:11 <%cauchy> zalozmy ze mamy opkody
00:11 <%cauchy> 74 52 EB 16
00:11 <%cauchy> bajty nie opkody, jebie mi sie juz no :)
00:12 <%cauchy> teraz zeby miec wersje zaszyfrowana tych bajtow
00:12 <%cauchy> wybieramy sobie dowolna liczbe
00:12 <%cauchy> np wlasnie 12345678h
00:12 <%cauchy> nastepnie xorujemy ja z 16EB5274 (notacja intela xD)
00:13 <%cauchy> i mamy jakis tam wynik ktory zapisujemy sobie w gotowym execu
00:13 <%cauchy> oczywiscie takie machinacje zle sie robi recznie
00:13 <%cauchy> najlepiej jest napisac sobie jakas maszynke ktora by za nas to wszystko zrobila
00:14 <%cauchy> przez te lata od kiedy komputery staly sie domowym narzedziem w wielu domach
00:14 <%cauchy> postep w tej technologii tak sie rozwinal ze nie sposob opisac na jednym wykladzie chodz niewielkiej czesci tego co moze zostac zrobione
00:14 <%cauchy> mysle teraz w szczegolnosci o czyms takim jak protectory
00:15 <%cauchy> dla czesci pewnie nowe slowko
00:15 <%cauchy> zastanaiwalem sie jak to jakos jasno opisac
00:15 <%cauchy> i pomyslalem ze opisze to za pomoca packerow ;]
00:16 <%cauchy> kazdy z nas wie co to ZIP, RAR TAR etc
00:16 <%cauchy> to programy pakujace dowolne pliki binarne
00:16 <%cauchy> pakujace czy zmniejszajace ich objectosc
00:16 <%cauchy> packery plikow PE dzialaja na podobnej zasadzie
00:17 <%cauchy> tylko zamiast tworzyc pliki o nowym rozszerzeniu, kompresuje zawartosc starego pliku
00:18 <%cauchy> wrzuca do nowej "przestrzeni" w pliku PE (np nowa sekcja, zmodyfikowany uklad obecnych sekcji, dopianie do ostatniej sekcji etc)
00:18 <%cauchy> kawalek kodu, ktory ma za zadanie rozpakowac spakowane dane (np secke kodu, sekcje danyc czasami zasoby)
00:19 <%cauchy> a nastepnie uruchomic ten program
00:19 <%cauchy> jest kilka packerow dobrze znanych
00:19 <%cauchy> najbardziej znany jest chyba UPX, kazdy praktycznie mial z nim do czynienia
00:19 <%cauchy> drugi rownie popularny jest FSG autorstwa barta
00:20 <%cauchy> ktory chyba uciekl z tego kanalu jak mnie nie bylo ;]
00:20 <%cauchy> a jest
00:20 <%cauchy> junk_equ_bart <- FSG to jego jest :)
00:20 <%cauchy> a z kmercyjnych packerow najbardziej znany to chyba ASPack
00:21 <%cauchy> protectory dziala praktycznie na podobnej zasadzie jak packery
00:21 <%cauchy> tylko zamiast kompresowac kod
00:21 <%cauchy> maja za zadanie tak ten kod "zamieszac" zeby maksymalnie utrudnic odczytanie oryginalnego kodu
00:22 <%cauchy> tego typu produkcje sa czesto uzywane w oprogramowaniu typu shareware, zeby zabezpieczyc program przed mozliwoscia nielegalnej rejestracji za pomoca modyfikacji czy sledzenia kodu
00:23 <%cauchy> do takich celow czesto uzywa sie komercyjnych narzedzi typu armadillo czy asprotect
00:23 <%cauchy> z darmowych narzedzi warto wspomniec o pespinie autorstwa cyberboba (polskie toolsy rox :P)
00:23 <%cauchy> ok to tak na samo zakonczenie
00:24 <%cauchy> wklepie kawaleczek takiego mega prostackiego kodu
00:24 <%cauchy> ktory moze byc uzywany do szyfrowania pliku
00:24 <%cauchy> nie bede tutaj wklejal ani przedstawial jak sie dobrac do takiego pliku etc, bo to ejst temat na totalnie nowy wyklad
00:25 <%cauchy> opisze tylko krotka procke
00:25 <%cauchy> mozna nawet sie daleko zapedzic
00:25 <%cauchy> i powiedziec ze zawiera ona elementy polimorficzne :)
00:25 <%cauchy> znowu bedziemy korzystac z ukochanego nam xora
00:26 <%cauchy> tylko ze element ktorym bedziemy xorowac
00:26 <%cauchy> bedzie randomowy
00:26 <%cauchy> ten kodzik bedzie napisany w C
00:26 <%cauchy> dla ulatwienia :)
00:27 <%cauchy> int Syfik_szyfr(char *bufor,int dlugosc){
00:27 <%cauchy> int l,i;
00:27 <%cauchy> l = rand() | 0xFF;
00:27 <%cauchy> for(i=0;i00:27 <%cauchy> bufor[i] = bufor[i] ^ l;
00:27 <%cauchy> }
00:27 <%cauchy> return l;
00:27 <%cauchy> taby sie troszke popsuly, ale chyba widac
00:27 <%cauchy> :)
00:28 <%cauchy> jako parametry funkcji sa podane bufor, w ktorym jest nasz kodzik ktory chcemy zaszyfrowac
00:28 <%cauchy> a takze ilosc bajtow ktore maja zostac zaszyfrowane
00:29 <%cauchy> oj chyba sie jebnalem lekko mowiac ;]
00:29 <%cauchy> zamiast | dajcie % i wszystko bedzie ok ;]
00:30 <%cauchy> chodz w sumie nie wiem czy to bedzie mialo jakies znaczenie
00:30 <%cauchy> za pomoca tej procedurki w naszym protectorze
00:30 <%cauchy> szyfrujemy np cala sekcje kodu
00:30 <%cauchy> po czyms takim, kod bedzie niezdolny do wykonywania
00:31 <%cauchy> zatem musimy w jakies miejsce w pliku wrzucic procedurke deszyfrujaca
00:32 <%cauchy> procedurka deszyfrujaca ten kod
00:32 <%cauchy> wyklada praktycznie tak samo
00:32 <%cauchy> tylko dajemy dodatkowy parametr, ktorym jest liczba (1 bajt), ktorym bedziemy deszyfrowac
00:33 <%cauchy> dla porzadku publicznego wkleje tez proce do deszyfracji
00:33 <%cauchy> :)
00:38 <%cauchy> o :)
00:38 <%cauchy> ja zyje ;]
00:38 <%cauchy> co to ja mialem
00:38 <%cauchy> aha ostani fragment kodu i lulu pac ;]
00:38 <%cauchy> void Syfik_deszyfr(char *bufor,int dlugosc, int l){
00:38 <%cauchy> int i;
00:38 <%cauchy> for(i=0;i00:38 <%cauchy> bufor[i] = bufor[i] ^ l;
00:38 <%cauchy> }
00:38 <%cauchy> return;
00:39 <%cauchy> aha ostani fragment kodu i lulu pac ;]
00:39 <%cauchy> kurr
00:39 <%cauchy> juz nie widze na oczy
00:39 <%cauchy> sorka
00:39 <%cauchy> tutaj jak widzimy mamy praktycznie taka sama procke
00:39 <%cauchy> tylko pobieramy jako param liczbe ktora xorujemy
00:40 <%cauchy> po przejsciu takiej procki mamy znowu ladnie odszyfrowany kod :)
00:40 <%cauchy> podsumowanko
00:40 <%cauchy> metod obfuskacji, czy tam zasmiecania kodu jest masa
00:40 <%cauchy> od tych najprostszych, ktore przedstawilem tutaj
00:41 <%cauchy> po te bardziej skomplikowane ktore moze przedstawi na next wykladzie z tej serii kolega bart jak go poprosicie :)
00:41 <%cauchy> az po takie cudenka jak polimorficzne czy wrecz metamorficzne szyfratory czy protektory
00:42 <%cauchy> w kazdym badz razie, jest to galaz codingu dosc waska
00:42 <%cauchy> ktora zajmuje sie niewiele osob
00:42 <%cauchy> i chociazby dlatego warto na nia od czasu do czasu luknac :)
00:42 <%cauchy> no i to by bylo na tyle
00:42 <%cauchy> czekam na ew pytania
00:42 <%cauchy> i flame
00:42 <%cauchy> :)
00:42 <%cauchy> w sumie kurde prawie 1:45, juz all poszli spac widze ;]