通过前面几篇关于有效ip发现的文章介绍后，接下来就是对于这些活着的主机进行端口扫描的介绍了。

端口对应了网络服务及应用端程序，服务的程序的漏洞通过端口攻入；通过开放的端口，可以进行更具体、更高效的攻击。

UDP端口扫描

一般都会假设ICMP Port Unreachable响应代表端口关闭，不过当目标系统设置了不响应ICMP Port Unreachable时，就会存在误判的情况。

当然还可以通过完整的UDP应用层请求来进行端口扫描，虽然能提升准确性，但是会消耗大量时间。

UDP端口扫描：scapy

最好去了解每一种基于UDP的应用层包结构，对于使用udp来进行端口扫描的工作会很有帮助。

直接上代码吧：

#!/usr/bin/Python/ target=_blank class=infotextkey>Python3

import logging
logging.getLogger('scapy.runtime').setLevel(logging.ERROR)
import time
import sys
from scapy.all import *

if len(sys.argv) != 4:
	print('Usage ./udp_port_scan.py [Target-IP] [First Port] [Last Port]')
	print('Example ./udp_port_scan.py 172.18.14.1 1 100')
	print('Example will UDP port scan ports 1 through 100 on 172.18.14.1')
	sys.exit()

ip = str(sys.argv[1])
start = int(sys.argv[2])
end = int(sys.argv[3])

for port in range(start, end):
	a = sr1(IP(dst=ip)/UDP(dport=port), timeout=5, verbose=0)
	time.sleep(1)
	if a == None:
		print(port)
	else:
		pass

执行结果就是这样：

执行结果

可以看到结果显示没有一个端口是开放的，这个结果可能有问题，将端口范围加大一些再试试：

./udp_port_scan.py 192.168.31.168 1 150

扫出一个开放的端口，可以参考一下，但不要完全相信。

UDP端口扫描：nmap

使用nmap进行udp的端口扫描，需要传的参数是-sU，不指定端口的话以前默认是扫描1000个常用的端口，如果通过-p指定端口的话，就只会对指定端口进行扫描：

nmap -sU 192.168.31.168

当然通过-p也是可以传递端口范围的，比如这样：

nmap -sU 192.168.31.168 -p1-100

也能通过-iL传递指定文档里的ip进行端口扫描：

nmap -iL ip.txt -sU -p1-100

TCP端口扫描

使用tcp端口扫描，主要是基于连接协议，基于三次握手的。可以实现隐蔽扫描、僵尸扫描、全连接扫描，所有的tcp扫描方式，都是基于三次握手的变化来判断目标端口状态。

隐蔽扫描是只发syn包，不建立完整连接，应用日志不记录扫描行为，所以相对比较隐蔽，在网络层还是会留下记录。

僵尸扫描比前一个隐蔽扫描更加隐蔽，实施条件比较苛刻（现在伪造来源地址比较困难），可伪造来源地址，选择僵尸机（闲置系统、系统使用递增的IPID，IPID不可以是0或者随机产生的）

僵尸扫描目标端口打开

1.扫描者向僵尸机发送一个SYN/ACK，僵尸机回复一个RST，并取得僵尸机的IPID，假设为x；

2.扫描者伪造来源为僵尸机，向目标主机发送一个SYN，然后目标主机给僵尸机返回一个SYN/ACK的RST，僵尸机收到后给目标主机返回一个RST，并且IPID加1；

3.然后扫描者再次向僵尸机发送一个SYN/ACK，如果收到僵尸机返回的RST中IPID比第1步中收到IPID大2，就是目标机器端口处于打开状态，如果大1则处于关闭状态。

僵尸扫描目标端口关闭

隐蔽的端口扫描：scapy

隐蔽端口扫描的定义已经在前面说过了，这里直接用scapy来演示具体操作：

a = sr1(IP(dst='36.152.44.96')/TCP(flags='S',dport=80), timeout=1, verbose=0)

从结果来看，目标机器的80端口是开放的。

然后通过抓包工具看一下：

wireshark抓包

