Thursday, July 22, 2010

Jak wygląda crackowanie?

Większość obecnych użytkowników Linuksa, podobnie jak ja parę lat temu, używała systemu Windows. My, Linuksiarze wiemy co najczęściej robi się na naszym ulubionym systemie. Są to głównie sieci i związane z tym rozwiązania. Nie jest też tajemnicą, że osoby używające Linuksa należą do tych, które lubią „grzebać” w komputerze. Zmierzam do zadania pytania: w takim razie, co te osoby robiły przed laty na systemie Windows?

W moim przypadku była to wielka miłość do programowania. Mimo, iż już od 4 lat tym się tak nie interesuję jak niegdyś, to postanowiłem trochę powspominać te piękne czasy i zaprezentować z nich to, co najciekawsze.

Wpis ten nie jest poradnikiem na temat łamania zabezpieczenia, choć może tak wyglądać. Jest to, mam nadzieję, niezwykle ciekawa informacja z dającym do myślenia morałem, jak łatwo oszukać komputer na swoją korzyść. Jest to również moja sentymentalna opowieść o tym, jak wiedza na temat tworzenia może zostać użyta do innych celów, takich jak łamanie programów. Jeżeli zastanawiałeś się kiedyś kim są Ci kolesie podpisujący się w notatniku i dostarczający małe pliczki o takiej samej nazwie jak aplikacja, z tym, że te dostarczone przez nich nie pytają o hasło. Od razu zaznaczam, że nie byłem żadnym crackerem, tylko interesowałem się tym z czystej ciekawości i w celu sprawdzenia swoich umiejętności. Tak więc opowiem o tym, jak to się robi oraz o tym, że nikt tak nie umie łamać programów jak sami programiści. Dlaczego? Bo nikt tak dobrze nie zna zasad działania programów, jak ich twórcy.

Moja przygoda z programowaniem zaczęła się dosyć szybko licząc od momentu posiadania pierwszego komputera. Programowaniem, a w szczególności w języku C++ zacząłem interesować się jakieś 10 lat temu. Uczyłem się z książek, bardzo grubych zresztą i nie jednej. Ta fascynacja trwała chyba jakieś 5 lat. W tym czasie poznałem bardzo wiele języków programowania i ciągle było mi mało. Po C++ przyszedł czas na Assemblera, choć dziś praktycznie nieużywany, to wydanej kasy na książkę ani poświęconego czasu nie żałuję. To była jedna z najciekawszych rzeczy jakich nauczyłem się o komputerach. Ach, to były czasy, aplikacja napisana w Assemblerze ważyła parę KB. W każdym bądź razie, po poznaniu sposobu w jaki tworzy się programy oraz jak system i procesor je wykonują, w którymś momencie mojej nauki dotarło do mnie, że wiem już tak dużo, iż mógłbym trochę namieszać w tych programach nawet nie mając ich kodu. Cracowanie nie występuje pod Linuksem bo sam możesz zmieniać kod. W Windows, nie mogłeś sprawdzić jak oni to zrobili pisząc swój program. Linux daje Ci taką możliwość, dlatego jest w pewnym sensie rajem dla programistów. Sam na niego przeszedłem między innymi z tych względów.

Kiedyś były takie programiki, które ściągało się z sieci w wersji trial. Zazwyczaj miały w menu pozycję „Pomoc” albo „About”, w której znajdowało się takie polecenie jak „Rejestracja”, gdzie należało wpisać swój klucz. Powiem szczerze, że zdarzało mi się kiedyś takie programy „rejestrować” ale to stary sposób zabezpieczeń, chyba dziś już niespotykany w nowych programach. Dlaczego to robiłem? Bo gdy przez parę lat myśli się o programowaniu to człowiek w pewnym momencie przekracza pewną granice abstrakcji i patrząc na przycisk widzi kod pod nim, patrząc na pole do wpisywania tekstu widzi kod pod nim itd. i to w dwóch językach, ludzkim - C++ i maszynowym - Assembler.

