python如何编写类似nmap的扫描工具
本文主要是利用scapy包编写了一个简易扫描工具，支持ARP、ICMP、TCP、UDP发现扫描，支持TCP SYN、UDP端口扫描，如下：
usage: python scan.py <-p ping扫描类型> <-s 端口发现类型> [-t target] [--port ports]
简单扫描工具，可以进行存活扫描及端口扫描.
存活扫描包括：ARP扫描、ICMP扫描、TCP扫描、UDP扫描.
端口扫描包括：TCP SYN扫描、TCP ACK扫描、TCP FIN扫描.
optional arguments:
-h, --help show this help message and exit
-v, --version show program's version number and exit
target group:
用于设置IP、PORT参数
--target TARGET target为IP或IP段，如192.168.1.1，192.168.1.x，或1
92.168.1.1-254
--port PORT port为待扫描的端口，如21,80,...或21-80
ping group:
用于开启存活扫描相关选项
-p 开启存活扫描
--ARP 启动ARP扫描
--ICMP 启动ICMP扫描
--TCP 启动TCP扫描
--UDP 启动UDP扫描
port scan group:
用于开启端口扫描相关选项
-s 开启端口扫描
--SYN 开启SYN扫描
--ACK 开启ACK扫描
--FIN 开启FIN扫描
--UPORT 开启UDP端口扫描
utils group:
用于开启扫描过程中的一些实用选项
--timeout TIMEOUT 设置发包超时时间,默认0.5秒
--retry RETRY 设置发包重试次数，默认不重试
以上做为说明，祝好运！
一、发现扫描
1.首先进行ARP扫描
python scan.py -p --target 192.168.1.1-254 --ARP [+]IP: 192.168.1.1 => MAC: 14:75:90:xx:xx:xx [+]IP: 192.168.1.111 => MAC: c6:36:55:xx:xx:xx [+]总共耗时9.84091806412秒.
通过retry参数增加发包尝试次数，如下：
python scan.py -p --target 192.168.1.1-254 --ARP --retry 2[+]IP: 192.168.1.1 => MAC: 14:75:90:xx:xx:xx[+]IP: 192.168.1.111 => MAC: c6:36:55:xx:xx:xx[+]IP: 192.168.1.102 => MAC: 58:1f:28:xx:xx:xx[+]IP: 192.168.1.114 => MAC: 6c:8d:c1:xx:xx:xx[+]IP: 192.168.1.103 => MAC: 84:38:38:xx:xx:xx[+]总共耗时20.429942131秒.
2.使用ICMP扫描，若没有指定任何扫描类型参数，默认会启用ICMP扫描，如下：
python scan.py -p --target 192.168.1.1-254 [+]没有指定任何ping扫描方式，默认选择ICMP扫描 [+]IP:主机192.168.1.1 echo-reply. [+]IP:主机192.168.1.111 echo-reply. [+]总共耗时10.7177450657秒.
通过timeout参数，设置较长的超时，可以防止网络状况不好造成的丢包，如下：
python scan.py -p --target 192.168.1.1-254 --timeout 2 [+]没有指定任何ping扫描方式，默认选择ICMP扫描 [+]IP:主机192.168.1.1 echo-reply. [+]IP:主机192.168.1.111 echo-reply. [+]IP:主机192.168.1.114 echo-reply. [+]总共耗时10.7566649914秒.
3.使用TCP扫描
python scan.py -p --target 192.168.1.100-120 --TCP --timeout 1 [+]请稍等，时间较长！ [!]扫描... 192.168.1.100 [!]扫描... 192.168.1.101 [!]扫描... 192.168.1.102 [!]扫描... 192.168.1.103 [!]扫描... 192.168.1.104 [!]扫描... 192.168.1.105 [!]扫描... 192.168.1.106 [!]扫描... 192.168.1.107 [!]扫描... 192.168.1.108 [!]扫描... 192.168.1.109 [!]扫描... 192.168.1.110 [!]扫描... 192.168.1.111 [!]扫描... 192.168.1.112 [!]扫描... 192.168.1.113 [!]扫描... 192.168.1.114 [!]扫描... 192.168.1.115 [!]扫描... 192.168.1.116 [!]扫描... 192.168.1.117 [!]扫描... 192.168.1.118 [!]扫描... 192.168.1.119 [!]扫描... 192.168.1.120 [+]正在处理扫描信息. ==================== [+]主机 192.168.1.102 在线. [+]主机 192.168.1.103 在线. [+]主机 192.168.1.111 在线. [+]主机 192.168.1.114 在线. [+]总共耗时16.4359779358秒.
4.使用UDP扫描
python scan.py -p --target 192.168.1.100-120 --UDP --retry 3 [+]请稍等，时间较长！ [!]扫描... 192.168.1.100 [!]扫描... 192.168.1.101 [!]扫描... 192.168.1.102 [!]扫描... 192.168.1.103 [!]扫描... 192.168.1.104 [!]扫描... 192.168.1.105 [!]扫描... 192.168.1.106 [!]扫描... 192.168.1.107 [!]扫描... 192.168.1.108 [!]扫描... 192.168.1.109 [!]扫描... 192.168.1.110 [!]扫描... 192.168.1.111 [!]扫描... 192.168.1.112 [!]扫描... 192.168.1.113 [!]扫描... 192.168.1.114 [!]扫描... 192.168.1.115 [!]扫描... 192.168.1.116 [!]扫描... 192.168.1.117 [!]扫描... 192.168.1.118 [!]扫描... 192.168.1.119 [!]扫描... 192.168.1.120 [+]正在处理扫描信息. ==================== [+]主机 192.168.1.102 在线. [+]主机 192.168.1.103 在线. [+]主机 192.168.1.111 在线. [+]主机 192.168.1.114 在线. [+]总共耗时33.5198891163秒.
二、端口扫描
1、TCP SYN端口扫描，不设置端口参数，则默认扫描1-1024端口
python scan.py --target 192.168.1.110-115 -s --SYN [+]没有指定任何扫描端口，默认扫描1-1024 [!]扫描... 192.168.1.110 [!]扫描... 192.168.1.111 [!]扫描... 192.168.1.112 [!]扫描... 192.168.1.113 [!]扫描... 192.168.1.114 [!]扫描... 192.168.1.115 [+]正在处理扫描信息. ==================== [+]主机 192.168.1.111 开放的TCP端口有：[80] [+]总共耗时165.125555992秒.
扫描指定端口：
python scan.py --target 192.168.1.1-254 -s --SYN --port 80 --timeout 1 [!]扫描... 192.168.1.1 [!]扫描... 192.168.1.2 [!]扫描... 192.168.1.3 [!]扫描... 192.168.1.4 ... [!]扫描... 192.168.1.253 [!]扫描... 192.168.1.254 [+]正在处理扫描信息. ==================== [+]主机 192.168.1.111 开放的TCP端口有：[80] [+]主机 192.168.1.1 开放的TCP端口有：[80] [+]总共耗时9.72222185135秒.
2、扫描UDP端口
python scan.py --target 192.168.1.1 -s --UPORT --timeout 1 [+]没有指定任何扫描端口，默认扫描1-1024 [!]扫描... 192.168.1.1 [+]正在处理扫描信息. ==================== [+]主机 192.168.1.1 开放的UDP端口有：[520] [+]总共耗时27.4742250443秒.
也可同时进行发现扫描与端口扫描，如下：
python scan.py --target 192.168.1.1-254 -p --ARP -s --SYN --port 80 --timeout 1 --retry 2 [+]IP: 192.168.1.1 => MAC: 14:75:90:xx:xx:xx [+]IP: 192.168.1.102 => MAC: 58:1f:28:xx:xx:xx [+]IP: 192.168.1.114 => MAC: 6c:8d:c1:xx:xx:xx [+]IP: 192.168.1.103 => MAC: 84:38:38:xx:xx:xx [+]IP: 192.168.1.101 => MAC: 5c:f7:e6:xx:xx:xx [!]扫描... 192.168.1.1 [!]扫描... 192.168.1.2 ... [!]扫描... 192.168.1.253 [!]扫描... 192.168.1.254 [+]正在处理扫描信息. ==================== [+]主机 192.168.1.1 开放的TCP端口有：[80] [+]主机 192.168.1.111 开放的TCP端口有：[80] [+]总共耗时45.2775988579秒.
OK，最后附上源码：
import argparse
import re
import time
import threading
from scapy.all import *
import logging
logging.getLogger('scapy.runtime').setLevel(logging.ERROR)
class Discovery_Scan(object):
'''
说明:用于发现扫描
'''
def __init__(self,args,timeout=0.5,retry=0):
self.targets = parse_target(args)
self.timeout = timeout
self.retry = retry
def arp_scan(self,pdst):
#ARP发现扫描
ans = sr1(ARP(pdst=pdst),timeout=self.timeout,retry=self.retry,verbose=False)
if ans:
if ans[ARP].op == 2: #操作码为2是is-at，是ARP响应
print '[+]IP: %s => MAC: %s' % (pdst,ans[ARP].hwsrc)
def icmp_scan(self,dst):
#ICMP发现扫描
ans = sr1(IP(dst=dst)/ICMP(),timeout=self.timeout,retry=self.retry,verbose=False)
if ans:
if ans[ICMP].type == 0: #ICMP type为0表示是ICMP echo-reply
print '[+]IP:主机%s echo-reply.' % dst
tcp_info = {}
def tcp_scan(self,dst,port):
#TCP SYN,发送TCP SYN包，有响应表示端口开放
ans,unans = sr(IP(dst=dst)/TCP(sport=RandShort(),dport=port,flags='S'),
timeout=self.timeout,retry=self.retry,verbose=False)
if ans.res:
if ans.res[0][0][IP].dst not in Discovery_Scan.tcp_info:
Discovery_Scan.tcp_info[ans.res[0][0][IP].dst] = True
udp_info = {}
def udp_scan(self,dst,port):
#UDP，发送UDP包，有响应表示端口开放
ans,uans = sr(IP(dst=dst)/UDP(sport=RandShort(),dport=port),
timeout=self.timeout,retry=self.retry,verbose=False)
if ans.res:
if ans.res[0][0][IP].dst not in Discovery_Scan.udp_info:
Discovery_Scan.udp_info[ans.res[0][0][IP].dst] = True
class Port_Scan(object):
'''
说明:用于进行端口扫描，判断端口是否开放
'''
def __init__(self,args,timeout=0.5,retry=0):
self.targets = parse_target(args)
self.timeout = timeout
self.retry = retry
syn_port_dict = {}
def syn_port_scan(self,dst,port):
#TCP SYN端口扫描，若SYN包返回携带SYN、ACK（即TCP.flags=18）标志的包，则表明此端口打开。
ans,uans = sr(IP(dst=dst)/TCP(sport=RandShort(),dport=port,flags='S'),
timeout=self.timeout,retry=self.retry,verbose=False)
if ans:
first_respons_pkt = ans.res[0][1]
if first_respons_pkt[TCP] and first_respons_pkt[TCP].flags == 18:
if first_respons_pkt[IP].src not in Port_Scan.syn_port_dict:
Port_Scan.syn_port_dict[first_respons_pkt[IP].src] = [first_respons_pkt[TCP].sport]
else:
Port_Scan.syn_port_dict[first_respons_pkt[IP].src].append(first_respons_pkt[TCP].sport)
udp_port_dict = {}
def udp_port_scan(self,dst,port):
#UDP端口扫描，若UDP端口返回ICMP port-unreachable,则表示端口打开。（排除某些主机对任何UDP端口的探测都响应为ICMP port-unrechable）
ans,uans = sr(IP(dst=dst)/UDP(sport=RandShort(),dport=port),
timeout=self.timeout, retry=self.retry, verbose=False)
if ans.res and ans.res[0][1].haslayer(UDPerror):
first_respons_pkt = ans.res[0][1]
if first_respons_pkt[IP].src not in Port_Scan.udp_port_dict:
Port_Scan.udp_port_dict[first_respons_pkt[IP].src] = [first_respons_pkt[UDPerror].dport]
else:
Port_Scan.udp_port_dict[first_respons_pkt[IP].src].append(first_respons_pkt[UDPerror].dport)
def parse_opt():
'''
@说明：通过argparse模块解析程序传入的参数
@return:args
'''
usage = 'python %(prog)s <-p ping扫描类型> <-s 端口发现类型> [-t target] [--port ports]'
description = '简单扫描工具，可以进行存活扫描及端口扫描.\n' \
'存活扫描包括：ARP扫描、ICMP扫描、TCP扫描、UDP扫描.\n' \
'端口扫描包括：TCP SYN扫描、TCP ACK扫描、TCP FIN扫描.'
epilog = '以上做为说明，祝好运！'
parser = argparse.ArgumentParser(usage=usage,description=description,epilog=epilog,version='v1.0')
target_group = parser.add_argument_group('target group',description='用于设置IP、PORT参数')
target_group.add_argument('--target',dest='target',action='store',
help='target为IP或IP段，如192.168.1.1，192.168.1.x，或192.168.1.1-254')
target_group.add_argument('--port',dest='port',action='store',
help='port为待扫描的端口，如21,80,...或21-80')
ping_group = parser.add_argument_group('ping group',description='用于开启存活扫描相关选项')
ping_group.add_argument('-p',dest='ping',action='store_true',help='开启存活扫描')
ping_group.add_argument('--ARP',dest='ARP',action='store_true',help='启动ARP扫描')
ping_group.add_argument('--ICMP',dest='ICMP',action='store_true',help='启动ICMP扫描')
ping_group.add_argument('--TCP',dest='TCP',action='store_true',help='启动TCP扫描')
ping_group.add_argument('--UDP',dest='UDP',action='store_true',help='启动UDP扫描')
port_scan_group = parser.add_argument_group('port scan group',description='用于开启端口扫描相关选项')
port_scan_group.add_argument('-s',dest='scan',action='store_true',help='开启端口扫描')
port_scan_group.add_argument('--SYN',dest='SYN',action='store_true',help='开启SYN扫描')
port_scan_group.add_argument('--ACK',dest='ACK',action='store_true',help='开启ACK扫描')
port_scan_group.add_argument('--FIN',dest='FIN',action='store_true',help='开启FIN扫描')
port_scan_group.add_argument('--UPORT', dest='UPORT', action='store_true', help='开启UDP端口扫描')
utils_group = parser.add_argument_group('utils group',description='用于开启扫描过程中的一些实用选项')
utils_group.add_argument('--timeout',dest='timeout',action='store',type=float,help='设置发包超时时间,默认0.5秒')
utils_group.add_argument('--retry',dest='retry',action='store',type=int,help='设置发包重试次数，默认不重试')
args = parser.parse_args()
if not args.ping and not args.scan:
print '[-]必须通过-p/-s选项开启一种扫描'
print '\n'
parser.print_help()
exit(1)
elif not args.target:
print '[-]必须通过--target选项指定扫描的对象'
print '\n'
parser.print_help()
exit(1)
if args.ping:
if not args.ARP and not args.ICMP and not args.TCP and not args.UDP:
args.ICMP = True #若没有指定任何ping扫描方式，则默认选择ICMP扫描
print '[+]没有指定任何ping扫描方式，默认选择ICMP扫描'
if args.scan:
if not args.SYN and not args.ACK and not args.FIN and not args.UPORT:
args.SYN = True #若没有指定任何端口扫描方式，则默认选择SYN扫描
print '[+]没有指定任何端口扫描方式，默认选择SYN扫描'
if not args.port:
args.port = '1-1024' #若没有指定任何扫描端口，则默认扫描1-1024
print '[+]没有指定任何扫描端口，默认扫描1-1024'
return args
def parse_target(args):
'''
@说明：用于解析如'192.168.1.1，192.168.1.x，...或192.168.1.1-254'格式的IP为单独的IP，用于解析如'21,80,...或21-80'格式的端口为单独的端口
@param: args,一个namespace对象
@return: (ip_list,port_list)
'''
pattern1 = r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$'
pattern2 = r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}-\d{1,3}$'
pattern3 = r'\d{1,5}$'
pattern4 = r'\d{1,5}-\d{1,5}$'
ip_list,port_list = None,None
if args.target:
if re.search(pattern1,args.target):
ip_list = args.target.split(',')
elif re.match(pattern2,args.target):
_split = args.target.split('-')
first_ip = _split[0]
ip_split = first_ip.split('.')
ipdot4 = range(int(ip_split[3]), int(_split[1]) + 1)
ip_list = [ip_split[0] + '.' + ip_split[1] + '.' + ip_split[2] + '.' + str(p) for p in ipdot4]
else:
print '[-]target格式输入有误，请查看帮助！'
exit(1)
if args.port:
if re.match(pattern4,args.port):
_split = args.port.split('-')
port_list = range(int(_split[0]),int(_split[1])+1)
elif re.search(pattern3,args.port):
port_list = args.port.split(',')
else:
print '[-]port格式输入有误，请查看帮助！'
exit(1)
return ip_list,port_list
def main():
'''
@说明：扫描的主程序，首先根据条件创建Ping扫描或端口扫描对象，然后调用相关的扫描方法进行扫描。
'''
args = parse_opt()
if args.ping: #是否启动Ping扫描
if not args.timeout and not args.retry:
obj_ping = Discovery_Scan(args)
elif args.timeout and not args.retry:
obj_ping = Discovery_Scan(args,timeout=args.timeout)
elif not args.timeout and args.retry:
obj_ping = Discovery_Scan(args,retry=args.retry)
else:
obj_ping = Discovery_Scan(args,args.timeout,args.retry)
ip_list = obj_ping.targets[0]
if ip_list:
#ARP扫描
if args.ARP:
for pdst in ip_list:
t = threading.Thread(target=obj_ping.arp_scan,args=(pdst,))
t.start()
while threading.activeCount() != 1: #避免线程还没有运行完就提前输出不全的结果
time.sleep(1)
#ICMP扫描
elif args.ICMP:
for dst in ip_list:
t = threading.Thread(target=obj_ping.icmp_scan,args=(dst,))
t.start()
while threading.activeCount() != 1: #避免线程还没有运行完就提前输出不全的结果
time.sleep(1)
#TCP扫描
elif args.TCP:
port_list = [80,443,21,22,23,25,53,135,139,137,445,1158,1433,1521,3306,3389,7001,8000,8080,9090]
print '[+]请稍等，时间较长！'
for dst in ip_list:
print '[!]扫描...',dst
for port in port_list:
t = threading.Thread(target=obj_ping.tcp_scan,args=(dst,port))
t.start()
print '[+]正在处理扫描信息.'
while threading.activeCount() != 1: #避免线程还没有运行完就提前输出不全的结果
time.sleep(1)
if not obj_ping.tcp_info:
print '\n'
print '=' * 20
print '[+]未发现在线主机.'
else:
print '\n'
print '=' * 20
for ip_a in sorted(obj_ping.tcp_info.keys()):
print '[+]主机 %s 在线.' % ip_a
#UDP扫描
elif args.UDP:
port_list = [7,9.13,15,37,53,67,68,69,135,137,138,139,445,520]
print '[+]请稍等，时间较长！'
for dst in ip_list:
print '[!]扫描...',dst
for port in port_list:
t = threading.Thread(target=obj_ping.udp_scan,args=(dst,port))
t.start()
print '[+]正在处理扫描信息.'
while threading.activeCount() != 1: #避免线程还没有运行完就提前输出不全的结果
time.sleep(1)
if not obj_ping.udp_info:
print '\n'
print '=' * 20
print '[+]未发现在线主机.'
else:
print '\n'
print '=' * 20
for ip_a in sorted(obj_ping.udp_info.keys()):
print '[+]主机 %s 在线.' % ip_a
if args.scan: #是否启动端口扫描
if not args.timeout and not args.retry:
obj_port = Port_Scan(args)
elif args.timeout and not args.retry:
obj_port = Port_Scan(args,timeout=args.timeout)
elif not args.timeout and args.retry:
obj_port = Port_Scan(args,retry=args.retry)
else:
obj_port = Port_Scan(args,args.timeout,args.retry)
ip_list,port_list = obj_port.targets
if ip_list and port_list:
if args.SYN:
for dst in ip_list:
print '[!]扫描...',dst
for port in port_list:
t = threading.Thread(target=obj_port.syn_port_scan,args=(dst,int(port)))
t.start()
print '[+]正在处理扫描信息.'
while threading.activeCount() != 1: #避免线程还没有运行完就提前输出不全的结果
time.sleep(1)
if not obj_port.syn_port_dict:
print '\n'
print '=' * 20
print '[+]未发现开放TCP端口.'
else:
print '\n'
print '=' * 20
for k,v in obj_port.syn_port_dict.items():
print '[+]主机 %s 开放的TCP端口有：%s' % (k,str(v))
elif args.ACK:
pass #基本不能使用
elif args.FIN:
pass #基本不能使用
elif args.UPORT:
for dst in ip_list:
print '[!]扫描...',dst
for port in port_list:
t = threading.Thread(target=obj_port.udp_port_scan,args=(dst,int(port)))
t.start()
print '[+]正在处理扫描信息.'
while threading.activeCount() != 1: #避免线程还没有运行完就提前输出不全的结果
time.sleep(1)
if not obj_port.udp_port_dict:
print '\n'
print '=' * 20
print '[+]未发现开放UDP端口.'
else:
print '\n'
print '=' * 20
for k,v in obj_port.udp_port_dict.items():
print '[+]主机 %s 开放的UDP端口有：%s' % (k,str(v))
if __name__ == '__main__':
try:
start_time = time.time()
main()
stop_time = time.time()
print '[+]总共耗时'+str(stop_time-start_time)+'秒.'
except Exception,e:
print '[-]执行出错，具体错误见下面信息.'
print e
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我们。
相关推荐
-
Python实现的多线程端口扫描工具分享
昨晚今晚写了两晚,总算把Py Port Scanner 写完了,姑且称之为0.1版本,算是一个Python多线程端口扫描工具. 水平有限,实话中间有一些困惑和不解的地方,代码可能也写的比较乱.有些问题并未找到很好的解决方法,还望大家谅解.速度大家自己试验,我感觉还行. 送上效果图两份,分别是扫单IP和扫IP段: 源码: 复制代码 代码如下: # -*- coding: utf-8 -*- __author__ = 'Phtih0n' import threading, socket, sys,
-
Python实现的IP端口扫描工具类示例
本文实例讲述了Python实现的IP端口扫描工具类.分享给大家供大家参考,具体如下: 去年服务器老是被攻击,每次上线之后,上线的人急急忙忙下班,忘记关闭一些端口.导致有次服务器被攻破.损失严重. 这段时间再做仪器对接,把医疗器械对接到我们SAAS平台,有些仪器是通过网线进行数据传输的.通过网线进行数据传输,无非就是通过端口号进行传输交互,但是找不到说明书,国内搞仪器对接开发的也很少,所以网上开源的或者介绍的东西很少,对于我们来说,仪器是个黑盒,想要拿到里面的东西,还要自己去摸索,去试验,比较浪费
-
Python脚本实现Web漏洞扫描工具
这是去年毕设做的一个Web漏洞扫描小工具,主要针对简单的SQL注入漏洞.SQL盲注和XSS漏洞,代码是看过github外国大神(听说是SMAP的编写者之一)的两个小工具源码,根据里面的思路自己写的.以下是使用说明和源代码. 一.使用说明: 1.运行环境: Linux命令行界面+Python2.7 2.程序源码: Vim scanner//建立一个名为scanner的文件 Chmod a+xscanner//修改文件权限为可执行的 3.运行程序: Python scanner//运行文件 若没有携
-
在Python中合并字典模块ChainMap的隐藏坑【推荐】
在Python中,当我们有两个字典需要合并的时候,可以使用字典的 update 方法,例如: a = {'a': 1, 'b': 2} b = {'x': 3, 'y': 4} a.update(b) print(a) 运行效果如下图所示: 然而,这个方法有一个问题--它会改变其中一个字典.如果我们不想改变原有的两个字典,那么我们必需要单独再创建一个字典: a = {'a': 1, 'b': 2} b = {'x': 3, 'y': 4} c = dict(a) c.update(b) prin
-
python通过nmap扫描在线设备并尝试AAA登录(实例代码)
如果管理网络设备很多,不可能靠人力每天去登录设备去查看是否在线.所以,可以利用python脚本通过每天扫描网络中的在线设备.可以部署在服务器上做成定时任务,每天发送AAA巡检报告. 下面是我写的一个python练手小程序.用来扫描一个网段中的在线主机,并尝试AAA去登录.统计一个大网段内可以成功aaa登录的主机. 注意: 该程序只是测试小程序,还有些小bug需要解决.不是通用的程序.主要提供一个大致思路. 主要用到了python-nmap, paramiko库. 程序大概思路: 利用nmap扫描
-
python ChainMap的使用和说明详解
ChainMap是Python collections模块中的一个成员,它用来将多个map组合到一起.Chain是链条的意思,字面意思就是把map串联到一起. 问题的背景是我们有多个字典或者映射,想把它们合并成为一个单独的映射,有人说可以用update进行合并,这样做的问题就是新建了一个数据结构以致于当我们对原来的字典进行更改的时候不会同步.如果想建立一个同步的查询方法,可以使用ChainMap 先看一下初步使用 from collections import ChainMap a = {"x&
-
python nmap实现端口扫描器教程
NMap,也就是Network Mapper,最早是Linux下的网络扫描和嗅探工具包. nmap是一个网络连接端扫描软件,用来扫描网上电脑开放的网络连接端.确定哪些服务运行在哪些连接端,并且推断计算机运行哪个操作系统(这是亦称 fingerprinting).它是网络管理员必用的软件之一,以及用以评估网络系统安全. 正如大多数被用于网络安全的工具,nmap 也是不少黑客及骇客(又称脚本小子)爱用的工具 .系统管理员可以利用nmap来探测工作环境中未经批准使用的服务器,但是黑客会利用nmap来搜
-
巧用python和libnmapd,提取Nmap扫描结果
每当我进行内网渗透面对大量主机和服务时,我总是习惯使用自动化的方式从 nmap 扫描结果中提取信息.这样有利于自动化检测不同类型的服务,例如对 web 服务进行路径爆破,测试 SSL/TLS 服务使用的密钥或协议,以及其他有针对性的测试. 我在渗透测试中也会经常使用到 IPthon 或 *nix shell,而这些又都能够通过 Python 来访问,无论是直接在脚本中使用.在 REPL 环境下使用,还是将代码写入到磁盘上然后通过 shell 命令访问都是非常好用的. 为了完成这些,libnmap
-
python ChainMap 合并字典的实现步骤
字典是Python语言中唯一的映射类型. 映射类型对象里哈希值(键,key)和指向的对象(值,value)是一对多的的关系,通常被认为是可变的哈希表. 字典对象是可变的,它是一个容器类型,能存储任意个数的Python对象,其中也可包括其他容器类型. 字典类型与序列类型的区别: 1. 存取和访问数据的方式不同. 2. 序列类型只用数字类型的键(从序列的开始按数值顺序索引): 3. 映射类型可以用其他对象类型作键(如:数字.字符串.元祖,一般用字符串作键),和序列类型的键不同,映射类型的键直4.接或
-
python如何编写类似nmap的扫描工具
本文主要是利用scapy包编写了一个简易扫描工具,支持ARP.ICMP.TCP.UDP发现扫描,支持TCP SYN.UDP端口扫描,如下: usage: python scan.py <-p ping扫描类型> <-s 端口发现类型> [-t target] [--port ports] 简单扫描工具,可以进行存活扫描及端口扫描. 存活扫描包括:ARP扫描.ICMP扫描.TCP扫描.UDP扫描. 端口扫描包括:TCP SYN扫描.TCP ACK扫描.TCP FIN扫描. optio
-
利于python脚本编写可视化nmap和masscan的方法
介绍 我编写了一个快速且带有斑点的python脚本,以可视化nmap和masscan的结果.它通过解析来自扫描的XML日志并生成所扫描IP范围的直观表示来工作.以下屏幕截图是输出示例: 由于缺少更好的词,我将从现在开始将输出称为地图.每个主机由一个彩色正方形表示.覆盖地图大部分内容的浅蓝色方块表示主机处于脱机状态(或仅未响应masscan的SYN.)其他彩色方块表示处于联机状态且具有开放端口的主机.正方形的颜色从蓝色到红色.正方形越红,表示主机上打开的端口越多.将鼠标悬停在每个方块上,将在工具提
-
Python编程编写完善的命令行工具
目录 1. python-fire 2. mando 最后的话 1. python-fire python-fire 是一个三方库,可以将任何 Python 对象变成一个命令行接口. 使用前先 pip install fire 下. 可以把你的函数直接变成命令行接口: import fire def hello(name="World"): return "Hello %s!" % name if __name__ == '__main__': fire.Fire(
-
Python编写nmap扫描工具
NMAP是一款开源的网络探测和安全审核的工具,他能够快速的扫描出某个服务器对外暴露的端口信息.是在安全测试领域很常见的一个工具. 今天我们用python的模拟实现一个简单版本的端口扫描工具,主要使用到socket模块,socket模块中提供了connect()和connect_ex()两个方法,其中connect_ex()方法有返回值,返回值是一个int类型的数字,标记是否连接成功,0为连接成功,其他数字表示有异常. def connect(self, address: Union[_Addre
-
python 实现端口扫描工具
# 简单的端口扫描工具 # 作者: Charles # 公众号: Charles的皮卡丘 import time import socket import threading # 判断是否为正确的IP地址. def isIP(ip): ip_addr = ip.split('.') if len(ip_addr) != 4: return False for ipnum in ip_addr: if not (0 <= int(ipnum) < 255): return False else:
-
Python利用socket模块开发简单的端口扫描工具的实现
一.socket 1.简介 Socket又称"套接字",应用程序通常通过"套接字"向网络发出请求或者应答网络请求,使主机间或者一台计算机上的进程间可以通讯. socket的工作流程 socket 采用C/S 模式,分为服务端和客户端 服务端数据处理流程 创建socket -> 绑定到地址和端口 -> 等待连接 -> 开始通信-> 关闭连接 客户端数据处理流程 创建socket -> 等待连接 -> 开始通信-> 关闭连接 客