Code:
|=-----------------------------------------------------------------------=|
|=------------=[ T C P   S e s s i o n   H i j a c k i n g ]=------------=|
|=-----------------------------------------------------------------------=|
|=-----------------------=[      by Cheese      ]=-----------------------=|
|=-----------------------=[ cheese[at]mymail.ch ]=-----------------------=|
|=-----------------------=[ http://cheese.5x.to ]=-----------------------=|
|=-----------------------------------------------------------------------=|


---=[ Contents

    [0x01] - Einführung
    
    [0x02] - Theorie
        [0x02a] - TCP Sessions
        [0x02b] - Man-in-the-Middle
        [0x02c] - Session Hijack
    
    [0x03] - Praxis
        [0x03a] - Tools
        [0x03b] - Scenario
        [0x03c] - Angriff

    [0x04] - Outro



---=[ 0x01 - Einführung

        Hallo Leser, dieses Paper soll dir die Grundlagen sowie die
    Ausführung von Hijacking Angriffen auf TCP Sitzungen näher bringen.
    Mit Hijacking meine ich eine unrechtmäßige Übernahme einer Verbindung.
    Passwortabfragen werden normalerweise nur beim beginn einer Sitzung
    durchgeführt, mit einer Übernahme einer bestehenden Verbindung kann
    so diese Abfrage umgangen werden.


---=[ 0x02 - Theorie

-------=[ 0x02a - TCP Sessions

        Beim aufbauen einer TCP Verbindung beginnt der Client indem er ein
    SYN-Packet (SYN=synchronize) mit einer Sequenznummer sendet. Diese
    Sequenznummer wird benutzt um eine Übertragung in der richtigen
    Reihenfolge zu versichern. Sie wird mit jedem Packet um 1 erhöht.
    Jede Seite der Übertragung wartet auf ein Packet mit einer bestimmten 
    Sequenznummer, ist die des ankommenden Paketes höher wird es
    zurückgelegt bis es an der Reihe ist, ist sie niedriger wird es als
    veraltet gewertet und somit verworfen. Die erste Sequenznummer ist
    zufällig.
        Der Server antwortet mit einem SYN/ACK-Packet (ACK=acknowledgment)
    welches die Sequenznummer des Cleints+1 enthält sowie eine eigene
    Start-Sequenznummer. Der Client bestätigt mit einem ACK Packet welches
    wiederum die Sequenznummer des Servers+1 enthält, damit ist die
    Verbindung aufgebaut.
    
                +---+       syn seq=x       +---+
                | C | ------------------->  | S |
                | L |                       | E |
                | I |   syn ack=x+1 seq=y   | R |
                | E | <-------------------- | V |
                | N |                       | E |
                | T |    ack=y+1 seq=x+1    | R |
                +---+ --------------------> +---+
                
        Möchte man eine Session übernehmen ist eine Bedingung das man
    Pakete mit der richtigen Sequenznummer sendet, da sie sonst verworfen
    werden. Um an die Richtige Sequenznummer zu kommen gibt es zwei
    Möglichkeiten.
    
        Möglichkeit A: 
            Man versucht die Sequenznummer zu erraten. Sie besteht aus
            32Bit und hat damit _nur_ 4294967296 Möglichkeiten, viel Glück!
            
        Möglichkeit B:
            Man snifft die bestehende Verbindung, dies geht in Netzwerken
            welche HUBs benutzen ohne Probleme, aber um dies in einem 
            Netzwerk mit Switchen zu realisieren gibt es nur einen Weg:
                Man-in-the-Middle!

                
-------=[ 0x02b - Man-in-the-Middle

        Um Man-in-the-Middle zu werden benutzen wir ARP Poisoning.
    ARP (Address Resolution Protocol) weist IP Adressen MAC Adressen zu
    um eine Übertragung im Ethernet zu ermöglichen. Ihr solltet euch
    über dieses Protokoll informieren wenn euch das fremd ist.
        Um  den Datenverkehr zwischen 2 Hosts abzuhören sendet der
    Attacker ein manipuliertes ARP Packet an einen der Hosts welches die IP
    vom zweiten Host und die Mac vom Attacker enthält. Dadurch sendet er
    jedes Packet welches eigentlich für den zweiten Host bestimmt ist zum
    Attacker. Das gleiche macht man mit dem anderen Host, der Attacker
    selbst leitet jedes Packet zum eigentlichen Ziel weiter, somit agiert
    er als unbemerkte Zwischenstelle, als Man-in-the-Middle.
    
    
    +------+                                             +------+
    |HOST-A| -------------------SWITCH------------------ |HOST-B|
    +------+   .................  |  .................   +------+
                               :  |  :
                               :  |  :
                               :  |  :
                               :  |  :
                              +--------+
        Hello [A], I am [B] > |ATTACKER| < Hello [B], I am [A]
                              +--------+



-------=[ 0x02c - Session Hijack

        Hijackbar ist jede unverschlüsselte Verbindung. 
    Wir beginnen mit der Man-in-the-Middle attack zwischen dem Zielhost
    und dem Server, wenn der Server nicht im gleichen Subnet ist (Internet)
    greifen wir statt dem Server das Gateway an. Wenn dieser Angriff
    erfolgreich ist können wir alle Verbindungen von unserem Computer aus
    mit einem Packetsniffer überwachen.
    
        Wenn wir eine Verbindung Hijacken wollen warten wir auf ein Packet
    und übernehmen alle Infos aus diesem: Quell-IP, Ziel-IP, Quell-Port
    Ziel-Port sowie die Sequenznummer. Mit diesen Daten erzeugen wir ein
    eigenes Packet und sendet es zum Server. Der Server akzeptiert es
    und erhöht die erwartete Sequenznummer des nächsten Paketes.
    Sobald das echte Packet vom echten Client ankommt wird der Server es
    als Veraltet verwerfen, der Client ist somit desynchronisiert und 
    verliert die Verbindung. Die Verbindung wird nun zwischen Server und
    Attacker weitergeführt.
    

---=[ 0x03 - Praxis
    
-------=[ 0x03a - Tools

        Es existieren einige Programme welchen den kompletten Vorgang
    übernehmen können (Hunt,Juggernaut,T-Sight), jedoch hatte ich in 
    meinen Vorbereitungen einige Probleme mit diesen.

        Für die Man-in-the-Middle angriff werde ich das weit verbreitete
    Programm "Ettercap" benutzen. "Wireshark" kommt als Packetsniffer 
    zum Einsatz. Den Hijack werde ich mit "Shijack" durchführen.
    Das ganze passiert mit einer Linux/GNU Maschine.
    
     Shijack: http://packetstormsecurity.org/sniffers/shijack.tgz
     
     
-------=[ 0x03b - Scenario

        Unser Ziel ist es eine Telnet Verbindung zwischen einem Client
    und einem Server zu Hijacken.
    
    Netzwerk:
    
       +--------+                                 +--------+
       | SERVER | <.......T..E..L..N..E..T......> | CLIENT |
       |10.0.0.1| --------------+  +--------------|10.0.0.2|
       +--------+               |  |              +--------+
                                |  |
                              +------+
                              |SWITCH|
                              +------+
                                 | 
                                 |
                             +--------+
                             |ATTACKER|
                             |10.0.0.3|
                             +--------+

                        
 -------=[ 0x03c - Angriff
 
        Wie schon oft erwähnt beginnen wir mit dem MitM Angriff.
    Ettercap wird im GTK Modus gestartet und wir Aktiviren im Sniff Menu
    "Unified sniffing". Als Network interface eth0 und weiter geht es
    mit einem klick auf "Scan for hosts" im Hosts Menu. Nachdem der scan 
    beendet ist lasse ich mir im selben Menu mit "Host list" die Hosts
    anzeigen. 10.0.0.1 -> Add to Target 1, 10.0.0.2 -> Add to Target 2.
    "Start sniffing" im Start Menu und "Arp poisoning" im Mitm Menu.

        Als nächstes wird "Wireshark" gestartet und mit "List the avaible
    capture interfaces..." eine liste der Interfaces geholt und das
    Sniffing kann beginnen. Wir warten bis ein beliebiges Packet der Telnet
    Verbindung gesendet wird. Wenn wir es anwählen können wir alle Infos
    sehen.
    bsp:
        Source IP        10.0.0.2
        Destination IP   10.0.0.1
        Source Port      53517
        Destination Port 23
    
        Nun kommen wir zum Hijack mit "Shijack", nachdem Shijack
    erfolgreich Compiled wurde (wenn es Probleme beim compilen gibt nehmt
    die Binarys die dabei sind) können wir es starten.
#    
#cheese:/home/cheese/hijack# ./shijack
#Usage: ./shijack <interface> <src ip> <src port> <dst ip> <dst port> [-r]
#<interface>             The interface you are going to hijack on.
#<src ip>                The source ip of the connection.
#<src port>              The source port of the connection.
#<dst ip>                The destination IP of the connection.
#<dst port>              The destination port of the connection.
#[-r]                    Reset the connection rather than hijacking it.
#

        OK das ist simpel. 
        
#        
#cheese:/home/cheese/hijack# ./shijack eth0 10.0.0.2 53517 10.0.0.1 23
#

        Und ATTACKE!!! :>
        
#        
#Waiting for SEQ/ACK  to arrive from the srcip to the dstip.
#(To speed things up, try making some traffic between the two)
#

        Das Tool läuft und wartet auf ein weiteres Packet um eine
    funktionierende Sequenznummer zu bekommen. Sobald etwas über die
    Telnet Verbindung gesendet wird springt es an!
    
#
#Got packet! SEQ = 0xad6e5b8e ACK = 0x5ebaf20d
#Starting hijack session, Please use ^C to terminate.
#Anything you enter from now on is sent to the hijacked TCP connection.
#

        Hijack erfolgreich! Nun können wir beliebige Befehle über
    die TCP Verbindung senden.
    
    
---=[ 0x04 - Outro

        Alle unverschlüsselten Verbindungen sind Theoretisch anfällig
    für TCP Session Hijacking, obwohl es oft einfacher ist das Passwort
    zu sniffen sehe ich es trotzdem als gefährliche Technik denn auch
    Einmal-Passwörter wie TAN oder Security Token sind dadurch
    umgeh bar.
        Ich hoffe euch hat der Einblick ins Hijacking gefallen.
        
       
                    -Thx for reading-
        
    
    
    
    Written by : Cheese <cheese[at]mymail.ch>
         Visit : cheese.5x.to!
               : Back2Hack.cc
http://cheese.pytalhost.org/tutorials/tcp_hijack.txt