Dziś korzystając z okazji, że na VirtualBox ma zainstalowany Windows 7 (legalny, z MSDNAA  )zainstaluję co trzeba, napisze programik proszący o hasło z przyciskiem sprawdzającym poprawność kodu. Oczywiście będzie on tworzony tylko do celów prezentacyjnych, więc wiele aspektów zostanie w nim pominiętych – absolutne minimum. Wszystko po to, aby pokazać jak łatwo znając doskonale zasady działania programów komputerowych można taki program oszukać. Kiedyś stwierdziłem, że zabezpieczający takie programy oraz ten, który próbuje je łamać mają takie same możliwości, ponieważ obaj działają na tym samym gruncie. Oczywiście Ci drudzy mają trudniejsze zadanie ale i tak wygra sprytniejszy. Przykład, który zaprezentuję udowodni jak w logiczny sposób złamie program i stworze cracka zmieniając tylko jedne bajt w kodzie programu. Wiele rzeczy dla wielu może okazać się niezrozumiałych i tak powinno być
Zanim jednak wyruszymy na poszukiwania tego jednego bajta musimy go najpierw stworzyć.

Zaczynamy od ściągnięcia Borland C++ Builder 6 Personal, aby napisać taki program szybko. Znajdziemy go np. tu. Dlaczego wybrałem C++ Builder? Lubię go i chcę uniknąć pisania w WinAPI ale to nie oznacza, że nie trzeba go znać, wręcz przeciwnie.
Projekt programu oraz kod przedstawiam na zdjęciu.


Jak widzimy program jest bardzo prosty, posiada pole (Edit) do wpisania hasła i przycisk (Button) do sprawdzenia czy hasło jest poprawne. Kod również jest prosty. Gdy wciśniesz przycisk, program pobierze zawartość pola tekstowego i sprawdzi czy jest takie jak powinno. Ja jawnie napisałem w kodzie jaka to ma być wartość: „password” ale tak się nie robi. Nie zmienia to faktu, że przed samym porównaniem program i tak będzie musiał znać wartości, które będzie porównywał, więc i tak byśmy ją dorwali  Gdy wpiszemy w pole ciąg znaków „password” pokaże się komunikat o treści „kod prawidłowy”, w przeciwnym przypadku pokaże się komunikat „zły kod”.

Ok, mamy już te cudo. Jak wpisze zły kod to zobaczę komunikat o złym kodzie.



Tylko z samej obserwacji programu można założyć jak jest stworzony. Jego kod mógłby wyglądać tak:

if (to_co_wpisałem == to_co_powinno_być)
    // jedziesz dalej
 else
    // nigdzie nie pojedziesz

Co by się przed tą instrukcją nie działo, to program misi znać obie wartości już w tym momencie, chociażby ściągał poprawne hasło z FBI. Ale to nie wszystko, załóżmy specjalne okulary i zobaczymy jak to widzi procesor:

cmp reg, mem
je jump_to


Co w wolnym tłumaczeniu znaczy: porównaj dwie wartości (cmp - compare), jeżeli są równe skocz w wskazane miejsce (je - jump if equal), jeżeli nie, kontynuuj wykonywanie instrukcji. To tylko przykładowy kod wzięty z głowy, ten oryginalny może wyglądać inaczej, ale zasada działania będzie taka sama. To oczywiście nie jest takie proste, trzeba jeszcze uwzględnić zmianę kodu assemblerowego po optymalizacji kompilatora. Jak mówiłem to najprostszy przykład i dosyć okrojony, bo procesor przed wykorzystaniem zmiennych musi jeszcze załadować nimi rejestry itp..

Teraz należy się zastanowić co by się stało, gdybym odwrócił logikę kodu assemblera? Aby procesor wykonywał skok tylko wtedy, gdy porównywane wartości są różne. W takim wypadku program akceptowałby wszystkie hasła oprócz prawidłowego – chyba nie będziesz miła takiego pecha, że wpiszesz prawidłowe . Czyli nasz crack będzie działał na wszystko, oprócz poprawnego hasła, ale oni – użytkownicy – tego nie wiedzą hehehe. Czasami też się robi po prostu NOP-a ale to może mieć fatalne skutki w dalszym działaniu programu.

Teraz potrzebujemy debuggera, mój ulubiony to OllyDbg, bez problemu go znajdziecie. Skoro już go mamy, to uruchamiamy w nim nasz programik.


Teraz bez porządnej wiedzy się nie obędzie. Debugger załadował program, wybieramy polecenie ze zdjęcia.



