端口扫描程序_开发端口扫描

如何用Scapy写一个端口扫描器

常见的端口扫描类型有：

1. TCP 连接扫描

2. TCP SYN 扫描(也称为半开放扫描或stealth扫描)

3. TCP 圣诞树(Xmas Tree)扫描

4. TCP FIN 扫描

5. TCP 空扫描(Null)

6. TCP ACK 扫描

7. TCP 窗口扫描

8. UDP 扫描

下面先讲解每种扫描的原理，随后提供具体实现代码。

TCP 连接扫描

客户端与服务器建立 TCP 连接要进行一次三次握手，如果进行了一次成功的三次握手，则说明端口开放。

客户端想要连接服务器80端口时，会先发送一个带有 SYN 标识和端口号的 TCP 数据包给服务器(本例中为80端口)。如果端口是开放的，则服务器会接受这个连接并返回一个带有 SYN 和 ACK 标识的数据包给客户端。随后客户端会返回带有 ACK 和 RST 标识的数据包，此时客户端与服务器建立了连接。如果完成一次三次握手，那么服务器上对应的端口肯定就是开放的。

当客户端发送一个带有 SYN 标识和端口号的 TCP 数据包给服务器后，如果服务器端返回一个带 RST 标识的数据包，则说明端口处于关闭状态。

代码：

#! /usr/bin/python

import logging

logging.getLogger("scapy.runtime").setLevel(logging.ERROR)

from scapy.all import *

dst_ip = "10.0.0.1"

src_port = RandShort()

dst_port=80

tcp_connect_scan_resp = sr1(IP(dst=dst_ip)/TCP(sport=src_port,dport=dst_port,flags="S"),timeout=10)

if(str(type(tcp_connect_scan_resp))=="type 'NoneType'"):

print "Closed"

elif(tcp_connect_scan_resp.haslayer(TCP)):

if(tcp_connect_scan_resp.getlayer(TCP).flags == 0x12):

send_rst = sr(IP(dst=dst_ip)/TCP(sport=src_port,dport=dst_port,flags="AR"),timeout=10)

print "Open"

elif (tcp_connect_scan_resp.getlayer(TCP).flags == 0x14):

print "Closed"

TCP SYN 扫描

这个技术同 TCP 连接扫描非常相似。同样是客户端向服务器发送一个带有 SYN 标识和端口号的数据包，如果目标端口开发，则会返回带有 SYN 和 ACK 标识的 TCP 数据包。但是，这时客户端不会返回 RST+ACK 而是返回一个只带有 RST 标识的数据包。这种技术主要用于躲避防火墙的检测。

如果目标端口处于关闭状态，那么同之前一样，服务器会返回一个 RST 数据包。

代码：

#! /usr/bin/python

import logging

logging.getLogger("scapy.runtime").setLevel(logging.ERROR)

from scapy.all import *

dst_ip = "10.0.0.1"

src_port = RandShort()

dst_port=80

stealth_scan_resp = sr1(IP(dst=dst_ip)/TCP(sport=src_port,dport=dst_port,flags="S"),timeout=10)

if(str(type(stealth_scan_resp))=="type 'NoneType'"):

print "Filtered"

elif(stealth_scan_resp.haslayer(TCP)):

if(stealth_scan_resp.getlayer(TCP).flags == 0x12):

send_rst = sr(IP(dst=dst_ip)/TCP(sport=src_port,dport=dst_port,flags="R"),timeout=10)

print "Open"

elif (stealth_scan_resp.getlayer(TCP).flags == 0x14):

print "Closed"

elif(stealth_scan_resp.haslayer(ICMP)):

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

print "Filtered"

TCP 圣诞树(Xmas Tree)扫描

在圣诞树扫描中，客户端会向服务器发送带有 PSH,FIN,URG 标识和端口号的数据包给服务器。如果目标端口是开放的，那么不会有任何来自服务器的回应。

如果服务器返回了一个带有 RST 标识的 TCP 数据包，那么说明端口处于关闭状态。

