python命令解析使用多线程扫描端口

最新推荐文章于 2023-07-06 19:48:37 发布
最新推荐文章于 2023-07-06 19:48:37 发布
阅读量584 收藏
点赞数 1
分类专栏： python学习 文章标签： python 网络 udp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44975450/article/details/125243621
版权

使用python实现端口扫描的脚本，使用到optparse模块解析命令
大部分解释已写入脚本注释。文件名为portscan.py

'''
命令解析，多线程，端口扫描
----------author:Bluecap-------------
'''

#命令行参数解析模块
from optparse import OptionParser
import queue
import socket
import re
import threading


parser=OptionParser('Usage: %prog -i<target ip>')
#添加命令,这里可以选定类型，当然后面的正则可能没有必要
parser.add_option('-i',dest='ip',type='string',help='specify target ip')
#端口为范围,或者单个。单个单线程，多个多线程
parser.add_option('-p',dest='port',type='string',help='specify target port')
parser.add_option('--thread',dest='thread',type='int',help='specify thread num')
#接上--brief只显示开放端口，store_true为加上--brief时brief为True,否则为False
parser.add_option('--brief',dest='brief',action='store_true',help='brief mode')
#全局参数控制输出
# flag=False
#解析命令
opts,argv=parser.parse_args()
# print('opts:',opts)
# print('argv:',argv)
# print(type(opts))
# print(opts.ip)
# print(opts.port)
# print(type(opts.thread))
'''
opts: {'ip': None, 'port': None, 'thread': None}
E:\python作业2>python portscan.py -i 120.0.0.1 -p 21 --thread 4
opts: {'ip': '120.0.0.1', 'port': '21', 'thread': 4}
argv: []
'''
def print_help():
    print('Usage: %prog -i<target ip> -p<target port> --thread<thread num> --brief<show detail>')#至少要输入ip和端口


#单线程扫描 单个端口或者端口范围
def singleThread(ip,ports):
    try:
        port=int(ports)
        s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        if s.connect_ex((ip,port))==0:
            print('|{:^16}|{:^16}|{:^16}|'.format(ip,port,'开放'))
        else:
            print('|{:^16}|{:^16}|{:^16}|'.format(ip,port,'关闭'))
    except:
        pre_port=int(opts.port.split('-')[0])
        suf_port=int(opts.port.split('-')[1])
        if pre_port==suf_port:
            port=pre_port
            s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
            #连接成功返回0，失败返回编码
            if s.connect_ex((ip,port))==0:
                print('|{:^16}|{:^16}|{:^16}|'.format(ip,port,'开放'))
            else:
                print('|{:^16}|{:^16}|{:^16}|'.format(ip,port,'关闭'))
        elif pre_port<suf_port:
            try:
                for port in range(pre_port,suf_port+1):
                    s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
                    #连接成功返回0，失败返回编码
                    if s.connect_ex((ip,port))==0:
                        print('|{:^16}|{:^16}|{:^16}|'.format(ip,port,'开放'))
                    else:
                        #flag=opts.brief
                        if opts.brief:
                            pass#加上breif后不输出扫描信息
                        else:
                            print('|{:^16}|{:^16}|{:^16}|'.format(ip,port,'关闭'))
            except Exception as e:
                print(e)
        else:
            print('端口范围错误')
            exit(1)

#面向对象的方式进行调用
# ip=opts.ip
# ports=opts.port.split('-')

def scanport(ip ,port):
    #给线程上锁，防止取出重复端口
    with threading.Lock():#线程锁，自动加自动解
        s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)#TCP连接
        if s.connect_ex((ip,port))==0:
            print('|{:^16}|{:^16}|{:^16}|'.format(ip,port,'开放'))
        else:
            if opts.brief:
                pass
            else:
                print('|{:^16}|{:^16}|{:^16}|'.format(ip,port,'关闭'))