Ważne jest, że jesteśmy w module Project1. Wyszukujemy wszystkie odwołania do innych modułów (funkcji bibliotek), z których korzysta program. W tym przypadku będzie to VLC. W innym przypadku byłoby to WinAPI i szukalibyśmy funkcji GetWindowText. My szukamy miejsca w kodzie, w którym pobierane jest to co wpisaliśmy. Była to funkcja GetTextBuf. Więc szukamy takiej i zastawiamy na nią pułapkę – breakpoint. W tym momencie znajomość funkcji, z których składa się program jest wyznacznikiem do ustalenia tego, czego szukamy. Tak naprawdę jest to o wiele bardziej skomplikowane niż przedstawiłem, zazwyczaj trzeba ustalić w czym został napisany program. Można też bazować na funkcjach systemowych, czyli WinAPI.



Wracamy do okna z kodem i uruchamiamy aplikacje. Wpisujemy w pole cokolwiek i wciskamy przycisk, debugger zatrzyma działanie programu na wywołaniu tej funkcji, teraz możemy przeanalizować kod.



Jak widzicie już w kodzie widać nasze hasło, ale zazwyczaj tak nie jest. Teraz używając klawisza F8 wykonujemy program krok po kroku ale bez wchodzenia w wywoływane funkcje, inaczej skończylibyśmy w jakiejś funkcji systemu operacyjnego, które zresztą należy dobrze znać. W przedstawionym miejscu już widzę w rejestrach procesora wartości, które za chwilę zostaną porównane (okno po prawej).



Przede mną widzę wywołanie funkcji strcmp(), której użyłem i wiem do czego używają jej inni programiści. Wiemy, że w kodzie jest ona w samym warunku if. Parę instrukcji dalej widzę jedyne wykonanie instrukcji skoku: JNE SHORT 00401BFF, a na samym dole okna widzę już wywołanie funkcji ShowMessage. Teraz wystarczy zmienić warunek.



Na krok przed samym skokiem dokonuje jego edycji, aby przetestować działanie programu przed stworzeniem cracka.

Zmieniam wartość 75 na 74 – są to wartości w systemie szesnastkowym oczywiście. Instrukcje assemblera oraz odpowiadające im kody również można znaleźć w sieci, a najlepiej na stronie Intela. Ja akurat pamiętałem na co mam zmienić.


W efekcie zmieniłem warunek z JNE „jeżeli nie równy” na JE „jeżeli równy”. Teraz odpalamy program dalej przyciskiem niebieskiej strzałki w pasku narzędzi lub wcisnąć F9. Powinniśmy zobaczyć pozytywne rozpatrzenie naszej sprawy :)

hehe

Zazwyczaj przy takich zmianach trzeba być bardzo uważnym i precyzyjnym. Ponieważ jakby nie było nasza zmiana będzie miała wpływ na późniejsze zachowanie programu i należy to umieć przewidzieć. Nie raz mi się zdarzało, że udawało mi się wyświetlić okno o udanej rejestracji ale program nadal był niezarejestrowany. Po prostu miał inne zabezpieczenia. Pamiętam taką sytuację, gdy podczas badania pewnego programu natrafiłem na wiadomość (zdjęcie) od programistów, która co tu dużo mówić dawała do zrozumienia, że oni są od Ciebie lepsi – ale wtedy to się uśmiałem hehe i odpuściłem sobie – respect.

Teraz potrzebujemy hex edytora i musimy ustalić czego należy w nim szukać. Jako edytora użyłem WinHex, również znajdziecie go bez problemu.
Teraz trzeba zinterpretować kod z debuggera. Po lewej stronie instrukcji widzimy odpowiadające im wartości heksadecymalne. Ale hola hola. Część z nich jest stała, a część zmienna – program poznaje te wartości dopiero w trakcie wykonywania. Niemniej jednak są to wartości zmienne ale o stałej wielkości. Ja to analizuje tak: instrukcje ADD, TEST i warunek JNE powinny być niezmieniane, szukam więc ciągu: 83 C4 08 85 C0


Ustawiam kursor na bajcie o wartości 75 i zmieniam go na 74. Zapisuję zmieniony plik pod inną nazwą np. Project1_crack.exe.

