Python NmapProcess.run方法代码示例

# 需要导入模块: from libnmap.process import NmapProcess [as 别名]
# 或者: from libnmap.process.NmapProcess import run [as 别名]
    def _update_info(self):
        """ Scans the network for devices.
            Returns boolean if scanning successful. """
        if not self.success_init:
            return False

        _LOGGER.info("Scanning")

        options = "-F --host-timeout 5"
        exclude_targets = set()
        if self.home_interval:
            now = dt_util.now()
            for host in self.last_results:
                if host.last_update + self.home_interval > now:
                    exclude_targets.add(host)
            if len(exclude_targets) > 0:
                target_list = [t.ip for t in exclude_targets]
                options += " --exclude {}".format(",".join(target_list))

        nmap = NmapProcess(targets=self.hosts, options=options)

        nmap.run()

        if nmap.rc == 0:
            if self._parse_results(nmap.stdout):
                self.last_results.extend(exclude_targets)
        else:
            self.last_results = []
            _LOGGER.error(nmap.stderr)
            return False

# 需要导入模块: from libnmap.process import NmapProcess [as 别名]
# 或者: from libnmap.process.NmapProcess import run [as 别名]
 def start(self):
     ''' Start Discovery '''
     logs = core.logs.Logger(config=self.config, proc_name="discovery.nmap")
     logger = logs.getLogger()
     logger = logs.clean_handlers(logger)
     logger.info("Starting scan of environment")
     try:
         nmap = NmapProcess(self.config['discovery']['plugins']['nmap']['target'],
                            options=self.config['discovery']['plugins']['nmap']['flags'])
     except Exception as e:
         raise Exception("Failed to execute nmap process: {0}".format(e.message))
     up = []
     while True:
         nmap.run()
         nmap_report = NmapParser.parse(nmap.stdout)
         for scanned_host in nmap_report.hosts:
             if "up" in scanned_host.status and scanned_host.address not in up:
                 up.append(scanned_host.address)
                 logger.debug("Found new host: {0}".format(scanned_host.address))
                 if self.dbc.new_discovery(ip=scanned_host.address):
                     logger.debug("Added host {0} to discovery queue".format(
                         scanned_host.address))
                 else:
                     logger.debug("Failed to add host {0} to discovery queue".format(
                         scanned_host.address))
         logger.debug("Scanned {0} hosts, {1} found up".format(
             len(nmap_report.hosts), len(up)))
         time.sleep(self.config['discovery']['plugins']['nmap']['interval'])
     return True

# 需要导入模块: from libnmap.process import NmapProcess [as 别名]
# 或者: from libnmap.process.NmapProcess import run [as 别名]
def __do_scan(targets, options):
    '''
    do scan a target by nmap
    '''
    parsed = None
    nmproc = NmapProcess(targets=targets, options=options)
    nmproc.run()
    
    try:
        parsed = NmapParser.parse(nmproc.stdout)
    except NmapParserException as e:
        print("Exception raised while parsing scan: {0}".format(e.msg))

    return parsed

# 需要导入模块: from libnmap.process import NmapProcess [as 别名]
# 或者: from libnmap.process.NmapProcess import run [as 别名]
def knockd_test(ip,outfile,start_key,stop_key):
	## Baseline Nmap Scan
	print "\n[-] Scanning " + ip + " with Nmap, this could take a minute...go get some coffee"
	nm = NmapProcess(ip, options="-p 0-65535")
        rc = nm.run()
        if nm.rc == 0:
        	before = NmapParser.parse(nm.stdout)
        	before_ports = before.hosts[0].get_ports()
        else:
        	print nm.stderr
        	sys.exit()

	## Sending Default Knockd Port Knock Sequence with Scapy
        print "\n[-] Sending default knockd sequence to " + ip
	for x in start_key:
                send(IP(dst=ip)/TCP(dport=x),verbose=0)

	## Subsequent Nmap Scan
	print "\n[-] Scanning again...too soon for more coffee???"
	rc = nm.run()
	if nm.rc == 0:
		after = NmapParser.parse(nm.stdout)
		after_ports = after.hosts[0].get_ports()
	else:
		print nm.stderr
		sys.exit()
	
	## Compare Scans to Determine if any Services were Activated
	diff = set(after_ports)-set(before_ports)
	new_ports = list(diff)
	if len(new_ports) > 0:
		print "\n[+] " + str(len(new_ports)) + " new port(s) opened..."
		for x in new_ports:
			print x
		print "\nWriting to output file - " + outfile
                f = open(outfile,'a')
                f.write("Ports opened on " + ip + " - " + str(new_ports) + "\n")
		f.close()
	
	## Stopping Activated Services with Default Close Sequence
		print "\n[-] Disabling opened service on " + ip + " by sending default close sequence..."
		print "   *** If you want to manually interact with the service, use the knockd_on-off.py script ***\n"
        	for x in stop_key:
                	send(IP(dst=ip)/TCP(dport=x),verbose=0)
	elif len(new_ports) == 0:
		print "\n[-] No new services opened...\n"
	else:
		print "\n[-] An error has occurred"
		sys.exit()