可以看到我的机器又回来一个rst包给目标主机，这个不是scapy发的，是当前机器的系统内核自动发送的，后面会讲到如何处理这种rst包，避免对后续安全工作的干扰。

如果遇到端口没有开放会有两种可能，第一种就是啥都不回复，另一种就是回复一个flags为RA的数据包。

用前面的内容写一个python脚本：

#!/usr/bin/python3

import logging
logging.getLogger('scapy.runtime').setLevel(logging.ERROR)
import sys
from scapy.all import *

if len(sys.argv) != 4:
	print('Usage ./syn_port_scan.py [Target-IP] [First Port] [Last Port]')
	print('Example ./syn_port_scan.py 172.18.14.1 1 100')
	print('Example will TCP SYN port scan ports 1 through 100 on 172.18.14.1')
	sys.exit()

ip = str(sys.argv[1])
start = int(sys.argv[2])
end = int(sys.argv[3])

for port in range(start, end):
	a = sr1(IP(dst=ip)/TCP(dport=port, flags='S'), timeout=1, verbose=0)
	if a == None:
		pass
	else:
		if int(a[TCP].flags) == 18:
			print(port)
		else:
			pass

脚本中最后用18作为判断依据的原因可以看抓包中的数据：

SYN,ACK的抓包数据

可以看出来SYN,ACK转换成10进制后就是18。

执行方式还是一样，先赋予权限，然后传入正确的参数：

./syn_port_scan.py 36.152.44.96 50 200

隐蔽的端口扫描：nmap

scapy毕竟还要写好几行代码，实际工作中都是怎么简单高效怎么来。所以我们可以选择nmap来做隐蔽的端口扫描。

nmap使用syn做端口扫描只需要使用参数-sS：

nmap -sS 36.152.44.96 -p 1-100

有时候nmap的扫描结果里会有一些fAIl、close、filtered，如果不想要这些结果，只想知道open的端口的话，可以加个参数--open。

nmap也可以通过传递指定端口集合来扫描指定的端口：

nmap 36.152.44.238 -sS -p 50,80,88,90

隐蔽的端口扫描：hping3

hping3可以通过参数-S来使用syn进行扫描：

hping3 36.152.44.238 --scan 1-100 -S

hping3有一个伪装来源地址的参数--spoof：

hping3 -c 100 -S --spoof 192.168.10.13 -p ++1 36.152.44.238

其中-c表示发多少数量的包，-p ++1表示端口号每次加一，但是由于伪装了源地址，目标机器就算端口开放，发出来的synack数据包，也不会是我的主机，肯定是僵尸机。

全连接的端口扫描：scapy

全连接扫描只有在特殊情况下使用，很容易被防火墙发现。

scapy做全连接的端口扫描其实是有点麻烦的。因为syn扫描不需要raw packets，系统内核认为目标机器返回的syn/ack是非法包，直接发送rst终断连接。

在不解决系统内核自动发送RST时，用下面的脚本尝试一下全连接的端口扫描：

#!/usr/bin/python3

import logging
logging.getLogger('scapy.runtime').setLevel(logging.ERROR)
import sys
from scapy.all import *

SYN = IP(dst='36.152.44.238')/TCP(dport=80, flags='S')

print('--- SENT ---')
SYN.display()

print('nn ---RECEIVED---')
response = sr1(SYN, timeout=1, verbose=0)
response.display()

if int(response[TCP].flags) == 18:
	print('nn --- SENT')
	A = IP(dst='36.152.44.238')/TCP(dport=80, flags='A', ack=(response[TCP].seq + 1))
	A.display()
	print('nn ---RECEIVED---')
	response2 = sr1(A, timeout=1, verbose=0)
	response2.display()
else:
	print('SYN-ACK not returned')

抓包的结果：

未关闭系统内核发送RST时的执行结果

从抓包结果里看出这台目标服务器虽然没有回复RST，但是也没有真正建立连接。不过有些服务器会将收到RST包后过来的ACK包拒绝掉，直接返回一个RST过来。

