0x01 简介
今天用了用nmap的半连接扫描，不禁想知道半连接什么意思，它们有什么区别。
nmap扫描类型主要有TCP的全连接扫描(会在被扫描机器留下记录)，半连接扫描(不会留下记录)
0x02 原理

只有tcp三次握手完整才会在服务器留下记录，所以我们可以省略第三次握手，同样可以达到扫描的目的，但是不会在服务器留下记录。
我们先使用向服务器指定端口发送SYN请求，如果收到服务器的SYN+ACK回复，即可判断此端口开放，反之同理。

一、端口扫描简介
1.二三四层发现的目的只是为了准确发现所有存活的主机IP，确定攻击目标。端口扫描即发现开放端口，发现攻击点。一个端口就是一个潜在的通信通道，也就是一个入侵通道。对目标计算机进行端口扫描，能得到许多有用的信息。

2.进行端口扫描的原因

(1):端口对应网络服务及应用端程序

(2):服务端程序的漏洞通过端口攻入。

(3):通过发现的端口来放大攻击面
二、UDP端口扫描

原理:因为UDP是面向无连接的传输协议，尽最大努力传输。因此使用UDP来探测开启的端口的步骤如下：

(1):先向目标主机发送一个数据包并且目的端口是一个没有开启的端口(选择一个不常用并且尽可能大的端口)，如果收到数据包并且表明端口不可达，则表明主机存活。

(2):然后向目标主机发送需要测试的端口，如果收到数据包且表明端口不可达，则端口关闭；如果没有收到数据包，则端口开启
优点:速度快
缺点:准确性差

1.scapy

(1):探测主机是否存活

sr1(IP(dst=‘192.168.223.10’)/UDP(dport=8786),timeout=5,verbose=0).display()

IP(dst=‘192.168.223.10’):设置目标IP
UDP(dport=8786):设置目标端口
timeout=5:设置超时时间
verbose=0:verbose=0不显示详细信息，verbose=1显示详细信息





(2):探测端口是否开启



三、TCP端口扫描
TCP端口扫描可以分为两类:全连接扫描、半连接扫描

1.全连接扫描

原理:扫描者向目标主机发送一个SYN+SYN/ACK数据包，目标主机会回复一个ACK数据包。无法利用scapy模块进行全连接扫描，因为如果同时向目标主机发送一个SYN+SYN/ACK数据包，目标主机会认为这是一个错误的数据包，会直接回复一个RST。如果向目标主机发送一个SYN数据包，目标主机会回复一个SYN/ACK数据包，但是此时并没有再向目标主机发送ACK数据包，因此，全连接无法建立。(但是可以使用nmap中的-sT参数来进行全连接扫描)
优点:探测结果准确
缺点:会被目标主机的日志记录


(1):nmap

namp  -sT  IP地址

-sT:进行全连接扫描

可以使用-p来指定端口号或端口范围，不指定默认扫描前1000个端口




(2):dmitry

dmitry使用全连接进行扫描，默认扫描最常用的150个端口

dmitry  -p  IP地址




(3):nc

nc  -nv  -w  超时时间  -z  IP地址  端口号

-n表示跟数字内容，-v表示不做域名解析 -w表示超时时间  -z表示使用扫描模式



2.半连接扫描(也称为隐蔽扫描)

原理:扫描者向目标主机发送一个SYN，如果目标主机回复了一个SYN/ACK数据包，那么说明主机存活，如果收到一个RST/ACK数据包，那么主机没有存活。因为扫描者只向目标主机发送了SYN，并没有和目标主机进行连接，因此称为半连接。
优点:不会在目标主机的日志上有所记录
缺点:扫描结果不是很准确


(1):scapy




(2):nmap

nmap  -sS  IP地址

-sS:进程半连接扫描

可以使用-p来指定端口号或端口范围，不指定默认扫描前1000个端口




hping3

hping3  IP地址  --scan  目标端口  -S

原理简述：
端口扫描常见的一般有以下两种

 基于socket的connect全连接扫描（速度快，但是会在对方系统日志留下痕迹）
 基于scapy的SYN半连接扫描（不会被扫描的主机发现，速度慢。现在好像防火墙会有痕迹）