但如果服务器返回了一个 ICMP 数据包，其中包含 ICMP 目标不可达错误类型3以及 ICMP 状态码为1，2，3，9，10或13，则说明目标端口被过滤了无法确定是否处于开放状态。

代码：

#! /usr/bin/python

import logging

logging.getLogger("scapy.runtime").setLevel(logging.ERROR)

from scapy.all import *

dst_ip = "10.0.0.1"

src_port = RandShort()

dst_port=80

xmas_scan_resp = sr1(IP(dst=dst_ip)/TCP(dport=dst_port,flags="FPU"),timeout=10)

if (str(type(xmas_scan_resp))=="type 'NoneType'"):

print "Open|Filtered"

elif(xmas_scan_resp.haslayer(TCP)):

if(xmas_scan_resp.getlayer(TCP).flags == 0x14):

print "Closed"

elif(xmas_scan_resp.haslayer(ICMP)):

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

print "Filtered"

TCP FIN扫描

FIN 扫描会向服务器发送带有 FIN 标识和端口号的 TCP 数据包。如果没有服务器端回应则说明端口开放。

如果服务器返回一个 RST 数据包，则说明目标端口是关闭的。

如果服务器返回了一个 ICMP 数据包，其中包含 ICMP 目标不可达错误类型3以及 ICMP 代码为1，2，3，9，10或13，则说明目标端口被过滤了无法确定端口状态。

代码：

#! /usr/bin/python

import logging

logging.getLogger("scapy.runtime").setLevel(logging.ERROR)

from scapy.all import *

dst_ip = "10.0.0.1"

src_port = RandShort()

dst_port=80

fin_scan_resp = sr1(IP(dst=dst_ip)/TCP(dport=dst_port,flags="F"),timeout=10)

if (str(type(fin_scan_resp))=="type 'NoneType'"):

print "Open|Filtered"

elif(fin_scan_resp.haslayer(TCP)):

if(fin_scan_resp.getlayer(TCP).flags == 0x14):

print "Closed"

elif(fin_scan_resp.haslayer(ICMP)):

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

print "Filtered"

TCP 空扫描(Null)

在空扫描中，客户端发出的 TCP 数据包仅仅只会包含端口号而不会有其他任何的标识信息。如果目标端口是开放的则不会回复任何信息。

如果服务器返回了一个 RST 数据包，则说明目标端口是关闭的。

如果返回 ICMP 错误类型3且代码为1，2，3，9，10或13的数据包，则说明端口被服务器过滤了。

代码：

#! /usr/bin/python

import logging

logging.getLogger("scapy.runtime").setLevel(logging.ERROR)

from scapy.all import *

dst_ip = "10.0.0.1"

src_port = RandShort()

dst_port=80

null_scan_resp = sr1(IP(dst=dst_ip)/TCP(dport=dst_port,flags=""),timeout=10)

if (str(type(null_scan_resp))=="type 'NoneType'"):

print "Open|Filtered"

elif(null_scan_resp.haslayer(TCP)):

if(null_scan_resp.getlayer(TCP).flags == 0x14):

print "Closed"

elif(null_scan_resp.haslayer(ICMP)):

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

print "Filtered"

TCP ACK扫描

ACK 扫描不是用于发现端口开启或关闭状态的，而是用于发现服务器上是否存在有状态防火墙的。它的结果只能说明端口是否被过滤。再次强调，ACK 扫描不能发现端口是否处于开启或关闭状态。

客户端会发送一个带有 ACK 标识和端口号的数据包给服务器。如果服务器返回一个带有 RST 标识的 TCP 数据包，则说明端口没有被过滤，不存在状态防火墙。

如果目标服务器没有任何回应或者返回ICMP 错误类型3且代码为1，2，3，9，10或13的数据包，则说明端口被过滤且存在状态防火墙。

#! /usr/bin/python

import logging

logging.getLogger("scapy.runtime").setLevel(logging.ERROR)

from scapy.all import *

dst_ip = "10.0.0.1"

src_port = RandShort()

dst_port=80

ack_flag_scan_resp = sr1(IP(dst=dst_ip)/TCP(dport=dst_port,flags="A"),timeout=10)