#多线程端口扫描
def MultiThread(ip,port,threads):
    pre_port=int(opts.port.split('-')[0])
    suf_port=int(opts.port.split('-')[1])
    #print('pre_port:',pre_port)
    if pre_port==suf_port:
        singleThread(ip,pre_port)
        s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        banner()
        #连接成功返回0，失败返回编码
        if s.connect_ex((ip,port))==0:
            print('|{:^16}|{:^16}|{:^16}|'.format(ip,port,'开放'))
        else:
            print('|{:^16}|{:^16}|{:^16}|'.format(ip,port,'关闭'))
    elif pre_port<suf_port:
        port_num=suf_port-pre_port
        #print('port_num:',port_num)
         #把端口放入队列中，每个线程结束后取出一个
        queue_ports=queue.Queue(port_num+1)
        for port in range(pre_port,suf_port+1):
            queue_ports.put(port)
            #print('queue_ports size:',queue_ports.qsize())
        #print('queue_ports size:',queue_ports.qsize())
        #扫描的端口数小于用户输入的线程数，让线程数等于端口数
        if threads>0 and threads<=20:
            if threads>=port_num:
                #print('多线程第一种情况')
                threads=port_num
                for t in range(threads):
                    try:
                        thread=threading.Thread(target=scanport,args=(ip,pre_port+t),daemon=True)#传递参数，设置为守护线程
                        thread.start()
                        #print(f'线程{t+1}开始启动...')
                    except threading.ThreadError as e:
                        print(f'线程{t+1}执行异常')
            else:
                #print('多线程第二种情况')
                #初始时创建四个线程
                for th in range(threads):
                    try:
                        thread=threading.Thread(target=scanport,args=(ip,queue_ports.get()))#如果设置成守护线程可能有几个端口就有几个线程
                        thread.start()
                        #print(f'线程{th+1}开始启动...')
                    except threading.ThreadError as e:
                        print(f'线程{th+1}执行异常')
                else:#执行完for后执行else
                    while True:
                        # if queue_ports.empty():
                        #     break
                        thread_number=threading.active_count()#等同于threading.enumerate()
                        surplus_ports=queue_ports.qsize()#当前未扫描端口数
                        #print('surplus_ports:',surplus_ports)
                        if surplus_ports==0:
                            break
                        #print('未扫描端口数：',surplus_ports)
                        #保证有4个进程在运行，当扫描的端口少于4个时，且线程够用，就不再增加线程
                        if thread_number<(threads+1):
                            #补齐
                            gap_thread=threads-thread_number#差的线程数
                            for i in range(gap_thread):
                                thread=threading.Thread(target=scanport,args=(ip,queue_ports.get()))
                                thread.start()
                                #print(f'当前线程数为：{len(threading.enumerate())}')

                        else:
                            #等线程结束后再增加线程
                            continue
                        
                        

                       

        else:
            print('线程数最大为20')
            exit(1)
        
        if queue_ports.empty():
            #print('扫描完成...')
            exit(1)
        




def banner():
    print('+'+'-'*50+'+')
    print('|{:^16}|{:^16}|{:^16}|'.format('ip','port','status'))
    print('+'+'-'*50+'+')

if __name__=='__main__':
    #None为python空类型
    if opts.ip is None or opts.port is None:
        print_help()
    else:
        #检查IP格式
        ip=re.match('^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$',opts.ip)#匹配成功返回ip,不成功返回None
        if ip is None:
            print('ip格式错误')
            exit(1)
        else:
            ip=ip.group()
            try:#检查端口格式
                port=int(opts.port)
            except:
                #端口格式报错，说明输入是端口范围
                ports=re.match('^\d{1,5}-\d{1,5}$',opts.port)
                if ports is None:
                    print('端口格式错误')
                    exit(1)
                else:
                    #print('端口格式正确')
                    ports=ports.group()
                    threads=opts.thread
                    #print('threads:',type(threads))
                    if threads is None:#不输入线程数默认使用单线程
                        print('单线程扫描...')
                        banner()
                        singleThread(ip,ports)
                    else:
                        if threads>0 and threads<=20:
                            print('多线程扫描...')
                            banner()
                            MultiThread(ip,ports,threads)
                            print('-'*50)
                            print('扫描完成...')
                        else:
                            print('线程数错误，最大为20')
                            exit(1)
                        
                    
            else:
                banner()
                #为单端口
                singleThread(ip,port)
    #只剩下主线程，结束程序
    if threading.enumerate()==1:
        exit(1)    