可以通过iptables的命令将去往指定目标ip的数据包过滤掉：

iptables -A OUTPUT -p tcp --tcp-flags RST RST -d 36.152.44.238 -j DROP 

执行上面这个命令后，在执行脚本，就是这样的结果：

内核没有在发送RST数据包

虽然系统内核的确是没有发送RST数据包了，但是从执行结果看也是有问题的。可能是目标机器的防火墙功能比较强大，也可能是脚本的逻辑存在问题，如果有同学对这个感兴趣，可以私信我一起研究一下，这里就先这样吧。

全连接的端口扫描：nmap

通过传递参数-sT来使用nmap的全连接端口扫描：

nmap 36.152.44.238 -sT -p 70-90

在抓包工具中可以看到：

80端口建立起了连接

全连接的端口扫描：nc

nc也是可以做扫描工具的，只需要使用参数-z：

nc -nv -w 1 -z 36.152.44.238 70-90

僵尸扫描

僵尸扫描的定义已经在前面说过了，这里直接来介绍具体实现，分别用scapy和nmap。

需要先假设有了一台可以使用的僵尸机。

僵尸扫描：scapy

直接上脚本吧，应该都能看懂，如果有疑问，可以私信咨询我。脚本里主要是提供了两个方法，一个是校验不清楚僵尸机是否符合使用条件时调用，也就是最开始输入1的时候，另一个就是直接指定僵尸机和目标机器，直接进行扫描。

#!/usr/bin/python3

import logging
logging.getLogger('scapy.runtime').setLevel(logging.ERROR)
from scapy.all import *

def ipid(zombie):
    reply1 = sr1(IP(dst=zombie)/TCP(flags='SA'), timeout=2, verbose=0)
    send(IP(dst=zombie)/TCP(flags='SA'), verbose=0)
    reply2 = sr1(IP(dst=zombie)/TCP(flags='SA'), timeout=2, verbose=0)
    if reply2[IP].id == (reply1[IP].id+2):
        print('IPID sequence is incremental and target Appears to be idle. ZOMBIE LOCATED')
        response = input('Do you want to use this zombie to perform a scan?(Y or N): ')
        if response == 'Y':
            target = input('Enter the IP address of the target system: ')
            zombie_scan(target, zombie)
    else:
        print('Either the IPID sequence is not incremental or the target is not idle. NOT A GOOD ZOMBIE')

def zombie_scan(target, zombie):
        print('n Scanning target ' + target + ' with zombie ' + zombie)
        print('n ------ Open Ports on Target ------ n ')
        for port in range(1, 10000):
                try:
                        start_val = sr1(IP(dst=zombie)/TCP(flags='SA', dport=port), timeout=2, verbose=0)
                        send(IP(src=zombie, dst=target)/TCP(flags='S', dport=port), verbose=0)
                        end_val = sr1(IP(dst=zombie)/TCP(flags='SA'), timeout=2, verbose=0)
                        if end_val[IP].id == (start_val[IP].id + 2):
                                print(port)
                except:
                        pass

print('------Zombie Scan Suite------n')
print('1 - Identify Zombie Host n')
print('2 - Perform Zombie Scan n')
ans = input('Select an Option(1 or 2): ')
if ans == '1':
        zombie = input('Enter IP address to test IPID sequence: ')
        ipid(zombie)
else:
        if ans == '2':
                zombie = input('Enter IP address for zombie system: ')
                target = input('Enter IP address for scan target: ')
                zombie_scan(target, zombie)

我在网上找了一些机器，一时半会没找到合适的僵尸机，这里就不演示效果了。

僵尸扫描：nmap

nmap提供了专门用来检测指定机器是否是否作为僵尸机：

nmap -p端口 僵尸主机IP地址 --script=ipidseq.nse

如果能正常使用的话，在执行结果里会返回ipdi是否是递增的。

然后在有了合适的僵尸机以后，可以通过-sI参数来指定使用的僵尸机：

nmap 目标主机IP -sI 僵尸主机IP -Pn -p 端口号