if (str(type(ack_flag_scan_resp))=="type 'NoneType'"):

print "Stateful firewall presentn(Filtered)"

elif(ack_flag_scan_resp.haslayer(TCP)):

if(ack_flag_scan_resp.getlayer(TCP).flags == 0x4):

print "No firewalln(Unfiltered)"

elif(ack_flag_scan_resp.haslayer(ICMP)):

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

print "Stateful firewall presentn(Filtered)"

TCP窗口扫描

TCP 窗口扫描的流程同 ACK 扫描类似，同样是客户端向服务器发送一个带有 ACK 标识和端口号的 TCP 数据包，但是这种扫描能够用于发现目标服务器端口的状态。在 ACK 扫描中返回 RST 表明没有被过滤，但在窗口扫描中，当收到返回的 RST 数据包后，它会检查窗口大小的值。如果窗口大小的值是个非零值，则说明目标端口是开放的。

如果返回的 RST 数据包中的窗口大小为0，则说明目标端口是关闭的。

代码：

#! /usr/bin/python

import logging

logging.getLogger("scapy.runtime").setLevel(logging.ERROR)

from scapy.all import *

dst_ip = "10.0.0.1"

src_port = RandShort()

dst_port=80

window_scan_resp = sr1(IP(dst=dst_ip)/TCP(dport=dst_port,flags="A"),timeout=10)

if (str(type(window_scan_resp))=="type 'NoneType'"):

print "No response"

elif(window_scan_resp.haslayer(TCP)):

if(window_scan_resp.getlayer(TCP).window == 0):

print "Closed"

elif(window_scan_resp.getlayer(TCP).window 0):

print "Open"

UDP扫描

TCP 是面向连接的协议，而UDP则是无连接的协议。

面向连接的协议会先在客户端和服务器之间建立通信信道，然后才会开始传输数据。如果客户端和服务器之间没有建立通信信道，则不会有任何产生任何通信数据。

无连接的协议则不会事先建立客户端和服务器之间的通信信道，只要客户端到服务器存在可用信道，就会假设目标是可达的然后向对方发送数据。

客户端会向服务器发送一个带有端口号的 UDP 数据包。如果服务器回复了 UDP 数据包，则目标端口是开放的。

如果服务器返回了一个 ICMP 目标不可达的错误和代码3，则意味着目标端口处于关闭状态。

如果服务器返回一个 ICMP 错误类型3且代码为1，2，3，9，10或13的数据包，则说明目标端口被服务器过滤了。

但如果服务器没有任何相应客户端的 UDP 请求，则可以断定目标端口可能是开放或被过滤的，无法判断端口的最终状态。

代码：

#! /usr/bin/python

import logging

logging.getLogger("scapy.runtime").setLevel(logging.ERROR)

from scapy.all import *

dst_ip = "10.0.0.1"

src_port = RandShort()

dst_port=53

dst_timeout=10

def udp_scan(dst_ip,dst_port,dst_timeout):

udp_scan_resp = sr1(IP(dst=dst_ip)/UDP(dport=dst_port),timeout=dst_timeout)

if (str(type(udp_scan_resp))=="type 'NoneType'"):

retrans = []

for count in range(0,3):

retrans.append(sr1(IP(dst=dst_ip)/UDP(dport=dst_port),timeout=dst_timeout))

for item in retrans:

if (str(type(item))!="type 'NoneType'"):

udp_scan(dst_ip,dst_port,dst_timeout)

return "Open|Filtered"

elif (udp_scan_resp.haslayer(UDP)):

return "Open"

elif(udp_scan_resp.haslayer(ICMP)):

if(int(udp_scan_resp.getlayer(ICMP).type)==3 and int(udp_scan_resp.getlayer(ICMP).code)==3):

return "Closed"

elif(int(udp_scan_resp.getlayer(ICMP).type)==3 and int(udp_scan_resp.getlayer(ICMP).code) in [1,2,9,10,13]):

return "Filtered"

print udp_scan(dst_ip,dst_port,dst_timeout)

