精华内容
下载资源
问答
  • 只有tcp三次握手完整才会在服务器留下记录,所以我们可以省略第三次握手,同样可以达到扫描的目的,但是不会在服务器留下记录。 我们先使用向服务器指定端口发送SYN请求,如果收到服务器的SYN+ACK回复,即可判断此...

    0x01 简介

    今天用了用nmap的半连接扫描,不禁想知道半连接什么意思,它们有什么区别。

    nmap扫描类型主要有TCP的全连接扫描(会在被扫描机器留下记录),半连接扫描(不会留下记录)

    0x02 原理

    在这里插入图片描述

    只有tcp三次握手完整才会在服务器留下记录,所以我们可以省略第三次握手,同样可以达到扫描的目的,但是不会在服务器留下记录。

    我们先使用向服务器指定端口发送SYN请求,如果收到服务器的SYN+ACK回复,即可判断此端口开放,反之同理。

    展开全文
  • 基于scapy的SYN半连接扫描(不会被扫描的主机发现,速度慢。现在好像防火墙会有痕迹) 详细说明 connect全连接扫描,基于socket套接字的connect方法,它的参数是一个元组(ip, port),此扫描试图与每一个TCP端口...

    原理简述:

    端口扫描常见的一般有以下两种
    • 基于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,日志输出

    1. 单个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()
    
    1. 一个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')
    
    
    1. 启动函数,函数的入口
    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参数
    
    
    
    1. 配置文件
      注意: 代码不能直接跑,需要配置自己的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个端口都返回),可以完成握手但是,不能通信

    展开全文
  • 适合有一点Python编程基础的学员学习实现的...如果该端口是开放的,操作系统就能完成TCP三次握手,然后端口扫描工具会立即关闭刚建立的该连接,防止拒绝服务攻击。这种扫描模式的优势是用户无需特殊权限。但使用操...

    适合有一点Python编程基础的学员学习

    实现的原理

    最简单的端口扫描工具使用TCP连接扫描的方式,即利用操作系统原生的网络功能,且通常作为SYN扫描的替代选项。Nmap将这种模式称为连接扫描,因为使用了类似Unix系统的connect()命令。如果该端口是开放的,操作系统就能完成TCP三次握手,然后端口扫描工具会立即关闭刚建立的该连接,防止拒绝服务攻击。这种扫描模式的优势是用户无需特殊权限。但使用操作系统原生网络功能不能实现底层控制,因此这种扫描方式并不流行。并且TCP扫描很容易被发现,尤其作为端口清扫的手段:这些服务会记录发送者的IP地址,入侵检测系统可能触发警报。

    还有另外一种扫描方式是SYN扫描,端口扫描工具不使用操作系统原生网络功能,而是自行生成、发送IP数据包,并监控其回应。这种扫描模式被称为“半开放扫描”,因为它从不建立完整的TCP连接。端口扫描工具生成一个SYN包,如果目标端口开放,则会返回SYN-ACK包。扫描端回应一个RST包,然后在握手完成前关闭连接。如果端口关闭了但未使用过滤,目标端口应该会持续返回RST包。这种粗略的网络利用方式有几个优点:给扫描工具全权控制数据包发送和等待回应时长的权力,允许更详细的回应分析。关于哪一种对目标主机的扫描方式更不具备入侵性存在一些争议,但SYN扫描的优势是从不会建立完整的连接。然而,RST包可能导致网络堵塞,尤其是一些简单如打印机之类的网络设备。

    实例中采用的是第一种扫描方式,直接利用操作系统的socket连接接口,初步测试目标服务器的端口是否可以连接,如果可以则返回端口打开状态。

    实现单线程扫描功能

    主要实现这个简单的扫描器为单线程扫描,具体步骤如下:

    获取端口及目标服务器

    新建代码如下:

    #!/usr/bin/python

    # -*- coding: utf-8 -*-

    import sys

    from socket import *

    # port_scan.py -

    host = sys.argv[1]

    protstrs = sys.argv[2].splist('-')

    start_port = int(portstrs[0])

    end_port = int(portstrs[1])

    target_ip = gethostbyname(host)

    opened_ports = []

    for port in range(start_port, end_port):

    sock = socket(AF_INET, SOCK_STREAM)

    sock.settimeout(10)

    result = sock.connect_ex((target_ip, port))

    if result == 0:

    opened_ports.append(port)

    print("Opened ports:")

    for i in opened_ports:

    print(i)

    代码解析:

    获取目标ip地址:

    target_ip = gethostbyname(host)

    进入循环连接:

    opened_ports = []

    for port in range(start_port, end_port):

    sock = socket(AF_INET, SOCK_STREAM)

    sock.settimeout(10)

    result = sock.connect_ex((target_ip, port))

    if result == 0:

    opened_ports.append(port)

    打印opened_ports 列表

    print i in opened_ports:

    print(i)

    测试扫描10-200端口情况

    >> python3 scanning_demo.py 127.0.0.1 10-200

    Opened ports:

    53

    80

    我们可以看到 53 与 80端口正处于开启的状态,你可以使用127.0.0.1:80 查看开启了什么类型的服务

    多线程扫描

    上面代码实现了单线程扫描端口的测试,但是正常的程序在执行中我们需要考虑执行效率和提升性能,所以需要实现多线程程序:

    新建代码如下:

    #!/usr/bin/python

    # -*- coding: utf-8 -*-

    import sys

    import thread

    from socket import *

    def tcp_test(port):

    sock = socket(AF_INET, SOCK_STREAM)

    sock.settimeout(10)

    result = sock.connect_ex((target_ip, port))

    if result == 0:

    lock.acquire()

    print "Opened Port:", port

    lock.release()

    if __name__=='__main__':

    # portscan.py -

    post = sys.argv[1]

    portstrs = sys.argv[2].split('_')

    start_port = int(portstrs[0])

    end_port = int(portstrsp[1])

    target_ip = gethostbyname(host)

    lock = thread.allocate_lock()

    for port in range(start_port, end_port):

    thread.start_new_thread(tcp_test, (port,))

    代码解析

    引入代码包 thread ,这个是实现多线程必须要的:

    import thread

    实现TCP测试函数

    需要注意print输出时候需要加锁,如果不加锁可能会出现多个输出混合在一起的错误状态,而锁需要在程序启动时创建,从而能让新建的线程共享这个锁

    def tcp_test(port):

    sock = socket(AF_INET, SOCK_STREAM)

    sock.settimeout(10)

    result = sock.connect_ex((target_ip, port))

    if result == 0:

    lock.acquire()

    print "Opened Port:", port

    lock.release()

    当代码执行完之后要把锁释放掉(释放lock)

    输入的处理及lock的创建可以放在main函数中:

    if __name__=='__main__':

    # portscan.py -

    host = sys.argv[1]

    portstrs = sys.argv[2].split('-')

    start_port = int(portstrs[0])

    end_port = int(portstrs[1])

    target_ip = gethostbyname(host)

    lock = thread.allocate_lock()

    然后修改for循环:

    for port in range(start_port, end_port):

    thread.start_new_thread(tcp_test, (port,))

    thread.start_new_thread 用来创建一个线程,该函数的第一个参数是一个线程中执行的函数,第二个参数必须是个元组,作为函数的输入,由于 tcp_test 函数只有一个参数,所以我们使用(port,)这种形式表示这个参数为元组。

    最后去掉上一节中的输出代码后我们的多线程改造就已经完成了。

    测试结果如下:

    >> python3 all_scanning_demo.py 127.0.0.1 80-200

    Opened ports:80

    python-nmap 包

    学习Python端口扫描我们必须要接触的一个非常强大的Python端口扫描包 pyton-nmap 这是一款很有名的安全工具,开源的。它可以在python程序中使用nmap端口扫描的Python包,可以允许开发者对nmap扫描结果进行解析并实现自动化扫描的任务,并输出报告。还有牛B的是可以支持异步操作,当执行扫描完成之后调用用户自定义的回调函数。

    install

    执行安装命令

    pip install pyton-nmap

    Collecting python-nmap

    Downloading python-nmap-0.6.1.tar.gz (41kB)

    100% |████████████████████████████████| 51kB 65kB/s

    Building wheels for collected packages: python-nmap

    Running setup.py bdist_wheel for python-nmap ... done

    Stored in directory: /Users/devon/Library/Caches/pip/wheels/d2/20/17/8eb9401fb0fa5ffbd0394c44d9d1c743036896c86029b0a613

    Successfully built python-nmap

    Installing collected packages: python-nmap

    Successfully installed python-nmap-0.6.1

    进入到python shell 操作:

    加载nmap包

    import nmap

    创建PortScanner对象

    nm = nmap.PortScanner()

    扫描 127.0.0.1的 80-200端口:

    nm.scan('127.0.0.1','22-100')

    查看使用的命令行和扫描信息:

    nm.command_line()

    Nm.scaninfo()

    查看扫描的目标主机信息:

    nm.all_hosts()

    nm['127.0.0.1'].hostname()

    nm['127.0.0.1'].state()

    nm['127.0.0.1'].all_protocols()

    nm['127.0.0.1']['tcp'].keys()

    扩展

    通过nmap我们可以实现比较复杂的一些扫描程序,你可以给予我们上面写的程序尝试引入python-nmap包并将其拓展改版,实现一些有用的功能:

    1.增加GUI,手动添加扫描的端口范围和主机

    2.生成csv格式的扫描报告

    3.后台进行扫描,完成后吧扫描报告已邮件的形式发送给管理员

    常动手,常思考 祝进步!

    展开全文
  • 目标端口上的 TCP 三次握手用于识别端口是否接受连接。这一类型的扫描指代隐秘扫描, SYN 扫描,或者开放扫描。这个秘籍演示了如何使用 Scapy 执行 TCP 隐秘扫描。准备为了使用 Scapy 执行 TCP 隐秘 扫描,你需要...

    第三章 端口扫描(二)

    作者:Justin Hutchens

    译者:飞龙

    协议:CC BY-NC-SA 4.0

    3.6 Scapy 隐秘扫描

    执行 TCP 端口扫描的一种方式就是执行一部分。目标端口上的 TCP 三次握手用于识别端口是否接受连接。这一类型的扫描指代隐秘扫描, SYN 扫描,或者半开放扫描。这个秘籍演示了如何使用 Scapy 执行 TCP 隐秘扫描。

    准备

    为了使用 Scapy 执行 TCP 隐秘 扫描,你需要一个运行 TCP 网络服务的远程服务器。这个例子中我们使用 Metasploitable2 实例来执行任务。配置 Metasploitable2 的更多信息请参考第一章中的“安装 Metasploitable2”秘籍。

    此外,这一节也需要编写脚本的更多信息,请参考第一章中的“使用文本编辑器*VIM 和 Nano)。

    操作步骤

    为了展示如何执行 SYN 扫描,我们需要使用 Scapy 构造 TCP SYN 请求,并识别和开放端口、关闭端口以及无响应系统有关的响应。为了向给定端口发送 TCP SYN 请求,我们首先需要构建请求的各个层面。我们需要构建的第一层就是 IP 层:

    root@KaliLinux:~# scapy 
    Welcome to Scapy (2.2.0) 
    >>> i = IP() 
    >>> i.display()
    ###[ IP ]###  
        version= 4  
        ihl= None  
        tos= 0x0  
        len= None  
        id= 1  
        flags=   
        frag= 0  
        ttl= 64  
        proto= ip  
        chksum= None  
        src= 127.0.0.1  
        dst= 127.0.0.1  
        \options\ 
    >>> i.dst = "172.16.36.135" 
    >>> i.display() 
    ###[ IP ]###  
        version= 4  
        ihl= None  
        tos= 0x0  
        len= None  
        id= 1  
        flags=   
        frag= 0  
        ttl= 64  
        proto= ip  
        chksum= None  
        src= 172.16.36.180  
        dst= 172.16.36.135  
        \options\

    为了构建请求的 IP 层,我们需要将IP对象赋给变量i。通过调用display函数,我们可以确定对象的属性配置。通常,发送和接受地址都设为回送地址,127.0.0.1。这些值可以通过修改目标地址来修改,也就是设置i.dst为想要扫描的地址的字符串值。通过再次调用dislay函数,我们看到不仅仅更新的目标地址,也自动更新了和默认接口相关的源 IP 地址。现在我们构建了请求的 IP 层,我们可以构建 TCP 层了。

    >>> t = TCP() 
    >>> t.display() 
    ###[ TCP ]###  
        sport= ftp_data  
        dport= http  
        seq= 0  
        ack= 0  
        dataofs= None  
        reserved= 0  
        flags= S  
        window= 8192  
        chksum= None  
        urgptr= 0  
        options= {}

    为了构建请求的 TCP 层,我们使用和 IP 层相同的技巧。在这个立即中,TCP对象赋给了t变量。像之前提到的那样,默认的配置可以通过调用display函数来确定。这里我们可以看到目标端口的默认值为 HTTP 端口 80。对于我们的首次扫描,我们将 TCP 设置保留默认。现在我们创建了 TCP 和 IP 层,我们需要将它们叠放来构造请求。

    >>> request = (i/t) 
    >>> request.display() 
    ###[ IP ]###  
        version= 4  
        ihl= None  
        tos= 0x0  
        len= None  
        id= 1
        flags=   
        frag= 0  
        ttl= 64  
        proto= tcp  
        chksum= None  
        src= 172.16.36.180  
        dst= 172.16.36.135  
        \options\ 
    ###[ TCP ]###     
        sport= ftp_data     
        dport= http     
        seq= 0     
        ack= 0     
        dataofs= None     
        reserved= 0     
        flags= S     
        window= 8192     
        chksum= None     
        urgptr= 0     
        options= {}

    我们可以通过以斜杠分离变量来叠放 IP 和 TCP 层。这些层面之后赋给了新的变量,它代表整个请求。我们之后可以调用dispaly函数来查看请求的配置。一旦构建了请求,可以将其传递给sr1函数来分析响应:

    >>> response = sr1(request) 
    ...Begin emission: 
    ........Finished to send 1 packets. 
    ....* 
    Received 16 packets, got 1 answers, remaining 0 packets 
    >>> response.display() 
    ###[ IP ]###  
        version= 4L  
        ihl= 5L  
        tos= 0x0  
        len= 44
        id= 0  
        flags= DF  
        frag= 0L  
        ttl= 64  
        proto= tcp  
        chksum= 0x9970  
        src= 172.16.36.135  
        dst= 172.16.36.180  
        \options\ 
    ###[ TCP ]###     
        sport= http     
        dport= ftp_data     
        seq= 2848210323L     
        ack= 1     
        dataofs= 6L     
        reserved= 0L     
        flags= SA     
        window= 5840     
        chksum= 0xf82d     
        urgptr= 0     
        options= [('MSS', 1460)] 
    ###[ Padding ]###        
        load= '\x00\x00'

    相同的请求可以不通过构建和堆叠每一层来执行。反之,我们使用单独的一条命令,通过直接调用函数并传递合适的参数:

    >>> sr1(IP(dst="172.16.36.135")/TCP(dport=80)) 
    .Begin emission: .............Finished to send 1 packets. 
    ....* 
    Received 19 packets, got 1 answers, remaining 0 packets 
    <IP  version=4L ihl=5L tos=0x0 len=44 id=0 flags=DF frag=0L ttl=64 proto=tcp chksum=0x9970 src=172.16.36.135 dst=172.16.36.180 options=[] |<TCP  sport=http dport=ftp_data seq=542529227 ack=1 dataofs=6L reserved=0L flags=SA window=5840 chksum=0x6864 urgptr=0 options=[('MSS', 1460)] |<Padding  load='\x00\x00' |>>>

    要注意当 SYN 封包发往目标 Web 服务器的 TCP 端口 80,并且该端口上运行了 HTTP 服务时,响应中会带有 TCP 标识 SA 的值,这表明 SYN 和 ACK 标识都被激活。这个响应表明特定的目标端口是开放的,并接受连接。如果相同类型的封包发往不接受连接的端口,会收到不同的请求。

    >>> response = sr1(IP(dst="172.16.36.135")/TCP(dport=4444)) 
    ..Begin emission: 
    .Finished to send 1 packets. 
    ...* Received 7 packets, got 1 answers, remaining 0 packets 
    >>> response.display() 
    ###[ IP ]###  
        version= 4L  
        ihl= 5L  
        tos= 0x0  
        len= 40  
        id= 0  
        flags= DF  
        frag= 0L 
        ttl= 64  
        proto= tcp 
        chksum= 0x9974 
        src= 172.16.36.135 
        dst= 172.16.36.180 
        \options\ 
    ###[ TCP ]###  
        sport= 4444    
        dport= ftp_data 
        seq= 0   
        ack= 1   
        dataofs= 5L  
        reserved= 0L  
        flags= RA  
        window= 0    
        chksum= 0xfd03   
        urgptr= 0
        options= {} 
    ###[ Padding ]###   
        load= '\x00\x00\x00\x00\x00\x00'

    当 SYN 请求发送给关闭的端口时,返回的响应中带有 TCP 标识 RA,这表明 RST 和 ACK 标识为都被激活。ACK 为仅仅用于承认请求被接受,RST 为用于断开连接,因为端口不接受连接。作为替代,如果 SYN 封包发往崩溃的系统,或者防火墙过滤了这个请求,就可能接受不到任何信息。由于这个原因,在sr1函数在脚本中使用时,应该始终使用timeout选项,来确保脚本不会在无响应的主机上挂起。

    >>> response = sr1(IP(dst="172.16.36.136")/TCP(dport=4444),timeout=1,verb ose=1) 
    Begin emission: 
    Finished to send 1 packets
    
    Received 15 packets, got 0 answers, remaining 1 packets 

    如果函数对无响应的主机使用时,timeout值没有指定,函数会无限继续下去。这个演示中,timout值为 1秒,用于使这个函数更加完备,响应的值可以用于判断是否收到了响应:

    root@KaliLinux:~# 
    python Python 2.7.3 (default, Jan  2 2013, 16:53:07) 
    [GCC 4.7.2] on linux2 
    Type "help", "copyright", "credits" or "license" for more information. 
    >>> from scapy.all import * 
    >>> response = sr1(IP(dst="172.16.36.136")/TCP(dport=4444),timeout=1,verb ose=1) 
    Begin emission: 
    WARNING: Mac address to reach destination not found. Using broadcast. Finished to send 1 packets.
    
    Received 15 packets, got 0 answers, remaining 1 packets 
    >>> if response == None: 
    ...     print "No Response!!!" 
    ... 
    No Response!!!

    Python 的使用使其更易于测试变量来识别sr1函数是否对其复制。这可以用作初步检验,来判断是否接收到了任何响应。对于接收到的响应,可以执行一系列后续检查来判断响应表明端口开放还是关闭。这些东西可以轻易使用 Python 脚本来完成,像这样:

    #!/usr/bin/python
    
    import logging 
    logging.getLogger("scapy.runtime").setLevel(logging.ERROR) 
    from scapy.all import * 
    import sys
    
    if len(sys.argv) != 4:   
        print "Usage - ./syn_scan.py [Target-IP] [First Port] [Last Port]"   
        print "Example - ./syn_scan.py 10.0.0.5 1 100"   
        print "Example will TCP SYN scan ports 1 through 100 on 10.0.0.5"   
        sys.exit()
    
    ip = sys.argv[1] 
    start = int(sys.argv[2]) 
    end = int(sys.argv[3])
    
    for port in range(start,end):   
        ans = sr1(IP(dst=ip)/TCP(dport=port),timeout=1,verbose=0)   
        if ans == None:      
            pass   
        else:      
            if int(ans[TCP].flags) == 18:    
                print port  
            else:       
                pass 

    在这个 Python 脚本中,用于被提示来输入 IP 地址,脚本之后会对定义好的端口序列执行 SYN 扫描。脚本之后会得到每个连接的响应,并尝试判断响应的 SYN 和 ACK 标识是否激活。如果响应中出现并仅仅出现了这些标识,那么会输出相应的端口号码。

    root@KaliLinux:~# chmod 777 syn_scan.py 
    root@KaliLinux:~# ./syn_scan.py 
    Usage - ./syn_scan.py [Target-IP] [First Port] [Last Port] 
    Example - ./syn_scan.py 10.0.0.5 1 100 
    Example will TCP SYN scan ports 1 through 100 on 10.0.0.5 
    root@KaliLinux:~# ./syn_scan.py 172.16.36.135 1 100
    
    21 
    22 
    23 
    25 
    53 
    80 

    运行这个脚本之后,输出会显示所提供的 IP 地址的系统上,前 100 个端口中的开放端口。

    工作原理

    这一类型的扫描由发送初始 SYN 封包给远程系统的目标 TCP 端口,并且通过返回的响应类型来判断端口状态来完成。如果远程系统返回了 SYN+ACK 响应,那么它正在准备建立连接,我们可以假设这个端口开放。如果服务返回了 RST 封包,这就表明端口关闭并且不接收连接。此外,如果没有返回响应,扫描系统和远程系统之间可能存在防火墙,它丢弃了请求。这也可能表明主机崩溃或者目标 IP 上没有关联任何系统。

    3.7 Nmap 隐秘扫描

    Nmap 拥有可以执行远程系统 SYN 扫描的扫描模式。这个秘籍展示了如何使用 Namp 执行 TCP 隐秘扫描。

    准备

    为了使用 Nmap 执行 TCP 隐秘扫描,你需要一个运行 TCP 网络服务的远程服务器。这个例子中我们使用 Metasploitable2 实例来执行任务。配置 Metasploitable2 的更多信息请参考第一章中的“安装 Metasploitable2”秘籍。

    操作步骤

    就像多数扫描需求那样,Nmap 拥有简化 TCP 隐秘扫描执行过程的选项。为了使用 Nmap 执行 TCP 隐秘扫描,应使用-sS选项,并附带被扫描主机的 IP 地址。

    root@KaliLinux:~# nmap -sS 172.16.36.135 -p 80
    
    Starting Nmap 6.25 ( http://nmap.org ) at 2013-12-17 21:47 EST
    Nmap scan report for 172.16.36.135 
    Host is up (0.00043s latency). 
    PORT   STATE SERVICE 
    80/tcp open  http 
    MAC Address: 00:0C:29:3D:84:32 (VMware)
    
    Nmap done: 1 IP address (1 host up) scanned in 13.05 seconds 

    在提供的例子中,特定的 IP 地址的 TCP 80 端口上执行了 TCP 隐秘扫描。和 Scapy 中的技巧相似,Nmap 监听响应并通过分析响应中所激活的 TCP 标识来识别开放端口。我们也可以使用 Namp 执行多个特定端口的扫描,通过传递逗号分隔的端口号列表。

    root@KaliLinux:~# nmap -sS 172.16.36.135 -p 21,80,443
    
    Starting Nmap 6.25 ( http://nmap.org ) at 2013-12-17 21:48 EST 
    Nmap scan report for 172.16.36.135 
    Host is up (0.00035s latency). 
    PORT    STATE  SERVICE 
    21/tcp  open   ftp 
    80/tcp  open   http 
    443/tcp closed https 
    MAC Address: 00:0C:29:3D:84:32 (VMware)
    
    Nmap done: 1 IP address (1 host up) scanned in 13.05 seconds 

    在这个例子中,目标 IP 地址的端口 21、80 和 443 上执行了 SYN 扫描。我们也可以使用 Namp 来扫描主机序列,通过标明要扫描的第一个和最后一个端口号,以破折号分隔:

    root@KaliLinux:~# nmap -sS 172.16.36.135 -p 20-25
    
    Starting Nmap 6.25 ( http://nmap.org ) at 2013-12-17 21:48 EST 
    Nmap scan report for 172.16.36.135 
    Host is up (0.00035s latency). 
    PORT   STATE  SERVICE 
    20/tcp closed ftp-data 
    21/tcp open   ftp
    22/tcp open   ssh 
    23/tcp open   telnet 
    24/tcp closed priv-mail 
    25/tcp open   smtp 
    MAC Address: 00:0C:29:3D:84:32 (VMware)
    
    Nmap done: 1 IP address (1 host up) scanned in 13.05 seconds 

    在所提供的例子中,SYN 扫描在 TCP 20 到 25 端口上执行。除了拥有指定被扫描端口的能力之外。Nmap 同时拥有配置好的 1000 和常用端口的列表。我们可以执行这些端口上的扫描,通过不带任何端口指定信息来运行 Nmap:

    root@KaliLinux:~# nmap -sS 172.16.36.135
    
    Starting Nmap 6.25 ( http://nmap.org ) at 2013-12-17 21:46 EST 
    Nmap scan report for 172.16.36.135 
    Host is up (0.00038s latency). N
    ot shown: 977 closed ports 
    PORT     STATE SERVICE 
    21/tcp   open  ftp 
    22/tcp   open  ssh 
    23/tcp   open  telnet 
    25/tcp   open  smtp 
    53/tcp   open  domain 
    80/tcp   open  http 
    111/tcp  open  rpcbind 
    139/tcp  open  netbios-ssn 
    445/tcp  open  microsoft-ds 
    512/tcp  open  exec 
    513/tcp  open  login 
    514/tcp  open  shell 
    1099/tcp open  rmiregistry 
    1524/tcp open  ingreslock 
    2049/tcp open  nfs 
    2121/tcp open  ccproxy-ftp 
    3306/tcp open  mysql
    5432/tcp open  postgresql 
    5900/tcp open  vnc 
    6000/tcp open  X11 
    6667/tcp open  irc 
    8009/tcp open  ajp13 
    8180/tcp open  unknown 
    MAC Address: 00:0C:29:3D:84:32 (VMware)
    
    Nmap done: 1 IP address (1 host up) scanned in 13.17 seconds 

    在上面的例子中,扫描了 Nmap 定义的 1000 个常用端口,用于识别 Metasploitable2 系统上的大量开放端口。虽然这个技巧在是被多数设备上很高效,但是也可能无法识别模糊的服务或者不常见的端口组合。如果扫描在所有可能的 TCP 端口上执行,所有可能的端口地址值都需要被扫描。定义了源端口和目标端口地址的 TCP 头部部分是 16 位长。并且,每一位可以为 1 或者 0。因此,共有2 ** 16或者 65536 个可能的 TCP 端口地址。对于要扫描的全部可能的地址空间,需要提供 0 到 65535 的端口范围,像这样:

    root@KaliLinux:~# nmap -sS 172.16.36.135 -p 0-65535
    
    Starting Nmap 6.25 ( http://nmap.org ) at 2013-12-17 21:51 EST 
    Nmap scan report for 172.16.36.135 
    Host is up (0.00033s latency). 
    Not shown: 65506 closed ports 
    PORT      STATE SERVICE 
    21/tcp    open  ftp 
    22/tcp    open  ssh 
    23/tcp    open  telnet 
    25/tcp    open  smtp 
    53/tcp    open  domain 
    80/tcp    open  http 
    111/tcp   open  rpcbind 
    139/tcp   open  netbios-ssn 
    445/tcp   open  microsoft-ds 
    512/tcp   open  exec 
    513/tcp   open  login 
    514/tcp   open  shell
    1099/tcp  open  rmiregistry 
    1524/tcp  open  ingreslock 
    2049/tcp  open  nfs 
    2121/tcp  open  ccproxy-ftp 
    3306/tcp  open  mysql 
    3632/tcp  open  distccd 
    5432/tcp  open  postgresql 
    5900/tcp  open  vnc 
    6000/tcp  open  X11 
    6667/tcp  open  irc 
    6697/tcp  open  unknown 
    8009/tcp  open  ajp13 
    8180/tcp  open  unknown 
    8787/tcp  open  unknown 
    34789/tcp open  unknown 
    50333/tcp open  unknown 
    56375/tcp open  unknown 
    57385/tcp open  unknown 
    MAC Address: 00:0C:29:3D:84:32 (VMware)
    
    Nmap done: 1 IP address (1 host up) scanned in 16.78 seconds 

    这个例子中,Metasploitable2 系统上所有可能的 65536 和 TCP 地址都扫描了一遍。要注意该扫描中识别的多数服务都在标准的 Nmap 1000 扫描中识别过了。这就表明在尝试识别目标的所有可能的攻击面的时候,完整扫描是个最佳实践。Nmap 可以使用破折号记法,扫描主机列表上的 TCP 端口:

    root@KaliLinux:~# nmap 172.16.36.0-255 -sS -p 80
    
    Starting Nmap 6.25 ( http://nmap.org ) at 2013-12-17 21:56 EST 
    Nmap scan report for 172.16.36.1 Host is up (0.00023s latency). 
    PORT   STATE  SERVICE 
    80/tcp closed http 
    MAC Address: 00:50:56:C0:00:08 (VMware)
    
    Nmap scan report for 172.16.36.2 Host is up (0.00018s latency). 
    PORT   STATE  SERVICE 
    80/tcp closed http 
    MAC Address: 00:50:56:FF:2A:8E (VMware)
    
    Nmap scan report for 172.16.36.132 Host is up (0.00047s latency). 
    PORT   STATE  SERVICE 
    80/tcp closed http 
    MAC Address: 00:0C:29:65:FC:D2 (VMware)
    
    Nmap scan report for 172.16.36.135 
    Host is up (0.00016s latency). 
    PORT   STATE SERVICE 
    80/tcp open  http 
    MAC Address: 00:0C:29:3D:84:32 (VMware)
    
    Nmap scan report for 172.16.36.180 
    Host is up (0.0029s latency). 
    PORT   STATE SERVICE 
    80/tcp open  http
    
    Nmap done: 256 IP addresses (5 hosts up) scanned in 42.85 seconds 

    这个例子中,TCP 80 端口的 SYN 扫描在指定地址范围内的所有主机上执行。虽然这个特定的扫描仅仅执行在单个端口上,Nmap 也能够同时扫描多个系统上的多个端口和端口范围。此外,Nmap 也能够进行配置,基于 IP 地址的输入列表来扫描主机。这可以通过-iL选项并指定文件名,如果文件存放于执行目录中,或者文件路径来完成。Nmap 之后会遍历输入列表中的每个地址,并对地址执行特定的扫描。

    root@KaliLinux:~# cat iplist.txt 
    172.16.36.1 
    172.16.36.2 
    172.16.36.132 
    172.16.36.135
    
    root@KaliLinux:~# nmap -sS -iL iplist.txt -p 80
    
    Starting Nmap 6.25 ( http://nmap.org ) at 2013-12-17 21:59 EST 
    Nmap scan report for 172.16.36.1 
    Host is up (0.00016s latency). 
    PORT   STATE  SERVICE 
    80/tcp closed http 
    MAC Address: 00:50:56:C0:00:08 (VMware)
    
    Nmap scan report for 172.16.36.2 
    Host is up (0.00047s latency). 
    PORT   STATE  SERVICE 
    80/tcp closed http 
    MAC Address: 00:50:56:FF:2A:8E (VMware)
    
    Nmap scan report for 172.16.36.132 
    Host is up (0.00034s latency). 
    PORT   STATE  SERVICE 
    80/tcp closed http 
    MAC Address: 00:0C:29:65:FC:D2 (VMware)
    
    Nmap scan report for 172.16.36.135 
    Host is up (0.00016s latency). 
    PORT   STATE SERVICE 
    80/tcp open  http 
    MAC Address: 00:0C:29:3D:84:32 (VMware)
    
    Nmap done: 4 IP addresses (4 hosts up) scanned in 13.05 seconds

    工作原理

    Nmap SYN 扫描背后的底层机制已经讨论过了。但是,Nmap 拥有多线程功能,是用于执行这类扫描的快速高效的方式。

    3.8 Metasploit 隐秘扫描

    除了其它已经讨论过的工具之外,Metasploit 拥有用于 SYN 扫描的辅助模块。这个秘籍展示了如何使用 Metasploit 来执行 TCP 隐秘扫描。

    准备

    为了使用 Metasploit 执行 TCP 隐秘扫描,你需要一个运行 TCP 网络服务的远程服务器。这个例子中我们使用 Metasploitable2 实例来执行任务。配置 Metasploitable2 的更多信息请参考第一章中的“安装 Metasploitable2”秘籍。

    操作步骤

    Metasploit 拥有可以对特定 TCP 端口执行 SYN 扫描的辅助模块。为了在 Kali 中启动 Metasploit,我们在终端中执行msfconsole命令。

    root@KaliLinux:~# msfconsole 
    IIIIII    dTb.dTb        _.---._
      II     4'  v  'B   .'"".'/|\`.""'.  
      II     6.     .P  :  .' / | \ `.  :  
      II     'T;. .;P'  '.'  /  |  \  `.'  
      II      'T; ;P'    `. /   |   \ .' 
    IIIIII     'YvP'       `-.__|__.-'
    
    I love shells --egypt
    
    Using notepad to track pentests? Have Metasploit Pro report on hosts, services, sessions and evidence -- type 'go_pro' to launch it now.
    
           =[ metasploit v4.6.0-dev [core:4.6 api:1.0] 
    + -- --=[ 1053 exploits - 590 auxiliary - 174 post 
    + -- --=[ 275 payloads - 28 encoders - 8 nops
    
    msf > use auxiliary/scanner/portscan/syn 
    msf  auxiliary(syn) > show options
    
    Module options (auxiliary/scanner/portscan/syn):
    
        Name       Current Setting  Required  Description   
        ----       ---------------  --------  ----------   
        BATCHSIZE  256              yes       The number of hosts to scan per set   
        INTERFACE                   no        The name of the interface   
        PORTS      1-10000          yes       Ports to scan (e.g. 2225,80,110-900)   
        RHOSTS                      yes       The target address range or CIDR identifier   
        SNAPLEN    65535            yes       The number of bytes to capture   
        THREADS    1                yes       The number of concurrent threads   
        TIMEOUT    500              yes       The reply read timeout in milliseconds 

    为了在 Metasploit 中执行 SYN 扫描,以辅助模块的相对路径调用use命令。一旦模块被选中,可以执行show options命令来确认或修改扫描配置。这个命令会展示四列的表格,包括namecurrent settingsrequireddescriptionname列标出了每个可配置变量的名称。current settings列列出了任何给定变量的现有配置。required列标出对于任何给定变量,值是否是必须的。description列描述了每个变量的功能。任何给定变量的值可以使用set命令,并且将新的值作为参数来修改。

    msf  auxiliary(syn) > set RHOSTS 172.16.36.135 
    RHOSTS => 172.16.36.135 
    msf  auxiliary(syn) > set THREADS 20 
    THREADS => 20 
    msf  auxiliary(syn) > set PORTS 80 
    PORTS => 80 
    msf  auxiliary(syn) > show options
    
    Module options (auxiliary/scanner/portscan/syn):
    
       Name       Current Setting  Required  Description   
       ----       ---------------  --------  ----------   
       BATCHSIZE  256              yes       The number of hosts to scan per set
       INTERFACE                   no        The name of the interface   
       PORTS      80               yes       Ports to scan (e.g. 2225,80,110-900)   
       RHOSTS     172.16.36.135    yes       The target address range or CIDR identifier   
       SNAPLEN    65535            yes       The number of bytes to capture   
       THREADS    20               yes       The number of concurrent threads   
       TIMEOUT    500              yes       The reply read timeout in milliseconds

    在上面的例子中,RHOSTS值修改为我们打算扫描的远程系统的 IP 地址。地外,线程数量修改为 20。THREADS的值定义了在后台执行的当前任务数量。确定线程数量涉及到寻找一个平衡,既能提升任务速度,又不会过度消耗系统资源。对于多数系统,20 个线程可以足够快,并且相当合理。PORTS值设为 TCP 端口 80(HTTP)。修改了必要的变量之后,可以再次使用show options命令来验证。一旦所需配置验证完毕,就可以执行扫描了。

    msf  auxiliary(syn) > run
    
    [*] TCP OPEN 172.16.36.135:80 [*] Scanned 1 of 1 hosts (100% complete) 
    [*] Auxiliary module execution completed The run command is used in Metasploit to execute the selected auxiliary module. In the example provided, the run command executed a TCP SYN scan against port 80 of the specified IP address. We can also run this TCP SYN scan module against a sequential series  of TCP ports by supplying the first and last values, separated by a dash notation:
    
    msf  auxiliary(syn) > set PORTS 0-100 
    PORTS => 0-100 
    msf  auxiliary(syn) > show options
    
    Module options (auxiliary/scanner/portscan/syn):
    
       Name       Current Setting  Required  Description   
       ----       ---------------  --------  ----------   
       BATCHSIZE  256              yes       The number of hosts to scan per set   
       INTERFACE                   no        The name of the interface
       PORTS      0-100            yes       Ports to scan (e.g. 2225,80,110-900)   
       RHOSTS     172.16.36.135    yes       The target address range or CIDR identifier   
       SNAPLEN    65535            yes       The number of bytes to capture   
       THREADS    20               yes       The number of concurrent threads   
       TIMEOUT    500              yes       The reply read timeout in milliseconds
    
    msf  auxiliary(syn) > run
    
    [*]  TCP OPEN 172.16.36.135:21 
    [*]  TCP OPEN 172.16.36.135:22 
    [*]  TCP OPEN 172.16.36.135:23 
    [*]  TCP OPEN 172.16.36.135:25 
    [*]  TCP OPEN 172.16.36.135:53 
    [*]  TCP OPEN 172.16.36.135:80 
    [*] Scanned 1 of 1 hosts (100% complete) 
    [*] Auxiliary module execution completed 

    上面的例子中,所指定的远程主机的钱 100 个 TCP 端口上执行了 TCP SYN 扫描。虽然这个扫描识别了目标系统的多个设备,我们不能确认所有设备都识别出来,除非所有可能的端口地址都扫描到。定义来源和目标端口地址的TCP 头部部分是 16 位长。并且,每一位可以为 1 或者 0。因此,共有2 ** 16或 65536 个可能的 TCP 端口地址。对于要扫描的整个地址空间,需要提供 0 到 65535 的 端口范围,像这样:

    msf  auxiliary(syn) > set PORTS 0-65535 
    PORTS => 0-65535 
    msf  auxiliary(syn) > show options
    
    Module options (auxiliary/scanner/portscan/syn):
    
       Name       Current Setting  Required  Description   
       ----       ---------------  --------  ----------   
       BATCHSIZE  256              yes       The number of hosts to scan per set   
       INTERFACE                   no        The name of the interface
       PORTS      0-65535          yes       Ports to scan (e.g. 2225,80,110-900)   
       RHOSTS     172.16.36.135    yes       The target address range or CIDR identifier   
       SNAPLEN    65535            yes       The number of bytes to capture   
       THREADS    20               yes       The number of concurrent threads   
       TIMEOUT    500              yes       The reply read timeout in milliseconds 
    
    msf  auxiliary(syn) > run
    
    [*]  TCP OPEN 172.16.36.135:21 
    [*]  TCP OPEN 172.16.36.135:22 
    [*]  TCP OPEN 172.16.36.135:23 
    [*]  TCP OPEN 172.16.36.135:25 
    [*]  TCP OPEN 172.16.36.135:53 
    [*]  TCP OPEN 172.16.36.135:80 
    [*]  TCP OPEN 172.16.36.135:111 
    [*]  TCP OPEN 172.16.36.135:139 
    [*]  TCP OPEN 172.16.36.135:445 
    [*]  TCP OPEN 172.16.36.135:512 
    [*]  TCP OPEN 172.16.36.135:513 
    [*]  TCP OPEN 172.16.36.135:514 
    [*]  TCP OPEN 172.16.36.135:1099 
    [*]  TCP OPEN 172.16.36.135:1524 
    [*]  TCP OPEN 172.16.36.135:2049 
    [*]  TCP OPEN 172.16.36.135:2121 
    [*]  TCP OPEN 172.16.36.135:3306 
    [*]  TCP OPEN 172.16.36.135:3632 
    [*]  TCP OPEN 172.16.36.135:5432 
    [*]  TCP OPEN 172.16.36.135:5900 
    [*]  TCP OPEN 172.16.36.135:6000 
    [*]  TCP OPEN 172.16.36.135:6667 
    [*]  TCP OPEN 172.16.36.135:6697 
    [*]  TCP OPEN 172.16.36.135:8009 
    [*]  TCP OPEN 172.16.36.135:8180 
    [*]  TCP OPEN 172.16.36.135:8787 
    [*]  TCP OPEN 172.16.36.135:34789
    [*]  TCP OPEN 172.16.36.135:50333 
    [*]  TCP OPEN 172.16.36.135:56375 
    [*]  TCP OPEN 172.16.36.135:57385 
    [*] Scanned 1 of 1 hosts (100% complete) 
    [*] Auxiliary module execution completed

    在这个李忠,远程系统的所有开放端口都由扫描所有可能的 TCP 端口地址来识别。我们也可以修改扫描配置使用破折号记法来扫描地址序列。

    msf  auxiliary(syn) > set RHOSTS 172.16.36.0-255 
    RHOSTS => 172.16.36.0-255 
    msf  auxiliary(syn) > show options
    
    Module options (auxiliary/scanner/portscan/syn):
    
       Name       Current Setting  Required  Description   
       ----       ---------------  --------  ----------   
       BATCHSIZE  256              yes       The number of hosts to scan per set   
       INTERFACE                   no        The name of the interface   
       PORTS      80               yes       Ports to scan (e.g. 2225,80,110-900)   
       RHOSTS     172.16.36.0-255  yes       The target address range or CIDR identifier   
       SNAPLEN    65535            yes       The number of bytes to capture   
       THREADS    20               yes       The number of concurrent threads   
       TIMEOUT    500              yes       The reply read timeout in milliseconds
    
    msf  auxiliary(syn) > run
    
    [*] TCP OPEN 172.16.36.135:80 
    [*] Scanned 256 of 256 hosts (100% complete) 
    [*] Auxiliary module execution completed

    这个例子中,TCP SYN 扫描执行在由RHOST变量指定的所有主机地址的 80 端口上。与之相似,RHOSTS可以使用 CIDR 记法定义网络范围。

    msf  auxiliary(syn) > set RHOSTS 172.16.36.0/24 
    RHOSTS => 172.16.36.0/24 
    msf  auxiliary(syn) > show options
    
    Module options (auxiliary/scanner/portscan/syn):
    
       Name       Current Setting  Required  Description   
       ----       ---------------  --------  ----------   
       BATCHSIZE  256              yes       The number of hosts to scan per set   
       INTERFACE                   no        The name of the interface   
       PORTS      80               yes       Ports to scan (e.g. 2225,80,110-900)   
       RHOSTS     172.16.36.0/24   yes       The target address range or CIDR identifier   
       SNAPLEN    65535            yes       The number of bytes to capture   
       THREADS    20               yes       The number of concurrent threads   
       TIMEOUT    500              yes       The reply read timeout in milliseconds
    
    msf  auxiliary(syn) > run
    
    [*] TCP OPEN 172.16.36.135:80 
    [*] Scanned 256 of 256 hosts (100% complete) 
    [*] Auxiliary module execution completed

    工作原理

    Metasploit SYN 扫描辅助模块背后的底层原理和任何其它 SYN 扫描工具一样。对于每个被扫描的端口,会发送 SYN 封包。SYN+ACK 封包会用于识别活动服务。使用 MEtasploit 可能更加有吸引力,因为它拥有交互控制台,也因为它是个已经被多数渗透测试者熟知的工具。

    7.9 hping3 隐秘扫描

    除了我们之前学到了探索技巧,hping3 也可以用于执行端口扫描。这个秘籍展示了如何使用 hping3 来执行 TCP 隐秘扫描。

    准备

    为了使用 hping3 执行 TCP 隐秘扫描,你需要一个运行 TCP 网络服务的远程服务器。这个例子中我们使用 Metasploitable2 实例来执行任务。配置 Metasploitable2 的更多信息请参考第一章中的“安装 Metasploitable2”秘籍。

    操作步骤

    除了我们之前学到了探索技巧,hping3 也可以用于执行端口扫描。为了使用 hping3 执行端口扫描,我们需要以一个整数值使用--scan模式来指定要扫描的端口号。

    root@KaliLinux:~# hping3 172.16.36.135 --scan 80 -S 
    Scanning 172.16.36.135 (172.16.36.135), port 80 
    1 ports to scan, use -V to see all the replies 
    +----+-----------+---------+---+-----+-----+-----+ 
    |port| serv name |  flags  |ttl| id  | win | len | 
    +----+-----------+---------+---+-----+-----+-----+   
       80 http       : .S..A...  64     0  5840    46 
    All replies received. Done. 
    Not responding ports: 

    上面的例子中,SYN 扫描执行在指定 IP 地址的 TCP 端口 80 上。-S选项指明了发给远程系统的封包中激活的 TCP 标识。表格展示了接收到的响应封包中的属性。我们可以从输出中看到,接收到了SYN+ACK 响应,所以这表示目标主机端口 80 是开放的。此外,我们可以通过输入够好分隔的端口号列表来扫描多个端口,像这样:

    root@KaliLinux:~# hping3 172.16.36.135 --scan 22,80,443 -S 
    Scanning 172.16.36.135 (172.16.36.135), port 22,80,443 
    3 ports to scan, use -V to see all the replies
    +----+-----------+---------+---+-----+-----+-----+ 
    |port| serv name |  flags  |ttl| id  | win | len | 
    +----+-----------+---------+---+-----+-----+-----+   
       22 ssh        : .S..A...  64     0  5840    46   
       80 http       : .S..A...  64     0  5840    46 
    All replies received. Done. 
    Not responding ports: 

    在上面的扫描输出中,你可以看到,仅仅展示了接受到 SYN+ACK 标识的结果。要注意和发送到 443 端口的 SYN 请求相关的响应并没有展示。从输出中可以看出,我们可以通过使用-v选项增加详细读来查看所有响应。此外,可以通过传递第一个和最后一个端口地址值,来扫描端口范围,像这样:

    root@KaliLinux:~# hping3 172.16.36.135 --scan 0-100 -S 
    Scanning 172.16.36.135 (172.16.36.135), port 0-100 
    101 ports to scan, use -V to see all the replies 
    +----+-----------+---------+---+-----+-----+-----+ 
    |port| serv name |  flags  |ttl| id  | win | len | 
    +----+-----------+---------+---+-----+-----+-----+   
       21 ftp        : .S..A...  64     0  5840    46   
       22 ssh        : .S..A...  64     0  5840    46   
       23 telnet     : .S..A...  64     0  5840    46   
       25 smtp       : .S..A...  64     0  5840    46   
       53 domain     : .S..A...  64     0  5840    46   
       80 http       : .S..A...  64     0  5840    46 
    All replies received. Done. 
    Not responding ports: 

    这个例子中,100 个端口的扫描足以识别 Metasploitable2 系统上的服务。但是,为了执行 所有 TCP 端口的扫描,需要扫描所有可能的端口地址值。定义了源端口和目标端口地址的 TCP 头部部分是 16 位长。并且,每一位可以为 1 或者 0。因此,共有2 ** 16或者 65536 个可能的 TCP 端口地址。对于要扫描的全部可能的地址空间,需要提供 0 到 65535 的端口范围,像这样:

    root@KaliLinux:~# hping3 172.16.36.135 --scan 0-65535 -S 
    Scanning 172.16.36.135 (172.16.36.135), port 0-65535 
    65536 ports to scan, use -V to see all the replies
    +----+-----------+---------+---+-----+-----+-----+ 
    |port| serv name |  flags  |ttl| id  | win | len | 
    +----+-----------+---------+---+-----+-----+-----+   
       21 ftp        : .S..A...  64     0  5840    46   
       22 ssh        : .S..A...  64     0  5840    46   
       23 telnet     : .S..A...  64     0  5840    46   
       25 smtp       : .S..A...  64     0  5840    46   
       53 domain     : .S..A...  64     0  5840    46  
      111 sunrpc     : .S..A...  64     0  5840    46 
     1099 rmiregistry: .S..A...  64     0  5840    46 
     1524 ingreslock : .S..A...  64     0  5840    46 
     2121 iprop      : .S..A...  64     0  5840    46 
     8180            : .S..A...  64     0  5840    46 
    34789            : .S..A...  64     0  5840    46  
      512 exec       : .S..A...  64     0  5840    46  
      513 login      : .S..A...  64     0  5840    46  
      514 shell      : .S..A...  64     0  5840    46 
     3632 distcc     : .S..A...  64     0  5840    46 
     5432 postgresql : .S..A...  64     0  5840    46 
    56375            : .S..A...  64     0  5840    46   
       80 http       : .S..A...  64     0  5840    46  
      445 microsoft-d: .S..A...  64     0  5840    46 
     2049 nfs        : .S..A...  64     0  5840    46 
     6667 ircd       : .S..A...  64     0  5840    46
     6697            : .S..A...  64     0  5840    46 
    57385            : .S..A...  64     0  5840    46  
      139 netbios-ssn: .S..A...  64     0  5840    46 
     6000 x11        : .S..A...  64     0  5840    46 
     3306 mysql      : .S..A...  64     0  5840    46 
     5900            : .S..A...  64     0  5840    46 
     8787            : .S..A...  64     0  5840    46 
    50333            : .S..A...  64     0  5840    46 
     8009            : .S..A...  64     0  5840    46 
    All replies received. Done. 
    Not responding ports:

    工作原理

    hping3 不用于一些已经提到的其它工具,因为它并没有 SYN 扫描模式。但是反之,它允许你指定 TCP 封包发送时的激活的 TCP 标识。在秘籍中的例子中,-S选项让 hping3 使用 TCP 封包的 SYN 标识。

    3.10 Scapy 连接扫描

    在多数扫描工具当中,TCP 连接扫描比 SYN 扫描更加容易。这是因为 TCP 连接扫描并不需要为了生成和注入 SYN 扫描中使用的原始封包而提升权限。Scapy 是它的一大例外。Scapy 实际上非常难以执行完全的 TCP 三次握手,也不实用。但是,出于更好理解这个过程的目的,我们来看看如何使用 Scapy 执行连接扫描。

    准备

    为了使用 Scapy 执行全连接扫描,你需要一个运行 UDP 网络服务的远程服务器。这个例子中我们使用 Metasploitable2 实例来执行任务。配置 Metasploitable2 的更多信息请参考第一章中的“安装 Metasploitable2”秘籍。

    此外,这一节也需要编写脚本的更多信息,请参考第一章中的“使用文本编辑器*VIM 和 Nano)。

    操作步骤

    Scapy 中很难执行全连接扫描,因为系统内核不知道你在 Scapy 中发送的请求,并且尝试阻止你和远程系统建立完整的三次握手。你可以在 Wireshark 或 tcpdump 中,通过发送 SYN 请求并嗅探相关流量来看到这个过程。当你接收到来自远程系统的 SYN+ACK 响应时,Linux 内核会拦截它,并将其看做来源不明的响应,因为它不知道你在 Scapy 中 发送的请求。并且系统会自动使用 TCP RST 封包来回复,因此会断开握手过程。考虑下面的例子:

    #!/usr/bin/python
    
    import logging 
    logging.getLogger("scapy.runtime").setLevel(logging.ERROR) 
    from scapy.all import *
    
    response = sr1(IP(dst="172.16.36.135")/TCP(dport=80,flags='S')) 
    reply = sr1(IP(dst="172.16.36.135")/TCP(dport=80,flags='A',ack=(respon se[TCP].seq + 1)))

    这个 Python 脚本的例子可以用做 POC 来演系统破坏三次握手的问题。这个脚本假设你将带有开放端口活动系统作为目标。因此,假设 SYN+ACK 回复会作为初始 SYN 请求的响应而返回。即使发送了最后的 ACK 回复,完成了握手,RST 封包也会阻止连接建立。我们可以通过观察封包发送和接受来进一步演示。

    #!/usr/bin/python
    
    import logging 
    logging.getLogger("scapy.runtime").setLevel(logging.ERROR) 
    from scapy.all import *
    
    SYN = IP(dst="172.16.36.135")/TCP(dport=80,flags='S')
    
    print "-- SENT --" 
    SYN.display()
    
    print "\n\n-- RECEIVED --" 
    response = sr1(SYN,timeout=1,verbose=0) 
    response.display()
    
    if int(response[TCP].flags) == 18:   
        print "\n\n-- SENT --"   
        ACK = IP(dst="172.16.36.135")/TCP(dport=80,flags='A',ack=(response[    TCP].seq + 1))   
        response2 = sr1(ACK,timeout=1,verbose=0)   
        ACK.display()   
        print "\n\n-- RECEIVED --"   
        response2.display() 
    else:   
        print "SYN-ACK not returned"

    在这个 Python 脚本中,每个发送的封包都在传输之前展示,并且每个收到的封包都在到达之后展示。在检验每个封包所激活的 TCP 标识的过程中,我们可以看到,三次握手失败了。考虑由脚本生成的下列输出:

    root@KaliLinux:~# ./tcp_connect.py 
    -- SENT -
    ###[ IP ]###
        version   = 4  
        ihl       = None  
        tos       = 0x0  
        len       = None  
        id        = 1  
        flags     =   
        frag      = 0  
        ttl       = 64  
        proto     = tcp  
        chksum    = None  
        src       = 172.16.36.180  
        dst       = 172.16.36.135  
        \options   \ 
    ###[ TCP ]###     
        sport     = ftp_data     
        dport     = http     
        seq       = 0     
        ack       = 0     
        dataofs   = None     
        reserved  = 0     
        flags     = S     
        window    = 8192     
        chksum    = None     
        urgptr    = 0     
        options   = {}
    -- RECEIVED -
    ###[ IP ]###  
        version   = 4L  
        ihl       = 5L  
        tos       = 0x0  
        len       = 44  
        id        = 0  
        flags     = DF
        frag      = 0L  
        ttl       = 64  
        proto     = tcp  
        chksum    = 0x9970  
        src       = 172.16.36.135  
        dst       = 172.16.36.180  
        \options   \ 
    ###[ TCP ]###     
        sport     = http     
        dport     = ftp_data     
        seq       = 3013979073L     
        ack       = 1     
        dataofs   = 6L     
        reserved  = 0L     
        flags     = SA     
        window    = 5840     
        chksum    = 0x801e     
        urgptr    = 0     
        options   = [('MSS', 1460)] 
    ###[ Padding ]###        
        load      = '\x00\x00'
    -- SENT -
    ###[ IP ]###  
        version   = 4  
        ihl       = None  
        tos       = 0x0  
        len       = None  
        id        = 1  
        flags     =   
        frag      = 0  
        ttl       = 64  
        proto     = tcp  
        chksum    = None
        src       = 172.16.36.180  
        dst       = 172.16.36.135  
        \options   \ 
    ###[ TCP ]###     
        sport     = ftp_data     
        dport     = http     
        seq       = 0     
        ack       = 3013979074L     
        dataofs   = None     
        reserved  = 0     
        flags     = A     
        window    = 8192     
        chksum    = None     
        urgptr    = 0     
        options   = {}
    -- RECEIVED -
    ###[ IP ]###  
        version   = 4L  
        ihl       = 5L  
        tos       = 0x0  
        len       = 40  
        id        = 0  
        flags     = DF  
        frag      = 0L  
        ttl       = 64  
        proto     = tcp  
        chksum    = 0x9974  
        src       = 172.16.36.135  
        dst       = 172.16.36.180  
        \options   \ 
    ###[ TCP ]###     
        sport     = http     
        dport     = ftp_data
        seq       = 3013979074L     
        ack       = 0     
        dataofs   = 5L     
        reserved  = 0L     
        flags     = R     
        window    = 0     
        chksum    = 0xaeb8     
        urgptr    = 0     
        options   = {} 
    ###[ Padding ]###        
        load      = '\x00\x00\x00\x00\x00\x00'

    在脚本的输出中,我们看到了四个封包。第一个封包是发送的 SYN 请求,第二个封包时接收到的 SYN+ACK 回复,第三个封包时发送的 ACK 回复,之后接收到了 RST 封包,它是最后的 ACK 回复的响应。最后一个封包表明,在建立连接时出现了问题。Scapy 中可能能够建立完成的三次握手,但是它需要对本地 IP 表做一些调整。尤其是,如果你去掉发往远程系统的 TSR 封包,你就可以完成握手。通过使用 IP 表建立过滤机制,我们可以去掉 RST 封包来完成三次握手,而不会干扰到整个系统(这个配置出于功能上的原理并不推荐)。为了展示完整三次握手的成功建立,我们使用 Netcat 建立 TCP 监听服务。之后尝试使用 Scapy 连接开放的端口。

    admin@ubuntu:~$ nc -lvp 4444 
    listening on [any] 4444 ... 

    这个例子中,我们在 TCP 端口 4444 开启了监听服务。我们之后可以修改之前的脚本来尝试连接 端口 4444 上的 Netcat 监听服务。

    #!/usr/bin/python
    
    import logging 
    logging.getLogger("scapy.runtime").setLevel(logging.ERROR) 
    from scapy.all import *
    
    response = sr1(IP(dst="172.16.36.135")/TCP(dport=4444,flags='S')) 
    reply = sr1(IP(dst="172.16.36.135")/TCP(dport=4444,flags='A',ack=(resp onse[TCP].seq + 1)))

    这个脚本中,SYN 请求发送给了监听端口。收到 SYN+ACK 回复之后,会发送 ACK回复。为了验证连接尝试被系统生成的 RST 封包打断,这个脚本应该在 Wireshark 启动之后执行,来捕获请求蓄力。我们使用 Wireshark 的过滤器来隔离连接尝试序列。所使用的过滤器是tcp && (ip.src == 172.16.36.135 || ip.dst == 172.16.36.135)。过滤器仅仅用于展示来自或发往被扫描系统的 TCP 流量。像这样:

    既然我们已经精确定位了问题。我们可以建立过滤器,让我们能够去除系统生成的 RST 封包。这个过滤器可以通过修改本地 IP 表来建立:

    以如下方式修改本地 IP 表会通过阻塞所有发出的 RST 响应,改变和目标系统之间的 TCP/IP 事务的处理方式。确保常见的 iptable 规则在这个秘籍完成之后移除,或者之后使用下列命令刷新 iptable。

    iptables --flush
    root@KaliLinux:~# iptables -A OUTPUT -p tcp --tcp-flags RST RST -d 172.16.36.135 -j DROP 
    root@KaliLinux:~# iptables --list 
    Chain INPUT (policy ACCEPT) 
    target     prot opt source               destination         
    
    Chain FORWARD (policy ACCEPT) 
    target     prot opt source               destination      
    
    Chain OUTPUT (policy ACCEPT) 
    target     prot opt source               destination         
    DROP       tcp  --  anywhere             172.16.36.135       tcp flags:RST/RST

    在这个例子中,本地 IP 表的修改去除了所有发往被扫描主机的目标地址的 TCP RST 封包。list选项随后可以用于查看 IP 表的条目,以及验证配置已经做了修改。为了执行另一次连接尝试,我们需要确保 Natcat 仍旧监听目标的 4444 端口,像这样:

    admin@ubuntu:~$ nc -lvp 4444 
    listening on [any] 4444 ...

    和之前相同的 Python 脚本可以再次使用,同时 WIreshark 会捕获后台的流量。使用之前讨论的显示过滤器,我们可以轻易专注于所需的流量。要注意三次握手的所有步骤现在都可以完成,而不会收到系统生成的 RST 封包的打断,像这样:

    此外,如果我们看一看运行在目标系统的 Netcat 服务,我们可以注意到,已经建立了连接。这是用于确认成功建立连接的进一步的证据。这可以在下面的输出中看到:

    admin@ubuntu:~$ nc -lvp 4444 
    listening on [any] 4444 ... 172.16.36.132: inverse host lookup failed: No address associated with name 
    connect to [172.16.36.135] from (UNKNOWN) [172.16.36.132] 42409

    虽然这个练习对理解和解决 TCP 连接的问题十分有帮助,恢复 IP 表的条目也十分重要。RST 封包 是 TCP 通信的重要组成部分,去除这些响应会影响正常的通信功能。洗唛按的命令可以用于刷新我们的 iptable 规则,并验证刷新成功:

    root@KaliLinux:~# iptables --flush 
    root@KaliLinux:~# iptables --list 
    Chain INPUT (policy ACCEPT) 
    target     prot opt source               destination   
    
    Chain FORWARD (policy ACCEPT) 
    target     prot opt source               destination    
    
    Chain OUTPUT (policy ACCEPT) 
    target     prot opt source               destination 

    就像例子中展示的那样,flush选项应该用于清楚 IP 表的条目。我们可以多次使用list选项来验证 IP 表的条目已经移除了。

    工作原理

    执行 TCP 连接扫描的同居通过执行完整的三次握手,和远程系统的所有被扫描端口建立连接。端口的状态取决于连接是否成功建立。如果连接建立,端口被认为是开放的,如果连接不能成功建立,端口被认为是关闭的。

    展开全文
  • TCP协议中的三次握手,建立半连接,向目的端口发送SYN请求,确认其是否开放,需要winpcap。包括程序说明及winpcap使用图解。
  • Nmap 扫描详解

    2014-06-25 13:40:34
    扫描方式:全连接扫描三次握手 防火墙能有效拦截,故很少使用(产生大量日志,很少使用)链接扫描,三次握手前两次,源SYN 目标SYN/ACK 端口开放;源SYN 目标RST/ACK 端口关闭 (不记日志,隐蔽性好)秘密扫描,...
  • 端口扫描原理和划分

    2020-11-10 15:18:49
    其中***代表性的就是TCP连接扫描,需要扫描方通过三次握手过程与目标主机建立完整的TCP连接,可靠性高,但是在扫描的过程中会产生大量审计数据。这种扫描在有些场合是非常有用的,它可以作为正常扫描行为,直接由...
  • 端口扫描详解

    千次阅读 2016-08-08 09:59:54
    TCPconnect扫描: tcp全连接扫描,使用系统提供的connect()...通过完整的tcp三次握手(也即一次tcp连接),来判断目标端口的状态 TCPSYN扫描: tcp隐藏扫描,打开扫描。首先客户端向要扫描的端口发送一个SYN分组()
  • 端口扫描原理

    2012-11-19 10:39:34
    这种扫描方法使用三次握手,与目标计算机建立标准的TCP连接。需要说明的是,这种古老的扫描方法很容易被目标主机记录。 (2)打开式扫描(SYN扫描) 在这种扫描技术中,扫描主机自动向目标计算机的
  • TCP 连接扫描:客户端与服务器建立 TCP 连接要进行一次三次握手,如果进行了一次成功的三次握手,则说明端口开放; TCP SYN 扫描(也称为开放扫描或stealth扫描):这个技术同 TCP 连接扫描非常相似。同样是客户端向...
  • TCP connect扫描:也称为全连接扫描,这种方式直接连接到目标端口,完成了TCP三次握手的过程,这种方式扫描结果比较准确,但速度比较慢而且可轻易被目标系统检测到。 TCP SYN扫描:也称为开放扫描,这种方式将发送...
  • NMAP是一款强大的网络扫描安全监测工具,通过扫描网络中不需要的服务端口来关闭这些服务,提高安全性。...  语法是  nmap [扫描类型] [选项]... -sT TCP连接扫描(全开),发送TCP三次握手,完全连接成功  -sF TCP
  • TCP协议为面向连接、可靠的、基于字节流的通信协议,其在通信中要实现三次握手连接,我们可以通过向目标主机发送连接请求的方式来确定目标主机是否存活。当然实现TCP扫描的方式有很多种,例如:简单的端口扫描(即:...
  • 使用全连接进行扫描,完成tcp的三次握手,若建立连接说明端口开放(速度相对慢) 3.nmap - sS 192.168.1.1 使用半连接进行扫描,如果接收到SYN/ACK包则说明端口开放,如果收到RST包,则说明端口关...
  • 扫描程序发送的是一个SYN数据包,好象准备打开一个实际的连接并等待反应一样(参考TCP的三次握手建立一个TCP连接的过程)。一个SYN|ACK的返回信息表示端口处于侦听状态。一个RST返回,表示端口没有处于侦听态。如果...
  • TCP connect扫描 三次握手完成/全连接/速度慢/易被检测到 TCP SYN扫描 扫描/发送SYN包启动TCP会话 TCP FIN扫描 扫描/发送SYN包启动TCP会话 TCP XMAS扫描 扫描/发送PSH、FIN、URG、TCP标志位为1的...
  • NMAP的各种使用方法

    2020-07-27 17:06:15
    Nmap安装在真实机中 ...SYN半连接扫描【nmap 10.3.139.26 -p 80-sS】 确定端口开放的时候,仅进行TCP三次握手的前两次过程 优点:快速,绕过防火墙检测 缺点:需要管理员权限 隐蔽扫描(linux)【nm
  • 安全攻防笔记

    2018-12-01 12:35:29
    TCP/IP:可靠性链接,三次握手 UDP::不可靠连接,eg:视频直播、游戏。 (一)nmap扫描语法:nmap +命令+地址 -sn:主机发现,扫描网段内主机 nmap -sn 10.10.8.0/24 注意:扫描结果中的SERVICE为端口默认使用的...
  • Socket通讯之UDP

    2021-03-16 18:01:58
    在TCP全开扫描中有一点不太好,可能在全开扫描中会被目标主机的日志记录下来,而且最为主要的是建立了TCP三次握手后最后一次是没用的,在目标返回一个SYN+ACK类型的数据包之后,已经达到了目的,最后发送的ACK数据...
  • -sS:扫描,Nmap发送SYN包到远程主机,不建立完整的三次握手 -F:快速扫描扫描一些常用端口 -sV:探测开启的端口来获取服务、版本信息 如图所示,发现其开放了22和80端口,接下来我们用浏览器进入网站...
  • 使用本机操作系统提供的connect()函数来连接目标端口,与目标系统完成一次完整的三次握手过程。如果目标端口正在监听connect()就成功返回;否则,说明该端口不可访问 TCP SYN扫描打开扫描) 客户端首先向...
  • Nmap详解

    2019-10-05 05:35:18
    -sT:TCP Connect扫描,进行完整的TCP三次握手,该类型扫描已被检测,且会在目标日志中记录大量连接请求和错误信息 -sS:TCP SYN扫描,只会发送SYN包,简称扫描。使用者机器发送SYN请求给目标机器,若对方返回...
  • 1. -sS Tcp SYN Scan 不需要三次握手,速度快 优点:开放扫描,Nmap发送SYN包到远程主机,但是它不会产生任何会话,目标主机几乎不会把连接记入系统日志。(防止对方判断为扫描攻击),扫描速度快,效率高,在...
  • 3.3.2 长连接与短连接 3.3.3 二分图应用于最佳匹配问题(游客对房间的满意度之和最大问题) 3.3.4 class与struct的区别? 3.3.5 虚函数和纯虚函数 3.3.6 menset()函数 3.3.7 实现一个函数,对一个正整数n,算...
  • 敖丙用近 40 张图解被问千百遍的 TCP 三次握手和四次挥手面试题 键入网址后,期间发生了什么? IP 基础知识“全家桶”,敖丙45 张图一套带走你 你还在为 TCP 重传、滑动窗口、流量控制、拥塞控制发愁吗?看完图解就...

空空如也

空空如也

1 2
收藏数 29
精华内容 11
关键字:

半连接扫描三次握手