mirror of
https://github.com/nmap/nmap.git
synced 2025-12-06 04:31:29 +00:00
324 lines
14 KiB
Python
324 lines
14 KiB
Python
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
# ***********************IMPORTANT NMAP LICENSE TERMS************************
|
|
# * *
|
|
# * The Nmap Security Scanner is (C) 1996-2020 Insecure.Com LLC ("The Nmap *
|
|
# * Project"). Nmap is also a registered trademark of the Nmap Project. *
|
|
# * *
|
|
# * This program is distributed under the terms of the Nmap Public Source *
|
|
# * License (NPSL). The exact license text applying to a particular Nmap *
|
|
# * release or source code control revision is contained in the LICENSE *
|
|
# * file distributed with that version of Nmap or source code control *
|
|
# * revision. More Nmap copyright/legal information is available from *
|
|
# * https://nmap.org/book/man-legal.html, and further information on the *
|
|
# * NPSL license itself can be found at https://nmap.org/npsl. This header *
|
|
# * summarizes some key points from the Nmap license, but is no substitute *
|
|
# * for the actual license text. *
|
|
# * *
|
|
# * Nmap is generally free for end users to download and use themselves, *
|
|
# * including commercial use. It is available from https://nmap.org. *
|
|
# * *
|
|
# * The Nmap license generally prohibits companies from using and *
|
|
# * redistributing Nmap in commercial products, but we sell a special Nmap *
|
|
# * OEM Edition with a more permissive license and special features for *
|
|
# * this purpose. See https://nmap.org/oem *
|
|
# * *
|
|
# * If you have received a written Nmap license agreement or contract *
|
|
# * stating terms other than these (such as an Nmap OEM license), you may *
|
|
# * choose to use and redistribute Nmap under those terms instead. *
|
|
# * *
|
|
# * The official Nmap Windows builds include the Npcap software *
|
|
# * (https://npcap.org) for packet capture and transmission. It is under *
|
|
# * separate license terms which forbid redistribution without special *
|
|
# * permission. So the official Nmap Windows builds may not be *
|
|
# * redistributed without special permission (such as an Nmap OEM *
|
|
# * license). *
|
|
# * *
|
|
# * Source is provided to this software because we believe users have a *
|
|
# * right to know exactly what a program is going to do before they run it. *
|
|
# * This also allows you to audit the software for security holes. *
|
|
# * *
|
|
# * Source code also allows you to port Nmap to new platforms, fix bugs, *
|
|
# * and add new features. You are highly encouraged to submit your *
|
|
# * changes as a Github PR or by email to the dev@nmap.org mailing list *
|
|
# * for possible incorporation into the main distribution. Unless you *
|
|
# * specify otherwise, it is understood that you are offering us very *
|
|
# * broad rights to use your submissions as described in the Nmap Public *
|
|
# * Source License Contributor Agreement. This is important because we *
|
|
# * fund the project by selling licenses with various terms, and also *
|
|
# * because the inability to relicense code has caused devastating *
|
|
# * problems for other Free Software projects (such as KDE and NASM). *
|
|
# * *
|
|
# * The free version of Nmap is distributed in the hope that it will be *
|
|
# * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. Warranties, *
|
|
# * indemnification and commercial support are all available through the *
|
|
# * Npcap OEM program--see https://nmap.org/oem. *
|
|
# * *
|
|
# ***************************************************************************/
|
|
|
|
import gobject
|
|
import gtk
|
|
import gtk.gdk
|
|
import pango
|
|
import re
|
|
|
|
import zenmapCore.I18N # lgtm[py/unused-import]
|
|
from zenmapCore.UmitLogging import log
|
|
from zenmapCore.UmitConf import NmapOutputHighlight
|
|
|
|
from zenmapGUI.NmapOutputProperties import NmapOutputProperties
|
|
|
|
|
|
class NmapOutputViewer (gtk.VBox):
|
|
HIGHLIGHT_PROPERTIES = ["details", "date", "hostname", "ip", "port_list",
|
|
"open_port", "closed_port", "filtered_port"]
|
|
|
|
def __init__(self, refresh=1, stop=1):
|
|
self.nmap_highlight = NmapOutputHighlight()
|
|
gtk.VBox.__init__(self)
|
|
|
|
# Creating widgets
|
|
self.__create_widgets()
|
|
|
|
# Setting scrolled window
|
|
self.__set_scrolled_window()
|
|
|
|
# Setting text view
|
|
self.__set_text_view()
|
|
|
|
buffer = self.text_view.get_buffer()
|
|
# The end mark is used to scroll to the bottom of the display.
|
|
self.end_mark = buffer.create_mark(None, buffer.get_end_iter(), False)
|
|
|
|
self.refreshing = True
|
|
|
|
# Adding widgets to the VBox
|
|
self.pack_start(self.scrolled, expand=True, fill=True)
|
|
|
|
# The NmapCommand instance, if any, whose output is shown in this
|
|
# display.
|
|
self.command_execution = None
|
|
# The position of the last read from the output stream.
|
|
self.output_file_pointer = None
|
|
|
|
def __create_widgets(self):
|
|
# Creating widgets
|
|
self.scrolled = gtk.ScrolledWindow()
|
|
self.text_view = gtk.TextView()
|
|
|
|
def __set_scrolled_window(self):
|
|
# Seting scrolled window
|
|
self.scrolled.set_border_width(5)
|
|
self.scrolled.add(self.text_view)
|
|
self.scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
|
|
|
|
def __set_text_view(self):
|
|
self.text_view.set_wrap_mode(gtk.WRAP_WORD)
|
|
self.text_view.set_editable(False)
|
|
|
|
self.tag_font = self.text_view.get_buffer().create_tag(None)
|
|
self.tag_font.set_property("family", "Monospace")
|
|
for property in self.HIGHLIGHT_PROPERTIES:
|
|
settings = self.nmap_highlight.__getattribute__(property)
|
|
tag = self.text_view.get_buffer().create_tag(property)
|
|
|
|
if settings[0]:
|
|
tag.set_property("weight", pango.WEIGHT_HEAVY)
|
|
else:
|
|
tag.set_property("weight", pango.WEIGHT_NORMAL)
|
|
|
|
if settings[1]:
|
|
tag.set_property("style", pango.STYLE_ITALIC)
|
|
else:
|
|
tag.set_property("style", pango.STYLE_NORMAL)
|
|
|
|
if settings[2]:
|
|
tag.set_property("underline", pango.UNDERLINE_SINGLE)
|
|
else:
|
|
tag.set_property("underline", pango.UNDERLINE_NONE)
|
|
|
|
text_color = settings[3]
|
|
highlight_color = settings[4]
|
|
|
|
tag.set_property(
|
|
"foreground", gtk.color_selection_palette_to_string(
|
|
[gtk.gdk.Color(*text_color), ]))
|
|
tag.set_property(
|
|
"background", gtk.color_selection_palette_to_string(
|
|
[gtk.gdk.Color(*highlight_color), ]))
|
|
|
|
def go_to_host(self, host):
|
|
"""Go to host line on nmap output result"""
|
|
buff = self.text_view.get_buffer()
|
|
start_iter = buff.get_start_iter()
|
|
|
|
found_tuple = start_iter.forward_search(
|
|
"\nNmap scan report for %s\n" % host, gtk.TEXT_SEARCH_TEXT_ONLY
|
|
)
|
|
if found_tuple is None:
|
|
return
|
|
|
|
found = found_tuple[0]
|
|
if not found.forward_line():
|
|
return
|
|
self.text_view.scroll_to_iter(found, 0, True, 0, 0)
|
|
|
|
def show_output_properties(self, widget):
|
|
nmap_out_prop = NmapOutputProperties(self.text_view)
|
|
|
|
nmap_out_prop.run()
|
|
|
|
for prop in nmap_out_prop.property_names:
|
|
widget = nmap_out_prop.property_names[prop][8]
|
|
|
|
wid_props = []
|
|
|
|
if widget.bold:
|
|
wid_props.append(1)
|
|
else:
|
|
wid_props.append(0)
|
|
|
|
if widget.italic:
|
|
wid_props.append(1)
|
|
else:
|
|
wid_props.append(0)
|
|
|
|
if widget.underline:
|
|
wid_props.append(1)
|
|
else:
|
|
wid_props.append(0)
|
|
|
|
wid_props.append("(%s, %s, %s)" % (widget.text_color.red,
|
|
widget.text_color.green,
|
|
widget.text_color.blue))
|
|
wid_props.append("(%s, %s, %s)" % (widget.highlight_color.red,
|
|
widget.highlight_color.green,
|
|
widget.highlight_color.blue))
|
|
|
|
self.nmap_highlight.__setattr__(widget.property_name, wid_props)
|
|
|
|
nmap_out_prop.destroy()
|
|
self.nmap_highlight.save_changes()
|
|
self.apply_highlighting()
|
|
|
|
def apply_highlighting(self, start_iter=None, end_iter=None):
|
|
buf = self.text_view.get_buffer()
|
|
|
|
if start_iter is None:
|
|
start_iter = buf.get_start_iter()
|
|
else:
|
|
# Patterns are line-oriented; start on a line boundary.
|
|
start_iter.backward_line()
|
|
if end_iter is None:
|
|
end_iter = buf.get_end_iter()
|
|
|
|
buf.apply_tag(self.tag_font, start_iter, end_iter)
|
|
|
|
if not self.nmap_highlight.enable:
|
|
return
|
|
|
|
text = buf.get_text(start_iter, end_iter)
|
|
|
|
for property in self.HIGHLIGHT_PROPERTIES:
|
|
settings = self.nmap_highlight.__getattribute__(property)
|
|
for m in re.finditer(settings[5], text, re.M):
|
|
m_start_iter = start_iter.copy()
|
|
m_start_iter.forward_chars(m.start())
|
|
m_end_iter = start_iter.copy()
|
|
m_end_iter.forward_chars(m.end())
|
|
buf.apply_tag_by_name(property, m_start_iter, m_end_iter)
|
|
|
|
def show_nmap_output(self, output):
|
|
"""Show the string (or unicode) output in the output display."""
|
|
try:
|
|
self.text_view.get_buffer().set_text(output)
|
|
self.apply_highlighting()
|
|
except MemoryError:
|
|
self.show_large_output_message(self.command_execution)
|
|
|
|
def set_command_execution(self, command):
|
|
"""Set the live running command whose output is shown by this display.
|
|
The current output is extracted from the command object."""
|
|
self.command_execution = command
|
|
if command is not None:
|
|
self.text_view.get_buffer().set_text(u"")
|
|
self.output_file_pointer = 0
|
|
else:
|
|
self.output_file_pointer = None
|
|
self.refresh_output()
|
|
|
|
def show_large_output_message(self, command=None):
|
|
buf = self.text_view.get_buffer()
|
|
try:
|
|
running = (command is not None and command.scan_state() is True)
|
|
except Exception:
|
|
running = False
|
|
complete = False
|
|
else:
|
|
complete = not running
|
|
if running:
|
|
buf.set_text("Warning: You have insufficient resources for Zenmap "
|
|
"to be able to display the complete output from Nmap here. \n"
|
|
"Zenmap will continue to run the scan to completion. However,"
|
|
" some features of Zenmap might not work as expected.")
|
|
elif complete:
|
|
buf.set_text("Warning: You have insufficient resources for Zenmap "
|
|
"to be able to display the complete output from Nmap here. \n"
|
|
"The scan has completed. However, some features of Zenmap "
|
|
"might not work as expected.")
|
|
else:
|
|
buf.set_text("Warning: You have insufficient resources for Zenmap "
|
|
"to be able to display the complete output from Nmap here. \n"
|
|
"The scan has been stopped. Some features of Zenmap might not "
|
|
"work as expected.")
|
|
|
|
def refresh_output(self, widget=None):
|
|
"""Update the output from the latest output of the command associated
|
|
with this view, as set by set_command_execution. It has no effect if no
|
|
command has been set."""
|
|
log.debug("Refresh nmap output")
|
|
|
|
if self.command_execution is None:
|
|
return
|
|
|
|
# Seek to the end of the most recent read.
|
|
self.command_execution.stdout_file.seek(self.output_file_pointer)
|
|
|
|
try:
|
|
new_output = self.command_execution.stdout_file.read()
|
|
except MemoryError:
|
|
self.show_large_output_message(self.command_execution)
|
|
return
|
|
|
|
self.output_file_pointer = self.command_execution.stdout_file.tell()
|
|
|
|
v_adj = self.scrolled.get_vadjustment()
|
|
if new_output and v_adj is not None:
|
|
# Find out if the view is already scrolled to the bottom.
|
|
at_end = (v_adj.value >= v_adj.upper - v_adj.page_size)
|
|
|
|
buf = self.text_view.get_buffer()
|
|
prev_end_mark = buf.create_mark(
|
|
None, buf.get_end_iter(), left_gravity=True)
|
|
try:
|
|
buf.insert(buf.get_end_iter(), new_output)
|
|
# Highlight the new text.
|
|
self.apply_highlighting(
|
|
buf.get_iter_at_mark(prev_end_mark),
|
|
buf.get_end_iter())
|
|
except MemoryError:
|
|
self.show_large_output_message(self.command_execution)
|
|
return
|
|
|
|
if at_end:
|
|
# If we were already scrolled to the bottom, scroll back to the
|
|
# bottom again. Also do it in an idle handler in case the added
|
|
# text causes a scroll bar to appear and reflow the text,
|
|
# making the text a bit taller.
|
|
self.text_view.scroll_mark_onscreen(self.end_mark)
|
|
gobject.idle_add(
|
|
lambda: self.text_view.scroll_mark_onscreen(
|
|
self.end_mark))
|