下面解释下上述代码中的一些函数和变量：

RandShort()：产生随机数

type()：获取数据类型

sport：源端口号

dport：目标端口号

timeout：等待相应的时间

haslayer()：查找指定层：TCP或UDP或ICMP

getlayer()：获取指定层：TCP或UDP或ICMP

以上扫描的概念可以被用于“多端口扫描”，源码可以参考这里：

Scapy 是一个非常好用的工具，使用它可以非常简单的构建自己的数据包，还可以很轻易的处理数据包的发送和相应。

（译者注：上述所有代码均在Kali 2.0下测试通过，建议读者在Linux环境下测试代码，如想在Windows上测试，请参见 Scapy官方文档 配置好scapy环境）

渗透测试之端口扫描

端口扫描:端口对应 *** 服务及应用端程序

服务端程序的漏洞通过端口攻入

发现开放的端口

更具体的攻击面

UDP端口扫描:

如果收到ICMP端口不可达,表示端口关闭

如果没有收到回包,则证明端口是开放的

和三层扫描IP刚好相反

Scapy端口开发扫描

命令:sr1(IP(dst="192.168.45.129")/UDP(dport=53),timeout=1,verbose=1)

nmap -sU 192.168.45.129

TCP扫描:基于连接的协议

三次握手:基于正常的三次握手发现目标是否在线

隐蔽扫描:发送不完整的数据包,不建立完整的连接,如ACK包,SYN包,不会在应用层访问,

僵尸扫描:不和目标系统产生交互,极为隐蔽

全连接扫描:建立完整的三次握手

所有的TCP扫描方式都是基于三次握手的变化来判断目标系统端口状态

隐蔽扫描:发送SYN数据包,如果收到对方发来的ACK数据包,证明其在线,不与其建立完整的三次握手连接,在应用层日志内不记录扫描行为,十分隐蔽, *** 层审计会被发现迹象

僵尸扫描:是一种极其隐蔽的扫描方式,实施条件苛刻,对于扫描发起方和被扫描方之间,必须是需要实现地址伪造,必须是僵尸机(指的是闲置系统,并且系统使用递增的IPID)早期的win xp,win 2000都是递增的IPID,如今的LINUX,WINDOWS都是随机产生的IPID

1,扫描者向僵尸机发送SYN+ACY,僵尸机判断未进行三次握手,所以返回RST包,在RST数据包内有一个IPID,值记为X,那么扫描者就会知道被扫描者的IPID

2,扫描者向目标服务器发送SYN数据包,并且伪装源地址为僵尸机,如果目标服务器端口开放,那么就会向僵尸机发送SYN+ACK数据包,那么僵尸机也会发送RST数据包,那么其IPID就是X+1(因为僵尸机足够空闲,这个就为其收到的第二个数据包)

3,扫描者再向僵尸机发送SYN+ACK,那么僵尸机再次发送RST数据包,IPID为X+2,如果扫描者收到僵尸机的IPID为X+2,那么就可以判断目标服务器端口开放

使用scapy发送数据包:首先开启三台虚拟机,

kali虚拟机:192.168.45.128

Linux虚拟机:192.168.45.129

windows虚拟机:192.168.45.132

发送SYN数据包:

通过抓包可以查看kali给linux发送syn数据包

linux虚拟机返回Kali虚拟机SYN+ACK数据包

kali系统并不知道使用者发送了SYN包,而其莫名其妙收到了SYN+ACK数据包,便会发RST包断开连接

也可以使用下列该命令查看收到的数据包的信息,收到对方相应的SYN+ACK数据包,scapy默认从本机的80端口往目标系统的20号端口发送,当然也可以修改

如果向目标系统发送一个 随机端口:

通过抓包的获得:1,kali向linux发送SYN数据包,目标端口23456,

2,Linux系统由自己的23456端口向kali系统的20号端口返回RST+ACK数据包,表示系统端口未开放会话结束

使用python脚本去进行scapy扫描

nmap做隐蔽端口扫描:

nmap -sS  192.168.45.129 -p 80,21,110,443 #扫描固定的端口