Teraz możesz odpalić zmodyfikowaną aplikacje i przetestować jak działa.

Przedstawiony przykład pokazuje jak niewiele trzeba, aby złamać program.

Sunday, July 18, 2010

Zmiana rozdzielczości trybu tekstowego jądra Linux

Jakiś czas temu już zrobiłem z tym porządek, ale wczoraj zmieniłem jądro i wielkie czcionki podczas ładowania systemu powróciły. Postanowiłem je wypisać na blogu, w końcu będę miał własną ściągę.

| 640x480  800x600  1024x768 1280x1024
  ---+-------------------------------------
 256 |  0x301    0x303    0x305    0x307   
 32k |  0x310    0x313    0x316    0x319   
 64k |  0x311    0x314    0x317    0x31A   
 16M |  0x312    0x315    0x318    0x31B

Teraz możemy dokonać zmiany rozdzielczości w jakiej jądro będzie wyświetlać teksy. W tym celu należy dokonać zmian w pliku:

vim /boot/grub/grub.cfg

Odnajdujemy w nim wpis opisujący jądro, z którego korzysta nasz komputer, w moim przypadku będzie to:
...
menuentry 'Debian GNU/Linux, with Linux 2.6.32-5-amd64' --class debian --class gnu-linux --class gnu --class os {
    insmod part_msdos
    insmod ext2
    set root='(hd0,msdos1)'
    search --no-floppy --fs-uuid --set 2d498ccc-9416-4d78-8a38-ec84974dd4f0
    echo    'Loading Linux 2.6.32-5-amd64 ...'
    linux    /boot/vmlinuz-2.6.32-5-amd64 root=UUID=2d498ccc-9416-4d78-8a38-ec84974dd4f0 ro  quiet
    echo    'Loading initial ramdisk ...'
    initrd    /boot/initrd.img-2.6.32-5-amd64
}
...

teraz w linii zaczynającej się od słowa "linux" dopisujemy parametr "vga" z jedną z wartości z tabelki, którą podałem na samym początku.

linux /boot/vmlinuz-2.6.32-5-amd64 root=UUID=2d498ccc-9416-4d78-8a38-ec84974dd4f0 ro quiet vga=0x31A

Przy próbie zapisania zmian pojawi się komunikat, iż plik jest tylko do odczytu. W edytorze Vim aby wymusić zapis zamiast zwykłego ":w" należy wydać polecenie ":w!".

To wszystko, teraz należy ponownie uruchomić komputer, a na ekranie zmieści się nam dużo więcej niż dotychczas. Jest to bardzo przydatne podczas prac z terminalem, które od czasu do czasu przyjdzie nam wykonać.

Sunday, July 11, 2010

Zapora ogniowa w Linuksie na komputerze domowym

Wiele osób pyta jak skonfigurować zaporę na komputerze domowym, często jest to podobna konfiguracja więc dlaczego nie stworzyć pewnego wzorca?

Przygotowałem taki wzorzec, nie sprawdzałem go pod każdym kątem więc może coś nie działać, zwłaszcza na desktopie, dlaczego? Ponieważ to właśnie na nim więcej jest oprogramowania, lub jak kto woli bajerów np. komunikatory itp. itd.. Tak więc postawiłem za cel sobie napisanie takiej zapory, aby tworzyła najlepszy kompromis między bezproblemowym użytkowaniem komputera (wygoda), bezpieczeństwem i prędkością.

Najpierw należy wspomnieć o założeniach zapory (polityce):
  • zapora korzysta z architektury klient-serwer, desktop jest klientem, jego użytkownik może inicjować połączenia (porty źródłowe aplikacji klienckich to zakres 1024-65535), serwery nie mogą inicjować połączeń z naszym komputerem - na tej samej zasadzie działa przekazywanie ruchu z mechanizmem NAT
  • odpowiedz serwera jest akceptowana poprzez mechanizm filtrowania stateful
  • zapora zezwala na przyjmowanie, wysyłanie i przekazywanie komunikatów protokołu ICMP (np. polecenie ping)
  • zapora zezwala na przyjmowanie pakietów kierowanych do interfejsu local loopback, czyli lo
  • zapora udostępnia dwie usługi, pierwsza to zasoby sieciowe jakie oferuje pakiet Samba (często użytkownicy instalują taki serwer na potrzeby wymiany plików wewnątrz sieci prywatnej - domu) oraz SSH, czyli szyfrowany terminal, jest on dostępny również z zewnątrz a nie tylko z wewnątrz jak SMB