'''
使用示例：
python portscan.py -i 127.0.0.1 -p 440-500 --thread 10 --brief使用10个线程扫描，只显示开放端口
python portscan.py -i 127.0.0.1 -p 440-500 --thread 10 使用10个线程扫描，显示所有端口
python portscan.py -i 127.0.0.1 -p 440-500不加线程参数，默认使用单线程
python portscan.py -i 127.0.0.1 -p 440-440只扫描440端口
python portscan.py -i 127.0.0.1 -p 445只扫描445端口
'''

练习使用python optparse写的一个作业，粗糙还望见谅！目前还存在Bug,也暂时还找不出问题所在。有需求的大佬可以进一步更改以实现更多的功能，比如说扫描ip段。

飞花舞者
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
C#实现多线程局域网扫描器的思路与具体代码
Documentlv的博客
08-04 829
要解决错误“WaitHandles的数量必须小于或等于64”，需要将句柄列表拆分为更小的块，并使用WaitAll分别等待每个块。同时，在使用多线程和异步 I/O 操作时，也需要注意程序的正确性和健壮性。因此，在使用这些技术时，请务必小心并仔细测试程序。具体来说，可以将 IP 地址分成若干段，每个线程负责扫描一段 IP 地址。上述代码实现了一个简单的多线程局域网扫描器，支持 Ping 主机和扫描主机端口，并输出扫描结果。需要注意的是，在实际应用中，可能需要对输入进行严格的验证和过滤，以确保系统安全。
C#多线程扫描IP段和端口段.exe 小黄人软件定制
chenhao0568的专栏
12-23 669
下载http://pan.baidu.com/s/1skNzDDV
多线程端口扫描器的实现(java)
热门推荐
绿眼加菲的博客
07-28 1万+
这是我大三下学期课程设计的题目，没有想象中的那么难。 一、要求： 1．利用Socket通信机制实现一个多线程的端口扫描器。 2．设计要求：       2.1用户界面：用户可以输入IP地址或IP地址段；输入端口号或端口号范围；列表显示主机名、开放的端口及开放端口上相应的服务或恶意程序的名称；功能按钮。       2.2使用多线程机制对某一地址（段）的主机端口进行扫描；说明开放端口的
c# winform 获得局域网内在线IP和计算机名，获取IP，多线程网络编程
黑色头发
10-15 1060
[code="c#"]using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text; using System.Windows.Forms; using System.Co...
C#网段扫描练习
万事胜意
04-21 1014
网段扫描练习 创建一个WPF应用程序，分别用多线程/线程池/多任务来扫描一个网段内的计算机，根据计算机的IP地址获取其主机域名。 涉及到相关的知识点：练习IPAddress类、Dns类和IPHostEntry类的基本用法，练习WPF应用程序中多线程编程的基本用法，练习多任务编程。 MainActivity.xaml <Window x:Class="网段扫描练习.MainWindow" ...
python多线程扫描端口(线程池)
09-18
主要为大家详细介绍了python多线程扫描端口，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
python使用多线程+socket实现端口扫描
01-20
今天老师上课说的内容，使用多线程+socket写一个端口扫描器 写的些许潦草，也没注释，不过问题不大，应该都能看懂 多线程+queue真的nice！！ import socket import threading import time import queue import sys ...
python实现的多线程端口扫描功能示例
09-21
主要介绍了python实现的多线程端口扫描功能,结合实例形式分析了Python基于socket的端口扫描具体步骤与相关操作技巧,需要的朋友可以参考下
python多线程端口扫描工具
01-17
python多线程端口扫描工具，多线程自定义扫描主机开放端口。 Usage: portScan.py [options] Options: -h, --help show this help message and exit -i IP, --ip=IP scan only ip default port in number 1 ...
python端口扫描器—多线程
最新发布
qq_23347209的博客
07-06 441
而多线程是Python中常用的一种并发编程方式，能够提高程序的运行效率。通过使用多线程，可以在程序中同时运行多个任务，充分利用CPU资源。提供了多线程编程的支持，可以通过创建Thread对象来创建和启动线程，通过使用锁机制来避免多个线程同时访问共享资源导致的数据竞争和错误。可以用于网络编程、数据处理、并发读写等场景，可以大大提高程序的效率和性能。Python中内置的。
C# 多线程IP端口扫描器
08-22
csdn上出现过同类代码，我下几个看效果不是很好，所以自己写了个，带上详细注释。主要用到：多线程+委托+大胆的用goto语句
多线程端口扫描器
12-20
非常好用，本人已经通过测试没有任何问题。在解决网络问题监听都行
多线程端口扫描器（C++实现）
05-21
多线程 端口扫描器 可导出扫描记录 自定义线程数 自己写的
多线程端口扫描
02-03
用于扫描服务器或者他人计算机端口是否开放，检查自己服务器端口设置。
基于Python Tkinter的多线程局域网扫描器
qq_45612828的博客
06-14 976
python、图形化界面、IP扫描、端口扫描
[python]多线程socket端口探测(包含top50-1000)
sGanYu
03-16 5270
# 多线程扫描工具 import optparse import queue import socket import sys import threading # 定义端口扫描类 # 要想创建一个线程对象，只要继承类threading.Thread，然后在__ init__里边调用threading.Thread.__init__()方法 class PortScaner(threading.Thread): def __init__(self, ip, portqueue, timeout.
Python安全开发——socket端口扫描&多线程&客户端（服务端）建立
m0_61506558的博客
02-09 417
import socket #socket库导入 import subprocess#执行cmd命令并输出的一个功能import time def connectHost(ht,pt) :再尝试用参数模式传入，直接在该脚本下调用cmd窗口即可。紧接着我们添加信息队列，保证线程的正常运行。再进行打包为exe，和nc功能类似。
docker remote api未授权访问漏洞批量扫描脚本
你和萤火虫有两个共同点，在我的眼里都会发光，同时，都已经很多年没见了
10-25 656
docker remote api未授权访问漏洞批量扫描脚本 # python3 # 5wimming import queue import threading import time import requests import json from docker import Client thread_lock = threading.Lock() out_result = [] # 输出列表 multi = 7 # 线程数量 queueSize = 10 # 申请队列空间大小,值一般略大于m
python多线程扫描端口
04-27
可以使用Python的socket模块来扫描端口，同时使用多线程可以提高扫描效率。以下是一个简单的Python多线程扫描端口的示例代码： ```python import socket import threading # 定义扫描端口的函数 def scan_port(host, port): try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.settimeout(1) s.connect((host, port)) print(f"Port {port} is open") s.close() except: pass # 定义多线程扫描端口的函数 def scan_ports(host): for port in range(1, 1024): t = threading.Thread(target=scan_port, args=(host, port)) t.start() # 测试 if __name__ == '__main__': host = '127.0.0.1' scan_ports(host) ``` 在这个示例代码中，首先定义了一个`scan_port`函数来扫描指定主机的指定端口。然后定义了一个`scan_ports`函数来使用多线程扫描指定主机的1~1023号端口。最后在主程序中调用`scan_ports`函数，并传入要扫描的主机IP地址。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值