nmap -sS 192.168.45.129 -p 1-65535 --open  #扫描该IP地址下1-65535端口扫描,并只显示开放的端口

nmap -sS 192.168.45.129 -p --open  #参数--open表示只显示开放的端口

nmap -sS -iL iplist.txt -p 80

由抓包可知,nmap默认使用-sS扫描,发送SYN数据包,即nmap=nmap  -sS

hping3做隐蔽端口扫描:

hping3 192.168.45.129 --scan 80 -S  #参数--scan后面接单个端口或者多个端口.-S表示进行SYN扫描

hping3 192.168.45.129 --scan 80,21,25,443 -S

hping3 192.168.45.129 --scan 1-65535 -S

由抓包可得:

hping3 -c 100  -S  --spoof 192.168.45.200 -p ++1 192.168.45.129

参数-c表示发送数据包的数量

参数-S表示发送SYN数据包

--spoof:伪造源地址,后面接伪造的地址,

参数-p表示扫描的端口,++1表示每次端口号加1,那么就是发送SYN从端口1到端口100

最后面跟的是目标IP

通过抓包可以得知地址已伪造,但对于linux系统(192.168.45.129)来说,它收到了192.168.45.200的SYN数据包,那么就会给192.168.45.200回复SYN+ACK数据包,但该地址却是kali伪造的地址,那么要查看目标系统哪些端口开放,必须登陆地址为kali伪造的地址即(192.168.45.200)进行抓包

hping3和nmap扫描端口的区别:1,hping3结果清晰明了

  2,nmap首先对IP进行DNS反向解析,如果没成功,那么便会对其端口发送数据包,默认发送SYN数据包

hping3直接向目标系统的端口发送SYN数据包,并不进行DNS反向解析

全连接端口扫描:如果单独发送SYN数据包被被过滤,那么就使用全连接端口扫描,与目标建立三次握手连接,结果是最准确的,但容易被入侵检测系统发现

response=sr1(IP(dst="192.168.45.129")/TCP(dport=80,flags="S"))

reply=sr1(IP(dst="192.168.45.129")/TCP(dport=80,flags="A",ack=(response[TCP].seq+1)))

抓包情况:首先kali向Linux发送SYN,Linux回复SYN+ACK给kali,但kali的系统内核不清楚kali曾给linux发送给SYN数据包,那么kali内核莫名其妙收到SYN+ACK包,那么便会返回RST请求断开数据包给Linux,三次握手中断,如今kali再给Linux发ACK确认数据包,Linux莫名其妙收到了ACK数据包,当然也会返回RST请求断开数据包,具体抓包如下:

那么只要kali内核在收到SYN+ACK数据包之后,不发RST数据包,那么就可以建立完整的TCP三次握手,判断目标主机端口是否开放

因为iptables存在于Linux内核中,通过iptables禁用内核发送RST数据包,那么就可以实现

使用nmap进行全连接端口扫描:(如果不指定端口,那么nmap默认会扫描1000个常用的端口,并不是1-1000号端口)

使用dmitry进行全连接端口扫描:

dmitry:功能简单,但功能简便

默认扫描150个最常用的端口

dmitry -p 192.168.45.129  #参数-p表示执行TCP端口扫描

dmitry -p 192.168.45.129 -o output  #参数-o表示把结果保存到一个文本文档中去

使用nc进行全连接端口扫描:

nc -nv -w 1 -z 192.168.45.129 1-100:      1-100表示扫描1-100号端口

参数-n表示不对Ip地址进行域名解析,只把其当IP来处理

参数-v表示显示详细信息

参数-w表示超时时间

-z表示打开用于扫描的模式

什么是端口扫描？

