def getUniquePortsOutput(hosts, option=constants.PORT_OPT_DEFAULT, filters=None):
if filters == None:
filters = nmap.NmapFilters()
tcpPorts = set()
udpPorts = set()
allPorts = set()
for ip in hosts:
host = hosts[ip]
tcpPorts = tcpPorts.union(host.getUniquePortIds('tcp', port_filter=filters.ports, service_filter=filters.services))
udpPorts = udpPorts.union(host.getUniquePortIds('udp', port_filter=filters.ports, service_filter=filters.services))
allPorts = tcpPorts.union(udpPorts)
output = common.TextOutput()
output.addHumn(getNmapFiltersString(filters))
output.addHumn(getHeader('Unique open port list (%s)' % (option)))
if option == constants.PORT_OPT_DEFAULT:
output.addHumn(getHeader("TCP:"))
output.addMain(re.sub(r'[\[\] ]','',str(sorted(tcpPorts))))
output.addHumn(getHeader("UDP:"))
output.addMain(re.sub(r'[\[\] ]','',str(sorted(udpPorts))))
output.addHumn(getHeader("Combined:"))
output.addMain(re.sub(r'[\[\] ]','',str(sorted(allPorts))))
elif option == constants.PORT_OPT_TCP:
output.addMain(re.sub(r'[\[\] ]','',str(sorted(tcpPorts))))
elif option == constants.PORT_OPT_UDP:
output.addMain(re.sub(r'[\[\] ]','',str(sorted(udpPorts))))
elif option == constants.PORT_OPT_COMBINED:
output.addMain(re.sub(r'[\[\] ]','',str(sorted(allPorts))))
return output
def executeCommands(cmd, nmapOutput, filters=None):
if(filters == None):
filters = nmap.NmapFilters()
header('Running Commands')
for host in nmapOutput.getHosts(filters):
if len(host.ports) > 0:
executeCommand(cmd, host.ip)
def getHostListOutput(nmapOutput, includePorts = True, filters = None):
'''Returns string representations of filtered hosts output'''
if filters == None:
filters = nmap.NmapFilters()
output = common.TextOutput()
output.addHumn(getNmapFiltersString(filters))
output.addHumn(getHeader('Matched IP list'))
# Get all hosts that are up and matched filters
hostsOutput = []
for host in nmapOutput.getHosts(filters=filters):
curHostOutput = [host.ip, '']
for protocol in constants.PROTOCOLS:
fullPortsString = ''
for port in [port for port in host.ports if port.protocol == protocol]:
tmpPortString = str(port.portId)
if(settings.colourSupported and port.matched):
tmpPortString = "\033[1;32m" + tmpPortString + "\033[1;m"
if len(fullPortsString) > 0:
fullPortsString += ","
fullPortsString += tmpPortString
curHostOutput[1] += "%s:[%s] " % (protocol,fullPortsString)
hostsOutput.append(curHostOutput)
for hostOutput in hostsOutput:
if includePorts:
output.addMain("%s\t%s" % (hostOutput[0], hostOutput[1]))
else:
output.addMain(hostOutput[0])
return output
def getFilters(self):
filters = nmap.NmapFilters()
filters.services = self.getServiceFilter()
filters.ports = self.getPortFilter()
filters.hosts = self.getHostFilter()
filters.onlyAlive = self.only_alive
filters.mustHavePorts = self.have_ports
return filters
def main():
parser = OptionParser(
usage=
"%prog [options] [list of nmap xml files or directories containing xml files]"
)
parser.add_option("-p",
"--port",
dest="ports",
help="Optional port filter argument e.g. 80 or 80,443",
metavar="PORTS")
parser.add_option(
"--service",
dest="svcFilter",
help=
"Optional service filter argument e.g. http or ntp,http (only used in conjunction with -s)"
)
parser.add_option(
"-e",
"--exec",
dest="cmd",
help=
"Script or tool to run on each IP remaining after port filter is applied. IP will be appended to end of script command line",
metavar="CMD")
parser.add_option("-l",
"--iplist",
dest="ipList",
action="store_true",
help="Print plain list of matching IPs")
parser.add_option("-a",
"--alive-hosts",
dest="aliveHosts",
action="store_true",
help="Print plain list of all alive IPs")
parser.add_option("-s",
"--service-list",
dest="servicelist",
action="store_true",
help="Also print list of unique services with names")
parser.add_option("-S",
"--host-summary",
dest="hostSummary",
action="store_true",
help="Show summary of scanned/alive hosts")
parser.add_option("-v",
"--verbose",
dest="verbose",
action="store_true",
help="Verbose service list")
parser.add_option("-u",
"--unique-ports",
dest="uniquePorts",
action="store_true",
default=False,
help="Print list of unique open ports")
parser.add_option("-R",
"--raw",
dest="raw",
action="store_true",
help="Only print raw output (no headers)")
parser.add_option(
"-r",
"--recurse",
dest="recurse",
action="store_true",
help="Recurse subdirectories if directory provided for nmap files")
parser.add_option("-i",
"--interactive",
dest="interactive",
action="store_true",
help="Enter interactive shell")
parser.add_option(
"-c",
"--combine",
dest="combine",
help=
"Combine all input files into single nmap-parse compatible xml file")
parser.add_option("--imported-files",
dest="importedFiles",
action="store_true",
help="List successfully imported files")
parser.add_option("-V",
"--version",
dest="version",
action="store_true",
help="Print version info")
(options, args) = parser.parse_args()
if (options.version):
print("Nmap Parse Version %s\nReleased: %s" % (VERSION, RELEASE_DATE))
return
# Determine whether to output headings
settings.printHumanFriendlyText = not options.raw
settings.colourSupported = helpers.supportsColour()
# Find all XML files
nmapXmlFilenames = []
for arg in args:
nmapXmlFilenames.extend(
helpers.getNmapFiles(arg, recurse=options.recurse))
# Exit if no XML files found
if nmapXmlFilenames == []:
eprint('No Nmap XML files found.\n')
parser.print_help()
sys.exit(1)
portFilter = []
serviceFilter = []
filters = nmap.NmapFilters()
if not options.interactive:
# Check if only specific ports should be parsed
if options.ports:
portFilter = list(map(int, options.ports.split(',')))
filters.ports = portFilter
hprint('Set port filter to %s' % portFilter)
# Check if only specific ports should be parsed
if options.svcFilter:
serviceFilter = options.svcFilter.split(',')
filters.services = serviceFilter
hprint('Set service filter to %s' % serviceFilter)
# Parse nmap files
nmapOutput = nmap.NmapOutput(nmapXmlFilenames)
# Output successfully loaded and any failed files
helpers.printImportSummary(nmapOutput, False)
# Print import summary if requested
if options.importedFiles:
header("Import Summary")
helpers.printImportSummary(nmapOutput, True)
# Check if default flags were used
defaultFlags = not options.ipList and not options.aliveHosts and not options.servicelist and not options.verbose and not options.cmd and not options.combine and not options.uniquePorts and not options.importedFiles
if options.combine:
nmapOutput.generateNmapParseXml(options.combine)
if not options.interactive:
if (defaultFlags):
defaultFilters = nmap.NmapFilters()
defaultFilters.onlyAlive = False
defaultFilters.mustHavePorts = False
helpers.printHosts(nmapOutput, filters=defaultFilters)
helpers.printUniquePorts(nmapOutput.getHostDictionary(),
filters=defaultFilters)
if options.ipList:
helpers.printHosts(nmapOutput, filters=filters)
if (options.uniquePorts):
helpers.printUniquePorts(
nmapOutput.getHostDictionary(filters=filters), filters=filters)
if options.aliveHosts:
helpers.printAliveIps(nmapOutput)
if options.servicelist or options.verbose:
helpers.printServiceList(nmapOutput,
filters=filters,
verbose=options.verbose)
if options.cmd:
helpers.executeCommands(options.cmd, nmapOutput, filters=filters)
if settings.printHumanFriendlyText and (defaultFlags
or options.hostSummary):
hprint("\nSummary\n-------")
hprint("Total hosts: %s" % str(len(nmapOutput.Hosts)))
hprint("Alive hosts: %s" %
str(len(nmapOutput.getAliveHosts(filters))))
else:
enterInteractiveShell(nmapOutput)