# 需要导入模块: from libnmap.process import NmapProcess [as 别名]
# 或者: from libnmap.process.NmapProcess import run [as 别名]
    def _process(self, session):
        nmproc = NmapProcess("10.0.0.1", "-sT")
        parsed = None
        rc = nmproc.run()
        if rc != 0:
            logging.critical("NMAP Scan failed: {0}".format(nmproc.stderr))

        try:
            parsed = NmapParser.parse(nmproc.stdout)
        except NmapParserException as e:
            logging.critical("NMAP Parse failed: {0}".format(e.msg))

        if parsed is not None:
            for host in parsed.hosts:
                if len(host.hostnames):
                    tmp_host = host.hostnames.pop()
                else:
                    tmp_host = host.address

                print("Nmap scan report for {0} ({1})".format(tmp_host, host.address))
                print("Host is {0}.".format(host.status))
                print("  PORT     STATE         SERVICE")

                for serv in host.services:
                    pserv = "{0:>5s}/{1:3s}  {2:12s}  {3}".format(
                        str(serv.port), serv.protocol, serv.state, serv.service
                    )
                    if len(serv.banner):
                        pserv += " ({0})".format(serv.banner)
                    print(pserv)

# 需要导入模块: from libnmap.process import NmapProcess [as 别名]
# 或者: from libnmap.process.NmapProcess import run [as 别名]
def celery_nmap_scan(targets, options):
    """celery_nmap_scan task"""

    def status_callback(nmapscan=None):
        """status callback"""
        try:
            current_task.update_state(state="PROGRESS",
                                      meta={"done": nmapscan.progress,
                                            "etc": nmapscan.etc})
        except Exception as e:
            print("status_callback error: " + str(e))

    nm = NmapProcess(targets, options, event_callback=status_callback)
    rc = nm.run()

    if rc == 0 and nm.stdout:
        r = nm.stdout

        # scan is finished. Now call task to insert Report into persistent db
        celery_nmap_store_report.delay(task_id=celery_nmap_scan.request.id)

    else:
        r = None

    return {"rc": rc, "report": r}

# 需要导入模块: from libnmap.process import NmapProcess [as 别名]
# 或者: from libnmap.process.NmapProcess import run [as 别名]
    def nmap_script_scan(self, target, portlist=None, version_intense="0", script_name=None):
        '''
        Runs nmap with the -sC arg or the --script arg if script_name is provided. Options used are: -sV --version-intensity <default:0> -sC|--script=<script_name>
        Arguments:
            - ``target``: IP or the range of IPs that need to be tested
            - ``portlist``: list of ports, range of ports that need to be tested. They can either be comma separated or separated by hyphen
            example: 121,161,240 or 1-100
            - ``version_intense``: Version intensity of OS detection
            - ``script_name``: Script Name that needs to be referenced
        Examples:
        | nmap script scan  | target | portlist | version_intense | script_name |
        '''
        target = str(target)
        if portlist and script_name:
            nmap_proc_cmd = "-Pn -sV --version-intensity {0} --script={1} -p {2}".format(version_intense, script_name, portlist)
        elif portlist and not script_name:
            nmap_proc_cmd = "-Pn -sV --version-intensity {0} -sC -p {1}".format(version_intense, portlist)
        elif script_name and not portlist:
            raise Exception('EXCEPTION: If you use specific script, you have to specify a port')
        else:
            nmap_proc_cmd = "-Pn -sV --version-intensity {0} -sC".format(version_intense)

        nmproc = NmapProcess(target, nmap_proc_cmd)
        rc = nmproc.run()
        if rc != 0:
            raise Exception('EXCEPTION: nmap scan failed: {0}'.format(nmproc.stderr))
        try:
            parsed = NmapParser.parse(nmproc.stdout)
            print parsed
            self.results = parsed
        except NmapParserException as ne:
            print 'EXCEPTION: Exception in parsing results: {0}'.format(ne.msg)