Ponieważ zapora wykorzystuje mechanizm NAT należy uruchomić tą funkcję usuwając znak komentarza '#' przed linią '# net.ipv4.ip_forward=1' w pliku /etc/sysctl.conf

root@home:/home/grzesiek# cat /etc/sysctl.conf | grep forward
# Uncomment the next line to enable packet forwarding for IPv4
net.ipv4.ip_forward=1
# Uncomment the next line to enable packet forwarding for IPv6
#net.ipv6.conf.all.forwarding=1

Następnie należy przeładować konfigurację poleceniem:
root@home:/home/grzesiek# sysctl -p /etc/sysctl.conf
net.ipv4.ip_forward = 1


Została jeszcze tylko kwestia nazwy interfejsu, którym ISP dostarcza nam połączenie (Internet), w moim przypadku jest to eth2, Twój może nazywać się zupełnie inaczej, zazwyczaj eth0 (możesz to sprawdzić wydając polecenie ifconfig). Zakładam, iż sieć wewnętrzna należy do klasy 192.168.0.0/24, czyli np. 192.168.4.0, 192.168.42.0 itp..

Oto kod konfiguracji zapory:

#!/bin/sh
##
##   DESKTOP FIREWALL by grzesiek ;)
##
##

start () {

iptables -F
iptables -X
iptables -F -t nat
iptables -X -t nat

iptables -P FORWARD DROP
iptables -P INPUT DROP
iptables -P OUTPUT DROP

# INPUT
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A INPUT -i eth1 -s 192.168.0.0/16 -p udp -m multiport --dport 137,138 -m state --state NEW -j ACCEPT
iptables -A INPUT -i eth1 -s 192.168.0.0/16 -p tcp -m multiport --dport 139,445 -m state --state NEW -j ACCEPT
iptables -A INPUT -p tcp --dport 22 -m state --state NEW -j ACCEPT
#
# tu możemy zezwalać na łączenie się z innymi usługami świadczonymi przez nasz komputer
# np.
# iptables -A INPUT -p tcp --dport 80 -j  ACCEPT
#
iptables -A INPUT -i lo -m state --state NEW -j ACCEPT
iptables -A INPUT -p icmp -m state --state NEW -j ACCEPT
iptables -A INPUT -j REJECT --reject-with icmp-host-prohibited

# OUTPUT
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -p tcp --sport 1024:65535 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -p udp --sport 1024:65535 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -p icmp -m state --state NEW -j ACCEPT
iptables -A OUTPUT -j REJECT --reject-with icmp-host-prohibited

# FORWARD
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -s 192.168.0.0/255.255.0.0 -p tcp --sport 1024:65535 -m state --state NEW -j ACCEPT
iptables -A FORWARD -s 192.168.0.0/255.255.0.0 -p udp --sport 1024:65535 -m state --state NEW -j ACCEPT
iptables -A FORWARD -p icmp -m state --state NEW -j ACCEPT
iptables -A FORWARD -j REJECT --reject-with icmp-host-prohibited

# NAT system
iptables -t nat  -A POSTROUTING -s 192.168.0.0/255.255.0.0 -d 0/0 -j  MASQUERADE

echo "Configuration iptables on... (more information use option: show)"
exit 0
}

stop () {
iptables -F
iptables -X
iptables -F -t nat
iptables -X -t nat

iptables -P FORWARD ACCEPT
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT

iptables -t nat -A POSTROUTING -s 192.168.0.0/255.255.0.0 -d 0/0 -j  MASQUERADE

echo "Configuration iptables off (except NAT system for 192.168.0.0/16 !)... (more information use option: show)"
exit 0
}

show () {
echo "\n                            [ Table: filter ]\n"
iptables -L -nv --line-numbers -t filter
echo "\n                            [ Table: nat ]\n"
iptables -L -nv --line-numbers -t nat
echo "\n"
exit 0
}