注意


 connect全连接扫描，基于socket套接字的connect方法，它的参数是一个元组(ip, port)，此扫描试图与每一个TCP端口进行“三次握手”通信。如果能够成功建立接连，则证明端口开发，否则为关闭。准确度很高。缺点：最容易被防火墙和IDS检测到，并且在目标主机的日志中会记录大量的连接请求以及错误信息。优点：另一优点是扫描速度快。如果对每个目标端口以线性的方式，使用单独的connect()调用，可以通过同时打开多个套接字，从而加速扫描。


 SYN半连接扫描，扫描IP段的全部端口部分的实现，基于scapy构造SYN数据包向目标主机的一个端口发送连接请求，当我们收到SYN/ACK包后，不发送的ACK应答而是发送RST包请求断开连接。这样，三次握手就没有完成，无法建立正常的TCP连接，因此，这次扫描就不会被记录到系统日志中，但是可能会在防火墙上留下痕迹。


1、Client发送SYN

2、Server端发送SYN/ACK

3、Client发送RST断开（只需要前两步就可以判断端口开放）


1、Client发送SYN

2、Server端回复RST（表示端口关闭）

输入：

是一个ip的list文件（按行存储的都可以）,例如下面这样：


104.168.0.0/16,pcapname
104.28.0.0/16,pcapname
134.29.0.0/16,pcapname
21.61.127.231,pcapname_port
221.17.0.0/16,pcapname
23.25.36.58,pcapname_port

输出：

对应的IP和开放的PORT及其pcapname和扫描时间插入mysql，日志输出

单个ip进行全端口扫描或指定端口扫描（日志输出，mysql插入，和传入的pcap包的name解析）

# 单个IP全端口扫描
import time  
import socket  
import threading 
from scapy.all import *
  

class SingelIP_Scan:
    def connScan(self, tgtHost, tgtPort, name):  
        try:  
            # SYN扫描
            syn = IP(dst=tgtHost)/TCP(dport=tgtPort, flags=2)
            result_raw = sr(syn, iface='enp6s0f0', timeout=1, verbose=False)  # Linux下少了iface参数，需要加上
            result_list = result_raw[0].res
            for i in range(len(result_list)):
                if result_list[i][1].haslayer(TCP):
                    TCP_fields = result_list[i][1].getlayer(TCP).fields
                    if TCP_fields['flags'] == 18:
                        port = TCP_fields['sport']
                        # print('[+]', port, ' : is open', name)
                        n = News(tgtHost, port, name)
                        n.insert()
                        logger.warning('from: ' + name +  ' insert [+] ' + tgtHost + ' [+] ' + str(port) + ' : is open')

        except:   
            # print("[-]%d/tcp close" % tgtPort)  
            pass
      
    def portScan(self, tgtHost, name):  
        try:  
            tgtIP = socket.gethostbyname(tgtHost)  
        except:  
            # print("[-]cannot connect %s" % tgtIP)  
            logger.warning(' [-] ' + tgtIP + ' can not connect')
            return  

        # print("\n[+]scan results for:" + tgtIP)   
        if '_' in name:
            result = name.split('_')
            name = result[0]
            if result[1].isdigit():
                port = int(result[1])
                self.connScan(tgtHost, port, name)
            else:
                for port in range(0, 65535):  
                    time.sleep(1)
                    print("scanning port:" + str(port)) 
                    t2 = threading.Thread(target=self.connScan, args=(tgtHost, port, name))
                    # t.daemon = True
                    t2.start() 
                    # self.connScan(tgtHost,int(port), name)   
        else:
            for port in range(0, 65535):  
                time.sleep(1)
                # print("scanning port:" + str(port))  
                t3 = threading.Thread(target=self.connScan, args=(tgtHost, port, name))
                # t.daemon = True
                t3.start()


一个IP段解进行全端口扫描或者指定端口扫描（log输出，mysql插入，pcap包name解析）

import logging
from scapy.all import *
from random import randint
import threading
import time
from config import *

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