一个端口就是一个潜在的通信通道，也就是一个入侵通道。对目标计算机进行端口扫描，能得到许多有用的信息。进行扫描的 *** 很多，可以是手工进行扫描，也可以用端口扫描软件进行。 在手工进行扫描时，需要熟悉各种命令。对命令执行后的输出进行分析。用扫描软件进行扫描时，许多扫描器软件都有分析数据的功能。 通过端口扫描，可以得到许多有用的信息，从而发现系统的安全漏洞。 什么是扫描器 扫描器是一种自动检测远程或本地主机安全性弱点的程序，通过使用扫描器你可一不留痕迹的发现远程服务器的各种TCP端口的分配及提供的服务和它们的软件版本！这就能让我们间接的或直观的了解到远程主机所存在的安全问题。 工作原理 扫描器通过选用远程TCP/IP不同的端口的服务，并记录目标给予的回答，通过这种 *** ，可以搜集到很多关于目标主机的各种有用的信息（比如：是否能用匿名登陆！是否有可写的FTP目录，是否能用TELNET，HTTPD是用ROOT还是nobady在跑！） 扫描器能干什么 扫描器并不是一个直接的攻击 *** 漏洞的程序，它仅仅能帮助我们发现目标机的某些内在的弱点。一个好的扫描器能对它得到的数据进行分析，帮助我们查找目标主机的漏洞。但它不会提供进入一个系统的详细步骤。 扫描器应该有三项功能：发现一个主机或 *** 的能力；一旦发现一台主机，有发现什么服务正运行在这台主机上的能力；通过测试这些服务，发现漏洞的能力。 编写扫描器程序必须要很多TCP/IP程序编写和C, Perl和或SHELL语言的知识。需要一些Socket编程的背景，一种在开发客户/服务应用程序的 *** 。开发一个扫描器是一个雄心勃勃的项目，通常能使程序员感到很满意。 常用的端口扫描技术 TCP connect() 扫描 这是最基本的TCP扫描。操作系统提供的connect()系统调用，用来与每一个感兴趣的目标计算机的端口进行连接。如果端口处于侦听状态，那么connect()就能成功。否则，这个端口是不能用的，即没有提供服务。这个技术的一个更大的优点是，你不需要任何权限。系统中的任何用户都有权利使用这个调用。另一个好处就是速度。如果对每个目标端口以线性的方式，使用单独的connect()调用，那么将会花费相当长的时间，你可以通过同时打开多个套接字，从而加速扫描。使用非阻塞I/O允许你设置一个低的时间用尽周期，同时观察多个套接字。但这种 *** 的缺点是很容易被发觉，并且被过滤掉。目标计算机的logs文件会显示一连串的连接和连接是出错的服务消息，并且能很快的使它关闭。 TCP SYN扫描 这种技术通常认为是“半开放”扫描，这是因为扫描程序不必要打开一个完全的TCP连接。扫描程序发送的是一个SYN数据包，好象准备打开一个实际的连接并等待反应一样（参考TCP的三次握手建立一个TCP连接的过程）。一个SYN|ACK的返回信息表示端口处于侦听状态。一个RST返回，表示端口没有处于侦听态。如果收到一个SYN|ACK，则扫描程序必须再发送一个RST信号，来关闭这个连接过程。这种扫描技术的优点在于一般不会在目标计算机上留下记录。但这种 *** 的一个缺点是，必须要有root权限才能建立自己的SYN数据包。 TCP FIN 扫描 有的时候有可能SYN扫描都不够秘密。一些防火墙和包过滤器会对一些指定的端口进行监视，有的程序能检测到这些扫描。相反，FIN数据包可能会没有任何麻烦的通过。这种扫描 *** 的思想是关闭的端口会用适当的RST来回复FIN数据包。另一方面，打开的端口会忽略对FIN数据包的回复。这种 *** 和系统的实现有一定的关系。有的系统不管端口是否打开，都回复RST，这样，这种扫描 *** 就不适用了。并且这种 *** 在区分Unix和NT时，是十分有用的。 IP段扫描 这种不能算是新 *** ，只是其它技术的变化。它并不是直接发送TCP探测数据包，是将数据包分成两个较小的IP段。这样就将一个TCP头分成好几个数据包，从而过滤器就很难探测到。但必须小心。一些程序在处理这些小数据包时会有些麻烦。 TCP 反向 ident扫描 ident 协议允许(rfc1413)看到通过TCP连接的任何进程的拥有者的用户名，即使这个连接不是由这个进程开始的。因此你能，举