#main:
case "$1" in 
 start)
  start ;;
 stop)
  stop ;;
 show)
  show ;;
 *)
  echo $"  Składnia: $0 {stary, stop, show}"
  echo "@@@ Firewall by grzesiek ;) @@@"
  exit 1
esac

Przedstawiony skrypt należy jeszcze dodać do rozruchu systemu, czyli do katalogu /etc/init.d/firewall. Następnie należy wykonać polecenie, które przypisze go do sekwencji startowych:

update-rc.d firewall defaults

Nasz skrypt obsługuje dwie wymagane opcje; start i stop oraz dodatkową show. Aby zobaczyć jak wygląda konfiguracja zapory należy wydać polecenie:

root@home:/home/grzesiek# /etc/init.d/firewall show

[ Table: filter ]

Chain INPUT (policy DROP 0 packets, 0 bytes)
num   pkts bytes target     prot opt in     out     source               destination         
1    22785 6326K ACCEPT     all  --  *      *       0.0.0.0/0            0.0.0.0/0           state RELATED,ESTABLISHED 
2        0     0 ACCEPT     udp  --  eth1   *       192.168.0.0/16       0.0.0.0/0           multiport dports 137,138 state NEW 
3        2   120 ACCEPT     tcp  --  eth1   *       192.168.0.0/16       0.0.0.0/0           multiport dports 139,445 state NEW 
4       10   584 ACCEPT     tcp  --  *      *       0.0.0.0/0            0.0.0.0/0           tcp dpt:22 state NEW 
5       18  1080 ACCEPT     all  --  lo     *       0.0.0.0/0            0.0.0.0/0           state NEW 
6        2   144 ACCEPT     icmp --  *      *       0.0.0.0/0            0.0.0.0/0           state NEW 
7    12728 1068K REJECT     all  --  *      *       0.0.0.0/0            0.0.0.0/0           reject-with icmp-host-prohibited 

Chain FORWARD (policy DROP 0 packets, 0 bytes)
num   pkts bytes target     prot opt in     out     source               destination         
1    36828   34M ACCEPT     all  --  *      *       0.0.0.0/0            0.0.0.0/0           state RELATED,ESTABLISHED 
2     3443  207K ACCEPT     tcp  --  *      *       192.168.0.0/16       0.0.0.0/0           tcp spts:1024:65535 state NEW 
3      174 11240 ACCEPT     udp  --  *      *       192.168.0.0/16       0.0.0.0/0           udp spts:1024:65535 state NEW 
4        7   588 ACCEPT     icmp --  *      *       0.0.0.0/0            0.0.0.0/0           state NEW 
5       39  2124 REJECT     all  --  *      *       0.0.0.0/0            0.0.0.0/0           reject-with icmp-host-prohibited 

Chain OUTPUT (policy DROP 0 packets, 0 bytes)
num   pkts bytes target     prot opt in     out     source               destination         
1    22312 3900K ACCEPT     all  --  *      *       0.0.0.0/0            0.0.0.0/0           state RELATED,ESTABLISHED 
2      794 47640 ACCEPT     tcp  --  *      *       0.0.0.0/0            0.0.0.0/0           tcp spts:1024:65535 state NEW 
3     1021 68127 ACCEPT     udp  --  *      *       0.0.0.0/0            0.0.0.0/0           udp spts:1024:65535 state NEW 
4       13  1188 ACCEPT     icmp --  *      *       0.0.0.0/0            0.0.0.0/0           state NEW 
5    14518 1240K REJECT     all  --  *      *       0.0.0.0/0            0.0.0.0/0           reject-with icmp-host-prohibited 

[ Table: nat ]

Chain PREROUTING (policy ACCEPT 16181 packets, 1264K bytes)
num   pkts bytes target     prot opt in     out     source               destination         

Chain POSTROUTING (policy ACCEPT 1754 packets, 109K bytes)
num   pkts bytes target     prot opt in     out     source               destination         
1     2941  177K MASQUERADE  all  --  *      *       192.168.0.0/16       0.0.0.0/0           

Chain OUTPUT (policy ACCEPT 15834 packets, 1320K bytes)
num   pkts bytes target     prot opt in     out     source               destination         


root@home:/home/grzesiek#