class SegmentIP_Scan:
	def ping_one(self, host):
		ip_id = randint(1, 65535)
		icmp_id = randint(1, 65535)
		icmp_seq = randint(1, 65535)

		packet = IP(dst=host, ttl=64, id=ip_id)/ICMP(id=icmp_id, seq=icmp_seq)/b'hello'
		ping = sr1(packet, iface='enp6s0f0', timeout=2, verbose=False)  # Linux下少了iface参数，指定网卡
		if ping:
			return 0
		else:
			return -1

	def loop_addrs(self, addrs, pcapname):
		for addr in addrs:
			if self.ping_one(addr) == -1:
				# 说明对方关机，或者没有这个地址，设置了ICMP数据包过滤
				# print(addr, ': 不可达')  # 不能有中文
				logger.warning(' [-] ' + addr + ' can not connect')
			else:
				t4 = threading.Thread(target=self.syn_scan, args=(addr, pcapname))  # , 100, 500
				# t.daemon = True  # 全开守护线程快是快，但是开100个线程就占用大概3G的运存
				t4.start()

	def syn_scan(self, hostname, pcapname):  # , lport, hport
		# print('scan: ', hostname, pcapname)  # , str(lport), '-', str(hport)
		if '_' in pcapname:
			result = pcapname.split('_')
			pcapname = result[0]
			if result[1].isdigit():
				port = int(result[1])
				syn = IP(dst=hostname)/TCP(dport=port, flags=2)
				result_raw = sr(syn, iface='enp6s0f0', timeout=1, verbose=False)  # iface参数
				result_list = result_raw[0].res
				for i in range(len(result_list)):
					if result_list[i][1].haslayer(TCP):
						TCP_fields = result_list[i][1].getlayer(TCP).fields
						if TCP_fields['flags'] == 18:
							port = TCP_fields['sport']
							# print('[+]', port, ' : is open')
							n = News(hostname, port, pcapname)
							n.insert()
							logger.warning('from: ' + pcapname +  ' insert [+] ' + hostname + ' [+] ' + str(port) + ' : is open')
			else:
				for port in range(0, 65535):
					time.sleep(1)
					syn = IP(dst=hostname)/TCP(dport=port, flags=2)
					result_raw = sr(syn, iface='enp6s0f0', timeout=1, verbose=False)
					result_list = result_raw[0].res
					for i in range(len(result_list)):
						if result_list[i][1].haslayer(TCP):
							TCP_fields = result_list[i][1].getlayer(TCP).fields
							if TCP_fields['flags'] == 18:
								port = TCP_fields['sport']
								# print('[+]', port, ' : is open')
								n = News(hostname, port, pcapname)
								n.insert()
								logger.warning('from: ' + pcapname +  ' insert [+] ' + hostname + ' [+] ' + str(port) + ' : is open')
		else:
			for port in range(0, 65535):
				time.sleep(1)
				syn = IP(dst=hostname)/TCP(dport=port, flags=2)
				result_raw = sr(syn, iface='enp6s0f0', timeout=1, verbose=False)  # iface参数
				result_list = result_raw[0].res
				for i in range(len(result_list)):
					if result_list[i][1].haslayer(TCP):
						TCP_fields = result_list[i][1].getlayer(TCP).fields
						if TCP_fields['flags'] == 18:
							port = TCP_fields['sport']
							# print('[+]', port, ' : is open')
							n = News(hostname, port, pcapname)
							n.insert()
							logger.warning('from: ' + pcapname +  ' insert [+] ' + hostname + ' [+] ' + str(port) + ' : is open')



启动函数，函数的入口

from ip_List_All import *
from ip_scan_all import *
from config import *
import re
import threading


def ip_match(line):
    p = re.compile(r'(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})(\/{0,1}\d{0,3})(.\w*\_{0,1}\w*)')
    s = p.match(line)
    name = s.group(3)[1:]
    result = []
    if s:
        if s.group(2) == '/16':  # and '_' not in s.group(3)[1:]:
            q = re.compile(r'(\d{1,3}\.\d{1,3}\.)')
            a = q.match(s.group(1))
            h = a.group(1)
            ips = []
            for i in range(256):
                ip1 = h + str(i)
                for j in range(256):
                    ip2 = ip1 + '.' + str(j)
                    ips.append(ip2)
            result.append(2)
            result.append(ips)
            result.append(name)
            # print(result)
            return result
        elif s.group(2) == '/24':  # and '_' not in s.group(3)[1:]:
            q = re.compile(r'(\d{1,3}\.\d{1,3}\.\d{1,3}\.)')
            a = q.match(s.group(1))
            h = a.group(1)
            ips = []
            for i in range(256):
                ip1 = h + str(i)
                ips.append(ip1)
            result.append(2)
            result.append(ips)
            result.append(name)
            # print(result)
            return result
        elif '/' not in s.group(2):  # and '_' not in s.group(3)[1:]:
            result.append(4)
            result.append(s.group(1))
            result.append(name)
            # print(result)
            return result