# 需要导入模块: from libnmap.process import NmapProcess [as 别名]
# 或者: from libnmap.process.NmapProcess import run [as 别名]
	def do_scan(targets,options):
		parsed = None
		proc = NmapProcess(targets,options)
		running = proc.run()
		if running != 0:
			raise Exception("Scan failed")
		return NmapParser.parse(proc.stdout)

# 需要导入模块: from libnmap.process import NmapProcess [as 别名]
# 或者: from libnmap.process.NmapProcess import run [as 别名]
class Mynmap(object):
    def __init__(self, scanIp):
        self.scanIp = scanIp
    def startNmap(self):
        self.nmapScan = NmapProcess(self.scanIp, options='-sV -T4 -A -Pn -p 22-65534')
        self.rc = self.nmapScan.run()
        if self.nmapScan.rc == 0:
        #print self.nmapScan.stdout
            return self.nmapScan.stdout
        else:
            print self.nmapScan.stderr
            logging.info('nmap scan error'+ self.scanIp)
            return False
    def startParse(self):
    #nmap xml parse func
        try:
            self.startNmapScan = self.startNmap()
            if self.startNmap is not False:
                self.parse = NmapParser.parse(self.startNmapScan)
                self.nmapScanreport = self.startReport()
            else:
                sys.exit(0)
        except NmapParserException as e:
                logging.info(e)
                sys.exit(0)
    def startReport(self):
        self.report = self.parse
        if self.report:
            for self.host in self.report.hosts:
                for self.serv in self.host.services:
                    if len(self.serv.banner) and self.serv.state == 'open':
                        scanResult.append((str(self.host.address) + ' ' + '+' + ' ' + 'NmapService: [' +str(self.serv.state) + ' ' + str(self.serv.protocol) + ' ' + "<" + str(self.serv.port) + ">"  + ' ' + str(self.serv.service) + ' ' +  str(self.serv.banner)) + ']')
                    else:
                        if self.serv.state == 'open':
                            scanResult.append((str(self.host.address) + ' ' + '+' + ' ' + 'NmapService: [' + str(self.serv.state) + ' ' + str(self.serv.protocol) + ' ' + "<" + str(self.serv.port) + ">" +  ' ' + str(self.serv.service)) + ']')

# 需要导入模块: from libnmap.process import NmapProcess [as 别名]
# 或者: from libnmap.process.NmapProcess import run [as 别名]
	def getC(self,ip=None,config=None):
		try:
			if ip==None:
				ip=self.ip
			count={}
			ip=ip+"/24"
			ops="-open -p%s"
			getops=ops%config
			nm=NmapProcess(ip,options=getops)
			ps=nm.run()
			parsed=NmapParser.parse(nm.stdout)
			for host in parsed.hosts:
				count[host.address]=[host.address]
				for serv in host.services:
					if len(serv.cpelist)>1:

						count[host.address].append(serv.service+":"+str(serv.port)+":"+serv.cpelist[0])
					else:
						count[host.address].append(serv.service+":"+str(serv.port))
			return count



		except Exception,e:
			print e
			return []