Krótki komentarz do każdej z linii:
INPUT
1 Linia: przepuszcza pakiety powrotne z połączeń, które wcześniej zainicjowaliśmy
2 Linia: przepuszcza ruch dla usługi Samba z sieci lokalnej, czyli nie przychodzącego z internetu - interfejs eth2 w moim przypadku
3 Linia: jw. porty TCP
4 Linia: zezwala na łączenie się przez SSH z każdego miejsca
5 Linia: zezwala na połączenia z interfejsem zwrotnym lo
6 Linia: zezwala na odbieranie komunikatów ICMP, czyli np. używanie polecenia ping
7 Linia: w tym miejscu wszystkie przewidziane, a tym samym dozwolone możliwości dla ruchu przychodzącego się wyczerpały, można by nie robić nic i pakiety zostałyby odrzucone ale optymalniej będzie odsyłać określony w tej regule komunikaty do nadawcy

FORWARD
1 Linia: przekazuje pakiety z połączeń, które wcześniej zainicjowali użytkownicy naszej sieci wewnętrznej - LAN
2 Linia: zezwala na przekazywanie pakietów protokołu TCP z naszej sieci do serwerów w internecie jeżeli pochodzą z portów aplikacji klienckich (1024-65535)
3 Linia: jw. porty UDP
4 Linia: zezwala na przekazywanie komunikatów ICMP między siecią WAN a LAN
5 Linia: pozostałe pakiety są odrzucane, a dla nadawcy wysyłany jest komunikat ICMP informujący, iż połączenie zostało zabronione

OUTPUT
1 Linia: zezwala na wysyłanie odpowiedzi na połączenia zezwolone przez łańcuchu INPUT
2 Linia: zezwala na wysyłanie z naszego komputera pakietów protokołu TCP do serwerów w internecie jeżeli pochodzą z portów aplikacji klienckich (1024-65535)
3 Linia: jw. porty UDP
4 Linia: zezwala na wysyłanie komunikatów ICMP z naszego komputera
5 Linia: pozostałe pakiety są odrzucane, a dla nadawcy wysyłany jest komunikat ICMP informujący, iż połączenie zostało zabronione - czyli nam :)

Czas na małe sprawdzenie, najpierw sprawdzimy jak wygląda nasza zapora z zewnątrz:

grzesiek@bvm1XX:~$ nmap 7X.X6.2X.XX5 -PN

Starting Nmap 4.62 ( http://nmap.org ) at 2010-11-07 15:18 CET
Interesting ports on PC-7X-X6-2X-XX5.xxxx-net.pl (7X.X6.2X.XX5):
Not shown: 1714 filtered ports
PORT STATE SERVICE
22/tcp open ssh

Nmap done: 1 IP address (1 host up) scanned in 8.701 seconds

oraz z sieci wewnętrznej:

[root@localhost grzesiek]# nmap 192.168.42.1 -PN

Starting Nmap 5.21 ( http://nmap.org ) at 2010-11-07 17:29 CET
Nmap scan report for 192.168.42.1
Host is up (0.00025s latency).
Not shown: 997 filtered ports
PORT STATE SERVICE
22/tcp open ssh
139/tcp open netbios-ssn
445/tcp open microsoft-ds

MAC Address: 0A:00:27:00:00:00 (Unknown)

Nmap done: 1 IP address (1 host up) scanned in 5.43 seconds
[root@localhost grzesiek]#


Jak widać wszystko jest zablokowane, oprócz tego na co zezwoliliśmy, podczas gdy możemy bez problemów korzystać z komputera. Gdyby jednak znalazły się jakieś błędy albo należało dodać jakąś funkcjonalność proszę o komentarze. Jak pisałem wcześniej zapora była tworzona szybko więc może czegoś nie przewidziałem.

Miało być krótko a wyszło jak zwykle :)

Saturday, July 10, 2010

Fraktale - film dokumentalny

Jeżeli interesujesz bądź interesowałeś się programowaniem na pewno słyszałeś o fraktalach, ale czy wiesz do czego jeszcze mogą one służyć poza rysowaniem fajnych wzorów na ekranie komputera. Rozwój komputerów umożliwił stosowanie matematyki fraktalnej w wielu dziedzinach nauki. Z filmu dowiesz się między innymi o tym, że w Twojej komórce użyto anteny fraktalnej.