def read_ip_list(filename):
    # 返回值为2: 走ip_list全端口扫描或指定端口
    # 返回值为4: 走单个ip全端口扫描或指定端口
    with open(filename, 'r') as f:
        lines = f.readlines()

    for line in lines:
        a = ip_match(line)
        if a[0] == 2:
            scan = SegmentIP_Scan()
            # scan.loop_addrs(a[1], a[2])
            t = threading.Thread(target=scan.loop_addrs, args=(a[1], a[2]))
            t.start()
        elif a[0] == 4:
            scan = SingelIP_Scan()
            # scan.portScan(a[1], a[2])
            t1 = threading.Thread(target=scan.portScan, args=(a[1], a[2]))
            t1.start()


if __name__ == '__main__':
    try:
        read_ip_list('ip.list')
    except Exception as e:
        print(e)
    finally:
        logger.warning('scaner finished!')

    # 注意在Linux下跑的时候需要sudo权限，
    # 使用scapy的sr发包的时候需要添加上，选用的网卡信息 iface参数




配置文件

注意： 代码不能直接跑，需要配置自己的mysql数据库和log日志输出的文件路径

import logging
from contextlib import closing
import datetime
import pymysql as Mdb

logger = logging.getLogger("scan_port")
formatter = logging.Formatter('%(name)s %(asctime)s %(levelname)-5s %(lineno)d: %(message)s')

file_handler = logging.FileHandler("log/scan_port.log")
file_handler.setFormatter(formatter)
file_handler.setLevel(logging.WARNING)

console_handler = logging.StreamHandler()
console_handler.setFormatter(formatter)
console_handler.setLevel(logging.DEBUG)

logger.addHandler(console_handler)
logger.addHandler(file_handler)

logger.setLevel(logging.INFO)


class News(object):
    def __init__(self, scan_ip, open_port, pcapname):
        self.__scan_ip = scan_ip
        self.__open_port = open_port
        self.__pcapname = pcapname

    def insert(self):
        with closing(Mdb.connect("127.0.0.1", "root", "password", "db01",charset="utf8")) as db:
            with closing(db.cursor()) as cursor:
                now_time = datetime.datetime.strftime(datetime.datetime.now(), "%Y-%m-%dT%H:%M:%S")

                cursor.execute("INSERT INTO tablename(`scan_ip`, `open_port`, `pcapname`, `updated_time`) VALUES (%s,%s,%s,%s)", \
                               (self.__scan_ip, self.__open_port, self.__pcapname, now_time))
                db.commit()


BUG： 这个代码有个问题就是发送SYN给端口时对于防火墙返回SYN/ACK的时候无法判断是否可连接（防火墙对65535个端口都返回），可以完成握手但是，不能通信

常见的端口扫描类型及原理
常见的扫描类型有以下几种：
     
 
秘密扫描
秘密扫描是一种不被审计工具所检测的扫描技术。
它通常用于在通过普通的防火墙或路由器的筛选（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可以辨别某台主机运行的操作系统是什么操作系统，是为windows呢？还是*nix？
端口开放：Client发送Null，server没有响应

端口关闭：1、Client发送NUll   2、Server回复RST

说明：Null扫描和前面的TCP Connect（）和SYN的判断条件正好相反。在前两种扫描中，有响应数据包的表示端口开放，但在NUll扫描中，收到响应数据包表示端口关闭。反向扫描比前两种隐蔽性高些，当精确度也相对低一些。
用途：判断是否为Windows系统还是*nix
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字段，能确定目标主机上哪些端口是开放的还是关闭的。