# 需要导入模块: from libnmap.process import NmapProcess [as 别名]
# 或者: from libnmap.process.NmapProcess import run [as 别名]
    def consume(self, targets):
        print(targets)
        nm = NmapProcess(targets, options='-v -sn')
        rc = nm.run()

        try:
            parsed = NmapParser.parse(nm.stdout)
        except NmapParserException as e:
            print("Exception raised while parsing scan: %s" % (e.msg))

        HOST_UP = 1
        HOST_DOWN = 0

        scans = Table('host_up', connection=self.dynamo)

        with scans.batch_write() as batch:
            for host in parsed.hosts:
                # Insert into database and delete from queue
                if (host.status == 'down'):
                    status = 0
                elif (host.status == 'up'):
                    status = 1
                else:
                    status = -1

                batch.put_item(data={
                    'ip': host.address,
                    'status': status,
                    'datetime': int(time.time())
                })

# 需要导入模块: from libnmap.process import NmapProcess [as 别名]
# 或者: from libnmap.process.NmapProcess import run [as 别名]
    def nmap_os_services_scan(self, target, portlist=None, version_intense = 0):
        '''
        Runs
        Arguments:
            - ``target``: IP or the range of IPs that need to be tested
            - ``portlist``: list of ports, range of ports that need to be tested. They can either be comma separated or separated by hyphen
            example: 121,161,240 or 1-100
            - ``version_intense``: Version intensity of OS detection
        Examples:
        | nmap os services scan  | target | portlist | version_intense |
        '''
        target = str(target)
        if portlist:
            nmap_proc_cmd = "-Pn -sV --version-intensity {0} -p {1}".format(portlist, version_intense)
        else:
            nmap_proc_cmd = "-Pn -sV --version-intensity {0}".format(portlist)

        nmproc = NmapProcess(target, nmap_proc_cmd)
        rc = nmproc.run()
        if rc != 0:
            raise Exception('EXCEPTION: nmap scan failed: {0}'.format(nmproc.stderr))
        try:
            parsed = NmapParser.parse(nmproc.stdout)
            print parsed
            self.results = parsed
        except NmapParserException as ne:
            print 'EXCEPTION: Exception in parsing results: {0}'.format(ne.msg)

# 需要导入模块: from libnmap.process import NmapProcess [as 别名]
# 或者: from libnmap.process.NmapProcess import run [as 别名]
def portScan():
	global parsed
	print"Scanning ports: %s" %ports
	nm = NmapProcess(args.target, options="-sS -n -T4 -p%s" %ports)
	rc = nm.run()
	if rc != 0:
		print("nmap scan failed: {0}".format(nm.stderr))
	parsed = NmapParser.parse(nm.stdout)

# 需要导入模块: from libnmap.process import NmapProcess [as 别名]
# 或者: from libnmap.process.NmapProcess import run [as 别名]
    def run(self):
        nm = NmapProcess(targets=str(self.artifact['name']), options='-sT -sV -Pn -T5 -p21,22,23,25,80,6667,1337')
        nm.run()

        if nm.is_successful():
            report = NmapParser.parse_fromstring(nm.stdout)
            for host in report.hosts:
                if host.is_up():
                    results = {
                        'ports': host.get_open_ports(),
                        'services': []
                    }

                    for service in host.services:
                        if service.state == 'open':
                            serv = {
                                'banner': service.banner,
                                'protocol': service.protocol,
                                'service': service.service,
                                'port': service.port}
                            results['services'].append(serv)

                    if self.artifact['subtype'] == 'ipv4':
                        results['hostnames'] = host.hostnames
                        for h in host.hostnames:
                            self.artifact['children'].append({
                                'name': h,
                                'type': 'host',
                                'subtype': 'fqdn',
                                'source': 'Nmap'
                            })

                    elif self.artifact['subtype'] == 'fqdn':
                        results['ipv4'] = host.address
                        self.artifact['children'].append({
                            'name': host.address,
                            'type': 'host',
                            'subtype': 'ipv4',
                            'source': 'Nmap'
                        })

                    self.artifact['data']['nmap'] = results

        else:
            warning('Nmap scanner failed - no results')

# 需要导入模块: from libnmap.process import NmapProcess [as 别名]
# 或者: from libnmap.process.NmapProcess import run [as 别名]
def nmap_scan(targets, options):
	
	nm = NmapProcess(targets, options)
	rc = nm.run()
	
	if nm.rc == 0:
		return nm.stdout
	else:
		return nm.stderr