如何扫描某一计算机开放的所有端口？

扫描某一计算机开放的所有端口可在windows系统输入-netstat -an即可。

一、打开端口的步骤：

1、首先，打开电脑的控制面板，然后在控制面板中找到防火墙。

2、在防火墙设置左边选择点击高级设置。

3、高级安全设置中，我们点击选择左边的入站规则。

4、在右侧栏选择点击新建规则。

5、规则类型选择端口类型。

6、选择tcp协议，特定端口，端口自己规定，比如4444。

7、何时应用规则，默认全选。

8、退出之后，我们就看到创建的入站规则，该端口允许。

二、端口分类：

1、硬件端口

CPU通过接口寄存器或特定电路与外设进行数据传送，这些寄存器或特定电路称之为端口。

其中硬件领域的端口又称接口，如：并行端口、串行端口等。

2、 *** 端口

在 *** 技术中，端口（Port）有好几种意思。集线器、交换机、路由器的端口指的是连接其他 *** 设备的接口，如RJ-45端口、Serial端口等。我们 这里所指的端口不是指物理意义上的端口，而是特指TCP/IP协议中的端口，是逻辑意义上的端口。

3、软件端口

缓冲区。

Python 实现端口扫描

一、常见端口扫描的原理

0、秘密扫描

秘密扫描是一种不被审计工具所检测的扫描技术。

它通常用于在通过普通的防火墙或路由器的筛选（filtering）时隐藏自己。

秘密扫描能躲避IDS、防火墙、包过滤器和日志审计，从而获取目标端口的开放或关闭的信息。由于没有包含TCP 3次握手协议的任何部分，所以无法被记录下来，比半连接扫描更为隐蔽。

但是这种扫描的缺点是扫描结果的不可靠性会增加，而且扫描主机也需要自己构造IP包。现有的秘密扫描有TCP FIN扫描、TCP ACK扫描、NULL扫描、XMAS扫描和SYN/ACK扫描等。

1、Connect()扫描

此扫描试图与每一个TCP端口进行“三次握手”通信。如果能够成功建立接连，则证明端口开发，否则为关闭。准确度很高，但是最容易被防火墙和IDS检测到，并且在目标主机的日志中会记录大量的连接请求以及错误信息。

TCP connect端口扫描服务端与客户端建立连接成功（目标端口开放）的过程：

① Client端发送SYN；

② Server端返回SYN/ACK，表明端口开放；

③ Client端返回ACK，表明连接已建立；

④ Client端主动断开连接。

建立连接成功（目标端口开放）

TCP connect端口扫描服务端与客户端未建立连接成功（目标端口关闭）过程：

① Client端发送SYN；

② Server端返回RST/ACK，表明端口未开放。

优点：实现简单，对操作者的权限没有严格要求（有些类型的端口扫描需要操作者具有root权限），系统中的任何用户都有权力使用这个调用，而且如果想要得到从目标端口返回banners信息，也只能采用这一 *** 。

另一优点是扫描速度快。如果对每个目标端口以线性的方式，使用单独的connect()调用，可以通过同时打开多个套接字，从而加速扫描。

缺点：是会在目标主机的日志记录中留下痕迹，易被发现，并且数据包会被过滤掉。目标主机的logs文件会显示一连串的连接和连接出错的服务信息，并且能很快地使它关闭。

2、SYN扫描

扫描器向目标主机的一个端口发送请求连接的SYN包，扫描器在收到SYN/ACK后，不是发送的ACK应答而是发送RST包请求断开连接。这样，三次握手就没有完成，无法建立正常的TCP连接，因此，这次扫描就不会被记录到系统日志中。这种扫描技术一般不会在目标主机上留下扫描痕迹。但是，这种扫描需要有root权限。

·端口开放：（1）Client发送SYN；（2）Server端发送SYN/ACK；（3）Client发送RST断开（只需要前两步就可以判断端口开放）

·端口关闭：（1）Client发送SYN；（2）Server端回复RST（表示端口关闭）

优点：SYN扫描要比TCP Connect()扫描隐蔽一些，SYN仅仅需要发送初始的SYN数据包给目标主机，如果端口开放，则相应SYN-ACK数据包；如果关闭，则响应RST数据包；

3、NULL扫描

反向扫描—-原理是将一个没有设置任何标志位的数据包发送给TCP端口，在正常的通信中至少要设置一个标志位，根据FRC 793的要求，在端口关闭的情况下，若收到一个没有设置标志位的数据字段，那么主机应该舍弃这个分段，并发送一个RST数据包，否则不会响应发起扫描的客户端计算机。也就是说，如果TCP端口处于关闭则响应一个RST数据包，若处于开放则无相应。但是应该知道理由NULL扫描要求所有的主机都符合RFC 793规定，但是windows系统主机不遵从RFC 793标准，且只要收到没有设置任何标志位的数据包时，不管端口是处于开放还是关闭都响应一个RST数据包。但是基于Unix(*nix,如Linux)遵从RFC 793标准，所以可以用NULL扫描。 经过上面的分析，我们知道NULL可以辨别某台主机运行的操作系统是什么操作系统。

端口开放：Client发送Null，server没有响应

端口关闭：（1）Client发送NUll；（2）Server回复RST

说明：Null扫描和前面的TCP Connect（）和SYN的判断条件正好相反。在前两种扫描中，有响应数据包的表示端口开放，但在NUll扫描中，收到响应数据包表示端口关闭。反向扫描比前两种隐蔽性高些，当精确度也相对低一些。

用途：判断是否为Windows系统还是Linux。

4、FIN扫描

与NULL有点类似，只是FIN为指示TCP会话结束，在FIN扫描中一个设置了FIN位的数据包被发送后，若响应RST数据包，则表示端口关闭，没有响应则表示开放。此类扫描同样不能准确判断windows系统上端口开 *** 况。

·端口开放：发送FIN，没有响应

·端口关闭：（1）发送FIN；（2）回复RST

5、ACK扫描

扫描主机向目标主机发送ACK数据包。根据返回的RST数据包有两种 *** 可以得到端口的信息。 *** 一是： 若返回的RST数据包的TTL值小于或等于64，则端口开放，反之端口关闭。

6、Xmas-Tree扫描

通过发送带有下列标志位的tcp数据包。

·URG：指示数据时紧急数据，应立即处理。

·PSH：强制将数据压入缓冲区。

·FIN：在结束TCP会话时使用。

正常情况下，三个标志位不能被同时设置，但在此种扫描中可以用来判断哪些端口关闭还是开放，与上面的反向扫描情况相同，依然不能判断windows平台上的端口。

·端口开放：发送URG/PSH/FIN，没有响应

·端口关闭：（1）发送URG/PSH/FIN，没有响应；（2）响应RST

XMAS扫描原理和NULL扫描的类似，将TCP数据包中的ACK、FIN、RST、SYN、URG、PSH标志位置1后发送给目标主机。在目标端口开放的情况下，目标主机将不返回任何信息。

7、Dump扫描

也被称为Idle扫描或反向扫描，在扫描主机时应用了第三方僵尸计算机扫描。由僵尸主机向目标主机发送SYN包。目标主机端口开发时回应SYN|ACK，关闭时返回RST，僵尸主机对SYN|ACK回应RST，对RST不做回应。从僵尸主机上进行扫描时，进行的是一个从本地计算机到僵尸主机的、连续的ping操作。查看僵尸主机返回的Echo响应的ID字段，能确定目标主机上哪些端口是开放的还是关闭的。

二、Python 代码实现

1、利用Python的Socket包中的connect *** ，直接对目标IP和端口进行连接并且尝试返回结果，而无需自己构建SYN包。

2、对IP端口进行多线程扫描，注意的是不同的电脑不同的CPU每次最多创建的线程是不一样的，如果创建过多可能会报错，需要根据自己电脑情况修改每次扫描的个数或者将seelp的时间加长都可以。

看完了吗？感觉动手操作一下把！

python学习网，免费的在线学习python平台，欢迎关注！

本文转自：