diff options
Diffstat (limited to '')
24 files changed, 7563 insertions, 0 deletions
diff --git a/zenmap/zenmapCore/BasePaths.py b/zenmap/zenmapCore/BasePaths.py new file mode 100644 index 0000000..13be7f3 --- /dev/null +++ b/zenmap/zenmapCore/BasePaths.py @@ -0,0 +1,79 @@ +#!/usr/bin/env python3 + +# ***********************IMPORTANT NMAP LICENSE TERMS************************ +# * +# * The Nmap Security Scanner is (C) 1996-2023 Nmap Software 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.com) 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 os +import os.path +import sys + +from zenmapCore.Name import APP_NAME + + +HOME = os.path.expanduser("~") + +# The base_paths dict in this file gives symbolic names to various files. For +# example, use base_paths.target_list instead of 'target_list.txt'. + +base_paths = dict(user_config_file=APP_NAME + '.conf', + user_config_dir=os.path.join(HOME, '.' + APP_NAME), + scan_profile='scan_profile.usp', + profile_editor='profile_editor.xml', + recent_scans='recent_scans.txt', + target_list='target_list.txt', + options='options.xml', + user_home=HOME, + db=APP_NAME + ".db", + version=APP_NAME + "_version") diff --git a/zenmap/zenmapCore/DelayedObject.py b/zenmap/zenmapCore/DelayedObject.py new file mode 100644 index 0000000..d6751b7 --- /dev/null +++ b/zenmap/zenmapCore/DelayedObject.py @@ -0,0 +1,77 @@ +#!/usr/bin/env python3 + +# ***********************IMPORTANT NMAP LICENSE TERMS************************ +# * +# * The Nmap Security Scanner is (C) 1996-2023 Nmap Software 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.com) 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/ +# * +# ***************************************************************************/ + + +class DelayedObject(object): + def __init__(self, klass, *args, **kwargs): + object.__setattr__(self, "klass", klass) + object.__setattr__(self, "args", args) + object.__setattr__(self, "kwargs", kwargs) + + def __setattr__(self, name, value): + self = object.__getattribute__(self, "klass")( + *object.__getattribute__(self, "args"), + **object.__getattribute__(self, "kwargs") + ) + setattr(self, name, value) + + def __getattribute__(self, name): + self = object.__getattribute__(self, "klass")( + *object.__getattribute__(self, "args"), + **object.__getattribute__(self, "kwargs") + ) + return getattr(self, name) diff --git a/zenmap/zenmapCore/Diff.py b/zenmap/zenmapCore/Diff.py new file mode 100644 index 0000000..44f1271 --- /dev/null +++ b/zenmap/zenmapCore/Diff.py @@ -0,0 +1,187 @@ +#!/usr/bin/env python3 + +# ***********************IMPORTANT NMAP LICENSE TERMS************************ +# * +# * The Nmap Security Scanner is (C) 1996-2023 Nmap Software 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.com) 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 os +import subprocess +import sys +import tempfile +# Prevent loading PyXML +import xml +xml.__path__ = [x for x in xml.__path__ if "_xmlplus" not in x] + +import xml.sax + +from zenmapCore.Name import APP_NAME +from zenmapCore.NmapParser import NmapParserSAX +from zenmapCore.UmitConf import PathsConfig +from zenmapCore.UmitLogging import log +import zenmapCore.Paths + +# The [paths] configuration from zenmap.conf, used to get ndiff_command_path. +paths_config = PathsConfig() + + +class NdiffParseException(Exception): + pass + + +def get_path(): + """Return a value for the PATH environment variable that is appropriate + for the current platform. It will be the PATH from the environment plus + possibly some platform-specific directories.""" + path_env = os.getenv("PATH") + if path_env is None: + search_paths = [] + else: + search_paths = path_env.split(os.pathsep) + for path in zenmapCore.Paths.get_extra_executable_search_paths(): + if path not in search_paths: + search_paths.append(path) + return os.pathsep.join(search_paths) + + +class NdiffCommand(subprocess.Popen): + def __init__(self, filename_a, filename_b, temporary_filenames=[]): + self.temporary_filenames = temporary_filenames + + search_paths = get_path() + env = dict(os.environ) + env["PATH"] = search_paths + if "Zenmap.app" in sys.executable: + # These vars are set by the launcher, but they can interfere with + # Ndiff because Ndiff is also a Python application. Without + # removing these, Ndiff will attempt to run using the + # bundled Python library, and may run into version or + # architecture mismatches. + if "PYTHONPATH" in env: + del env["PYTHONPATH"] + if "PYTHONHOME" in env: + del env["PYTHONHOME"] + + command_list = [ + paths_config.ndiff_command_path, + "--verbose", + "--", + filename_a, + filename_b + ] + self.stdout_file = tempfile.TemporaryFile( + mode="r", + prefix=APP_NAME + "-ndiff-", + suffix=".xml" + ) + + log.debug("Running command: %s" % repr(command_list)) + # shell argument explained in zenmapCore.NmapCommand.py + subprocess.Popen.__init__( + self, + command_list, + universal_newlines=True, + stdout=self.stdout_file, + stderr=self.stdout_file, + env=env, + shell=(sys.platform == "win32") + ) + + def get_scan_diff(self): + self.wait() + self.stdout_file.seek(0) + + return self.stdout_file.read() + + def close(self): + """Clean up temporary files.""" + self.stdout_file.close() + for filename in self.temporary_filenames: + log.debug("Remove temporary diff file %s." % filename) + os.remove(filename) + self.temporary_filenames = [] + + def kill(self): + self.close() + + +def ndiff(scan_a, scan_b): + """Run Ndiff on two scan results, which may be filenames or NmapParserSAX + objects, and return a running NdiffCommand object.""" + temporary_filenames = [] + + if isinstance(scan_a, NmapParserSAX): + fd, filename_a = tempfile.mkstemp( + prefix=APP_NAME + "-diff-", + suffix=".xml" + ) + temporary_filenames.append(filename_a) + f = os.fdopen(fd, "w") + scan_a.write_xml(f) + f.close() + else: + filename_a = scan_a + + if isinstance(scan_b, NmapParserSAX): + fd, filename_b = tempfile.mkstemp( + prefix=APP_NAME + "-diff-", + suffix=".xml" + ) + temporary_filenames.append(filename_b) + f = os.fdopen(fd, "w") + scan_b.write_xml(f) + f.close() + else: + filename_b = scan_b + + return NdiffCommand(filename_a, filename_b, temporary_filenames) diff --git a/zenmap/zenmapCore/I18N.py b/zenmap/zenmapCore/I18N.py new file mode 100644 index 0000000..0942a1f --- /dev/null +++ b/zenmap/zenmapCore/I18N.py @@ -0,0 +1,109 @@ +#!/usr/bin/env python3 + +# ***********************IMPORTANT NMAP LICENSE TERMS************************ +# * +# * The Nmap Security Scanner is (C) 1996-2023 Nmap Software 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.com) 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 locale +import os + +from zenmapCore.Name import APP_NAME + + +def get_locales(): + """Get a list of locales to use based on system configuration.""" + locales = [] + # locale.getdefaultlocales already looks at LANG et al. on Unix but not on + # Windows. We look at the environment variables first to allow overriding + # the system-wide setting on Windows. + for envar in ("LANGUAGE", "LC_ALL", "LC_MESSAGES", "LANG"): + val = os.environ.get(envar) + if val: + locales = val.split(":") + break + try: + loc, enc = locale.getdefaultlocale() + if loc is not None: + locales.append(loc) + except ValueError: + # locale.getdefaultlocale can fail with ValueError on certain locale + # names; it has been seen with at least en_NG. + # http://bugs.python.org/issue6895 + pass + return locales + + +def install_gettext(locale_dir): + try: + locale.setlocale(locale.LC_ALL, '') + except locale.Error: + # This can happen if the LANG environment variable is set to something + # invalid, like LANG=nothing or LANG=en_US/utf8 or LANG=us-ascii. + # Continue without internationalization. + pass + + try: + import gettext + except ImportError: + pass + else: + t = gettext.translation( + APP_NAME, locale_dir, languages=get_locales(), fallback=True) + t.install() + +# Install a dummy _ function so modules can safely use it after importing this +# module, even if they don't install the gettext version. + +import builtins +builtins.__dict__["_"] = lambda s: s diff --git a/zenmap/zenmapCore/NSEDocParser.py b/zenmap/zenmapCore/NSEDocParser.py new file mode 100644 index 0000000..33b0af9 --- /dev/null +++ b/zenmap/zenmapCore/NSEDocParser.py @@ -0,0 +1,124 @@ +#!/usr/bin/env python3 + +# ***********************IMPORTANT NMAP LICENSE TERMS************************ +# * +# * The Nmap Security Scanner is (C) 1996-2023 Nmap Software 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.com) 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 re + + +class NSEDocEvent (object): + def __init__(self, type, text=None): + self.type = type + self.text = text + + +def nsedoc_parse_sub(text, pos): + """Parse paragraph-level NSEDoc markup, inside of paragraphs and lists. + Returns the position after the end of parsing followed by a list of + events.""" + events = [] + m = re.match(r'([^\n]*?)<code>(.*?)</code>', text[pos:], re.S) + if m: + if m.group(1): + events.append(NSEDocEvent("text", m.group(1).replace("\n", " "))) + events.append(NSEDocEvent("code", m.group(2))) + return pos + m.end(), events + m = re.match(r'[^\n]*(\n|$)', text[pos:]) + if m: + if m.group(): + events.append(NSEDocEvent("text", m.group().replace("\n", " "))) + return pos + m.end(), events + return pos, events + + +def nsedoc_parse(text): + """Parse text marked up for NSEDoc. This is a generator that returns a + sequence of NSEDocEvents. The type of the event may be "paragraph_start", + "paragraph_end", "list_start", "list_end", "list_item_start", + "list_item_end", "text", or "code". The types "text" and "code" have a text + member with the text that they contain.""" + i = 0 + in_list = False + + while i < len(text): + while i < len(text) and text[i].isspace(): + i += 1 + if i >= len(text): + break + yield NSEDocEvent("paragraph_start") + while i < len(text): + if re.match(r'\s*(\n|$)', text[i:]): + break + if text.startswith("* ", i): + if not in_list: + yield NSEDocEvent("list_start") + in_list = True + i += 2 + yield NSEDocEvent("list_item_start") + i, events = nsedoc_parse_sub(text, i) + for event in events: + yield event + yield NSEDocEvent("list_item_end") + else: + if in_list: + yield NSEDocEvent("list_end") + in_list = False + i, events = nsedoc_parse_sub(text, i) + for event in events: + yield event + if in_list: + yield NSEDocEvent("list_end") + in_list = False + yield NSEDocEvent("paragraph_end") diff --git a/zenmap/zenmapCore/Name.py b/zenmap/zenmapCore/Name.py new file mode 100644 index 0000000..166e7fe --- /dev/null +++ b/zenmap/zenmapCore/Name.py @@ -0,0 +1,73 @@ +#!/usr/bin/env python3 + +# ***********************IMPORTANT NMAP LICENSE TERMS************************ +# * +# * The Nmap Security Scanner is (C) 1996-2023 Nmap Software 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.com) 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/ +# * +# ***************************************************************************/ + +# This file contains global definitions of program names. The plain names are +# the usually lower-case program or package names. The display names are +# properly capitalized for use in human-readable sentences. + +APP_NAME = "zenmap" +APP_DISPLAY_NAME = "Zenmap" +APP_WEB_SITE = "https://nmap.org/zenmap/" +APP_DOWNLOAD_SITE = "https://nmap.org/download.html" +APP_DOCUMENTATION_SITE = "https://nmap.org/book/zenmap.html" +APP_COPYRIGHT = "Copyright 2005-2023 Nmap Software LLC" + +NMAP_DISPLAY_NAME = "Nmap" +NMAP_WEB_SITE = "https://nmap.org" + +UMIT_DISPLAY_NAME = "Umit" +UMIT_WEB_SITE = "http://www.umitproject.org/" diff --git a/zenmap/zenmapCore/NetworkInventory.py b/zenmap/zenmapCore/NetworkInventory.py new file mode 100644 index 0000000..f66000d --- /dev/null +++ b/zenmap/zenmapCore/NetworkInventory.py @@ -0,0 +1,675 @@ +#!/usr/bin/env python3 + +# ***********************IMPORTANT NMAP LICENSE TERMS************************ +# * +# * The Nmap Security Scanner is (C) 1996-2023 Nmap Software 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.com) 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 os +import unittest +import zenmapCore +import zenmapCore.NmapParser +from zenmapGUI.SearchGUI import SearchParser +from .SearchResult import HostSearch + + +class NetworkInventory(object): + """This class acts as a container for aggregated scans. It is also + responsible for opening/saving the aggregation from/to persistent + storage.""" + def __init__(self, filename=None): + # A list of all scans that make up this inventory + self.scans = [] + + # A dictionary mapping parsed scans to filenames they were loaded from + self.filenames = {} + + # A dictionary mapping IP addresses into HostInfo objects + self.hosts = {} + + if filename is not None: + self.open_from_file(filename) + + def add_scan(self, scan, filename=None): + """Adds a scan to the list of scans. The object passed as an argument + should be a parsed nmap result.""" + from time import localtime + + for host in scan.get_hosts(): + addr = "" + if host.ipv6 is not None: + # This is an IPv6 host, so we add the IPv6 address to the map + addr = host.ipv6["addr"] + elif host.ip is not None: + # IPv4 + addr = host.ip["addr"] + + if addr not in self.hosts: + # Add this host to the hosts dictionary, mapped by IP address + self.hosts[addr] = host.make_clone() + else: + # This host is already present in the host list, so we need to + # update its info with the info held in the current host object + old_host = self.hosts[addr] + # We need to find old_host's scan date + old_date = localtime(0) + for old_scan in self.scans: + if old_host in old_scan.get_hosts(): + old_date = old_scan.get_date() + new_date = scan.get_date() + self._update_host_info( + old_host, host, old_date, new_date, scan) + + self.scans.append(scan) + + if filename is not None: + basename = os.path.basename(filename) + + if basename in self.filenames.values(): + # We need to generate a new filename, since this basename + # already exists + base = basename + ext = "xml" + try: + base, ext = basename.rsplit(".", 1) + except ValueError: + pass + + counter = 2 + while basename in self.filenames.values(): + basename = "%s %s.%s" % (base, counter, ext) + counter += 1 + + self.filenames[scan] = basename + + def remove_scan(self, scan): + """Removes a scan and any host information it contained from the + inventory.""" + # Note: If a scan is passed in that isn't in the inventory then this + # method will throw a ValueError Exception and will not finish + # Remove the scan from our scan list + self.scans.remove(scan) + + # Clear the host dictionary + self.hosts = {} + + # Remember the scan list + scans = self.scans + + # Empty it + self.scans = [] + + # Delete the filename entry, if any + if scan in self.filenames: + del self.filenames[scan] + + # For each scan in the remembered list, append it to the scan list and + # update the host list accordingly + for scan in scans: + self.add_scan(scan) + + def _update_host_info(self, old_host, new_host, + old_date, new_date, new_scan): + """This function is called when a host needs to be added to the hosts + dictionary, but another HostInfo object for that host already exists + in the dictionary (from a previous scan). In that case, we need to + update the original HostInfo object so that it holds information from + both scans.""" + + # Ports + old_list = [] + old_list.extend(old_host.ports) + for new_port in new_host.ports: + # Check if new_port is already present in old_host's ports + for old_port in old_host.ports: + if (old_port["portid"] == new_port["portid"] and + old_port["protocol"] == new_port["protocol"]): + old_list.remove(old_port) + # We update old_host's port information to reflect the + # latest known port state + if old_date < new_date: + index = old_host.ports.index(old_port) + old_host.ports[index] = new_port + # Finished processing this new_port, we jump to the next + break + else: + # This new_port isn't present in old_host, so we simply append + # it to old_host's port info + old_host.ports.append(new_port) + + ports = new_scan.get_port_protocol_dict() + + #remove ports which are no longer up + if old_date < new_date: + for defunct_port in old_list: + # Check if defunct_port is in ports + # and that the protocol matches + port_number = int(defunct_port['portid']) + if port_number in ports: + if defunct_port['protocol'] in ports[port_number]: + old_host.ports.remove(defunct_port) + + # extraports, ipidsequence, state, tcpsequence, tcptssequence, uptime + if old_date < new_date: + old_host.extraports = new_host.extraports + old_host.ipidsequence = new_host.ipidsequence + old_host.state = new_host.state + old_host.tcpsequence = new_host.tcpsequence + old_host.tcptssequence = new_host.tcptssequence + old_host.uptime = new_host.uptime + + # Comment + if old_host.comment == "": + old_host.comment = new_host.comment + elif new_host.comment != "": + old_host.comment = "%s\n\n%s" % ( + old_host.comment, new_host.comment) + + # Hostnames + # Replace old_host's hostname with new_host's if old_host has no + # hostname or new_host's is newer. + if len(new_host.hostnames) > 0 and \ + (len(old_host.hostnames) == 0 or old_date < new_date): + old_host.hostnames = new_host.hostnames + + # MAC address + # If there was no MAC address set in old_host, set it to whatever is in + # new_host.mac. Do the same if both hosts have a MAC address set, but + # new_host's address is newer. + if (old_host.mac is None or + (old_host.mac is not None and + new_host.mac is not None and + old_date < new_date) + ): + old_host.mac = new_host.mac + + # OS detection fields + # Replace old_host's OS detection fields with new_host's if old_host + # has no OS detection info or new_host's info is newer. + if (len(new_host.osmatches) > 0 and + (len(old_host.osmatches) == 0 or old_date < new_date) + ): + old_host.osmatches = new_host.osmatches + old_host.ports_used = new_host.ports_used + + # Traceroute information + if (len(new_host.trace) > 0 and + (len(old_host.trace) == 0 or old_date < new_date) + ): + old_host.trace = new_host.trace + + def get_scans(self): + return self.scans + + def get_hosts(self): + return list(self.hosts.values()) + + def get_hosts_up(self): + return [h for h in list(self.hosts.values()) if h.get_state() == 'up'] + + def get_hosts_down(self): + return [h for h in list(self.hosts.values()) if h.get_state() == 'down'] + + def open_from_file(self, path): + """Loads a scan from the given file.""" + from zenmapCore.NmapParser import NmapParser + + parsed = NmapParser() + parsed.parse_file(path) + self.add_scan(parsed, path) + + def open_from_dir(self, path): + """Loads all scans from the given directory into the network + inventory.""" + from zenmapCore.NmapParser import NmapParser + + for filename in os.listdir(path): + fullpath = os.path.join(path, filename) + if os.path.isdir(fullpath): + continue + parsed = NmapParser() + parsed.parse_file(fullpath) + self.add_scan(parsed, filename=fullpath) + + def save_to_file(self, path, index, format="xml"): + """Saves the scan with the given list index into a file with a given + path. With format = "xml", saves Nmap XML; otherwise saves plain text + output.""" + f = open(path, 'w') + if format == "xml": + self.get_scans()[index].write_xml(f) + self.filenames[self.get_scans()[index]] = f + else: + self.get_scans()[index].write_text(f) + f.close() + + def _generate_filenames(self, path): + """Generates filenames for all scans that don't already have a + filename.""" + # The directory must not contain filenames other than those in the + # self.filenames dictionary + for filename in os.listdir(path): + if os.path.basename(filename) not in self.filenames.values(): + raise Exception("The destination directory contains a file" + "(%s) that's not a part of the current inventory." + "The inventory will not be saved." % + os.path.basename(filename)) + + for scan in self.scans: + if scan in self.filenames: + # This scan already has a filename + continue + + date = "%04d%02d%02d%02d%02d" % (scan.date[0], scan.date[1], + scan.date[2], scan.date[3], scan.date[4]) + filename = scan.get_scan_name() + + # Prepend the date + filename = "%s %s" % (date, filename) + + # Sanitize the filename + for char in ["\"", "'", "/", "\\", "?", "*", ":", ";"]: + if char in filename: + filename = filename.replace(char, "_") + + # Filename length check + # https://en.wikipedia.org/wiki/Comparison_of_file_systems#Limits + if len(filename) > 250: + filename = filename[:250] + + # TODO: Filename security checks? + + # Try to open the file in append mode. If file.tell() returns a + # greater-than-zero value, this means that the file already exists + # and has some data in it, so we choose another filename until we + # successfully open a zero-length file. + filename_full = filename + ".xml" + counter = 2 + while filename_full in self.filenames.values(): + # There's already a scan with this filename, so we generate a + # new name by appending the counter value before the file + # extension. + filename_full = "%s %s.xml" % (filename, str(counter)) + counter += 1 + + # Add the filename to the list of saved filenames + self.filenames[scan] = filename_full + + def save_to_dir(self, path): + """Saves all scans in the inventory into a given directory and returns + a list of (full-path) filenames that were used to save the scans.""" + self._generate_filenames(path) + + for scan, filename in self.filenames.items(): + f = open(os.path.join(path, filename), "w") + scan.write_xml(f) + f.close() + + return self.filenames.values() + + def open_from_db(self, id): + pass + + def save_to_db(self): + # For now, this saves each scan making up the inventory separately in + # the database. + from time import time + from io import StringIO + from zenmapCore.UmitDB import Scans + + for parsed in self.get_scans(): + f = StringIO() + parsed.write_xml(f) + + scan = Scans(scan_name=parsed.scan_name, + nmap_xml_output=f.getvalue(), + date=time()) + + +class FilteredNetworkInventory(NetworkInventory): + def __init__(self, filename=None): + NetworkInventory.__init__(self, filename) + + # A dictionary listing host filtering criteria + self.search_dict = {} + self.filtered_hosts = [] + search_keywords = dict() + search_keywords["target"] = "target" + search_keywords["t"] = "target" + search_keywords["inroute"] = "in_route" + search_keywords["ir"] = "in_route" + search_keywords["hostname"] = "hostname" + search_keywords["service"] = "service" + search_keywords["s"] = "service" + search_keywords["os"] = "os" + search_keywords["open"] = "open" + search_keywords["op"] = "open" + search_keywords["closed"] = "closed" + search_keywords["cp"] = "closed" + search_keywords["filtered"] = "filtered" + search_keywords["fp"] = "filtered" + search_keywords["unfiltered"] = "unfiltered" + search_keywords["ufp"] = "unfiltered" + search_keywords["open|filtered"] = "open_filtered" + search_keywords["ofp"] = "open_filtered" + search_keywords["closed|filtered"] = "closed_filtered" + search_keywords["cfp"] = "closed_filtered" + self.search_parser = SearchParser(self, search_keywords) + + # FIXME: This method doesn't do anything. We just need to support + # the type of interface that SearchParser expects in order to use it. + # Perhaps, we will eventually refactor the SearchParser a little bit + # more? + def init_search_dirs(self, junk): + pass + + def get_hosts(self): + if len(self.search_dict) > 0: + return self.filtered_hosts + else: + return NetworkInventory.get_hosts(self) + + def get_hosts_up(self): + if len(self.search_dict) > 0: + return [h for h in self.filtered_hosts if h.get_state() == 'up'] + else: + return NetworkInventory.get_hosts_up(self) + + def get_hosts_down(self): + if len(self.search_dict) > 0: + return [h for h in self.filtered_hosts if h.get_state() == 'down'] + else: + return NetworkInventory.get_hosts_down(self) + + def get_total_host_count(self): + return len(self.hosts) + + def _match_all_args(self, host, operator, args): + """A helper function that calls the matching function for the given + operator and each of its arguments.""" + for arg in args: + positive = True + if arg != "" and arg[0] == "!": + arg = arg[1:] + positive = False + if positive != self.__getattribute__( + "match_%s" % operator)(host, arg): + # No match for this operator + return False + else: + # if the operator is not supported, pretend its true + # All arguments for this operator produced a match + return True + + def get_host_count(self): + return len(self.network_inventory.hosts) + + def match_keyword(self, host, keyword): + return (self.match_os(host, keyword) or + self.match_target(host, keyword) or + self.match_service(host, keyword)) + + def match_target(self, host, name): + return HostSearch.match_target(host, name) + + def match_in_route(self, host, hop): + hops = host.get_trace().get('hops', []) + return hop in hops + + def match_hostname(self, host, hostname): + return HostSearch.match_hostname(host, hostname) + + def match_service(self, host, service): + return HostSearch.match_service(host, service) + + def match_os(self, host, os): + return HostSearch.match_os(host, os) + + def match_open(self, host, portno): + host_ports = host.get_ports() + return HostSearch.match_port(host_ports, portno, "open") + + def match_closed(self, host, portno): + host_ports = host.get_ports() + return HostSearch.match_port(host_ports, portno, "closed") + + def match_filtered(self, host, portno): + host_ports = host.get_ports() + return HostSearch.match_port(host_ports, portno, "filtered") + + def match_unfiltered(self, host, portno): + host_ports = host.get_ports() + return HostSearch.match_port(host_ports, portno, "unfiltered") + + def match_open_filtered(self, host, portno): + host_ports = host.get_ports() + return HostSearch.match_port(host_ports, portno, "open|filtered") + + def match_closed_filtered(self, host, portno): + host_ports = host.get_ports() + return HostSearch.match_port(host_ports, portno, "closed|filtered") + + def apply_filter(self, filter_text): + self.filter_text = filter_text.lower() + self.search_parser.update(self.filter_text) + self.filtered_hosts = [] + for hostname, host in self.hosts.items(): + # For each host in this scan + # Test each given operator against the current host + for operator, args in self.search_dict.items(): + if not self._match_all_args(host, operator, args): + # No match => we discard this scan_result + break + else: + # All operator-matching functions have returned True, so this + # host satisfies all conditions + self.filtered_hosts.append(host) + + +class NetworkInventoryTest(unittest.TestCase): + def test_no_external_modification(self): + """Test that HostInfo objects passed into the inventory are not + modified during aggregation.""" + scan_1 = zenmapCore.NmapParser.ParserBasics() + host_a = zenmapCore.NmapParser.HostInfo() + host_a.hostnames = ["a"] + host_a.set_state('up') + scan_1.start = "1000000000" + scan_1.nmap["hosts"] = [host_a] + + scan_2 = zenmapCore.NmapParser.ParserBasics() + host_b = zenmapCore.NmapParser.HostInfo() + host_b.hostnames = ["b"] + host_b.set_state('up') + scan_2.start = "1000000001" + scan_2.nmap["hosts"] = [host_b] + + inv = NetworkInventory() + inv.add_scan(scan_1) + inv.add_scan(scan_2) + + self.assertEqual(host_a.hostnames, ["a"]) + self.assertEqual(host_b.hostnames, ["b"]) + self.assertEqual(scan_1.nmap["hosts"], [host_a]) + self.assertEqual(scan_2.nmap["hosts"], [host_b]) + self.assertEqual(inv.get_hosts_up()[0].hostnames, ["b"]) + + def test_cancel_and_remove_scan(self): + """Test that canceling and removing a scan does not blow away the + inventory hosts""" + added_ips = ['10.0.0.1', '10.0.0.2'] + removed_ips = ['10.0.0.3'] + scan_1 = zenmapCore.NmapParser.ParserBasics() + host_a = zenmapCore.NmapParser.HostInfo() + host_a.hostnames = ["a"] + host_a.set_ip({'addr': added_ips[0]}) + scan_1.start = "1000000000" + scan_1.nmap["hosts"] = [host_a] + + scan_2 = zenmapCore.NmapParser.ParserBasics() + host_b = zenmapCore.NmapParser.HostInfo() + host_b.hostnames = ["b"] + host_b.set_ip({'addr': added_ips[1]}) + scan_2.start = "1000000001" + scan_2.nmap["hosts"] = [host_b] + + scan_3 = zenmapCore.NmapParser.ParserBasics() + host_c = zenmapCore.NmapParser.HostInfo() + host_c.hostnames = ["b"] + host_c.set_ip({'addr': removed_ips[0]}) + scan_3.start = "1000000001" + scan_3.nmap["hosts"] = [host_c] + + inv = NetworkInventory() + inv.add_scan(scan_1) + inv.add_scan(scan_2) + try: + inv.remove_scan(scan_3) + except Exception: + pass + self.assertEqual(added_ips, list(inv.hosts.keys())) + self.assertEqual(host_a.hostnames, ["a"]) + self.assertEqual(host_b.hostnames, ["b"]) + + +class FilteredNetworkInventoryTest(unittest.TestCase): + def test_filter(self): + """Test that the filter still works after moving code to the """ + """HostSearch class""" + from zenmapCore.NmapParser import NmapParser + inv = FilteredNetworkInventory() + scan = NmapParser() + scan.parse_file("test/xml_test9.xml") + filter_text = "open:22 os:linux service:openssh" + inv.add_scan(scan) + inv.apply_filter(filter_text) + assert(len(inv.get_hosts()) == 2) + + +class PortChangeTest(unittest.TestCase): + def test_port(self): + """Verify that the port status (open/filtered/closed) is displayed + correctly when the port status changes in newer scans""" + from zenmapCore.NmapParser import NmapParser + inv = NetworkInventory() + scan1 = NmapParser() + scan1.parse_file("test/xml_test13.xml") + inv.add_scan(scan1) + scan2 = NmapParser() + scan2.parse_file("test/xml_test14.xml") + inv.add_scan(scan2) + assert(len(inv.get_hosts()[0].ports) == 2) + scan3 = NmapParser() + scan3.parse_file("test/xml_test15.xml") + inv.add_scan(scan3) + assert(len(inv.get_hosts()[0].ports) == 0) + + # Additional test case for when the two scans have port scan ranges + # which do not overlap. Example nmap -F -sU versus + # nmap -F scanme.nmap.org + inv = NetworkInventory() + scan4 = NmapParser() + scan4.parse_file("test/xml_test16.xml") + inv.add_scan(scan4) + assert(len(inv.get_hosts()[0].ports) == 3) + scan5 = NmapParser() + scan5.parse_file("test/xml_test17.xml") + inv.add_scan(scan5) + assert(len(inv.get_hosts()[0].ports) == 7) + +if __name__ == "__main__": + unittest.main() + if False: + + scan1 = NmapParser("/home/ndwi/scanz/neobee_1.xml") + scan1.parse() + scan2 = NmapParser("/home/ndwi/scanz/scanme_nmap_org.usr") + scan2.parse() + + inventory1 = NetworkInventory() + inventory1.add_scan(scan1) + inventory1.add_scan(scan2) + + for host in inventory1.get_hosts(): + print("%s" % host.ip["addr"], end=' ') + #if len(host.hostnames) > 0: + # print "[%s]:" % host.hostnames[0]["hostname"] + #else: + # print ":" + #for port in host.ports: + # print " %s: %s" % (port["portid"], port["port_state"]) + #print " OS matches: %s" % host.osmatches + #print " Ports used: %s" % host.ports_used + #print " Trace: %s" % host.trace + #if "hops" in host.trace: + # print " (%d)" % len(host.trace["hops"]) + + inventory1.remove_scan(scan2) + print + for host in inventory1.get_hosts(): + print("%s" % host.ip["addr"], end=' ') + + inventory1.add_scan(scan2) + print + for host in inventory1.get_hosts(): + print("%s" % host.ip["addr"], end=' ') + + dir = "/home/ndwi/scanz/top01" + inventory1.save_to_dir(dir) + + inventory2 = NetworkInventory() + inventory2.open_from_dir(dir) + + print() + for host in inventory2.get_hosts(): + print("%s" % host.ip["addr"], end=' ') diff --git a/zenmap/zenmapCore/NmapCommand.py b/zenmap/zenmapCore/NmapCommand.py new file mode 100644 index 0000000..d266c0a --- /dev/null +++ b/zenmap/zenmapCore/NmapCommand.py @@ -0,0 +1,269 @@ +#!/usr/bin/env python3 + +# ***********************IMPORTANT NMAP LICENSE TERMS************************ +# * +# * The Nmap Security Scanner is (C) 1996-2023 Nmap Software 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.com) 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/ +# * +# ***************************************************************************/ + +# This file contains the definitions of the NmapCommand class, which represents +# and runs an Nmap command line. + +import codecs +import errno +import locale +import sys +import os +import tempfile +import unittest + +import zenmapCore.I18N # lgtm[py/unused-import] + +import subprocess + +import zenmapCore.Paths +from zenmapCore.NmapOptions import NmapOptions +from zenmapCore.UmitLogging import log +from zenmapCore.UmitConf import PathsConfig +from zenmapCore.Name import APP_NAME + +# The [paths] configuration from zenmap.conf, used to get nmap_command_path. +paths_config = PathsConfig() + +log.debug(">>> Platform: %s" % sys.platform) + + +def escape_nmap_filename(filename): + """Escape '%' characters so they are not interpreted as strftime format + specifiers, which are not supported by Zenmap.""" + return filename.replace("%", "%%") + + +class NmapCommand(object): + """This class represents an Nmap command line. It is responsible for + starting, stopping, and returning the results from a command-line scan. A + command line is represented as a string but it is split into a list of + arguments for execution. + + The normal output (stdout and stderr) are written to the file object + self.stdout_file.""" + + def __init__(self, command): + """Initialize an Nmap command. This creates temporary files for + redirecting the various types of output and sets the backing + command-line string.""" + self.command = command + self.command_process = None + + self.stdout_file = None + + self.ops = NmapOptions() + self.ops.parse_string(command) + # Replace the executable name with the value of nmap_command_path. + self.ops.executable = paths_config.nmap_command_path + + # Normally we generate a random temporary filename to save XML output + # to. If we find -oX or -oA, the user has chosen his own output file. + # Set self.xml_is_temp to False and don't delete the file when we're + # done. + self.xml_is_temp = True + self.xml_output_filename = None + if self.ops["-oX"]: + self.xml_is_temp = False + self.xml_output_filename = self.ops["-oX"] + if self.ops["-oA"]: + self.xml_is_temp = False + self.xml_output_filename = self.ops["-oA"] + ".xml" + + # Escape '%' to avoid strftime expansion. + for op in ("-oA", "-oX", "-oG", "-oN", "-oS"): + if self.ops[op]: + self.ops[op] = escape_nmap_filename(self.ops[op]) + + if self.xml_is_temp: + fh, self.xml_output_filename = tempfile.mkstemp( + prefix=APP_NAME + "-", suffix=".xml") + os.close(fh) + self.ops["-oX"] = escape_nmap_filename(self.xml_output_filename) + + log.debug(">>> Temporary files:") + log.debug(">>> XML OUTPUT: %s" % self.xml_output_filename) + + def close(self): + """Close and remove temporary output files used by the command.""" + self.stdout_file.close() + if self.xml_is_temp: + try: + os.remove(self.xml_output_filename) + except OSError as e: + if e.errno != errno.ENOENT: + raise + + def kill(self): + """Kill the nmap subprocess.""" + from time import sleep + + log.debug(">>> Killing scan process %s" % self.command_process.pid) + + if sys.platform != "win32": + try: + from signal import SIGTERM, SIGKILL + os.kill(self.command_process.pid, SIGTERM) + for i in range(10): + sleep(0.5) + if self.command_process.poll() is not None: + # Process has been TERMinated + break + else: + log.debug(">>> SIGTERM has not worked even after waiting for 5 seconds. Using SIGKILL.") # noqa + os.kill(self.command_process.pid, SIGKILL) + self.command_process.wait() + except Exception: + pass + else: + try: + import ctypes + ctypes.windll.kernel32.TerminateProcess( + int(self.command_process._handle), -1) + except Exception: + pass + + def get_path(self): + """Return a value for the PATH environment variable that is appropriate + for the current platform. It will be the PATH from the environment plus + possibly some platform-specific directories.""" + path_env = os.getenv("PATH") + if path_env is None: + search_paths = [] + else: + search_paths = path_env.split(os.pathsep) + for path in zenmapCore.Paths.get_extra_executable_search_paths(): + if path not in search_paths: + search_paths.append(path) + return os.pathsep.join(search_paths) + + def run_scan(self, stderr=None): + """Run the command represented by this class.""" + + # We don't need a file name for stdout output, just a handle. A + # TemporaryFile is deleted as soon as it is closed, and in Unix is + # unlinked immediately after creation so it's not even visible. + f = tempfile.TemporaryFile(mode="r", prefix=APP_NAME + "-stdout-") + self.stdout_file = f + if stderr is None: + stderr = f + + search_paths = self.get_path() + env = dict(os.environ) + env["PATH"] = search_paths + log.debug("PATH=%s" % env["PATH"]) + + command_list = self.ops.render() + log.debug("Running command: %s" % repr(command_list)) + + startupinfo = None + if sys.platform == "win32": + # This keeps a terminal window from opening. + startupinfo = subprocess.STARTUPINFO() + try: + startupinfo.dwFlags |= \ + subprocess._subprocess.STARTF_USESHOWWINDOW + except AttributeError: + # This name is used before Python 2.6.5. + startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW + + self.command_process = subprocess.Popen(command_list, bufsize=1, + universal_newlines=True, + stdin=subprocess.PIPE, + stdout=f, + stderr=stderr, + startupinfo=startupinfo, + env=env) + + def scan_state(self): + """Return the current state of a running scan. A return value of True + means the scan is running and a return value of False means the scan + subprocess completed successfully. If the subprocess terminated with an + error an exception is raised. The scan must have been started with + run_scan before calling this method.""" + if self.command_process is None: + raise Exception("Scan is not running yet!") + + state = self.command_process.poll() + + if state is None: + return True # True means that the process is still running + elif state == 0: + return False # False means that the process had a successful exit + else: + log.warning("An error occurred during the scan execution!") + log.warning("Command that raised the exception: '%s'" % + self.ops.render_string()) + log.warning("Scan output:\n%s" % self.get_output()) + + raise Exception( + "An error occurred during the scan execution!\n\n'%s'" % + self.get_output()) + + def get_output(self): + """Return the complete contents of the self.stdout_file. This modifies + the file pointer.""" + self.stdout_file.seek(0) + return self.stdout_file.read() + + def get_xml_output_filename(self): + """Return the name of the XML (-oX) output file.""" + return self.xml_output_filename + +if __name__ == '__main__': + unittest.TextTestRunner().run( + unittest.TestLoader().loadTestsFromTestCase(SplitQuotedTest)) diff --git a/zenmap/zenmapCore/NmapOptions.py b/zenmap/zenmapCore/NmapOptions.py new file mode 100644 index 0000000..296c7b0 --- /dev/null +++ b/zenmap/zenmapCore/NmapOptions.py @@ -0,0 +1,1406 @@ +#!/usr/bin/env python3 + +# This is an Nmap command line parser. It has two main parts: +# +# getopt_long_only_extras, which is like getopt_long_only with robust +# handling of unknown options. +# +# NmapOptions, a class representing a set of Nmap options. +# +# NmapOptions is the class for external use. NmapOptions.parse parses a list of +# a command followed by command-line arguments. NmapOptions.render returns a +# list of of a command followed by arguments. NmapOptions.parse_string and +# NmapOptions.render_string first split strings into lists, following certain +# quoting rules. +# +# >>> ops = NmapOptions() +# >>> ops.parse(["nmap", "-v", "--script", "safe", "localhost"]) +# >>> ops.executable +# 'nmap' +# >>> ops.target_specs +# ['localhost'] +# >>> ops["-v"] +# 1 +# >>> ops["--script"] +# 'safe' +# +# The command line may be modified by accessing member variables: +# +# >>> ops.executable = "C:\Program Files\Nmap\nmap.exe" +# >>> ops["-v"] = 2 +# >>> ops["-oX"] = "output.xml" +# >>> ops.render() +# ['C:\\Program Files\\Nmap\\nmap.exe', '-v', '-v', '-oX', 'output.xml', +# '--script', 'safe', 'localhost'] +# >>> ops.render_string() +# '"C:\\Program Files\\Nmap\\nmap.exe" -v -v -oX output.xml\ +# --script safe localhost' +# +# A primary design consideration was robust handling of unknown options. That +# gives this code a degree of independence from Nmap's own list of options. If +# an option is added to Nmap but not added here, that option is treated as an +# "extra," an uninterpreted string that is inserted verbatim into the option +# list. Because the unknown option may or may not take an argument, pains are +# taken to avoid interpreting any option ambiguously. +# +# Consider the following case, where -x is an unknown option: +# nmap -x -e eth0 scanme.nmap.org +# If -x, whatever it is, does not take an argument, it is equivalent to +# nmap -e eth0 scanme.nmap.org -x +# that is, a scan of scanme.nmap.org over interface eth0. But if it does take +# an argument, its argument is "-e", and the command line is the same as +# nmap eth0 scanme.nmap.org -x -e +# which is a scan of the two hosts eth0 and scanme.nmap.org, over the default +# interface. In either case scanme.nmap.org is a target but the other arguments +# are ambiguous. To resolve this, once an unknown option is found, all +# following arguments that can be interpreted ambiguously are removed with it +# and placed in the extras, with normal option processing resumed only when +# there is no more ambiguity. This ensures that such options maintain their +# relative order when rendered again to output. In this example "-x -e eth0" +# will always appear in that order, and the -e option will be uninterpreted. +# +# To add a new option, one should do the following: +# 1) Add a test case to the NmapOptionsTest::test_options() method for the new +# option and make sure it initially fails. +# 2) Add the new option to NmapOptions.SHORT_OPTIONS and/or +# NmapOptions.LONG_OPTIONS. +# 3) Add an appropriate case to NmapOptions::handle_result(). This should +# include a line something like +# self[opt] = True +# or, if the option has an argument 'arg': +# self[opt] = arg +# 4) Add an appropriate case to NmapOptions::render() +# This should include a check to make sure the option was set in +# handle_result: +# if self[opt]: +# or, if self[opt] contains arguments +# if self[opt] is not None: +# If the check passed, then opt should be added to opt_list. +# 5) Edit profile_editor.xml to display the new option in the GUI. +# 6) Depending on the option, one may need to edit +# get_option_check_auxiliary_widget in OptionBuilder.py. +# 7) Make sure the test case works now. + +from functools import reduce + + +class option: + """A single option, part of a pool of potential options. It's just a name + and a flag saying if the option takes no argument, if an argument is + optional, or if an argument is required.""" + NO_ARGUMENT = 0 + REQUIRED_ARGUMENT = 1 + OPTIONAL_ARGUMENT = 2 + + def __init__(self, name, has_arg): + self.name = name + self.has_arg = has_arg + + +def split_quoted(s): + """Like str.split, except that no splits occur inside quoted strings, and + quoted strings are unquoted.""" + r = [] + i = 0 + while i < len(s) and s[i].isspace(): + i += 1 + while i < len(s): + part = [] + while i < len(s) and not s[i].isspace(): + c = s[i] + if c == "\"" or c == "'": + begin = c + i += 1 + while i < len(s): + c = s[i] + if c == begin: + i += 1 + break + elif c == "\\": + i += 1 + if i < len(s): + c = s[i] + # Otherwise, ignore the error and leave the backslash + # at the end of the string. + part.append(c) + i += 1 + else: + part.append(c) + i += 1 + r.append("".join(part)) + while i < len(s) and s[i].isspace(): + i += 1 + + return r + + +def maybe_quote(s): + """Return s quoted if it needs to be, otherwise unchanged.""" + for c in s: + if c == "\"" or c == "\\" or c == "'" or c.isspace(): + break + else: + return s + + r = [] + for c in s: + if c == "\"": + r.append("\\\"") + elif c == "\\": + r.append("\\\\") + else: + r.append(c) + + return "\"" + "".join(r) + "\"" + + +def join_quoted(l): + return " ".join([maybe_quote(x) for x in l]) + + +def make_options(short_opts, long_opts): + """Parse a short option specification string and long option tuples into a + list of option objects.""" + options = [] + for name, has_arg in long_opts: + options.append(option(name, has_arg)) + + while len(short_opts) > 0: + name = short_opts[0] + short_opts = short_opts[1:] + assert name != ":" + num_colons = 0 + while len(short_opts) > 0 and short_opts[0] == ":": + short_opts = short_opts[1:] + num_colons += 1 + if num_colons == 0: + has_arg = option.NO_ARGUMENT + elif num_colons == 1: + has_arg = option.REQUIRED_ARGUMENT + else: + has_arg = option.OPTIONAL_ARGUMENT + options.append(option(name, has_arg)) + + return options + +lookup_option_cache = {} + + +def lookup_option(name, options): + """Find an option with the given (possibly abbreviated) name. None is + returned if no options match or if the name is ambiguous (more than one + option matches with no exact match).""" + + # This function turns out to be a huge bottleneck. Therefore we memoize it. + # We hash on the option name and the id of the options list, because lists + # aren't hashable. This means that the options list can't change after the + # first time you call this function, or you will get stale results. Turning + # the list into a tuple and hashing that is too slow. + cache_code = (name, id(options)) + try: + return lookup_option_cache[cache_code] + except KeyError: + pass + + # Nmap treats '_' the same as '-' in long option names. + def canonicalize_name(name): + return name.replace("_", "-") + + name = canonicalize_name(name) + matches = [o for o in options + if canonicalize_name(o.name).startswith(name)] + if len(matches) == 0: + # No match. + lookup_option_cache[cache_code] = None + elif len(matches) == 1: + # Only one match--not an ambiguous abbreviation. + lookup_option_cache[cache_code] = matches[0] + else: + # More than one match--return only an exact match. + for match in matches: + if canonicalize_name(match.name) == name: + lookup_option_cache[cache_code] = match + break + else: + # No exact matches + lookup_option_cache[cache_code] = None + return lookup_option_cache[cache_code] + + +def split_option(cmd_arg, options): + """Split an option into a name, argument (if any), and possible remainder. + It is not an error if the option does not include an argument even though + it is required; the caller must take the argument from the next + command-line argument. The remainder is what's left over after stripping a + single short option that doesn't take an argument. At most one of argument + and remainder will be non-None. + Examples: + >>> split_option("-v", [option("v", option.NO_ARGUMENT)]) + ('v', None, None) + >>> split_option("--min-rate", + ... [option("min-rate", option.REQUIRED_ARGUMENT)]) + ('min-rate', None, None) + >>> split_option("--min-rate=100", + ... [option("min-rate", option.REQUIRED_ARGUMENT)]) + ('min-rate', '100', None) + >>> split_option("-d9", [option("d", option.OPTIONAL_ARGUMENT)]) + ('d', '9', None) + >>> split_option("-AFn", [option("A", option.NO_ARGUMENT)]) + ('A', None, '-Fn') + >>> split_option("-Amin-rate", [option("A", option.NO_ARGUMENT)]) + ('A', None, '-min-rate') + """ + if cmd_arg.startswith("--"): + name = cmd_arg[2:] + index = name.find('=') + if index < 0: + arg = None + else: + name, arg = name[:index], name[index + 1:] + return name, arg, None + elif cmd_arg.startswith("-"): + name = cmd_arg[1:] + # Check for a lone -. + if name == "": + return name, None, None + # First see if it's really a long option (or a single short option). + index = name.find('=') + if index < 0: + arg = None + else: + name, arg = name[:index], name[index + 1:] + if lookup_option(name, options) is not None: + return name, arg, None + # No luck. Must be a short option. + name = cmd_arg[1] + option = lookup_option(name, options) + if option is None: + # An unknown short option. Return the whole thing. + return cmd_arg[1:], None, None + rest = cmd_arg[2:] + if rest == "": + return name, None, None + if option.has_arg == option.NO_ARGUMENT: + return name, None, "-" + rest + else: + return name, rest, None + else: + assert False, cmd_arg + + +def get_option(cmd_args, options): + """Find and return the first option (plus a possible option argument) or + positional argument from the command-line option list in cmd_args. The + return value will have one of the following forms: + * a string, representing a positional argument; + * an (option, argument) pair (argument may be None); + * a (None, extra, ...) tuple, where extra, ... is a chain of an unknown + option and its following arguments that cannot be interpreted + unambiguously; or + * None, at the end of the option list.""" + if len(cmd_args) == 0: + return None + cmd_arg = cmd_args.pop(0) + if cmd_arg == "--": + if len(cmd_args) == 0: + return None + # Grab the positional argument and replace the --. + name = cmd_args[0] + cmd_args[0] = "--" + return name + # A normal positional argument. + if not cmd_arg.startswith("-"): + return cmd_arg + name, arg, remainder = split_option(cmd_arg, options) + if remainder is not None: + cmd_args.insert(0, remainder) + option = lookup_option(name, options) + if option is None: + # Unrecognized option. + if arg is not None: + return (None, cmd_arg) + else: + extras = [None, cmd_arg] + # We found an unknown option but we have a problem--we don't know + # if it takes an argument or not. So what we do is, we simulate + # what would happen both if the option took and argument and if it + # didn't. The sync function does that by calling this function in a + # loop. + rest = sync(cmd_args[1:], cmd_args[:], options) + # rest is the part of the argument list that is the same whether or + # not the unknown option takes an argument. Put everything up until + # rest begins in the extras, then set cmd_args to rest. + extras += cmd_args[0:len(cmd_args) - len(rest)] + del cmd_args[0:len(cmd_args) - len(rest)] + return tuple(extras) + elif option.has_arg == option.NO_ARGUMENT and arg is not None: + # It has an arg but it shouldn't (like --send-ip=5). Treat it as + # an extra. + return (None, cmd_arg) + elif option.has_arg == option.REQUIRED_ARGUMENT and arg is None: + # An argument is required but not yet read. + if len(cmd_args) == 0: + # No more args. Treat it as an extra. + return (None, cmd_arg) + else: + arg = cmd_args.pop(0) + return (option.name, arg) + else: + return (option.name, arg) + + +def sync(a, b, options): + """Given two command-line argument lists, incrementally get an option from + whichever is longer until both lists are equal. Return the resulting + list.""" + while a != b: + if len(a) > len(b): + get_option(a, options) + else: + get_option(b, options) + return a + + +def getopt_long_only_extras(cmd_args, short_opts, long_opts): + """This is a generator version of getopt_long_only that additionally has + robust handling of unknown options. Each of the items in the sequence it + yields will be one of the following: + * a string, representing a positional argument; + * an (option, argument) pair (argument may be None); + * a (None, extra, ...) tuple, where extra, ... is a chain of an unknown + option and its following arguments that cannot be interpreted + unambiguously; or + * None, at the end of the option list.""" + options = make_options(short_opts, long_opts) + # get_option modifies its list of arguments in place. Don't modify the + # original list. + cmd_args_copy = cmd_args[:] + while True: + result = get_option(cmd_args_copy, options) + if result is None: + break + yield result + + +class NmapOptions(object): + SHORT_OPTIONS = "6Ab:D:d::e:Ffg:hi:M:m:nO::o:P:p:RrS:s:T:v::V" + LONG_OPTIONS = ( + ("allports", option.NO_ARGUMENT), + ("append-output", option.NO_ARGUMENT), + ("badsum", option.NO_ARGUMENT), + ("data-length", option.REQUIRED_ARGUMENT), + ("datadir", option.REQUIRED_ARGUMENT), + ("debug", option.OPTIONAL_ARGUMENT), + ("defeat-rst-ratelimit", option.NO_ARGUMENT), + ("dns-servers", option.REQUIRED_ARGUMENT), + ("exclude", option.REQUIRED_ARGUMENT), + ("excludefile", option.REQUIRED_ARGUMENT), + ("fuzzy", option.NO_ARGUMENT), + ("help", option.NO_ARGUMENT), + ("host-timeout", option.REQUIRED_ARGUMENT), + ("iL", option.REQUIRED_ARGUMENT), + ("iR", option.REQUIRED_ARGUMENT), + ("iflist", option.NO_ARGUMENT), + ("initial-rtt-timeout", option.REQUIRED_ARGUMENT), + ("ip-options", option.REQUIRED_ARGUMENT), + ("log-errors", option.NO_ARGUMENT), + ("max-hostgroup", option.REQUIRED_ARGUMENT), + ("max-os-tries", option.REQUIRED_ARGUMENT), + ("max-parallelism", option.REQUIRED_ARGUMENT), + ("max-rate", option.REQUIRED_ARGUMENT), + ("max-retries", option.REQUIRED_ARGUMENT), + ("max-rtt-timeout", option.REQUIRED_ARGUMENT), + ("max-scan-delay", option.REQUIRED_ARGUMENT), + ("min-hostgroup", option.REQUIRED_ARGUMENT), + ("min-parallelism", option.REQUIRED_ARGUMENT), + ("min-rate", option.REQUIRED_ARGUMENT), + ("min-retries", option.REQUIRED_ARGUMENT), + ("min-rtt-timeout", option.REQUIRED_ARGUMENT), + ("mtu", option.REQUIRED_ARGUMENT), + ("no-stylesheet", option.NO_ARGUMENT), + ("oA", option.REQUIRED_ARGUMENT), + ("oG", option.REQUIRED_ARGUMENT), + ("oM", option.REQUIRED_ARGUMENT), + ("oN", option.REQUIRED_ARGUMENT), + ("oS", option.REQUIRED_ARGUMENT), + ("oX", option.REQUIRED_ARGUMENT), + ("open", option.NO_ARGUMENT), + ("osscan-guess", option.NO_ARGUMENT), + ("osscan-limit", option.NO_ARGUMENT), + ("packet-trace", option.NO_ARGUMENT), + ("port-ratio", option.REQUIRED_ARGUMENT), + ("privileged", option.NO_ARGUMENT), + ("randomize-hosts", option.NO_ARGUMENT), + ("reason", option.NO_ARGUMENT), + ("release-memory", option.NO_ARGUMENT), + ("scan-delay", option.REQUIRED_ARGUMENT), + ("scanflags", option.REQUIRED_ARGUMENT), + ("sI", option.REQUIRED_ARGUMENT), + ("script", option.REQUIRED_ARGUMENT), + ("script-args", option.REQUIRED_ARGUMENT), + ("script-trace", option.NO_ARGUMENT), + ("script-updatedb", option.NO_ARGUMENT), + ("script-help", option.REQUIRED_ARGUMENT), + ("send-eth", option.NO_ARGUMENT), + ("send-ip", option.NO_ARGUMENT), + ("servicedb", option.REQUIRED_ARGUMENT), + ("source-port", option.REQUIRED_ARGUMENT), + ("spoof-mac", option.REQUIRED_ARGUMENT), + ("stylesheet", option.REQUIRED_ARGUMENT), + ("system-dns", option.NO_ARGUMENT), + ("timing", option.REQUIRED_ARGUMENT), + ("top-ports", option.REQUIRED_ARGUMENT), + ("traceroute", option.NO_ARGUMENT), + ("ttl", option.REQUIRED_ARGUMENT), + ("unprivileged", option.NO_ARGUMENT), + ("verbose", option.OPTIONAL_ARGUMENT), + ("version", option.NO_ARGUMENT), + ("version-all", option.NO_ARGUMENT), + ("version-intensity", option.REQUIRED_ARGUMENT), + ("version-light", option.NO_ARGUMENT), + ("version-trace", option.NO_ARGUMENT), + ("versiondb", option.REQUIRED_ARGUMENT), + ("webxml", option.NO_ARGUMENT), + ) + + # Sets of options that should be treated as equivalent from the point of + # view of the external interface. For example, ops["--timing"] means the + # same thing as ops["-T"]. + EQUIVALENT_OPTIONS = ( + ("debug", "d"), + ("help", "h"), + ("iL", "i"), + ("max-parallelism", "M"), + ("osscan-guess", "fuzzy"), + ("oG", "oM", "m"), + ("oN", "o"), + ("sP", "sn"), + ("P", "PE", "PI"), + ("PA", "PT"), + ("P0", "PD", "PN", "Pn"), + ("rH", "randomize-hosts"), + ("source-port", "g"), + ("timing", "T"), + ("verbose", "v"), + ("version", "V"), + ) + EQUIVALENCE_MAP = {} + for set in EQUIVALENT_OPTIONS: + base = set[0] + aliases = set[1:] + for alias in aliases: + EQUIVALENCE_MAP[alias] = base + + TIMING_PROFILE_NAMES = { + "paranoid": 0, "sneaky": 1, "polite": 2, + "normal": 3, "aggressive": 4, "insane": 5 + } + + def __init__(self): + self.options = make_options(self.SHORT_OPTIONS, self.LONG_OPTIONS) + + self.clear() + + def clear(self): + self._executable = None + self.target_specs = [] + self.extras = [] + + # This is the internal mapping of option names to values. + self.d = {} + + def _set_executable(self, executable): + self._executable = executable + + executable = property(lambda self: self._executable or "nmap", + _set_executable) + + def canonicalize_name(self, name): + opt, arg, remainder = split_option(name, self.options) + assert remainder is None + if arg is None: + option = lookup_option(opt, self.options) + if option: + option = option.name + else: + option = opt + else: + option = name.lstrip("-") + option = NmapOptions.EQUIVALENCE_MAP.get(option, option) + return option + + def __getitem__(self, key): + return self.d.get(self.canonicalize_name(key)) + + def __setitem__(self, key, value): + self.d[self.canonicalize_name(key)] = value + + def setdefault(self, key, default): + return self.d.setdefault(self.canonicalize_name(key), default) + + def handle_result(self, result): + if isinstance(result, str): + # A positional argument. + self.target_specs.append(result) + return + elif result[0] is None: + # An unknown option. + self.extras.extend(result[1:]) + return + + # A normal option. + opt, arg = result + if opt in ("6", "A", "F", "h", "n", "R", "r", "V"): + self["-" + opt] = True + elif opt in ( + "allports", + "append-output", + "badsum", + "defeat-rst-ratelimit", + "fuzzy", + "help", + "iflist", + "log-errors", + "no-stylesheet", + "open", + "osscan-guess", + "osscan-limit", + "packet-trace", + "privileged", + "randomize-hosts", + "reason", + "release-memory", + "script-trace", + "script-updatedb", + "send-eth", + "send-ip", + "system-dns", + "traceroute", + "unprivileged", + "version", + "version-all", + "version-light", + "version-trace", + "webxml", + ): + self["--" + opt] = True + elif opt in ("b", "D", "e", "g", "i", "iL", "m", "M", "o", "oA", "oG", + "oM", "oN", "oS", "oX", "p", "S", "sI"): + assert arg is not None + if self["-" + opt] is None: + self["-" + opt] = arg + else: + self.extras.extend(("-" + opt, arg)) + elif opt in ( + "datadir", + "data-length", + "dns-servers", + "exclude", + "excludefile", + "host-timeout", + "initial-rtt-timeout", + "ip-options", + "max-hostgroup", + "max-os-tries", + "max-parallelism", + "max-rate", + "max-retries", + "max-rtt-timeout", + "max-scan-delay", + "min-hostgroup", + "min-parallelism", + "min-rate", + "min-retries", + "min-rtt-timeout", + "mtu", + "port-ratio", + "scan-delay", + "scanflags", + "script", + "script-args", + "script-help", + "servicedb", + "source-port", + "spoof-mac", + "stylesheet", + "top-ports", + "ttl", + "versiondb", + "version-intensity", + ): + assert arg is not None + if self["--" + opt] is None: + self["--" + opt] = arg + else: + self.extras.extend(("--" + opt, arg)) + elif opt == "d" or opt == "debug": + if arg is None: + arg = "" + try: + self["-d"] = int(arg) + except ValueError: + if reduce(lambda x, y: x and y, + [z == "d" for z in arg], True): + self.setdefault("-d", 0) + self["-d"] += len(arg) + 1 + else: + self.extras.append("-d%s" % arg) + elif opt == "f": + self.setdefault("-f", 0) + self["-f"] += 1 + elif opt == "iR": + if self["-iR"] is None: + try: + self["-iR"] = int(arg) + except ValueError: + self.extras.extend(("-iR", arg)) + else: + self.extras.extend(("-iR", arg)) + elif opt == "O": + if arg is None: + if self["-O"] is None: + self["-O"] = True + else: + self.extras.append("-O") + else: + if self["-O"] is None: + self["-O"] = arg + else: + self.extras.append("-O%s" % arg) + elif opt == "P": + type, ports = arg[:1], arg[1:] + if (type == "0" or type == "D" or type == "N" or + type == "n" and ports == ""): + self["-Pn"] = True + elif (type == "" or type == "I" or type == "E") and ports == "": + self["-PE"] = True + elif type == "M" and ports == "": + self["-PM"] = True + elif type == "P" and ports == "": + self["-PP"] = True + elif type == "R" and ports == "": + self["-PR"] = True + elif type == "S": + self["-PS"] = ports + elif type == "T" or type == "A": + self["-PA"] = ports + elif type == "U": + self["-PU"] = ports + elif type == "O": + self["-PO"] = ports + elif type == "B": + self["-PB"] = ports + elif type == "Y": + self["-PY"] = ports + else: + self.extras.append("-P%s" % arg) + elif opt == "s": + for type in arg: + if type in "ACFLMNOPRSTUVWXYZn": + self["-s%s" % type] = True + else: + self.extras.append("-s%s" % type) + elif opt == "T" or opt == "timing": + if self["-T"] is None: + try: + self["-T"] = int(arg) + except ValueError: + try: + self["-T"] = self.TIMING_PROFILE_NAMES[arg.lower()] + except KeyError: + self.extras.extend(("-T", arg)) + else: + self.extras.extend(("-T", arg)) + elif opt == "v" or opt == "verbose": + if arg is None: + arg = "" + try: + self["-v"] = int(arg) + if self["-v"] == 0: + self["-v"] = -1 + except ValueError: + if reduce(lambda x, y: x and y, + [z == "v" for z in arg], True): + self.setdefault("-v", 0) + self["-v"] += len(arg) + 1 + else: + self.extras.append("-v%s" % arg) + else: + assert False, (opt, arg) + + def parse(self, opt_list): + self.clear() + + if len(opt_list) > 0: + self.executable = opt_list[0] + + for result in getopt_long_only_extras( + opt_list[1:], self.SHORT_OPTIONS, self.LONG_OPTIONS): + self.handle_result(result) + + def parse_string(self, opt_string): + self.parse(split_quoted(opt_string)) + + def render(self): + opt_list = [] + + for opt in ("-sA", "-sC", "-sF", "-sL", "-sM", "-sN", "-sO", "-sn", + "-sR", "-sS", "-sT", "-sU", "-sV", "-sW", "-sX", "-sY", "-sZ"): + if self[opt]: + opt_list.append(opt) + + if self["-sI"] is not None: + opt_list.extend(("-sI", self["-sI"])) + + for opt in ("-6",): + if self[opt]: + opt_list.append(opt) + + if self["-p"] is not None: + opt_list.extend(("-p", self["-p"])) + + if self["-T"] is not None: + opt_list.append("-T%s" % str(self["-T"])) + + if self["-O"] is not None: + if isinstance(self["-O"], str): + opt_list.append("-O%s" % self["-O"]) + elif self["-O"]: + opt_list.append("-O") + + if self["-A"]: + opt_list.append("-A") + + if self["-d"]: + if self["-d"] == 1: + opt_list.append("-d") + elif self["-d"] > 1: + opt_list.append("-d%s" % self["-d"]) + + if self["-f"]: + opt_list.extend(["-f"] * self["-f"]) + if self["-v"]: + if self["-v"] == -1: + opt_list.append("-v0") + opt_list.extend(["-v"] * self["-v"]) + + if self["-F"]: + opt_list.append("-F") + if self["-n"]: + opt_list.append("-n") + + if self["-iL"] is not None: + opt_list.extend(("-iL", self["-iL"])) + if self["-iR"] is not None: + opt_list.extend(("-iR", str(self["-iR"]))) + + for opt in ("-oA", "-oG", "-oN", "-oS", "-oX"): + if self[opt] is not None: + opt_list.extend((opt, self[opt])) + + for opt in ("--min-hostgroup", "--max-hostgroup", + "--min-parallelism", "--max-parallelism", + "--min-rtt-timeout", "--max-rtt-timeout", + "--initial-rtt-timeout", + "--scan-delay", "--max-scan-delay", + "--min-rate", "--max-rate", + "--max-retries", "--max-os-tries", "--host-timeout"): + if self[opt] is not None: + opt_list.extend((opt, self[opt])) + + for ping_option in ("-Pn", "-PE", "-PM", "-PP", "-PR"): + if self[ping_option]: + opt_list.append(ping_option) + for ping_option in ("-PS", "-PA", "-PU", "-PO", "-PY"): + if self[ping_option] is not None: + opt_list.append(ping_option + self[ping_option]) + if self["-PB"] is not None: + if isinstance(self["-PB"], str): + opt_list.append("-PB" + self["-PB"]) + elif self["-PB"]: + opt_list.append("-PB") + + for opt in ( + "--allports", + "--append-output", + "--badsum", + "--defeat-rst-ratelimit", + "--fuzzy", + "--help", + "--iflist", + "--log-errors", + "--no-stylesheet", + "--open", + "--osscan-guess", + "--osscan-limit", + "--packet-trace", + "--privileged", + "-r", + "-R", + "--randomize-hosts", + "--reason", + "--release-memory", + "--script-trace", + "--script-updatedb", + "--send-eth", + "--send-ip", + "--system-dns", + "--traceroute", + "--unprivileged", + "--version", + "--version-all", + "--version-light", + "--version-trace", + "--webxml", + ): + if self[opt]: + opt_list.append(opt) + + for opt in ( + "-b", + "-D", + "--datadir", + "--data-length", + "--dns-servers", + "-e", + "--exclude", + "--excludefile", + "-g", + "--ip-options", + "--mtu", + "--port-ratio", + "-S", + "--scanflags", + "--script", + "--script-args", + "--script-help", + "--servicedb", + "--spoof-mac", + "--stylesheet", + "--top-ports", + "--ttl", + "--versiondb", + "--version-intensity", + ): + if self[opt] is not None: + opt_list.extend((opt, self[opt])) + + opt_list.extend(self.target_specs) + + opt_list.extend(self.extras) + + return [self.executable] + opt_list + + def render_string(self): + return join_quoted(self.render()) + +import doctest +import unittest + + +class NmapOptionsTest(unittest.TestCase): + def test_clear(self): + """Test that a new object starts without defining any options, that the + clear method removes all options, and that parsing the empty string or + an empty list removes all options.""" + TEST = "nmap -T4 -A -v localhost --webxml" + ops = NmapOptions() + self.assertTrue(len(ops.render()) == 1) + ops.parse_string(TEST) + self.assertFalse(len(ops.render()) == 1) + ops.clear() + self.assertTrue(len(ops.render()) == 1) + ops.parse_string(TEST) + ops.parse_string("") + self.assertEqual(ops.render_string(), "nmap") + ops.parse_string(TEST) + ops.parse([]) + self.assertEqual(ops.render_string(), "nmap") + + def test_default_executable(self): + """Test that there is a default executable member set.""" + ops = NmapOptions() + self.assertNotNull(ops.executable) + + def test_default_executable(self): + """Test that you can set the executable.""" + ops = NmapOptions() + ops.executable = "foo" + self.assertEqual(ops.executable, "foo") + self.assertEqual(ops.render(), ["foo"]) + + def test_render(self): + """Test that the render method returns a list.""" + TEST = "nmap -T4 -A -v localhost --webxml" + ops = NmapOptions() + ops.parse_string(TEST) + self.assertTrue(type(ops.render()) == list, + "type == %s" % type(ops.render)) + + def test_quoted(self): + """Test that strings can be quoted.""" + ops = NmapOptions() + + ops.parse_string('nmap --script ""') + self.assertEqual(ops["--script"], "") + ops.parse_string("nmap --script ''") + self.assertEqual(ops["--script"], "") + + ops.parse_string('nmap --script test one two three') + self.assertEqual(ops["--script"], "test") + self.assertEqual(ops.target_specs, ["one", "two", "three"]) + ops.parse_string('nmap --script "test" one two three') + self.assertEqual(ops["--script"], "test") + self.assertEqual(ops.target_specs, ["one", "two", "three"]) + ops.parse_string('nmap --script "test one" two three') + self.assertEqual(ops["--script"], "test one") + self.assertEqual(ops.target_specs, ["two", "three"]) + ops.parse_string('nmap --script test" one" two three') + self.assertEqual(ops["--script"], "test one") + self.assertEqual(ops.target_specs, ["two", "three"]) + ops.parse_string('nmap --script test" one"""" two" three') + self.assertEqual(ops["--script"], "test one two") + self.assertEqual(ops.target_specs, ["three"]) + + ops.parse_string("nmap --script test one two three") + self.assertEqual(ops["--script"], "test") + self.assertEqual(ops.target_specs, ["one", "two", "three"]) + ops.parse_string("nmap --script 'test' one two three") + self.assertEqual(ops["--script"], "test") + self.assertEqual(ops.target_specs, ["one", "two", "three"]) + ops.parse_string("nmap --script 'test one' two three") + self.assertEqual(ops["--script"], "test one") + self.assertEqual(ops.target_specs, ["two", "three"]) + ops.parse_string("nmap --script test' one' two three") + self.assertEqual(ops["--script"], "test one") + self.assertEqual(ops.target_specs, ["two", "three"]) + ops.parse_string("nmap --script test' one'''' two' three") + self.assertEqual(ops["--script"], "test one two") + self.assertEqual(ops.target_specs, ["three"]) + + ops.parse_string('nmap --script "ab\\\"cd"') + self.assertEqual(ops["--script"], "ab\"cd") + ops.parse_string('nmap --script "ab\\\\cd"') + self.assertEqual(ops["--script"], "ab\\cd") + ops.parse_string('nmap --script "ab\\\'cd"') + self.assertEqual(ops["--script"], "ab'cd") + ops.parse_string("nmap --script 'ab\\\"cd'") + self.assertEqual(ops["--script"], 'ab"cd') + + ops.parse_string('nmap "--script" test') + self.assertEqual(ops["--script"], "test") + ops.parse_string("nmap '--script' test") + self.assertEqual(ops["--script"], "test") + + ops.parse_string('"nmap foo" --script test') + self.assertEqual(ops.executable, "nmap foo") + ops.parse_string("'nmap foo' --script test") + self.assertEqual(ops.executable, "nmap foo") + + def test_render_quoted(self): + """Test that strings that need to be quoted are quoted.""" + ops = NmapOptions() + ops.parse_string('"/path/ /nmap" --script "test one two three"') + self.assertEqual(ops.executable, "/path/ /nmap") + self.assertEqual(ops["--script"], "test one two three") + self.assertEqual(ops.target_specs, []) + s = ops.render_string() + ops.parse_string(s) + self.assertEqual(ops.executable, "/path/ /nmap") + self.assertEqual(ops["--script"], "test one two three") + self.assertEqual(ops.target_specs, []) + + def test_end(self): + """Test that -- ends argument processing.""" + ops = NmapOptions() + ops.parse_string("nmap -v -- -v") + self.assertTrue(ops["-v"] == 1) + self.assertTrue(ops.target_specs == ["-v"]) + + def test_roundtrip(self): + """Test that parsing and re-rendering a previous rendering gives the + same thing as the previous rendering.""" + TESTS = ( + "nmap", + "nmap -v", + "nmap -vv", + "nmap -d -v", + "nmap -d -d", + "nmap -d -v -d", + "nmap localhost", + "nmap -oX - 192.168.0.1 -PS10", + ) + ops = NmapOptions() + for test in TESTS: + ops.parse_string(test) + opt_string_1 = ops.render_string() + ops.parse_string(opt_string_1) + opt_string_2 = ops.render_string() + self.assertEqual(opt_string_1, opt_string_2) + + def test_underscores(self): + """Test that underscores in option names are treated the same as + dashes (and are canonicalized to dashes).""" + ops = NmapOptions() + ops.parse_string("nmap --osscan_guess") + self.assertTrue("--osscan-guess" in ops.render_string()) + + def test_args(self): + """Test potentially tricky argument scenarios.""" + ops = NmapOptions() + ops.parse_string("nmap -d9") + self.assertTrue(len(ops.target_specs) == 0) + self.assertTrue(ops["-d"] == 9, ops["-d"]) + ops.parse_string("nmap -d 9") + self.assertTrue(ops.target_specs == ["9"]) + self.assertTrue(ops["-d"] == 1) + + def test_repetition(self): + """Test options that can be repeated to increase their effect.""" + ops = NmapOptions() + ops.parse_string("nmap -vv") + self.assertTrue(ops["-v"] == 2) + ops.parse_string("nmap -v -v") + self.assertTrue(ops["-v"] == 2) + ops.parse_string("nmap -ff") + self.assertTrue(ops["-f"] == 2) + ops.parse_string("nmap -f -f") + self.assertTrue(ops["-f"] == 2) + # Note: unlike -d, -v doesn't take an optional numeric argument. + ops.parse_string("nmap -d2 -d") + self.assertTrue(ops["-d"] == 3) + + def test_scan_types(self): + """Test that multiple scan types given to the -s option are all + interpreted correctly.""" + ops = NmapOptions() + ops.parse_string("nmap -s") + self.assertTrue(ops.extras == ["-s"]) + ops.parse_string("nmap -sS") + self.assertTrue(ops.extras == []) + self.assertTrue(ops["-sS"]) + self.assertTrue(not ops["-sU"]) + ops.parse_string("nmap -sSU") + self.assertTrue(ops["-sS"]) + self.assertTrue(ops["-sU"]) + + def test_extras(self): + """Test that unknown arguments are correctly recorded. A few subtleties + are tested: + 1. Unknown options are not simply discarded. + 2. When an unknown option is found, any following arguments that could + have a different meaning depending on whether the unknown option + takes an argument are moved with the argument to the extras. + 3. Any arguments moved to the extras are not otherwise interpreted. + 4. Extra options so copied are copied in blocks, keeping their original + ordering with each block.""" + ops = NmapOptions() + + ops.parse_string("nmap --fee") + self.assertTrue(ops.extras == ["--fee"]) + self.assertTrue(ops.render_string() == "nmap --fee") + + # Note: -x is not a real Nmap option. + + ops.parse_string("nmap -x") + self.assertTrue(ops.extras == ["-x"]) + self.assertTrue(ops.render_string() == "nmap -x") + + ops.parse_string("nmap -v --fie scanme.nmap.org -d") + self.assertTrue(ops.extras == ["--fie", "scanme.nmap.org"]) + self.assertTrue(ops["-v"] == 1) + self.assertTrue(ops["-d"] == 1) + self.assertTrue(len(ops.target_specs) == 0) + + ops.parse_string("nmap -v --foe=5 scanme.nmap.org -d") + self.assertTrue(ops.extras == ["--foe=5"]) + self.assertTrue(ops.target_specs == ["scanme.nmap.org"]) + + ops.parse_string("nmap --fum -oX out.xml -v") + self.assertTrue(ops.extras == ["--fum", "-oX", "out.xml"]) + self.assertTrue(ops["-v"] == 1) + + ops.parse_string("nmap -x -A localhost") + self.assertTrue(ops.extras == ["-x", "-A"]) + + ops.parse_string("nmap -x --fee -A localhost") + self.assertTrue(ops.extras == ["-x", "--fee", "-A"]) + + ops.parse_string("nmap -x -x --timing 3 localhost") + self.assertTrue(ops.extras == ["-x", "-x", "--timing", "3"]) + self.assertTrue(ops.target_specs == ["localhost"]) + + ops.parse_string("nmap -x -x --timing=3 localhost") + self.assertTrue(ops.extras == ["-x", "-x", "--timing=3"]) + self.assertTrue(ops.target_specs == ["localhost"]) + + ops.parse_string("nmap -x -Ad9") + self.assertTrue(ops.extras == ["-x", "-Ad9"]) + + ops.parse_string("nmap -xrest") + self.assertTrue(ops.extras == ["-xrest"]) + + # Options that can't be given more than once should end up in extras. + ops.parse_string("nmap -p 53 -p 80 -O --mtu 50 --mtu 100 -O2") + self.assertTrue(ops["-p"] == "53") + self.assertTrue(ops["--mtu"] == "50") + self.assertTrue(ops["-O"]) + self.assertTrue(ops.extras == ["-p", "80", "--mtu", "100", "-O2"]) + + def test_quirks(self): + """Test the handling of constructions whose interpretation isn't + specified in documentation, but should match that of GNU getopt.""" + ops = NmapOptions() + # Long options can be written with one dash. + ops.parse_string("nmap -min-rate 100") + self.assertTrue(ops["--min-rate"] == "100") + ops.parse_string("nmap -min-rate=100") + self.assertTrue(ops["--min-rate"] == "100") + + # Short options not taking an argument can be followed by a long + # option. + ops.parse_string("nmap -nFmin-rate 100") + self.assertTrue(ops["-n"]) + self.assertTrue(ops["-F"]) + self.assertTrue(ops["--min-rate"] == "100") + + # Short options taking an argument consume the rest of the argument. + ops.parse_string("nmap -nFp1-100") + self.assertTrue(ops["-n"]) + self.assertTrue(ops["-F"]) + self.assertTrue(ops["-p"] == "1-100") + + def test_conversion(self): + """Test that failed integer conversions cause the option to wind up in + the extras.""" + ops = NmapOptions() + ops.parse_string("nmap -d#") + self.assertTrue(ops.extras == ["-d#"]) + ops.parse_string("nmap -T monkeys") + self.assertTrue(ops["-T"] is None) + self.assertTrue(ops.extras == ["-T", "monkeys"]) + ops.parse_string("nmap -iR monkeys") + self.assertTrue(ops["-iR"] is None) + self.assertTrue(ops.extras == ["-iR", "monkeys"]) + + def test_read_unknown(self): + """Test that getting the value of non-options returns None.""" + ops = NmapOptions() + self.assertEqual(ops["-x"], None) + self.assertEqual(ops["--nonoption"], None) + + def test_canonical_option_names(self): + """Test that equivalent option names are properly canonicalized, so + that ops["--timing"] and ops["-T"] mean the same thing, for example.""" + EQUIVS = ( + ("--debug", "-d"), + ("--help", "-h"), + ("-iL", "-i"), + ("--max-parallelism", "-M"), + ("--osscan-guess", "--fuzzy"), + ("-oG", "-oM", "-m"), + ("-oN", "-o"), + ("-sP", "-sn"), + ("-P", "-PE", "-PI"), + ("-PA", "-PT"), + ("-P0", "-PD", "-PN", "-Pn"), + ("--source-port", "-g"), + ("--timing", "-T"), + ("--verbose", "-v"), + ("--version", "-V"), + ("--min-rate", "-min-rate", "--min_rate", "-min_rate") + ) + ops = NmapOptions() + for set in EQUIVS: + for opt in set: + ops.clear() + ops[opt] = "test" + for other in set: + self.assertTrue(ops[other] == "test", + "%s and %s not the same" % (opt, other)) + + def test_options(self): + """Test that all options that are supposed to be supported are really + supported. They must be parsed and not as extras, and must produce + output on rendering that can be parsed again.""" + TESTS = ["-" + opt for opt in "6AFfhnRrVv"] + TESTS += ["-b host", "-D 192.168.0.1,ME,RND", "-d", "-d -d", "-d2", + "-e eth0", "-f -f", "-g 53", "-i input.txt", "-M 100", + "-m output.gnmap", "-O", "-O2", "-o output.nmap", "-p 1-100", + "-S 192.168.0.1", "-T0", "-v -v"] + TESTS += ["-s" + opt for opt in "ACFLMNnOPRSTUVWXYZ"] + TESTS += ["-P" + opt for opt in "IEMP0NnDRBSTAUOY"] + TESTS += ["-P" + opt + "100" for opt in "STAUOY"] + TESTS += [ + "--version", + "--verbose", + "--datadir=dir", + "--datadir dir", + "--servicedb=db", + "--servicedb db", + "--versiondb=db", + "--versiondb db", + "--debug", + "--debug=3", + "--debug 3", + "--help", + "--iflist", + "--release-memory", + "--max-os-tries=10", + "--max-os-tries 10", + "--max-parallelism=10", + "--min-parallelism 10", + "--timing=0", + "--timing 0", + "--max-rtt-timeout=10", + "--max-rtt-timeout 10", + "--min-rtt-timeout=10", + "--min-rtt-timeout 10", + "--initial-rtt-timeout=10", + "--initial-rtt-timeout 10", + "--excludefile=file", + "--excludefile file", + "--exclude=192.168.0.0", + "--exclude 192.168.0.0", + "--max-hostgroup=10", + "--max-hostgroup 10", + "--min-hostgroup=10", + "--min-hostgroup 10", + "--open", + "--scanflags=RST,ACK", + "--scanflags RST,ACK", + "--defeat-rst-ratelimit", + "--host-timeout=10", + "--host-timeout 10", + "--scan-delay=10", + "--scan-delay 10", + "--max-scan-delay=10", + "--max-scan-delay 10", + "--max-retries=10", + "--max-retries 10", + "--source-port=53", + "--source-port 53", + "--randomize-hosts", + "--osscan-limit", + "--osscan-guess", + "--fuzzy", + "--packet-trace", + "--version-trace", + "--data-length=10", + "--data-length 10", + "--send-eth", + "--send-ip", + "--stylesheet=style.xml", + "--stylesheet style.xml", + "--no-stylesheet", + "--webxml", + "--privileged", + "--unprivileged", + "--mtu=1500", + "--mtu 1500", + "--append-output", + "--spoof-mac=00:00:00:00:00:00", + "--spoof-mac 00:00:00:00:00:00", + "--badsum", + "--ttl=64", + "--ttl 64", + "--traceroute", + "--reason", + "--allports", + "--version-intensity=5", + "--version-intensity 5", + "--version-light", + "--version-all", + "--system-dns", + "--log-errors", + "--dns-servers=localhost", + "--dns-servers localhost", + "--port-ratio=0.5", + "--port-ratio 0.5", + "--top-ports=1000", + "--top-ports 1000", + "--script=script.nse", + "--script script.nse", + "--script-trace", + "--script-updatedb", + "--script-args=none", + "--script-args none", + "--script-help=script.nse", + "--script-help script.nse", + "--ip-options=S", + "--ip-options S", + "--min-rate=10", + "--min-rate 10", + "--max-rate=10", + "--max-rate 10", + "-iL=input.txt", + "-iL input.txt", + "-iR=1000", + "-iR 1000", + "-oA=out", + "-oA out", + "-oG=out.gnmap", + "-oG out.gnmap", + "-oM=out.gnmap", + "-oM out.gnmap", + "-oN=out.nmap", + "-oN out.nmap", + "-oS=out.skid", + "-oS out.skid", + "-oX=out.xml", + "-oX out.xml", + "-sI=zombie.example.com", + "-sI zombie.example.com", + ] + + # The following options are present in the Nmap source but are not + # tested for because they are deprecated or not documented or whatever. + # "-I", + # "--noninteractive", + # "--thc", + # "--nogcc", + # "-rH", + # "-ff", + # "-vv", + # "-oH", + + ops = NmapOptions() + for test in TESTS: + ops.parse_string("nmap " + test) + opt_list_1 = ops.render() + self.assertTrue(len(opt_list_1) > 1, "%s missing on render" % test) + self.assertTrue(len(ops.extras) == 0, + "%s caused extras: %s" % (test, repr(ops.extras))) + ops.parse(opt_list_1) + opt_list_2 = ops.render() + self.assertTrue(opt_list_1 == opt_list_2, + "Result of parsing and rendering %s not parsable again" % ( + test)) + self.assertTrue(len(ops.extras) == 0, + "Result of parsing and rendering %s left extras: %s" % ( + test, ops.extras)) + + +class SplitQuotedTest(unittest.TestCase): + """A unittest class that tests the split_quoted function.""" + + def test_split(self): + self.assertEqual(split_quoted(''), []) + self.assertEqual(split_quoted('a'), ['a']) + self.assertEqual(split_quoted('a b c'), 'a b c'.split()) + + def test_quotes(self): + self.assertEqual(split_quoted('a "b" c'), ['a', 'b', 'c']) + self.assertEqual(split_quoted('a "b c"'), ['a', 'b c']) + self.assertEqual(split_quoted('a "b c""d e"'), ['a', 'b cd e']) + self.assertEqual(split_quoted('a "b c"z"d e"'), ['a', 'b czd e']) + + def test_backslash(self): + self.assertEqual(split_quoted('"\\""'), ['"']) + self.assertEqual(split_quoted('\\"\\""'), ['\\"']) + self.assertEqual(split_quoted('"\\"\\""'), ['""']) + + +if __name__ == "__main__": + doctest.testmod() + unittest.main() diff --git a/zenmap/zenmapCore/NmapParser.py b/zenmap/zenmapCore/NmapParser.py new file mode 100644 index 0000000..bf9ad05 --- /dev/null +++ b/zenmap/zenmapCore/NmapParser.py @@ -0,0 +1,1345 @@ +#!/usr/bin/env python3 + +# ***********************IMPORTANT NMAP LICENSE TERMS************************ +# * +# * The Nmap Security Scanner is (C) 1996-2023 Nmap Software 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.com) 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 locale +import time +import socket +import copy + +from io import StringIO + +# Prevent loading PyXML +import xml +xml.__path__ = [x for x in xml.__path__ if "_xmlplus" not in x] + +from xml.sax import make_parser +from xml.sax import SAXException +from xml.sax.handler import ContentHandler, EntityResolver +from xml.sax.saxutils import XMLGenerator +from xml.sax.xmlreader import AttributesImpl as Attributes + +import zenmapCore.I18N # lgtm[py/unused-import] +from zenmapCore.NmapOptions import NmapOptions, join_quoted +from zenmapCore.StringPool import unique + +# The version of the Nmap DTD this file understands and emits. +XML_OUTPUT_VERSION = "1.04" + + +class HostInfo(object): + def __init__(self): + self.comment = None + self._tcpsequence = {} + self._osmatches = [] + self._ports = [] + self._ports_used = [] + self._extraports = [] + self._uptime = {} + self._hostnames = [] + self._tcptssequence = {} + self._ipidsequence = {} + self._ip = None + self._ipv6 = None + self._mac = None + self._state = '' + self._comment = '' + self._trace = {} + + def make_clone(self): + clone = HostInfo() + clone.comment = self.comment + clone._tcpsequence = copy.deepcopy(self._tcpsequence) + clone._osmatches = copy.deepcopy(self._osmatches) + clone._ports = copy.deepcopy(self._ports) + clone._ports_used = self._ports_used + clone._extraports = self._extraports + clone._uptime = copy.deepcopy(self._uptime) + clone._hostnames = copy.deepcopy(self._hostnames) + clone._tcptssequence = copy.deepcopy(self._tcptssequence) + clone._ipidsequence = copy.deepcopy(self._ipidsequence) + clone._ip = copy.deepcopy(self._ip) + clone._ipv6 = copy.deepcopy(self._ipv6) + clone._mac = copy.deepcopy(self._mac) + clone._state = self._state + clone._comment = self._comment + clone._trace = copy.deepcopy(self._trace) + + return clone + + # tcpsequence is a dict of the form + # {'index': u'203', + # 'values': u'3637785D,35B440D1,35E9FC3B,3640DB42,355F5931,3601AE14', + # 'difficulty': u'Good luck!'} + def set_tcpsequence(self, sequence): + self._tcpsequence = sequence + + def get_tcpsequence(self): + if self._tcpsequence: + return self._tcpsequence + return {} + + # tcptssequence is a dict of the form + # {'values': u'71D0483C,71D048A3,71D0490C,71D04973,71D049DB,71D04A45', + # 'class': u'1000HZ'} + def set_tcptssequence(self, sequence): + self._tcptssequence = sequence + + def get_tcptssequence(self): + if self._tcptssequence: + return self._tcptssequence + return {} + + # ipidsequence is a dict of the form + # {'values': u'0,0,0,0,0,0', 'class': u'All zeros'} + def set_ipidsequence(self, sequence): + self._ipidsequence = sequence + + def get_ipidsequence(self): + if self._ipidsequence: + return self._ipidsequence + return {} + + # osmatches is a list of dicts of the form + # {'name': u'Linux 2.6.24', 'accuracy': u'98', 'line': u'1000', + # 'osclasses': ...} + # where each 'osclasses' element is a dict of the form + # {'vendor': u'Linux', 'osfamily': u'Linux', 'type': u'general purpose', + # 'osgen': u'2.6.X', 'accuracy': u'98'} + def set_osmatches(self, matches): + self._osmatches = matches + + def get_osmatches(self): + return self._osmatches + + def get_best_osmatch(self): + """Return the OS match with the highest accuracy.""" + if not self._osmatches: + return None + + def osmatch_key(osmatch): + try: + return -float(osmatch["accuracy"]) + except ValueError: + return 0 + + return sorted(self._osmatches, key=osmatch_key)[0] + + # ports_used is a list like + # [{'state': u'open', 'portid': u'22', 'proto': u'tcp'}, + # {'state': u'closed', 'portid': u'25', 'proto': u'tcp'}, + # {'state': u'closed', 'portid': u'44054', 'proto': u'udp'}] + # but not all three elements are necessarily present. + def set_ports_used(self, ports): + self._ports_used = ports + + def get_ports_used(self): + return self._ports_used + + # uptime is a dict of the form + # {'seconds': u'1909493', 'lastboot': u'Wed Jul 2 06:48:31 2008'} + def set_uptime(self, uptime): + self._uptime = uptime + + def get_uptime(self): + if self._uptime: + return self._uptime + + # Avoid empty dict return + return {"seconds": "", "lastboot": ""} + + # ports is an array containing dicts of the form + # {'port_state': u'open', 'portid': u'22', 'protocol': u'tcp', + # 'service_conf': u'10', 'service_extrainfo': u'protocol 2.0', + # 'service_method': u'probed', 'service_name': u'ssh', + # 'service_product': u'OpenSSH', 'service_version': u'4.3'} + def set_ports(self, ports): + self._ports = ports + + def get_ports(self): + return self._ports + + # extraports is an array of dicts of the form + # {'count': u'1709', 'state': u'filtered'} + def set_extraports(self, port_list): + self._extraports = port_list + + def get_extraports(self): + return self._extraports + + # hostnames is a list containing dicts of the form + # [{'hostname': u'scanme.nmap.org', 'hostname_type': u'PTR'}] + def set_hostnames(self, hostname_list): + self._hostnames = hostname_list + + def get_hostnames(self): + return self._hostnames + + # ip, ipv6, and mac are either None or dicts of the form + # {'vendor': u'', 'type': u'ipv4', 'addr': u'64.13.134.52'} + def set_ip(self, addr): + self._ip = addr + + def get_ip(self): + return self._ip + + def set_mac(self, addr): + self._mac = addr + + def get_mac(self): + return self._mac + + def set_ipv6(self, addr): + self._ipv6 = addr + + def get_ipv6(self): + return self._ipv6 + + def get_addrs_for_sort(self): + """Return a list of addresses as opaque values sorted such that + 1) IPv4 comes before IPv6 comes before MAC, and + 2) addresses are sorted according to their binary values, not their + string representation. + Use this function to the the comparison key when sorting a list of + hosts by address.""" + l = [] + if self.ip: + l.append((1, socket.inet_aton(self.ip["addr"]))) + if self.ipv6: + try: + l.append((1, + socket.inet_pton(socket.AF_INET6, self.ipv6["addr"]))) + except AttributeError: + # Windows doesn't have socket.inet_pton. Go alphabetical. + # Encode to a byte string for possible comparison with binary + # address strings (which can't be converted to unicode). + l.append((1, self.ipv6["addr"].encode("utf-8"))) + if self.mac: + l.append((3, "".join( + chr(int(x, 16)) for x in self.mac["addr"].split(":")))) + l.sort() + return l + + # comment is a string. + def get_comment(self): + return self._comment + + def set_comment(self, comment): + self._comment = comment + + # state is a string like u'up' or u'down'. + def set_state(self, status): + self._state = status + + def get_state(self): + return self._state + + def get_hostname(self): + hostname = None + if len(self._hostnames) > 0: + hostname = self._hostnames[0]["hostname"] + + address = self.ip or self.ipv6 or self.mac + if address is not None: + address = address["addr"] + + if hostname is not None: + if address is not None: + return "%s (%s)" % (hostname, address) + else: + return hostname + else: + if address is not None: + return address + else: + return _("Unknown Host") + + def get_port_count_by_states(self, states): + count = 0 + + for p in self.ports: + state = p.get('port_state') + if state in states: + count += 1 + + for extra in self.get_extraports(): + if extra['state'] in states: + count += int(extra['count']) + + return count + + def get_open_ports(self): + return self.get_port_count_by_states(('open', 'open|filtered')) + + def get_filtered_ports(self): + return self.get_port_count_by_states( + ('filtered', 'open|filtered', 'closed|filtered')) + + def get_closed_ports(self): + return self.get_port_count_by_states(('closed', 'closed|filtered')) + + def get_scanned_ports(self): + scanned = 0 + + for p in self.ports: + scanned += 1 + + for extra in self.get_extraports(): + scanned += int(extra["count"]) + + return scanned + + def get_services(self): + services = [] + for p in self.ports: + services.append({ + "service_name": p.get("service_name", _("unknown")), + "portid": p.get("portid", ""), + "service_version": p.get("service_version", + _("Unknown version")), + "service_product": p.get("service_product", ""), + "service_extrainfo": p.get("service_extrainfo", ""), + "port_state": p.get("port_state", _("unknown")), + "protocol": p.get("protocol", "") + }) + return services + + def get_trace(self): + return self._trace + + def set_trace(self, trace): + self._trace = trace + + def append_trace_hop(self, hop): + if "hops" in self._trace: + self._trace["hops"].append(hop) + else: + self._trace["hops"] = [hop] + + def set_trace_error(self, errorstr): + self._trace["error"] = errorstr + + # Properties + tcpsequence = property(get_tcpsequence, set_tcpsequence) + osmatches = property(get_osmatches, set_osmatches) + ports = property(get_ports, set_ports) + ports_used = property(get_ports_used, set_ports_used) + extraports = property(get_extraports, set_extraports) + uptime = property(get_uptime, set_uptime) + hostnames = property(get_hostnames, set_hostnames) + tcptssequence = property(get_tcptssequence, set_tcptssequence) + ipidsequence = property(get_ipidsequence, set_ipidsequence) + ip = property(get_ip, set_ip) + ipv6 = property(get_ipv6, set_ipv6) + mac = property(get_mac, set_mac) + state = property(get_state, set_state) + comment = property(get_comment, set_comment) + services = property(get_services) + trace = property(get_trace, set_trace) + + +class ParserBasics(object): + def __init__(self): + # This flag informs us whether the XML output file is temporary (True), + # or user specified (False). If any of them is user-specified, it + # doesn't get stripped out of the command string in set_nmap_command. + self.xml_is_temp = True + + self.nmap = { + 'nmaprun': {}, + 'scaninfo': [], + 'verbose': '', + 'debugging': '', + 'hosts': [], + 'runstats': {} + } + + self.ops = NmapOptions() + self._nmap_output = StringIO() + + def set_xml_is_temp(self, xml_is_temp): + # This flag is False if a user has specified his own -oX option - in + # which case we not should remove the -oX option from the command + # string. A value of True means that we're using a temporary file which + # should be removed from the command string (see set_nmap_command). + self.xml_is_temp = xml_is_temp + + def get_profile_name(self): + return self.nmap['nmaprun'].get('profile_name', '') + + def set_profile_name(self, name): + self.nmap['nmaprun']['profile_name'] = name + + def get_targets(self): + return self.ops.target_specs + + def set_targets(self, targets): + self.ops.target_specs = targets + + def get_nmap_output(self): + return self._nmap_output.getvalue() + + def set_nmap_output(self, nmap_output): + self._nmap_output.close() + del self._nmap_output + self._nmap_output = StringIO() + self._nmap_output.write(nmap_output) + + def del_nmap_output(self): + self._nmap_output.close() + del self._nmap_output + + def get_debugging_level(self): + return self.nmap.get('debugging', '') + + def set_debugging_level(self, level): + self.nmap['debugging'] = level + + def get_verbose_level(self): + return self.nmap.get('verbose', '') + + def set_verbose_level(self, level): + self.nmap['verbose'] = level + + def get_scaninfo(self): + return self.nmap.get('scaninfo', '') + + def set_scaninfo(self, info): + self.nmap['scaninfo'] = info + + def get_services_scanned(self): + if self._services_scanned is None: + return self._services_scanned + + services = [] + for scan in self.nmap.get('scaninfo', []): + services.append(scan['services']) + + self._services_scanned = ','.join(services) + return self._services_scanned + + def set_services_scanned(self, services_scanned): + self._services_scanned = services_scanned + + def get_nmap_command(self): + return self.ops.render_string() + + def set_nmap_command(self, command): + self.ops.parse_string(command) + if self.xml_is_temp: + self.ops["-oX"] = None + self.nmap['nmaprun']['args'] = self.ops.render_string() + + def get_scan_type(self): + types = [] + for t in self.nmap.get('scaninfo', []): + types.append(t['type']) + return types + + def get_protocol(self): + protocols = [] + for proto in self.nmap.get('scaninfo', []): + protocols.append(proto['protocol']) + return protocols + + def get_num_services(self): + if self._num_services is None: + return self._num_services + + num = 0 + for n in self.nmap.get('scaninfo', []): + num += int(n['numservices']) + + self._num_services = num + return self._num_services + + def set_num_services(self, num_services): + self._num_services = num_services + + def get_date(self): + epoch = int(self.nmap['nmaprun'].get('start', '0')) + return time.localtime(epoch) + + def get_start(self): + return self.nmap['nmaprun'].get('start', '0') + + def set_start(self, start): + self.nmap['nmaprun']['start'] = start + + def set_date(self, date): + if type(date) == type(int): + self.nmap['nmaprun']['start'] = date + else: + raise Exception("Wrong date format. Date should be saved \ +in epoch format!") + + def get_open_ports(self): + ports = 0 + + for h in self.nmap.get('hosts', []): + ports += h.get_open_ports() + + return ports + + def get_filtered_ports(self): + ports = 0 + + for h in self.nmap.get('hosts', []): + ports += h.get_filtered_ports() + + return ports + + def get_closed_ports(self): + ports = 0 + + for h in self.nmap['hosts']: + ports += h.get_closed_ports() + + return ports + + def get_formatted_date(self): + return time.strftime("%B %d, %Y - %H:%M", self.get_date()) + + def get_scanner(self): + return self.nmap['nmaprun'].get('scanner', '') + + def set_scanner(self, scanner): + self.nmap['nmaprun']['scanner'] = scanner + + def get_scanner_version(self): + return self.nmap['nmaprun'].get('version', '') + + def set_scanner_version(self, version): + self.nmap['nmaprun']['version'] = version + + # IPv4 + def get_ipv4(self): + hosts = self.nmap.get('hosts') + if hosts is None: + return [] + return [host.ip for host in hosts if host.ip is not None] + + # MAC + def get_mac(self): + hosts = self.nmap.get('hosts') + if hosts is None: + return [] + return [host.mac for host in hosts if host.mac is not None] + + # IPv6 + def get_ipv6(self): + hosts = self.nmap.get('hosts') + if hosts is None: + return [] + return [host.ipv6 for host in hosts if host.ipv6 is not None] + + def get_hostnames(self): + hostnames = [] + for host in self.nmap.get('hosts', []): + hostnames += host.get_hostnames() + return hostnames + + def get_hosts(self): + return self.nmap.get('hosts', None) + + def get_runstats(self): + return self.nmap.get('runstats', None) + + def set_runstats(self, stats): + self.nmap['runstats'] = stats + + def get_hosts_down(self): + return int(self.nmap['runstats'].get('hosts_down', '0')) + + def set_hosts_down(self, down): + self.nmap['runstats']['hosts_down'] = int(down) + + def get_hosts_up(self): + return int(self.nmap['runstats'].get('hosts_up', '0')) + + def set_hosts_up(self, up): + self.nmap['runstats']['hosts_up'] = int(up) + + def get_hosts_scanned(self): + return int(self.nmap['runstats'].get('hosts_scanned', '0')) + + def set_hosts_scanned(self, scanned): + self.nmap['runstats']['hosts_scanned'] = int(scanned) + + def get_finish_time(self): + return time.localtime(int(self.nmap['runstats'].get('finished_time', + '0'))) + + def set_finish_time(self, finish): + self.nmap['runstats']['finished_time'] = int(finish) + + def get_finish_epoc_time(self): + return int(self.nmap['runstats'].get('finished_time', '0')) + + def set_finish_epoc_time(self, time): + self.nmap['runstats']['finished_time'] = time + + def get_scan_name(self): + """Get a human-readable string representing this scan.""" + scan_name = self.nmap.get("scan_name") + if scan_name: + return scan_name + if self.profile_name and self.get_targets(): + return _("%s on %s") % (self.profile_name, + join_quoted(self.get_targets())) + return self.get_nmap_command() + + def set_scan_name(self, scan_name): + self.nmap["scan_name"] = scan_name + + def get_formatted_finish_date(self): + return time.strftime("%B %d, %Y - %H:%M", self.get_finish_time()) + + def get_port_protocol_dict(self): + #Create a dict of port -> protocol for all ports scanned + ports = {} + for scaninfo in self.scaninfo: + services_string = scaninfo['services'].strip() + if services_string == "": + services_array = [] + else: + services_array = services_string.split(',') + for item in services_array: + if item.find('-') == -1: + if int(item) not in ports: + ports[int(item)] = [] + ports[int(item)].append(scaninfo['protocol']) + else: + begin, end = item.split('-') + for port in range(int(begin), int(end) + 1): + if int(port) not in ports: + ports[int(port)] = [] + ports[int(port)].append(scaninfo['protocol']) + return ports + + profile_name = property(get_profile_name, set_profile_name) + nmap_output = property(get_nmap_output, set_nmap_output, del_nmap_output) + debugging_level = property(get_debugging_level, set_debugging_level) + verbose_level = property(get_verbose_level, set_verbose_level) + scaninfo = property(get_scaninfo, set_scaninfo) + services_scanned = property(get_services_scanned, set_services_scanned) + nmap_command = property(get_nmap_command, set_nmap_command) + scan_type = property(get_scan_type) + protocol = property(get_protocol) + num_services = property(get_num_services, set_num_services) + date = property(get_date, set_date) + open_ports = property(get_open_ports) + filtered_ports = property(get_filtered_ports) + closed_ports = property(get_closed_ports) + formatted_date = property(get_formatted_date) + scanner = property(get_scanner, set_scanner) + scanner_version = property(get_scanner_version, set_scanner_version) + ipv4 = property(get_ipv4) + mac = property(get_mac) + ipv6 = property(get_ipv6) + hostnames = property(get_hostnames) + hosts = property(get_hosts) + runstats = property(get_runstats, set_runstats) + hosts_down = property(get_hosts_down, set_hosts_down) + hosts_up = property(get_hosts_up, set_hosts_up) + hosts_scanned = property(get_hosts_scanned, set_hosts_scanned) + finish_time = property(get_finish_time, set_finish_time) + finish_epoc_time = property(get_finish_epoc_time, set_finish_epoc_time) + formatted_finish_date = property(get_formatted_finish_date) + start = property(get_start, set_start) + scan_name = property(get_scan_name, set_scan_name) + + _num_services = None + _services_scanned = None + + +class NmapParserSAX(ParserBasics, ContentHandler): + def __init__(self): + ParserBasics.__init__(self) + ContentHandler.__init__(self) + + # The text inside an xml-stylesheet processing instruction, like + # 'href="file:///usr/share/nmap/nmap.xsl" type="text/xsl"'. + self.xml_stylesheet_data = None + + self.in_interactive_output = False + self.in_run_stats = False + self.in_host = False + self.in_hostnames = False + self.in_ports = False + self.in_port = False + self.in_os = False + self.in_trace = False + self.list_extraports = [] + + self.filename = None + + self.unsaved = False + + def set_parser(self, parser): + self.parser = parser + + def parse(self, f): + """Parse an Nmap XML file from the file-like object f.""" + self.parser.parse(f) + + def parse_file(self, filename): + """Parse an Nmap XML file from the named file.""" + with open(filename, "r") as f: + self.parse(f) + self.filename = filename + + def _parse_nmaprun(self, attrs): + run_tag = "nmaprun" + + if self.nmap_output == "" and "nmap_output" in attrs: + self.nmap_output = attrs["nmap_output"] + self.nmap[run_tag]["profile_name"] = attrs.get("profile_name", "") + self.nmap[run_tag]["start"] = attrs.get("start", "") + self.nmap[run_tag]["args"] = attrs.get("args", "") + self.nmap[run_tag]["scanner"] = attrs.get("scanner", "") + self.nmap[run_tag]["version"] = attrs.get("version", "") + self.nmap[run_tag]["xmloutputversion"] = attrs.get( + "xmloutputversion", "") + + self.nmap_command = self.nmap[run_tag]["args"] + + def _parse_output(self, attrs): + if attrs.get("type") != "interactive": + return + if self.in_interactive_output: + raise SAXException("Unexpected nested \"output\" element.") + self.in_interactive_output = True + self.nmap_output = "" + + def _parse_scaninfo(self, attrs): + dic = {} + + dic["type"] = unique(attrs.get("type", "")) + dic["protocol"] = unique(attrs.get("protocol", "")) + dic["numservices"] = attrs.get("numservices", "") + dic["services"] = attrs.get("services", "") + + self.nmap["scaninfo"].append(dic) + + def _parse_verbose(self, attrs): + self.nmap["verbose"] = attrs.get("level", "") + + def _parse_debugging(self, attrs): + self.nmap["debugging"] = attrs.get("level", "") + + def _parse_runstats_finished(self, attrs): + self.nmap["runstats"]["finished_time"] = attrs.get("time", "") + + def _parse_runstats_hosts(self, attrs): + self.nmap["runstats"]["hosts_up"] = attrs.get("up", "") + self.nmap["runstats"]["hosts_down"] = attrs.get("down", "") + self.nmap["runstats"]["hosts_scanned"] = attrs.get("total", "") + + def _parse_host(self, attrs): + self.host_info = HostInfo() + self.host_info.comment = attrs.get("comment", "") + + def _parse_host_status(self, attrs): + self.host_info.set_state(unique(attrs.get("state", ""))) + + def _parse_host_address(self, attrs): + address_attributes = {"type": unique(attrs.get("addrtype", "")), + "vendor": attrs.get("vendor", ""), + "addr": attrs.get("addr", "")} + + if address_attributes["type"] == "ipv4": + self.host_info.set_ip(address_attributes) + elif address_attributes["type"] == "ipv6": + self.host_info.set_ipv6(address_attributes) + elif address_attributes["type"] == "mac": + self.host_info.set_mac(address_attributes) + + def _parse_host_hostname(self, attrs): + self.list_hostnames.append({"hostname": attrs.get("name", ""), + "hostname_type": attrs.get("type", "")}) + + def _parse_host_extraports(self, attrs): + self.list_extraports.append({"state": unique(attrs.get("state", "")), + "count": attrs.get("count", "")}) + + def _parse_host_port(self, attrs): + self.dic_port = {"protocol": unique(attrs.get("protocol", "")), + "portid": unique(attrs.get("portid", ""))} + + def _parse_host_port_state(self, attrs): + self.dic_port["port_state"] = unique(attrs.get("state", "")) + self.dic_port["reason"] = unique(attrs.get("reason", "")) + self.dic_port["reason_ttl"] = unique(attrs.get("reason_ttl", "")) + + def _parse_host_port_service(self, attrs): + self.dic_port["service_name"] = attrs.get("name", "") + self.dic_port["service_method"] = unique(attrs.get("method", "")) + self.dic_port["service_conf"] = attrs.get("conf", "") + self.dic_port["service_product"] = attrs.get("product", "") + self.dic_port["service_version"] = attrs.get("version", "") + self.dic_port["service_extrainfo"] = attrs.get("extrainfo", "") + + def _parse_host_osmatch(self, attrs): + osmatch = self._parsing(attrs, [], ['name', 'accuracy', 'line']) + osmatch['osclasses'] = [] + self.list_osmatch.append(osmatch) + + def _parse_host_portused(self, attrs): + self.list_portused.append(self._parsing( + attrs, ['state', 'proto', 'portid'], [])) + + def _parse_host_osclass(self, attrs): + self.list_osclass.append(self._parsing( + attrs, ['type', 'vendor', 'osfamily', 'osgen'], ['accuracy'])) + + def _parsing(self, attrs, unique_names, other_names): + # Returns a dict with the attributes of a given tag with the + # attributes names as keys and their respective values + dic = {} + for at in unique_names: + dic[at] = unique(attrs.get(at, "")) + for at in other_names: + dic[at] = attrs.get(at, "") + return dic + + def _parse_host_uptime(self, attrs): + self.host_info.set_uptime(self._parsing( + attrs, [], ["seconds", "lastboot"])) + + def _parse_host_tcpsequence(self, attrs): + self.host_info.set_tcpsequence(self._parsing( + attrs, ['difficulty'], ['index', 'values'])) + + def _parse_host_tcptssequence(self, attrs): + self.host_info.set_tcptssequence(self._parsing( + attrs, ['class'], ['values'])) + + def _parse_host_ipidsequence(self, attrs): + self.host_info.set_ipidsequence(self._parsing( + attrs, ['class'], ['values'])) + + def _parse_host_trace(self, attrs): + trace = {} + for attr in ["proto", "port"]: + trace[attr] = unique(attrs.get(attr, "")) + self.host_info.set_trace(trace) + + def _parse_host_trace_hop(self, attrs): + hop = self._parsing(attrs, [], ["ttl", "rtt", "ipaddr", "host"]) + self.host_info.append_trace_hop(hop) + + def _parse_host_trace_error(self, attrs): + self.host_info.set_trace_error(unique(attrs.get("errorstr", ""))) + + def processingInstruction(self, target, data): + if target == "xml-stylesheet": + self.xml_stylesheet_data = data + + def startElement(self, name, attrs): + if name == "nmaprun": + self._parse_nmaprun(attrs) + if name == "output": + self._parse_output(attrs) + elif name == "scaninfo": + self._parse_scaninfo(attrs) + elif name == "verbose": + self._parse_verbose(attrs) + elif name == "debugging": + self._parse_debugging(attrs) + elif name == "runstats": + self.in_run_stats = True + elif self.in_run_stats and name == "finished": + self._parse_runstats_finished(attrs) + elif self.in_run_stats and name == "hosts": + self._parse_runstats_hosts(attrs) + elif name == "host": + self.in_host = True + self._parse_host(attrs) + self.list_ports = [] + self.list_extraports = [] + elif self.in_host and name == "status": + self._parse_host_status(attrs) + elif self.in_host and name == "address": + self._parse_host_address(attrs) + elif self.in_host and name == "hostnames": + self.in_hostnames = True + self.list_hostnames = [] + elif self.in_host and self.in_hostnames and name == "hostname": + self._parse_host_hostname(attrs) + elif self.in_host and name == "ports": + self.in_ports = True + elif self.in_host and self.in_ports and name == "extraports": + self._parse_host_extraports(attrs) + elif self.in_host and self.in_ports and name == "port": + self.in_port = True + self._parse_host_port(attrs) + elif self.in_host and self.in_ports and \ + self.in_port and name == "state": + self._parse_host_port_state(attrs) + elif self.in_host and self.in_ports and \ + self.in_port and name == "service": + self._parse_host_port_service(attrs) + elif self.in_host and name == "os": + self.in_os = True + self.list_portused = [] + self.list_osmatch = [] + elif self.in_host and self.in_os and name == "osmatch": + self._parse_host_osmatch(attrs) + elif self.in_host and self.in_os and name == "portused": + self._parse_host_portused(attrs) + elif self.in_host and self.in_os and name == "osclass": + self.list_osclass = [] + self._parse_host_osclass(attrs) + elif self.in_host and name == "uptime": + self._parse_host_uptime(attrs) + elif self.in_host and name == "tcpsequence": + self._parse_host_tcpsequence(attrs) + elif self.in_host and name == "tcptssequence": + self._parse_host_tcptssequence(attrs) + elif self.in_host and name == "ipidsequence": + self._parse_host_ipidsequence(attrs) + elif self.in_host and name == "trace": + self.in_trace = True + self._parse_host_trace(attrs) + elif self.in_host and self.in_trace and name == "hop": + self._parse_host_trace_hop(attrs) + elif self.in_host and self.in_trace and name == "error": + self._parse_host_trace_error(attrs) + + def endElement(self, name): + if name == "output": + self.in_interactive_output = False + elif name == "runstats": + self.in_run_stats = False + elif name == "host": + self.in_host = False + self.host_info.set_extraports(self.list_extraports) + self.host_info.set_ports(self.list_ports) + self.nmap["hosts"].append(self.host_info) + elif self.in_host and name == "hostnames": + self.in_hostnames = False + self.host_info.set_hostnames(self.list_hostnames) + elif self.in_host and name == "ports": + self.in_ports = False + elif self.in_host and self.in_ports and name == "port": + self.in_port = False + self.list_ports.append(self.dic_port) + del(self.dic_port) + elif self.in_host and self.in_os and name == "osmatch": + self.list_osmatch[-1]['osclasses'].extend(self.list_osclass) + self.list_osclass = [] + elif self.in_host and self.in_os and name == "os": + self.in_os = False + self.host_info.set_ports_used(self.list_portused) + self.host_info.set_osmatches(self.list_osmatch) + + del(self.list_portused) + del(self.list_osmatch) + elif self.in_host and self.in_trace and name == "trace": + self.in_trace = False + + def characters(self, content): + if self.in_interactive_output: + self._nmap_output.write(content) + + def write_text(self, f): + """Write the Nmap text output of this object to the file-like object + f.""" + if self.nmap_output == "": + return + f.write(self.nmap_output) + + def write_xml(self, f): + """Write the XML representation of this object to the file-like object + f.""" + writer = XMLGenerator(f) + writer.startDocument() + if self.xml_stylesheet_data is not None: + writer.processingInstruction( + "xml-stylesheet", self.xml_stylesheet_data) + self._write_nmaprun(writer) + self._write_scaninfo(writer) + self._write_verbose(writer) + self._write_debugging(writer) + self._write_output(writer) + self._write_hosts(writer) + self._write_runstats(writer) + writer.endElement("nmaprun") + writer.endDocument() + + def get_xml(self): + """Return a string containing the XML representation of this scan.""" + buffer = StringIO() + self.write_xml(buffer) + string = buffer.getvalue() + buffer.close() + return string + + def write_xml_to_file(self, filename): + """Write the XML representation of this scan to the file whose name is + given.""" + fd = open(filename, "w") + self.write_xml(fd) + fd.close() + + def _write_output(self, writer): + if self.nmap_output == "": + return + writer.startElement("output", Attributes({"type": "interactive"})) + writer.characters(self.nmap_output) + writer.endElement("output") + + def _write_runstats(self, writer): + ################## + # Runstats element + writer.startElement("runstats", Attributes(dict())) + + ## Finished element + writer.startElement("finished", + Attributes(dict(time=str(self.finish_epoc_time), + timestr=time.ctime(time.mktime( + self.get_finish_time()))))) + writer.endElement("finished") + + ## Hosts element + writer.startElement("hosts", + Attributes(dict(up=str(self.hosts_up), + down=str(self.hosts_down), + total=str(self.hosts_scanned)))) + writer.endElement("hosts") + + writer.endElement("runstats") + # End of Runstats element + ######################### + + def _write_hosts(self, writer): + for host in self.hosts: + # Start host element + writer.startElement("host", + Attributes(dict(comment=host.comment))) + + # Status element + writer.startElement("status", + Attributes(dict(state=host.state))) + writer.endElement("status") + + ################## + # Address elements + ## IPv4 + if host.ip is not None: + writer.startElement("address", + Attributes(dict(addr=host.ip.get("addr", ""), + vendor=host.ip.get("vendor", ""), + addrtype=host.ip.get("type", "")))) + writer.endElement("address") + + ## IPv6 + if host.ipv6 is not None: + writer.startElement("address", + Attributes(dict(addr=host.ipv6.get("addr", ""), + vendor=host.ipv6.get("vendor", ""), + addrtype=host.ipv6.get("type", "")))) + writer.endElement("address") + + ## MAC + if host.mac is not None: + writer.startElement("address", + Attributes(dict(addr=host.mac.get("addr", ""), + vendor=host.mac.get("vendor", ""), + addrtype=host.mac.get("type", "")))) + writer.endElement("address") + # End of Address elements + ######################### + + ################### + # Hostnames element + writer.startElement("hostnames", Attributes({})) + + for hname in host.hostnames: + writer.startElement("hostname", + Attributes(dict(name=hname.get("hostname", ""), + type=hname.get("hostname_type", "")))) + + writer.endElement("hostname") + + writer.endElement("hostnames") + # End of Hostnames element + ########################## + + ############### + # Ports element + writer.startElement("ports", Attributes({})) + + ## Extraports elements + for ext in host.get_extraports(): + writer.startElement("extraports", + Attributes(dict(count=ext.get("count", ""), + state=ext.get("state", "")))) + writer.endElement("extraports") + + ## Port elements + for p in host.ports: + writer.startElement("port", + Attributes(dict(portid=p.get("portid", ""), + protocol=p.get("protocol", "")))) + + ### Port state + writer.startElement("state", + Attributes(dict(state=p.get("port_state", ""), + reason=p.get("reason", ""), + reason_ttl=p.get("reason_ttl", "")))) + writer.endElement("state") + + ### Port service info + d = {} + for xml_attr, member in (("conf", "service_conf"), + ("method", "service_method"), + ("name", "service_name"), + ("product", "service_product"), + ("version", "service_version"), + ("extrainfo", "service_extrainfo")): + if p.get(member): + d[xml_attr] = p.get(member) + writer.startElement("service", Attributes(d)) + writer.endElement("service") + + writer.endElement("port") + + writer.endElement("ports") + # End of Ports element + ###################### + + ############ + # OS element + writer.startElement("os", Attributes({})) + + ## Ports used elements + for pu in host.ports_used: + writer.startElement("portused", + Attributes(dict(state=pu.get("state", ""), + proto=pu.get("proto", ""), + portid=pu.get("portid", "")))) + writer.endElement("portused") + + ## Osmatch elements + for om in host.osmatches: + writer.startElement("osmatch", + Attributes(dict(name=om.get("name", ""), + accuracy=om.get("accuracy", ""), + line=om.get("line", "")))) + ## Osclass elements + for oc in om['osclasses']: + writer.startElement("osclass", + Attributes(dict(vendor=oc.get("vendor", ""), + osfamily=oc.get("osfamily", ""), + type=oc.get("type", ""), + osgen=oc.get("osgen", ""), + accuracy=oc.get("accuracy", "")))) + writer.endElement("osclass") + writer.endElement("osmatch") + + writer.endElement("os") + # End of OS element + ################### + + # Uptime element + writer.startElement("uptime", + Attributes(dict(seconds=host.uptime.get("seconds", ""), + lastboot=host.uptime.get("lastboot", "")))) + writer.endElement("uptime") + + ##################### + # Sequences elements + ## TCP Sequence element + # Cannot use dict() here, because of the 'class' attribute. + writer.startElement("tcpsequence", + Attributes({"index": host.tcpsequence.get("index", ""), + "difficulty": host.tcpsequence.get("difficulty", ""), + "values": host.tcpsequence.get("values", "")})) + writer.endElement("tcpsequence") + + ## IP ID Sequence element + writer.startElement("ipidsequence", + Attributes({"class": host.ipidsequence.get("class", ""), + "values": host.ipidsequence.get("values", "")})) + writer.endElement("ipidsequence") + + ## TCP TS Sequence element + writer.startElement("tcptssequence", + Attributes({"class": host.tcptssequence.get("class", ""), + "values": host.tcptssequence.get("values", "")})) + writer.endElement("tcptssequence") + # End of sequences elements + ########################### + + ## Trace element + if len(host.trace) > 0: + writer.startElement("trace", + Attributes({"proto": host.trace.get("proto", ""), + "port": host.trace.get("port", "")})) + + if "hops" in host.trace: + for hop in host.trace["hops"]: + writer.startElement("hop", + Attributes({"ttl": hop["ttl"], + "rtt": hop["rtt"], + "ipaddr": hop["ipaddr"], + "host": hop["host"]})) + writer.endElement("hop") + + if "error" in host.trace: + writer.startElement("error", + Attributes({"errorstr": host.trace["error"]})) + writer.endElement("error") + + writer.endElement("trace") + # End of trace element + ########################### + + # End host element + writer.endElement("host") + + def _write_debugging(self, writer): + writer.startElement("debugging", Attributes(dict( + level=str(self.debugging_level)))) + writer.endElement("debugging") + + def _write_verbose(self, writer): + writer.startElement("verbose", Attributes(dict( + level=str(self.verbose_level)))) + writer.endElement("verbose") + + def _write_scaninfo(self, writer): + for scan in self.scaninfo: + writer.startElement("scaninfo", + Attributes(dict(type=scan.get("type", ""), + protocol=scan.get("protocol", ""), + numservices=scan.get("numservices", ""), + services=scan.get("services", "")))) + writer.endElement("scaninfo") + + def _write_nmaprun(self, writer): + writer.startElement("nmaprun", + Attributes(dict(args=str(self.nmap_command), + profile_name=str(self.profile_name), + scanner=str(self.scanner), + start=str(self.start), + startstr=time.ctime( + time.mktime(self.get_date())), + version=str(self.scanner_version), + xmloutputversion=str(XML_OUTPUT_VERSION)))) + + def set_unsaved(self): + self.unsaved = True + + def is_unsaved(self): + return self.unsaved + + +class OverrideEntityResolver(EntityResolver): + """This class overrides the default behavior of xml.sax to download + remote DTDs, instead returning blank strings""" + empty = StringIO() + + def resolveEntity(self, publicId, systemId): + return OverrideEntityResolver.empty + + +def nmap_parser_sax(): + parser = make_parser() + nmap_parser = NmapParserSAX() + + parser.setContentHandler(nmap_parser) + parser.setEntityResolver(OverrideEntityResolver()) + nmap_parser.set_parser(parser) + + return nmap_parser + +NmapParser = nmap_parser_sax + + +if __name__ == '__main__': + import sys + + file_to_parse = sys.argv[1] + + np = NmapParser() + np.parse_file(file_to_parse) + + for host in np.hosts: + print("%s:" % host.ip["addr"]) + print(" Comment:", repr(host.comment)) + print(" TCP sequence:", repr(host.tcpsequence)) + print(" TCP TS sequence:", repr(host.tcptssequence)) + print(" IP ID sequence:", repr(host.ipidsequence)) + print(" Uptime:", repr(host.uptime)) + print(" OS Match:", repr(host.osmatches)) + print(" Ports:") + for p in host.ports: + print("\t%s" % repr(p)) + print(" Ports used:", repr(host.ports_used)) + print(" OS Matches:", repr(host.osmatches)) + print(" Hostnames:", repr(host.hostnames)) + print(" IP:", repr(host.ip)) + print(" IPv6:", repr(host.ipv6)) + print(" MAC:", repr(host.mac)) + print(" State:", repr(host.state)) + if "hops" in host.trace: + print(" Trace:") + for hop in host.trace["hops"]: + print(" ", repr(hop)) + print() diff --git a/zenmap/zenmapCore/Paths.py b/zenmap/zenmapCore/Paths.py new file mode 100644 index 0000000..e441171 --- /dev/null +++ b/zenmap/zenmapCore/Paths.py @@ -0,0 +1,243 @@ +#!/usr/bin/env python3 + +# ***********************IMPORTANT NMAP LICENSE TERMS************************ +# * +# * The Nmap Security Scanner is (C) 1996-2023 Nmap Software 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.com) 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/ +# * +# ***************************************************************************/ + +from os.path import join, dirname + +import errno +import os +import os.path +import sys +import shutil + +from zenmapCore.BasePaths import base_paths +from zenmapCore.Name import APP_NAME + + +# Find out the prefix under which data files (interface definition XML, +# pixmaps, etc.) are stored. This can vary depending on whether we are running +# in an executable package and what type of package it is, which we check using +# the sys.frozen attribute. See +# http://mail.python.org/pipermail/pythonmac-sig/2004-November/012121.html. +def get_prefix(): + from site import getsitepackages + frozen = getattr(sys, "frozen", None) + if frozen == "macosx_app" or "Zenmap.app" in sys.executable: + # A py2app .app bundle. + return os.path.join(dirname(sys.executable), "..", "Resources") + elif frozen is not None: + # Assume a py2exe executable. + return dirname(sys.executable) + elif any(__file__.startswith(pdir) for pdir in getsitepackages()): + # Installed in site-packages; use configured prefix. + return sys.prefix + else: + # Normal script execution. Look in the current directory to allow + # running from the distribution. + return os.path.abspath(os.path.dirname(sys.argv[0])) + +prefix = get_prefix() + +# These lines are overwritten by the installer to hard-code the installed +# locations. +CONFIG_DIR = join(prefix, "share", APP_NAME, "config") +LOCALE_DIR = join(prefix, "share", APP_NAME, "locale") +MISC_DIR = join(prefix, "share", APP_NAME, "misc") +PIXMAPS_DIR = join(prefix, "share", "zenmap", "pixmaps") +DOCS_DIR = join(prefix, "share", APP_NAME, "docs") +NMAPDATADIR = join(prefix, "..") + + +def get_extra_executable_search_paths(): + """Return a list of additional executable search paths as a convenience for + platforms where the default PATH is inadequate.""" + if sys.platform == 'darwin': + return ["/usr/local/bin"] + elif sys.platform == 'win32': + return [dirname(sys.executable)] + return [] + + +####### +# Paths +class Paths(object): + """Paths + """ + hardcoded = ["config_dir", + "locale_dir", + "pixmaps_dir", + "misc_dir", + "docs_dir"] + + config_files_list = ["config_file", + "scan_profile", + "version"] + + empty_config_files_list = ["target_list", + "recent_scans", + "db"] + + misc_files_list = ["options", + "profile_editor"] + + def __init__(self): + self.config_dir = CONFIG_DIR + self.locale_dir = LOCALE_DIR + self.pixmaps_dir = PIXMAPS_DIR + self.misc_dir = MISC_DIR + self.docs_dir = DOCS_DIR + self.nmap_dir = NMAPDATADIR + self._delayed_incomplete = True + + # Delay initializing these paths so that + # zenmapCore.I18N.install_gettext can install _() before modules that + # need it get imported + def _delayed_init(self): + if self._delayed_incomplete: + from zenmapCore.UmitOptionParser import option_parser + self.user_config_dir = option_parser.get_confdir() + self.user_config_file = os.path.join( + self.user_config_dir, base_paths['user_config_file']) + self._delayed_incomplete = False + + def __getattr__(self, name): + if name in self.hardcoded: + return self.__dict__[name] + + self._delayed_init() + if name in self.config_files_list: + return return_if_exists( + join(self.user_config_dir, base_paths[name])) + + if name in self.empty_config_files_list: + return return_if_exists( + join(self.user_config_dir, base_paths[name]), True) + + if name in self.misc_files_list: + return return_if_exists(join(self.misc_dir, base_paths[name])) + + try: + return self.__dict__[name] + except Exception: + raise NameError(name) + + def __setattr__(self, name, value): + self.__dict__[name] = value + + +def create_dir(path): + """Create a directory with os.makedirs without raising an error if the + directory already exists.""" + try: + os.makedirs(path) + except OSError as e: + if e.errno != errno.EEXIST: + raise + + +def create_user_config_dir(user_dir, template_dir): + """Create a user configuration directory by creating the directory if + necessary, then copying all the files from the given template directory, + skipping any that already exist.""" + from zenmapCore.UmitLogging import log + log.debug(">>> Create user dir at %s" % user_dir) + create_dir(user_dir) + + for filename in os.listdir(template_dir): + template_filename = os.path.join(template_dir, filename) + user_filename = os.path.join(user_dir, filename) + # Only copy regular files. + if not os.path.isfile(template_filename): + continue + # Don't overwrite existing files. + if os.path.exists(user_filename): + log.debug(">>> %s already exists." % user_filename) + continue + shutil.copyfile(template_filename, user_filename) + log.debug(">>> Copy %s to %s." % (template_filename, user_filename)) + + +def return_if_exists(path, create=False): + path = os.path.abspath(path) + if os.path.exists(path): + return path + elif create: + f = open(path, "w") + f.close() + return path + raise Exception("File '%s' does not exist or could not be found!" % path) + +############ +# Singleton! +Path = Paths() + +if __name__ == '__main__': + print(">>> SAVED DIRECTORIES:") + print(">>> LOCALE DIR:", Path.locale_dir) + print(">>> PIXMAPS DIR:", Path.pixmaps_dir) + print(">>> CONFIG DIR:", Path.config_dir) + print() + print(">>> FILES:") + print(">>> USER CONFIG FILE:", Path.user_config_file) + print(">>> CONFIG FILE:", Path.user_config_file) + print(">>> TARGET_LIST:", Path.target_list) + print(">>> PROFILE_EDITOR:", Path.profile_editor) + print(">>> SCAN_PROFILE:", Path.scan_profile) + print(">>> RECENT_SCANS:", Path.recent_scans) + print(">>> OPTIONS:", Path.options) + print() + print(">>> DB:", Path.db) + print(">>> VERSION:", Path.version) diff --git a/zenmap/zenmapCore/RecentScans.py b/zenmap/zenmapCore/RecentScans.py new file mode 100644 index 0000000..6f5e556 --- /dev/null +++ b/zenmap/zenmapCore/RecentScans.py @@ -0,0 +1,116 @@ +#!/usr/bin/env python3 + +# ***********************IMPORTANT NMAP LICENSE TERMS************************ +# * +# * The Nmap Security Scanner is (C) 1996-2023 Nmap Software 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.com) 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/ +# * +# ***************************************************************************/ + +from os import access, R_OK, W_OK +from os.path import dirname +from zenmapCore.Paths import Path + + +class RecentScans(object): + def __init__(self): + self.temp_list = [] + + try: + self.recent_scans_file = Path.recent_scans + except Exception: + self.recent_scans_file = False + + if (self.recent_scans_file and + (access(self.recent_scans_file, R_OK and W_OK) or + access(dirname(self.recent_scans_file), R_OK and W_OK))): + self.using_file = True + + # Recovering saved targets + recent_file = open(self.recent_scans_file, "r") + self.temp_list = [ + t for t in recent_file.read().split(";") + if t != "" and t != "\n"] + recent_file.close() + else: + self.using_file = False + + def save(self): + if self.using_file: + recent_file = open(self.recent_scans_file, "w") + recent_file.write(";".join(self.temp_list)) + recent_file.close() + + def add_recent_scan(self, recent_scan): + if recent_scan in self.temp_list: + return + + self.temp_list.append(recent_scan) + self.save() + + def clean_list(self): + del self.temp_list + self.temp_list = [] + self.save() + + def get_recent_scans_list(self): + t = self.temp_list[:] + t.reverse() + return t + +recent_scans = RecentScans() + +if __name__ == "__main__": + r = RecentScans() + print(">>> Getting empty list:", r.get_recent_scans_list()) + print(">>> Adding recent scan bla:", r.add_recent_scan("bla")) + print(">>> Getting recent scan list:", r.get_recent_scans_list()) + del r diff --git a/zenmap/zenmapCore/ScriptArgsParser.py b/zenmap/zenmapCore/ScriptArgsParser.py new file mode 100644 index 0000000..180bb6c --- /dev/null +++ b/zenmap/zenmapCore/ScriptArgsParser.py @@ -0,0 +1,206 @@ +#!/usr/bin/env python3 + +# ***********************IMPORTANT NMAP LICENSE TERMS************************ +# * +# * The Nmap Security Scanner is (C) 1996-2023 Nmap Software 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.com) 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/ +# * +# ***************************************************************************/ + +# This module parses the --script-args and stores in the form of key/value +# pairs. The logic is same as in nse_main.lua, except that values are not +# returned as tables but as strings. + +import re +# "^%s*([^'\"%s{},=][^{},=]-)%s*[},=]" +unquoted_re = re.compile(r'\s*([^\'"\s{},=][^{},=]*?)\s*([},=]|$)') +# "^%s*(['\"])(.-[^\\])%1%s*[},=]" +quoted_re = re.compile(r'\s*(([\'"])(.*?[^\\])\2)\s*([},=]|$)') +# "^%s*(['\"])%1%s*[},=]" +empty_re = re.compile(r'\s*(([\'"])\2)\s*([},=]|$)') + + +def parse_string(s, start): + """Parses a single string that is quoted, unquoted or empty. It returns the + found string along with the next starting position """ + for pattern in unquoted_re, quoted_re, empty_re: + m = pattern.match(s, start) or quoted_re.match(s, start) + if m: + return m.group(1), m.end(1) + raise ValueError("No string found at %s." % repr(s[start:])) + + +def next_char(s, start): + """Returns the next character and position in the string.""" + while start < len(s) and s[start].isspace(): + start += 1 + if start < len(s): + return s[start], start + else: + return None, start + + +def parse_value(s, start): + """If the string starting from start is a name-value pair, returns a + name-value tuple. Otherwise returns a plain string.""" + nc, j = next_char(s, start) + if nc == "{": + j = parse_table(s, j) + return s[start:j], j + else: + tmp, j = parse_string(s, j) + nc, j = next_char(s, j) + if nc == "=": + # Key/value? + j += 1 + begin = j + nc, j = next_char(s, j) + if nc == "{": + j = parse_table(s, j) + else: + dummy, j = parse_string(s, j) + return (tmp, s[begin:j]), j + else: + return s[start:j], j + + +def parse_table(s, start): + """This function is responsible for parsing a table; i.e, a string that + starts with '{'. It returns the position where the balancing pair of braces + gets closed.""" + nc, j = next_char(s, start) + if not nc or nc != "{": + raise ValueError("No '{' found at %s." % repr(s[start:])) + j += 1 + while True: + nc, j = next_char(s, j) + if nc == "}": + # End of table. + return j + 1 + else: + # Replace this with a call to parse_value. + v, j = parse_value(s, j) + nc, j = next_char(s, j) + if nc == ",": + j += 1 + + +def parse_script_args(s): + """Main function responsible for parsing the script args and storing the + name-value pairs in a list. If an invalid argument is present it stores the + value as None.""" + args = [] + nc, j = next_char(s, 0) + try: + while nc is not None: + val, j = parse_value(s, j) + if type(val) == str: + raise ValueError( + "Only name-value pairs expected in parse_script_args.") + else: + args.append(val) + nc, j = next_char(s, j) + if nc == ",": + j += 1 + nc, j = next_char(s, j) + except ValueError: + return None + return args + + +def parse_script_args_dict(raw_argument): + """Wrapper function that copies the name-value pairs from a list into a + dictionary.""" + args_dict = {} + args = parse_script_args(raw_argument) + if args is None: + return None + for item in args: + if(len(item) == 2): # only key/value pairs are stored + args_dict[item[0]] = item[1] + return args_dict + +if __name__ == '__main__': + TESTS = ( + ('', []), + ('a=b,c=d', [('a', 'b'), ('c', 'd')]), + ('a="b=c"', [('a', '"b=c"')]), + ('a="def\\"ghi"', [('a', '"def\\"ghi"')]), + ('a={one,{two,{three}}}', [('a', '{one,{two,{three}}}')]), + ('a={"quoted}quoted"}', [('a', '{"quoted}quoted"}')]), + ('a="unterminated', None), + ('user=foo,pass=",{}=bar",whois={whodb=nofollow+ripe},' + 'userdb=C:\\Some\\Path\\To\\File', + [('user', 'foo'), ('pass', '",{}=bar"'), + ('whois', '{whodb=nofollow+ripe}'), + ('userdb', 'C:\\Some\\Path\\To\\File')]), + ) + + for test, expected in TESTS: + args_dict = parse_script_args_dict(test) + print(args_dict) + args = parse_script_args(test) + if args == expected: + print("PASS", test) + continue + print("FAIL", test) + if args is None: + print("Parsing error") + else: + print("%d args" % len(args)) + for a, v in args: + print(a, "=", v) + if expected is None: + print("Expected parsing error") + else: + print("Expected %d args" % len(expected)) + for a, v in expected: + print(a, "=", v) diff --git a/zenmap/zenmapCore/ScriptMetadata.py b/zenmap/zenmapCore/ScriptMetadata.py new file mode 100644 index 0000000..e348448 --- /dev/null +++ b/zenmap/zenmapCore/ScriptMetadata.py @@ -0,0 +1,451 @@ +#!/usr/bin/env python3 + +# ***********************IMPORTANT NMAP LICENSE TERMS************************ +# * +# * The Nmap Security Scanner is (C) 1996-2023 Nmap Software 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.com) 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/ +# * +# ***************************************************************************/ + +# This module has two classes. ScriptDB is responsible for parsing the +# script.db file and fetching each script's name and categories. +# ScriptMetadata gets the description, categories, @usage, @output, and +# arguments from the script itself. + +import re +import os +import sys + + +class ScriptDBSyntaxError(SyntaxError): + """Exception raised when encountering a syntax error in the script.db""" + pass + + +class ScriptDB (object): + """Class responsible for parsing the script.db file, fetching script + names and categories.""" + LUA_STRING_ESCAPES = { + "a": "\a", "b": "\b", "f": "\f", "n": "\n", "r": "\r", + "t": "\t", "v": "\v", "\\": "\\", "\"": "\"", "'": "'", "0": "\0" + } + + def __init__(self, script_db_path=None): + self.unget_buf = "" + + self.lineno = 1 + self.line = "" + with open(script_db_path, "r") as self.f: + self.entries_list = self.parse() + + def syntax_error(self, message): + e = ScriptDBSyntaxError(message) + e.filename = self.f.name + e.lineno = self.lineno + e.offset = len(self.line) + e.text = self.line + return e + + def getchar(self): + c = None + if self.unget_buf: + c = self.unget_buf[-1] + self.unget_buf = self.unget_buf[:-1] + else: + c = self.f.read(1) + if c == "\n": + self.lineno += 1 + self.line = "" + else: + self.line += c + return c + + def unget(self, data): + if data: + self.line = self.line[:-len(data)] + self.unget_buf += data + + def parse(self): + """Parses a script.db entry and returns it as a dictionary. An entry + looks like this: + Entry { filename = "afp-brute.nse", categories = \ + { "auth", "intrusive", } } + """ + entries = [] + while True: + entry = self.parse_entry() + if not entry: + break + entries.append(entry) + return entries + + def token(self): + """Returns a tuple whose first element is a type ("string", "ident", or + "delim") and whose second element is the token text.""" + c = self.getchar() + while c.isspace(): + c = self.getchar() + if not c: + return None + if c.isalpha() or c == "_": + ident = [] + while c.isalpha() or c.isdigit() or c == "_": + ident.append(c) + c = self.getchar() + self.unget(c) + return ("ident", "".join(ident)) + elif c in "'\"": + string = [] + begin_quote = c + c = self.getchar() + while c != begin_quote: + if c == "\\": + repl = None + c = self.getchar() + if not c: + raise self.syntax_error("Unexpected EOF") + if c.isdigit(): + d1 = c + d2 = self.getchar() + d3 = self.getchar() + if d1 and d2 and d3: + n = int(d1 + d2 + d3) + if n > 255: + raise self.syntax_error( + "Character code >255") + repl = chr(n) + else: + self.unget(d3) + self.unget(d2) + if not repl: + repl = self.LUA_STRING_ESCAPES.get(c) + if not repl: + raise self.syntax_error("Unhandled string escape") + c = repl + string.append(c) + c = self.getchar() + return ("string", "".join(string)) + elif c in "{},=": + return ("delim", c) + else: + raise self.syntax_error("Unknown token") + + def expect(self, tokens): + for token in tokens: + t = self.token() + if t != token: + raise self.syntax_error( + "Unexpected token '%s', expected '%s'" % ( + t[1], token[1])) + + def parse_entry(self): + entry = {} + token = self.token() + if not token: + return None + self.expect((("delim", "{"), ("ident", "filename"), ("delim", "="))) + token = self.token() + if not token or token[0] != "string": + raise self.syntax_error("Unexpected non-string token or EOF") + entry["filename"] = token[1] + self.expect((("delim", ","), ("ident", "categories"), + ("delim", "="), ("delim", "{"))) + entry["categories"] = [] + token = self.token() + if token and token[0] == "string": + entry["categories"].append(token[1]) + token = self.token() + while token == ("delim", ","): + token = self.token() + if token and token[0] == "string": + entry["categories"].append(token[1]) + else: + break + token = self.token() + if token != ("delim", "}"): + raise self.syntax_error( + "Unexpected token '%s', expected '}'" % (token[1])) + token = self.token() + if token == ("delim", ","): + token = self.token() + if token != ("delim", "}"): + raise self.syntax_error( + "Unexpected token '%s', expected '}'" % (token[1])) + return entry + + def get_entries_list(self): + return self.entries_list + + +def nsedoc_tags_iter(f): + in_doc_comment = False + tag_name = None + tag_text = None + for line in f: + # New LuaDoc comment? + if re.match(r'^\s*---', line): + in_doc_comment = True + if not in_doc_comment: + continue + # New LuaDoc tag? + m = re.match(r'^\s*--+\s*@(\w+)\s*(.*)', line, re.S) + if m: + if tag_name: + yield tag_name, tag_text + tag_name = None + tag_text = None + tag_name = m.group(1) + tag_text = m.group(2) + else: + # Still in comment? + m = re.match(r'^\s*--+\s*(.*)', line) + if m: + # Add to text if we're in a tag. + if tag_name: + tag_text += m.group(1) + "\n" + else: + in_doc_comment = False + if tag_name: + yield tag_name, tag_text + tag_name = None + tag_text = None + + +class ScriptMetadata (object): + """Class responsible for parsing all the script information.""" + + class Entry (object): + """An instance of this class is used to store all the information + related to a particular script.""" + def __init__(self, filename): + self.filename = filename + self.categories = [] + self.arguments = [] # Arguments including library arguments. + self.license = "" + self.author = [] + self.description = "" + self.output = "" + self.usage = "" + + url = property(lambda self: "https://nmap.org/nsedoc/scripts/" + "%s.html" % (os.path.splitext(self.filename)[0])) + + def __init__(self, scripts_dir, nselib_dir): + self.scripts_dir = scripts_dir + self.nselib_dir = nselib_dir + self.library_arguments = {} + self.library_requires = {} + self.construct_library_arguments() + + def get_metadata(self, filename): + entry = self.Entry(filename) + try: + entry.description = self.get_string_variable(filename, "description") + entry.arguments = self.get_arguments(entry.filename) + entry.license = self.get_string_variable(filename, "license") + entry.author = self.get_list_variable(filename, "author") or [ + self.get_string_variable(filename, "author")] + + filepath = os.path.join(self.scripts_dir, filename) + with open(filepath, "r") as f: + for tag_name, tag_text in nsedoc_tags_iter(f): + if tag_name == "output" and not entry.output: + entry.output = tag_text + elif tag_name == "usage" and not entry.usage: + entry.usage = tag_text + except IOError as e: + entry.description = "Error getting metadata: {}".format(e) + + return entry + + @staticmethod + def get_file_contents(filename): + with open(filename, "r") as f: + contents = f.read() + return contents + + def get_string_variable(self, filename, varname): + contents = ScriptMetadata.get_file_contents( + os.path.join(self.scripts_dir, filename)) + # Short string? + m = re.search( + re.escape(varname) + r'\s*=\s*(["\'])(.*?[^\\])\1', contents) + if m: + return m.group(2) + # Long string? + m = re.search( + re.escape(varname) + r'\s*=\s*\[(=*)\[(.*?)\]\1\]', contents, re.S) + if m: + return m.group(2) + return None + + def get_list_variable(self, filename, varname): + contents = ScriptMetadata.get_file_contents( + os.path.join(self.scripts_dir, filename)) + m = re.search( + re.escape(varname) + r'\s*=\s*\{(.*?)}', contents) + if not m: + return None + strings = m.group(1) + out = [] + for m in re.finditer(r'(["\'])(.*?[^\\])\1\s*,?', strings, re.S): + out.append(m.group(2)) + return out + + @staticmethod + def get_requires(filename): + with open(filename, "r") as f: + requires = ScriptMetadata.get_requires_from_file(f) + return requires + + @staticmethod + def get_requires_from_file(f): + require_expr = re.compile(r'.*\brequire\s*\(?([\'\"])([\w._-]+)\1\)?') + requires = [] + for line in f.readlines(): + m = require_expr.match(line) + if m: + requires.append(m.group(2)) + return requires + + @staticmethod + def get_script_args(filename): + with open(filename, "r") as f: + args = ScriptMetadata.get_script_args_from_file(f) + return args + + @staticmethod + def get_script_args_from_file(f): + """Extracts a list of script arguments from the file given. Results are + returned as a list of (argname, description) tuples.""" + args = [] + for tag_name, tag_text in nsedoc_tags_iter(f): + m = re.match(r'(\S+)\s+(.*?)', tag_text, re.DOTALL) + if (tag_name == "arg" or tag_name == "args") and m: + args.append((m.group(1), m.group(2))) + return args + + def get_arguments(self, filename): + """Returns list of arguments including library arguments on + passing the file name.""" + filepath = os.path.join(self.scripts_dir, filename) + script_args = self.get_script_args(filepath) + + # Recursively walk through the libraries required by the script (and + # the libraries they require, etc.), adding all arguments. + library_args = [] + seen = set() + pool = set(self.get_requires(filepath)) + while pool: + require = pool.pop() + if require in seen: + continue + seen.add(require) + sub_requires = self.library_requires.get(require) + if sub_requires: + pool.update(set(sub_requires)) + require_args = self.library_arguments.get(require) + if require_args: + library_args += require_args + + return script_args + library_args + + def construct_library_arguments(self): + """Constructs a dictionary of library arguments using library + names as keys and arguments as values. Each argument is really a + (name, description) tuple.""" + for filename in os.listdir(self.nselib_dir): + filepath = os.path.join(self.nselib_dir, filename) + if not os.path.isfile(filepath): + continue + + base, ext = os.path.splitext(filename) + if ext == ".lua" or ext == ".luadoc": + libname = base + else: + libname = filename + + self.library_arguments[libname] = self.get_script_args(filepath) + self.library_requires[libname] = self.get_requires(filepath) + + +def get_script_entries(scripts_dir, nselib_dir): + """Merge the information obtained so far into one single entry for + each script and return it.""" + metadata = ScriptMetadata(scripts_dir, nselib_dir) + try: + scriptdb = ScriptDB(os.path.join(scripts_dir, "script.db")) + except IOError: + return [] + entries = [] + for dbentry in scriptdb.get_entries_list(): + entry = metadata.get_metadata(dbentry["filename"]) + # Categories is the only thing ScriptMetadata doesn't take care of. + entry.categories = dbentry["categories"] + entries.append(entry) + return entries + +if __name__ == '__main__': + import sys + for entry in get_script_entries(sys.argv[1], sys.argv[2]): + print("*" * 75) + print("Filename:", entry.filename) + print("Categories:", entry.categories) + print("License:", entry.license) + print("Author:", entry.author) + print("URL:", entry.url) + print("Description:", entry.description) + print("Arguments:", [x[0] for x in entry.arguments]) + print("Output:") + print(entry.output) + print("Usage:") + print(entry.usage) + print("*" * 75) diff --git a/zenmap/zenmapCore/SearchResult.py b/zenmap/zenmapCore/SearchResult.py new file mode 100644 index 0000000..5f9f299 --- /dev/null +++ b/zenmap/zenmapCore/SearchResult.py @@ -0,0 +1,546 @@ +#!/usr/bin/env python3 + +# ***********************IMPORTANT NMAP LICENSE TERMS************************ +# * +# * The Nmap Security Scanner is (C) 1996-2023 Nmap Software 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.com) 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 os +import os.path +import re +import io +import unittest + +from glob import glob + +from zenmapCore.Name import APP_NAME +from zenmapCore.NmapOptions import NmapOptions +from zenmapCore.NmapParser import NmapParser +from zenmapCore.UmitLogging import log + + +class HostSearch(object): + @staticmethod + def match_target(host, name): + name = name.lower() + mac = host.get_mac() + ip = host.get_ip() + ipv6 = host.get_ipv6() + + if mac and 'addr' in mac: + if name in mac['addr'].lower(): + return True + if ip and 'addr' in ip: + if name in ip['addr'].lower(): + return True + if ipv6 and 'addr' in ipv6: + if name in ipv6['addr'].lower(): + return True + + if HostSearch.match_hostname(host, name): + return True + return False + + @staticmethod + def match_hostname(host, hostname): + hostname = hostname.lower() + hostnames = host.get_hostnames() + for hn in hostnames: + if hostname in hn['hostname'].lower(): + return True + else: + return False + + @staticmethod + def match_service(host, service): + for port in host.get_ports(): + # We concatenate all useful fields and add them to the list + if port['port_state'] not in ['open', 'open|filtered']: + continue + version = " ".join( + port.get(x, "") for x in ( + "service_name", + "service_product", + "service_version", + "service_extrainfo" + ) + ) + + if service in version.lower(): + return True + else: + return False + + @staticmethod + def match_os(host, os): + os = os.lower() + + osmatches = host.get_osmatches() + + for osmatch in osmatches: + os_str = osmatch['name'].lower() + for osclass in osmatch['osclasses']: + os_str += " " + osclass['vendor'].lower() + " " +\ + osclass['osfamily'].lower() + " " +\ + osclass['type'].lower() + if os in os_str: + return True + + return False + + @staticmethod + def match_port(host_ports, port, port_state): + # Check if the port is parsable, if not return False silently + if re.match(r"^\d+$", port) is None: + return False + + for hp in host_ports: + if hp['portid'] == port and hp['port_state'] == port_state: + return True + + return False + + +class SearchResult(object): + def __init__(self): + """This constructor is always called by SearchResult subclasses.""" + pass + + def search(self, **kargs): + """Performs a search on each parsed scan. Since the 'and' operator is + implicit, the search fails as soon as one of the tests fails. The + kargs argument is a map having operators as keys and argument lists as + values.""" + + for scan_result in self.get_scan_results(): + self.parsed_scan = scan_result + + # Test each given operator against the current parsed result + for operator, args in kargs.items(): + if not self._match_all_args(operator, args): + # No match => we discard this scan_result + break + else: + # All operator-matching functions have returned True, so this + # scan_result satisfies all conditions + yield self.parsed_scan + + def _match_all_args(self, operator, args): + """A helper function that calls the matching function for the given + operator and each of its arguments.""" + for arg in args: + positive = True + if arg != "" and arg[0] == "!": + arg = arg[1:] + positive = False + if positive != self.__getattribute__("match_%s" % operator)(arg): + # No match for this operator + return False + else: + # All arguments for this operator produced a match + return True + + def get_scan_results(self): + # To be implemented by classes that are going to inherit this one + pass + + def basic_match(self, keyword, property): + if keyword == "*" or keyword == "": + return True + + return keyword.lower() in str( + self.parsed_scan.__getattribute__(property)).lower() + + def match_keyword(self, keyword): + log.debug("Match keyword: %s" % keyword) + + return self.basic_match(keyword, "nmap_output") or \ + self.match_profile(keyword) or \ + self.match_target(keyword) + + def match_profile(self, profile): + log.debug("Match profile: %s" % profile) + log.debug("Comparing: %s == %s ??" % ( + str(self.parsed_scan.profile_name).lower(), + "*%s*" % profile.lower())) + return (profile == "*" or profile == "" or + profile.lower() in str(self.parsed_scan.profile_name).lower()) + + def match_option(self, option): + log.debug("Match option: %s" % option) + + if option == "*" or option == "": + return True + + ops = NmapOptions() + ops.parse_string(self.parsed_scan.get_nmap_command()) + + if "(" in option and ")" in option: + # The syntax allows matching option arguments as + # "opt:option_name(value)". Since we've received only the + # "option_name(value)" part, we need to parse it. + optname = option[:option.find("(")] + optval = option[option.find("(") + 1:option.find(")")] + + val = ops["--" + optname] + if val is None: + val = ops["-" + optname] + if val is None: + return False + return str(val) == optval or str(val) == optval + else: + return (ops["--" + option] is not None or + ops["-" + option] is not None) + + def match_date(self, date_arg, operator="date"): + # The parsed scan's get_date() returns a time.struct_time, so we + # need to convert it to a date object + from datetime import date, datetime + scd = self.parsed_scan.get_date() + scan_date = date(scd.tm_year, scd.tm_mon, scd.tm_mday) + + # Check if we have any fuzzy operators ("~") in our string + fuzz = 0 + if "~" in date_arg: + # Count 'em, and strip 'em + fuzz = date_arg.count("~") + date_arg = date_arg.replace("~", "") + + if re.match(r"\d\d\d\d-\d\d-\d\d$", date_arg) is not None: + year, month, day = date_arg.split("-") + parsed_date = date(int(year), int(month), int(day)) + elif re.match(r"[-|\+]\d+$", date_arg): + # We need to convert from the "-n" format (n days ago) to a date + # object (I found this in some old code, don't ask :) ) + parsed_date = date.fromordinal( + date.today().toordinal() + int(date_arg)) + else: + # Fail silently + return False + + # Now that we have both the scan date and the user date converted to + # date objects, we need to make a comparison based on the operator + # (date, after, before). + if operator == "date": + return abs((scan_date - parsed_date).days) <= fuzz + # We ignore fuzziness for after: and before: + elif operator == "after": + return (scan_date - parsed_date).days >= 0 + elif operator == "before": + return (parsed_date - scan_date).days >= 0 + + def match_after(self, date_arg): + return self.match_date(date_arg, operator="after") + + def match_before(self, date_arg): + return self.match_date(date_arg, operator="before") + + def match_target(self, target): + log.debug("Match target: %s" % target) + + for spec in self.parsed_scan.get_targets(): + if target in spec: + return True + else: + # We search the (rDNS) hostnames list + for host in self.parsed_scan.get_hosts(): + if HostSearch.match_target(host, target): + return True + return False + + def match_os(self, os): + # If you have lots of big scans in your DB (with a lot of hosts + # scanned), you're probably better off using the keyword (freetext) + # search. Keyword search just greps through the nmap output, while this + # function iterates through all parsed OS-related values for every host + # in every scan! + hosts = self.parsed_scan.get_hosts() + for host in hosts: + if HostSearch.match_os(host, os): + return True + return False + + def match_scanned(self, ports): + if ports == "": + return True + + # Transform a comma-delimited string containing ports into a list + ports = [not_empty for not_empty in ports.split(",") if not_empty] + + # Check if they're parsable, if not return False silently + for port in ports: + if re.match(r"^\d+$", port) is None: + return False + + # Make a list of all scanned ports + services = [] + for scaninfo in self.parsed_scan.get_scaninfo(): + services.append(scaninfo["services"].split(",")) + + # These two loops iterate over search ports and over scanned ports. As + # soon as the search finds a given port among the scanned ports, it + # breaks from the services loop and continues with the next port in the + # ports list. If a port isn't found in the services list, the function + # immediately returns False. + for port in ports: + for service in services: + if "-" in service and \ + int(port) >= int(service.split("-")[0]) and \ + int(port) <= int(service.split("-")[1]): + # Port range, and our port was inside + break + elif port == service: + break + else: + return False + else: + # The ports loop finished for all ports, which means the search was + # successful. + return True + + def match_port(self, ports, port_state): + log.debug("Match port:%s" % ports) + + # Transform a comma-delimited string containing ports into a list + ports = [not_empty for not_empty in ports.split(",") if not_empty] + + for host in self.parsed_scan.get_hosts(): + for port in ports: + if not HostSearch.match_port( + host.get_ports(), port, port_state): + break + else: + return True + else: + return False + + def match_open(self, port): + return self.match_port(port, "open") + + def match_filtered(self, port): + return self.match_port(port, "filtered") + + def match_closed(self, port): + return self.match_port(port, "closed") + + def match_unfiltered(self, port): + return self.match_port(port, "unfiltered") + + def match_open_filtered(self, port): + return self.match_port(port, "open|filtered") + + def match_closed_filtered(self, port): + return self.match_port(port, "closed|filtered") + + def match_service(self, sversion): + if sversion == "" or sversion == "*": + return True + + for host in self.parsed_scan.get_hosts(): + if HostSearch.match_service(host, sversion): + return True + else: + return False + + def match_in_route(self, host): + if host == "" or host == "*": + return True + host = host.lower() + + # Since the parser doesn't parse traceroute output, we need to cheat + # and look the host up in the Nmap output, in the Traceroute section of + # the scan. + nmap_out = self.parsed_scan.get_nmap_output() + tr_pos = 0 + traceroutes = [] # A scan holds one traceroute section per host + while tr_pos != -1: + # Find the beginning and the end of the traceroute section, and + # append the substring to the traceroutes list + tr_pos = nmap_out.find("TRACEROUTE", tr_pos + 1) + tr_end_pos = nmap_out.find("\n\n", tr_pos) + if tr_pos != -1: + traceroutes.append(nmap_out[tr_pos:tr_end_pos]) + + for tr in traceroutes: + if host in tr.lower(): + return True + else: + return False + + +class SearchDummy(SearchResult): + """A dummy search class that returns no results. It is used as a + placeholder when SearchDB can't be used.""" + def get_scan_results(self): + return [] + + +class SearchDB(SearchResult, object): + def __init__(self): + SearchResult.__init__(self) + log.debug(">>> Getting scan results stored in data base") + self.scan_results = [] + from zenmapCore.UmitDB import UmitDB + u = UmitDB() + + for scan in u.get_scans(): + log.debug(">>> Retrieving result of scans_id %s" % scan.scans_id) + log.debug(">>> Nmap xml output: %s" % scan.nmap_xml_output) + + try: + buffer = io.StringIO(scan.nmap_xml_output) + parsed = NmapParser() + parsed.parse(buffer) + buffer.close() + except Exception as e: + log.warning(">>> Error loading scan with ID %u from database: " + "%s" % (scan.scans_id, str(e))) + else: + self.scan_results.append(parsed) + + def get_scan_results(self): + return self.scan_results + + +class SearchDir(SearchResult, object): + def __init__(self, search_directory, file_extensions=["usr"]): + SearchResult.__init__(self) + log.debug(">>> SearchDir initialized") + self.search_directory = search_directory + + if isinstance(file_extensions, str): + self.file_extensions = file_extensions.split(";") + elif isinstance(file_extensions, list): + self.file_extensions = file_extensions + else: + raise Exception( + "Wrong file extension format! '%s'" % file_extensions) + + log.debug(">>> Getting directory's scan results") + self.scan_results = [] + files = [] + for ext in self.file_extensions: + files += glob(os.path.join(self.search_directory, "*.%s" % ext)) + + log.debug(">>> Scan results at selected directory: %s" % files) + for scan_file in files: + log.debug(">>> Retrieving scan result %s" % scan_file) + if os.access(scan_file, os.R_OK) and os.path.isfile(scan_file): + + try: + parsed = NmapParser() + parsed.parse_file(scan_file) + except Exception: + pass + else: + self.scan_results.append(parsed) + + def get_scan_results(self): + return self.scan_results + + +class SearchResultTest(unittest.TestCase): + class SearchClass(SearchResult): + """This class is for use by the unit testing code""" + def __init__(self, filenames): + SearchResult.__init__(self) + self.scan_results = [] + for filename in filenames: + scan = NmapParser() + scan.parse_file(filename) + self.scan_results.append(scan) + + def get_scan_results(self): + return self.scan_results + + def setUp(self): + files = ["test/xml_test%d.xml" % no for no in range(1, 13)] + self.search_result = self.SearchClass(files) + + def _test_skeleton(self, key, val): + results = [] + search = {key: [val]} + for scan in self.search_result.search(**search): + results.append(scan) + return len(results) + + def test_match_os(self): + """Test that checks if the match_os predicate works""" + assert(self._test_skeleton('os', 'linux') == 2) + + def test_match_target(self): + """Test that checks if the match_target predicate works""" + assert(self._test_skeleton('target', 'localhost') == 4) + + def test_match_port_open(self): + """Test that checks if the match_open predicate works""" + assert(self._test_skeleton('open', '22') == 7) + + def test_match_port_closed(self): + """Test that checks if the match_closed predicate works""" + assert(self._test_skeleton('open', '22') == 7) + assert(self._test_skeleton('closed', '22') == 9) + + def test_match_service(self): + """Test that checks if the match_service predicate works""" + assert(self._test_skeleton('service', 'apache') == 9) + assert(self._test_skeleton('service', 'openssh') == 7) + + def test_match_service_version(self): + """Test that checks if the match_service predicate works when """ + """checking version""" + assert(self._test_skeleton('service', '2.0.52') == 7) + + +if __name__ == "__main__": + unittest.main() diff --git a/zenmap/zenmapCore/StringPool.py b/zenmap/zenmapCore/StringPool.py new file mode 100644 index 0000000..3630817 --- /dev/null +++ b/zenmap/zenmapCore/StringPool.py @@ -0,0 +1,80 @@ +#!/usr/bin/env python3 + +# ***********************IMPORTANT NMAP LICENSE TERMS************************ +# * +# * The Nmap Security Scanner is (C) 1996-2023 Nmap Software 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.com) 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/ +# * +# ***************************************************************************/ + + +class UniqueStringMap(dict): + def __missing__(self, key): + self[key] = key + return key + +UNIQUE_STRING_MAP = UniqueStringMap() + +# Return a single unique representation of s (unique as to id), +# letting s be garbage collected. +unique = UNIQUE_STRING_MAP.__getitem__ + +import unittest + + +class StringPoolTest(unittest.TestCase): + + def test_pool(self): + source = "Test string. Zenmap. Test string." + self.assertIs(unique(source[:12]), unique(source[-12:])) + +if __name__ == '__main__': + unittest.main() diff --git a/zenmap/zenmapCore/TargetList.py b/zenmap/zenmapCore/TargetList.py new file mode 100644 index 0000000..e7a7172 --- /dev/null +++ b/zenmap/zenmapCore/TargetList.py @@ -0,0 +1,117 @@ +#!/usr/bin/env python3 + +# ***********************IMPORTANT NMAP LICENSE TERMS************************ +# * +# * The Nmap Security Scanner is (C) 1996-2023 Nmap Software 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.com) 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/ +# * +# ***************************************************************************/ + +from os import access, R_OK, W_OK +from os.path import dirname +from zenmapCore.Paths import Path + + +class TargetList(object): + def __init__(self): + self.temp_list = [] + + try: + self.target_list_file = Path.target_list + except Exception: + self.target_list_file = False + + #import pdb; pdb.set_trace() + if (self.target_list_file and + (access(self.target_list_file, R_OK and W_OK) or + access(dirname(self.target_list_file), R_OK and W_OK))): + self.using_file = True + + # Recovering saved targets + target_file = open(self.target_list_file, "r") + self.temp_list = [ + t for t in target_file.read().split(";") + if t != "" and t != "\n"] + target_file.close() + else: + self.using_file = False + + def save(self): + if self.using_file: + target_file = open(self.target_list_file, "w") + target_file.write(";".join(self.temp_list)) + target_file.close() + + def add_target(self, target): + if target in self.temp_list: + return + + self.temp_list.append(target) + self.save() + + def clean_list(self): + del self.temp_list + self.temp_list = [] + self.save() + + def get_target_list(self): + t = self.temp_list[:] + t.reverse() + return t + +target_list = TargetList() + +if __name__ == "__main__": + t = TargetList() + print(">>> Getting empty list:", t.get_target_list()) + print(">>> Adding target 127.0.0.1:", t.add_target("127.0.0.3")) + print(">>> Getting target list:", t.get_target_list()) + del t diff --git a/zenmap/zenmapCore/UmitConf.py b/zenmap/zenmapCore/UmitConf.py new file mode 100644 index 0000000..3f7bf0f --- /dev/null +++ b/zenmap/zenmapCore/UmitConf.py @@ -0,0 +1,643 @@ +#!/usr/bin/env python3 + +# ***********************IMPORTANT NMAP LICENSE TERMS************************ +# * +# * The Nmap Security Scanner is (C) 1996-2023 Nmap Software 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.com) 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 re + +from configparser import DuplicateSectionError, NoSectionError, NoOptionError +from configparser import Error as ConfigParser_Error + +from zenmapCore.Paths import Path +from zenmapCore.UmitLogging import log +from zenmapCore.UmitConfigParser import UmitConfigParser +import zenmapCore.I18N # lgtm[py/unused-import] + +# This is the global configuration parser object that represents the contents +# of zenmap.conf. It should be initialized once by the application. Most +# interaction with the global parser is done by other classes in this file, +# like SearchConfig, that wrap specific configuration sections. +config_parser = UmitConfigParser() + +# Check if running on Maemo +MAEMO = False +try: + import hildon + MAEMO = True +except ImportError: + pass + + +def is_maemo(): + return MAEMO + + +class SearchConfig(UmitConfigParser, object): + section_name = "search" + + def __init__(self): + if not config_parser.has_section(self.section_name): + self.create_section() + + def save_changes(self): + config_parser.save_changes() + + def create_section(self): + config_parser.add_section(self.section_name) + self.directory = "" + self.file_extension = "xml" + self.save_time = "60;days" + self.store_results = True + self.search_db = True + + def _get_it(self, p_name, default): + return config_parser.get(self.section_name, p_name, fallback=default) + + def _set_it(self, p_name, value): + config_parser.set(self.section_name, p_name, value) + + def boolean_sanity(self, attr): + if attr is True or \ + attr == "True" or \ + attr == "true" or \ + attr == "1": + return "True" + return "False" + + def get_directory(self): + return self._get_it("directory", "") + + def set_directory(self, directory): + self._set_it("directory", directory) + + def get_file_extension(self): + return self._get_it("file_extension", "xml").split(";") + + def set_file_extension(self, file_extension): + if isinstance(file_extension, list): + self._set_it("file_extension", ";".join(file_extension)) + elif isinstance(file_extension, str): + self._set_it("file_extension", file_extension) + + def get_save_time(self): + return self._get_it("save_time", "60;days").split(";") + + def set_save_time(self, save_time): + if isinstance(save_time, list): + self._set_it("save_time", ";".join(save_time)) + elif isinstance(save_time, str): + self._set_it("save_time", save_time) + + def get_store_results(self): + return self.boolean_sanity(self._get_it("store_results", True)) + + def set_store_results(self, store_results): + self._set_it("store_results", self.boolean_sanity(store_results)) + + def get_search_db(self): + return self.boolean_sanity(self._get_it("search_db", True)) + + def set_search_db(self, search_db): + self._set_it("search_db", self.boolean_sanity(search_db)) + + def get_converted_save_time(self): + try: + return int(self.save_time[0]) * self.time_list[self.save_time[1]] + except Exception: + # If something goes wrong, return a save time of 60 days + return 60 * 60 * 24 * 60 + + def get_time_list(self): + # Time as key, seconds a value + return {"hours": 60 * 60, + "days": 60 * 60 * 24, + "weeks": 60 * 60 * 24 * 7, + "months": 60 * 60 * 24 * 7 * 30, + "years": 60 * 60 * 24 * 7 * 30 * 12, + "minutes": 60, + "seconds": 1} + + directory = property(get_directory, set_directory) + file_extension = property(get_file_extension, set_file_extension) + save_time = property(get_save_time, set_save_time) + store_results = property(get_store_results, set_store_results) + search_db = property(get_search_db, set_search_db) + converted_save_time = property(get_converted_save_time) + time_list = property(get_time_list) + + +class Profile(UmitConfigParser, object): + """This class represents not just one profile, but a whole collection of + them found in a config file such as scan_profiles.usp. The methods + therefore all take an argument that is the name of the profile to work + on.""" + + def __init__(self, user_profile=None, *args): + UmitConfigParser.__init__(self, *args) + + try: + if not user_profile: + user_profile = Path.scan_profile + + self.read(user_profile) + except ConfigParser_Error as e: + # No scan profiles found is not a reason to crash. + self.add_profile(_("Profiles not found"), + command="nmap", + description=_("The {} file is missing or corrupted" + ).format(user_profile)) + + self.attributes = {} + + def _get_it(self, profile, attribute): + if self._verify_profile(profile): + return self.get(profile, attribute) + return "" + + def _set_it(self, profile, attribute, value=''): + if self._verify_profile(profile): + return self.set(profile, attribute, value) + + def add_profile(self, profile_name, **attributes): + """Add a profile with the given name and attributes to the collection + of profiles. If a profile with the same name exists, it is not + overwritten, and the method returns immediately. The backing file for + the profiles is automatically updated.""" + + log.debug(">>> Add Profile '%s': %s" % (profile_name, attributes)) + + try: + self.add_section(profile_name) + except DuplicateSectionError: + return None + + # Set each of the attributes ("command", "description") in the + # ConfigParser. + for attr in attributes: + self._set_it(profile_name, attr, attributes[attr]) + + self.save_changes() + + def remove_profile(self, profile_name): + try: + self.remove_section(profile_name) + except Exception: + pass + self.save_changes() + + def _verify_profile(self, profile_name): + if profile_name not in self.sections(): + return False + return True + + +class WindowConfig(UmitConfigParser, object): + section_name = "window" + + default_x = 0 + default_y = 0 + default_width = -1 + default_height = 650 + + def __init__(self): + if not config_parser.has_section(self.section_name): + self.create_section() + + def save_changes(self): + config_parser.save_changes() + + def create_section(self): + config_parser.add_section(self.section_name) + self.x = self.default_x + self.y = self.default_y + self.width = self.default_width + self.height = self.default_height + + def _get_it(self, p_name, default): + return config_parser.get(self.section_name, p_name, fallback=default) + + def _set_it(self, p_name, value): + config_parser.set(self.section_name, p_name, value) + + def get_x(self): + try: + value = int(self._get_it("x", self.default_x)) + except (ValueError, NoOptionError): + value = self.default_x + except TypeError as e: + v = self._get_it("x", self.default_x) + log.exception("Trouble parsing x value as int: %s", + repr(v), exc_info=e) + value = self.default_x + return value + + def set_x(self, x): + self._set_it("x", "%d" % x) + + def get_y(self): + try: + value = int(self._get_it("y", self.default_y)) + except (ValueError, NoOptionError): + value = self.default_y + except TypeError as e: + v = self._get_it("y", self.default_y) + log.exception("Trouble parsing y value as int: %s", + repr(v), exc_info=e) + value = self.default_y + return value + + def set_y(self, y): + self._set_it("y", "%d" % y) + + def get_width(self): + try: + value = int(self._get_it("width", self.default_width)) + except (ValueError, NoOptionError): + value = self.default_width + except TypeError as e: + v = self._get_it("width", self.default_width) + log.exception("Trouble parsing width value as int: %s", + repr(v), exc_info=e) + value = self.default_width + + if not (value >= -1): + value = self.default_width + + return value + + def set_width(self, width): + self._set_it("width", "%d" % width) + + def get_height(self): + try: + value = int(self._get_it("height", self.default_height)) + except (ValueError, NoOptionError): + value = self.default_height + except TypeError as e: + v = self._get_it("height", self.default_height) + log.exception("Trouble parsing y value as int: %s", + repr(v), exc_info=e) + value = self.default_height + + if not (value >= -1): + value = self.default_height + + return value + + def set_height(self, height): + self._set_it("height", "%d" % height) + + x = property(get_x, set_x) + y = property(get_y, set_y) + width = property(get_width, set_width) + height = property(get_height, set_height) + + +class CommandProfile (Profile, object): + """This class is a wrapper around Profile that provides accessors for the + attributes of a profile: command and description""" + def __init__(self, user_profile=None): + Profile.__init__(self, user_profile) + + def get_command(self, profile): + command_string = self._get_it(profile, 'command') + # Corrupted config file can include multiple commands. + # Take the first one. + if isinstance(command_string, list): + command_string = command_string[0] + if not hasattr(command_string, "endswith"): + return "nmap" + # Old versions of Zenmap used to append "%s" to commands and use that + # to substitute the target. Ignore it if present. + if command_string.endswith("%s"): + command_string = command_string[:-len("%s")] + return command_string + + def get_description(self, profile): + desc = self._get_it(profile, 'description') + if isinstance(desc, list): + desc = " ".join(desc) + return desc + + def set_command(self, profile, command=''): + self._set_it(profile, 'command', command) + + def set_description(self, profile, description=''): + self._set_it(profile, 'description', description) + + def get_profile(self, profile_name): + return {'profile': profile_name, + 'command': self.get_command(profile_name), + 'description': self.get_description(profile_name)} + + +class NmapOutputHighlight(object): + setts = ["bold", "italic", "underline", "text", "highlight", "regex"] + + def save_changes(self): + config_parser.save_changes() + + def __get_it(self, p_name): + property_name = "%s_highlight" % p_name + + try: + return self.sanity_settings([ + config_parser.get( + property_name, prop, raw=True) for prop in self.setts]) + except Exception: + settings = [] + prop_settings = self.default_highlights[p_name] + settings.append(prop_settings["bold"]) + settings.append(prop_settings["italic"]) + settings.append(prop_settings["underline"]) + settings.append(prop_settings["text"]) + settings.append(prop_settings["highlight"]) + settings.append(prop_settings["regex"]) + + self.__set_it(p_name, settings) + + return settings + + def __set_it(self, property_name, settings): + property_name = "%s_highlight" % property_name + settings = self.sanity_settings(list(settings)) + + for pos in range(len(settings)): + config_parser.set(property_name, self.setts[pos], settings[pos]) + + def sanity_settings(self, settings): + """This method tries to convert insane settings to sanity ones ;-) + If user send a True, "True" or "true" value, for example, it tries to + convert then to the integer 1. + Same to False, "False", etc. + + Sequence: [bold, italic, underline, text, highlight, regex] + """ + # log.debug(">>> Sanitize %s" % str(settings)) + + settings[0] = self.boolean_sanity(settings[0]) + settings[1] = self.boolean_sanity(settings[1]) + settings[2] = self.boolean_sanity(settings[2]) + + tuple_regex = r"[\(\[]\s?(\d+)\s?,\s?(\d+)\s?,\s?(\d+)\s?[\)\]]" + if isinstance(settings[3], str): + settings[3] = [ + int(t) for t in re.findall(tuple_regex, settings[3])[0] + ] + + if isinstance(settings[4], str): + settings[4] = [ + int(h) for h in re.findall(tuple_regex, settings[4])[0] + ] + + return settings + + def boolean_sanity(self, attr): + if attr is True or attr == "True" or attr == "true" or attr == "1": + return 1 + return 0 + + def get_date(self): + return self.__get_it("date") + + def set_date(self, settings): + self.__set_it("date", settings) + + def get_hostname(self): + return self.__get_it("hostname") + + def set_hostname(self, settings): + self.__set_it("hostname", settings) + + def get_ip(self): + return self.__get_it("ip") + + def set_ip(self, settings): + self.__set_it("ip", settings) + + def get_port_list(self): + return self.__get_it("port_list") + + def set_port_list(self, settings): + self.__set_it("port_list", settings) + + def get_open_port(self): + return self.__get_it("open_port") + + def set_open_port(self, settings): + self.__set_it("open_port", settings) + + def get_closed_port(self): + return self.__get_it("closed_port") + + def set_closed_port(self, settings): + self.__set_it("closed_port", settings) + + def get_filtered_port(self): + return self.__get_it("filtered_port") + + def set_filtered_port(self, settings): + self.__set_it("filtered_port", settings) + + def get_details(self): + return self.__get_it("details") + + def set_details(self, settings): + self.__set_it("details", settings) + + def get_enable(self): + enable = True + try: + enable = config_parser.get("output_highlight", "enable_highlight") + except NoSectionError: + config_parser.set( + "output_highlight", "enable_highlight", str(True)) + + if enable == "False" or enable == "0" or enable == "": + return False + return True + + def set_enable(self, enable): + if enable is False or enable == "0" or enable is None or enable == "": + config_parser.set( + "output_highlight", "enable_highlight", str(False)) + else: + config_parser.set( + "output_highlight", "enable_highlight", str(True)) + + date = property(get_date, set_date) + hostname = property(get_hostname, set_hostname) + ip = property(get_ip, set_ip) + port_list = property(get_port_list, set_port_list) + open_port = property(get_open_port, set_open_port) + closed_port = property(get_closed_port, set_closed_port) + filtered_port = property(get_filtered_port, set_filtered_port) + details = property(get_details, set_details) + enable = property(get_enable, set_enable) + + # These settings are made when there is nothing set yet. They set the + # "factory" default to highlight colors + default_highlights = { + "date": { + "bold": str(True), + "italic": str(False), + "underline": str(False), + "text": [0, 0, 0], + "highlight": [65535, 65535, 65535], + "regex": r"\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}\s.{1,4}"}, + "hostname": { + "bold": str(True), + "italic": str(True), + "underline": str(True), + "text": [0, 111, 65535], + "highlight": [65535, 65535, 65535], + "regex": r"(\w{2,}://)*[\w-]{2,}\.[\w-]{2,}" + r"(\.[\w-]{2,})*(/[[\w-]{2,}]*)*"}, + "ip": { + "bold": str(True), + "italic": str(False), + "underline": str(False), + "text": [0, 0, 0], + "highlight": [65535, 65535, 65535], + "regex": r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}"}, + "port_list": { + "bold": str(True), + "italic": str(False), + "underline": str(False), + "text": [0, 1272, 28362], + "highlight": [65535, 65535, 65535], + "regex": r"PORT\s+STATE\s+SERVICE(\s+VERSION)?[^\n]*"}, + "open_port": { + "bold": str(True), + "italic": str(False), + "underline": str(False), + "text": [0, 41036, 2396], + "highlight": [65535, 65535, 65535], + "regex": r"\d{1,5}/.{1,5}\s+open\s+.*"}, + "closed_port": { + "bold": str(False), + "italic": str(False), + "underline": str(False), + "text": [65535, 0, 0], + "highlight": [65535, 65535, 65535], + "regex": r"\d{1,5}/.{1,5}\s+closed\s+.*"}, + "filtered_port": { + "bold": str(False), + "italic": str(False), + "underline": str(False), + "text": [38502, 39119, 0], + "highlight": [65535, 65535, 65535], + "regex": r"\d{1,5}/.{1,5}\s+filtered\s+.*"}, + "details": { + "bold": str(True), + "italic": str(False), + "underline": str(True), + "text": [0, 0, 0], + "highlight": [65535, 65535, 65535], + "regex": r"^(\w{2,}[\s]{,3}){,4}:"} + } + + +# Retrieve details from zenmap.conf regarding paths subsection +# (e.g. nmap_command_path) - jurand +class PathsConfig(object): + section_name = "paths" + + # This accounts for missing entries conf file. + # Defaults to "nmap" if these errors occur. + # NoOptionError, NoSectionError + def __get_it(self, p_name, default): + try: + return config_parser.get(self.section_name, p_name) + except (NoOptionError, NoSectionError): + log.debug( + ">>> Using default \"%s\" for \"%s\"." % (default, p_name)) + return default + + def __set_it(self, property_name, settings): + config_parser.set(self.section_name, property_name, settings) + + def get_nmap_command_path(self): + return self.__get_it("nmap_command_path", "nmap") + + def set_nmap_command_path(self, settings): + self.__set_it("nmap_command_path", settings) + + def get_ndiff_command_path(self): + return self.__get_it("ndiff_command_path", "ndiff") + + def set_ndiff_command_path(self, settings): + self.__set_it("ndiff_command_path", settings) + + nmap_command_path = property(get_nmap_command_path, set_nmap_command_path) + ndiff_command_path = property( + get_ndiff_command_path, set_ndiff_command_path) + + +# Exceptions +class ProfileNotFound: + def __init__(self, profile): + self.profile = profile + + def __str__(self): + return "No profile named '" + self.profile + "' found!" + + +class ProfileCouldNotBeSaved: + def __init__(self, profile): + self.profile = profile + + def __str__(self): + return "Profile named '" + self.profile + "' could not be saved!" diff --git a/zenmap/zenmapCore/UmitConfigParser.py b/zenmap/zenmapCore/UmitConfigParser.py new file mode 100644 index 0000000..05b97a1 --- /dev/null +++ b/zenmap/zenmapCore/UmitConfigParser.py @@ -0,0 +1,137 @@ +#!/usr/bin/env python3 + +# ***********************IMPORTANT NMAP LICENSE TERMS************************ +# * +# * The Nmap Security Scanner is (C) 1996-2023 Nmap Software 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.com) 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/ +# * +# ***************************************************************************/ + +from configparser import ConfigParser, DEFAULTSECT, NoOptionError, \ + NoSectionError +from zenmapCore.UmitLogging import log + + +class UmitConfigParser(ConfigParser): + + def __init__(self, *args): + self.filenames = None + self.failed = False + ConfigParser.__init__(self, *args) + + def set(self, section, option, value): + if not self.has_section(section): + self.add_section(section) + + ConfigParser.set(self, section, option, str(value)) + self.save_changes() + + def read(self, filename): + log.debug(">>> Trying to parse: %s" % filename) + + if ConfigParser.read(self, filename): + self.filenames = filename + + return self.filenames + + def save_changes(self): + if self.filenames: + log.debug("saving to %s" % self.filenames) + try: + with open(self.filenames, 'w') as fp: + self.write(fp) + except Exception as e: + self.failed = e + log.error(">>> Can't save to %s: %s" % (self.filenames, e)) + return + self.failed = False + else: + log.debug(">>> UmitConfigParser can't save changes: no filename") + + def write(self, fp): + '''Write alphabetically sorted config files''' + if self._defaults: + fp.write("[%s]\n" % DEFAULTSECT) + + items = sorted(self._defaults.items()) + + for (key, value) in items: + fp.write("%s = %s\n" % (key, str(value).replace('\n', '\n\t'))) + fp.write("\n") + + sects = sorted(self._sections.keys()) + + for section in sects: + fp.write("[%s]\n" % section) + for (key, value) in self._sections[section].items(): + if key != "__name__": + fp.write("%s = %s\n" % + (key, str(value).replace('\n', '\n\t'))) + fp.write("\n") + + +def test_umit_conf_content(filename): + parser = ConfigParser() + parser.read(filename) + + # Paths section + section = "paths" + assert get_or_false(parser, section, "nmap_command_path") + + +def get_or_false(parser, section, option): + try: + result = parser.get(section, option) + return result + except NoOptionError: + return False + except NoSectionError: + return False diff --git a/zenmap/zenmapCore/UmitDB.py b/zenmap/zenmapCore/UmitDB.py new file mode 100644 index 0000000..2e6c77f --- /dev/null +++ b/zenmap/zenmapCore/UmitDB.py @@ -0,0 +1,324 @@ +#!/usr/bin/env python3 + +# ***********************IMPORTANT NMAP LICENSE TERMS************************ +# * +# * The Nmap Security Scanner is (C) 1996-2023 Nmap Software 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.com) 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 sqlite3 +import sys + +from hashlib import md5 +from time import time + +from zenmapCore.Paths import Path +from zenmapCore.UmitLogging import log + + +umitdb = "" + +try: + umitdb = Path.db +except Exception: + import os.path + from .BasePaths import base_paths + + umitdb = os.path.join(Path.user_config_dir, base_paths["db"]) + Path.db = umitdb + + +from os.path import exists, dirname +from os import access, R_OK, W_OK + +using_memory = False +if not exists(umitdb) or \ + not access(umitdb, R_OK and W_OK) or \ + not access(dirname(umitdb), R_OK and W_OK): + # Tells sqlite to use memory instead of a physics file to avoid crash + # and still serve user with most features + umitdb = ":memory:" + using_memory = True + +connection = sqlite3.connect(umitdb) + + +class Table(object): + def __init__(self, table_name): + self.table_name = table_name + self.table_id = "%s_id" % table_name + + self.cursor = connection.cursor() + + def get_item(self, item_name): + if self.__getattribute__("_%s" % item_name): + return self.__getattribute__("_%s" % item_name) + + sql = "SELECT %s FROM %s WHERE %s_id = %s" % ( + item_name, + self.table_name, + self.table_name, + self.__getattribute__(self.table_id)) + + self.cursor.execute(sql) + + self.__setattr__("_%s" % item_name, self.cursor.fetchall()[0][0]) + return self.__getattribute__("_%s" % item_name) + + def set_item(self, item_name, item_value): + if item_value == self.__getattribute__("_%s" % item_name): + return None + + sql = "UPDATE %s SET %s = ? WHERE %s_id = %s" % ( + self.table_name, + item_name, + self.table_name, + self.__getattribute__(self.table_id)) + self.cursor.execute(sql, (item_value,)) + connection.commit() + self.__setattr__("_%s" % item_name, item_value) + + def insert(self, **kargs): + sql = "INSERT INTO %s (" + for k in kargs.keys(): + sql += k + sql += ", " + + sql = sql[:][:-2] + sql += ") VALUES (" + + for v in range(len(kargs.values())): + sql += "?, " + + sql = sql[:][:-2] + sql += ")" + + sql %= self.table_name + + self.cursor.execute(sql, tuple(kargs.values())) + connection.commit() + + sql = "SELECT MAX(%s_id) FROM %s;" % (self.table_name, self.table_name) + self.cursor.execute(sql) + return self.cursor.fetchall()[0][0] + + +class UmitDB(object): + def __init__(self): + self.cursor = connection.cursor() + + def create_db(self): + drop_string = "DROP TABLE scans;" + + try: + self.cursor.execute(drop_string) + except Exception: + connection.rollback() + else: + connection.commit() + + creation_string = """CREATE TABLE scans ( + scans_id INTEGER PRIMARY KEY AUTOINCREMENT, + scan_name TEXT, + nmap_xml_output TEXT, + digest TEXT, + date INTEGER)""" + + self.cursor.execute(creation_string) + connection.commit() + + def add_scan(self, **kargs): + return Scans(**kargs) + + def get_scans_ids(self): + sql = "SELECT scans_id FROM scans;" + self.cursor.execute(sql) + return [sid[0] for sid in self.cursor.fetchall()] + + def get_scans(self): + scans_ids = self.get_scans_ids() + for sid in scans_ids: + yield Scans(scans_id=sid) + + def cleanup(self, save_time): + log.debug(">>> Cleaning up data base.") + log.debug(">>> Removing results older than %s seconds" % save_time) + self.cursor.execute("SELECT scans_id FROM scans WHERE date < ?", + (time() - save_time,)) + + for sid in [sid[0] for sid in self.cursor.fetchall()]: + log.debug(">>> Removing results with scans_id %s" % sid) + self.cursor.execute("DELETE FROM scans WHERE scans_id = ?", + (sid, )) + + connection.commit() + log.debug(">>> Data base successfully cleaned up!") + + +class Scans(Table, object): + def __init__(self, **kargs): + Table.__init__(self, "scans") + if "scans_id" in kargs.keys(): + self.scans_id = kargs["scans_id"] + else: + log.debug(">>> Creating new scan result entry at data base") + fields = ["scan_name", "nmap_xml_output", "date"] + + for k in kargs.keys(): + if k not in fields: + raise Exception( + "Wrong table field passed to creation method. " + "'%s'" % k) + + if ("nmap_xml_output" not in kargs.keys() or + not kargs["nmap_xml_output"]): + raise Exception("Can't save result without xml output") + + if not self.verify_digest( + md5(kargs["nmap_xml_output"].encode("UTF-8")).hexdigest()): + raise Exception("XML output registered already!") + + self.scans_id = self.insert(**kargs) + + def verify_digest(self, digest): + self.cursor.execute( + "SELECT scans_id FROM scans WHERE digest = ?", (digest, )) + result = self.cursor.fetchall() + if result: + return False + return True + + def add_host(self, **kargs): + kargs.update({self.table_id: self.scans_id}) + return Hosts(**kargs) + + def get_hosts(self): + sql = "SELECT hosts_id FROM hosts WHERE scans_id= %s" % self.scans_id + + self.cursor.execute(sql) + result = self.cursor.fetchall() + + for h in result: + yield Hosts(hosts_id=h[0]) + + def get_scans_id(self): + return self._scans_id + + def set_scans_id(self, scans_id): + if scans_id != self._scans_id: + self._scans_id = scans_id + + def get_scan_name(self): + return self.get_item("scan_name") + + def set_scan_name(self, scan_name): + self.set_item("scan_name", scan_name) + + def get_nmap_xml_output(self): + return self.get_item("nmap_xml_output") + + def set_nmap_xml_output(self, nmap_xml_output): + self.set_item("nmap_xml_output", nmap_xml_output) + self.set_item("digest", md5(nmap_xml_output.encode("UTF-8")).hexdigest()) + + def get_date(self): + return self.get_item("date") + + def set_date(self, date): + self.set_item("date", date) + + scans_id = property(get_scans_id, set_scans_id) + scan_name = property(get_scan_name, set_scan_name) + nmap_xml_output = property(get_nmap_xml_output, set_nmap_xml_output) + date = property(get_date, set_date) + + _scans_id = None + _scan_name = None + _nmap_xml_output = None + _date = None + + +###################################################################### +# Verify if data base exists and if it does have the required tables. +# If something is wrong, re-create table +def verify_db(): + cursor = connection.cursor() + try: + cursor.execute("SELECT scans_id FROM scans WHERE date = 0") + except sqlite3.OperationalError: + u = UmitDB() + u.create_db() +verify_db() + +###################################################################### + +if __name__ == "__main__": + from pprint import pprint + + u = UmitDB() + + #print "Creating Data Base" + #u.create_db() + + #print "Creating new scan" + #s = u.add_scan(scan_name="Fake scan", nmap_xml_output="", date="007") + + #s = Scans(scans_id=2) + #print s.scans_id + #print s.scan_name + #print s.nmap_xml_output + #print s.date + + sql = "SELECT * FROM scans;" + u.cursor.execute(sql) + print("Scans:", end=' ') + pprint(u.cursor.fetchall()) diff --git a/zenmap/zenmapCore/UmitLogging.py b/zenmap/zenmapCore/UmitLogging.py new file mode 100644 index 0000000..4c38fa4 --- /dev/null +++ b/zenmap/zenmapCore/UmitLogging.py @@ -0,0 +1,97 @@ +#!/usr/bin/env python3 + +# ***********************IMPORTANT NMAP LICENSE TERMS************************ +# * +# * The Nmap Security Scanner is (C) 1996-2023 Nmap Software 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.com) 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/ +# * +# ***************************************************************************/ + + +from logging import Logger, StreamHandler, Formatter +from zenmapCore.Name import APP_DISPLAY_NAME +from zenmapCore.UmitOptionParser import option_parser +from zenmapCore.DelayedObject import DelayedObject + + +class Log(Logger, object): + def __init__(self, name, level=0): + if level == 0: + level = option_parser.get_verbose() + Logger.__init__(self, name, level) + self.formatter = self.format + + handler = StreamHandler() + handler.setFormatter(self.formatter) + + self.addHandler(handler) + + def get_formatter(self): + return self.__formatter + + def set_formatter(self, fmt): + self.__formatter = Formatter(fmt) + + format = "%(levelname)s - %(asctime)s - %(message)s" + + formatter = property(get_formatter, set_formatter, doc="") + __formatter = Formatter(format) + + +# Import this! +log = DelayedObject(Log, APP_DISPLAY_NAME) + +if __name__ == '__main__': + log.debug("Debug Message") + log.info("Info Message") + log.warning("Warning Message") + log.error("Error Message") + log.critical("Critical Message") diff --git a/zenmap/zenmapCore/UmitOptionParser.py b/zenmap/zenmapCore/UmitOptionParser.py new file mode 100644 index 0000000..7a01754 --- /dev/null +++ b/zenmap/zenmapCore/UmitOptionParser.py @@ -0,0 +1,202 @@ +#!/usr/bin/env python3 + +# ***********************IMPORTANT NMAP LICENSE TERMS************************ +# * +# * The Nmap Security Scanner is (C) 1996-2023 Nmap Software 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.com) 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/ +# * +# ***************************************************************************/ + +from optparse import OptionParser +from zenmapCore.Name import NMAP_DISPLAY_NAME +from zenmapCore.Version import VERSION +import zenmapCore.I18N # lgtm[py/unused-import] +from zenmapCore.BasePaths import base_paths +from zenmapCore.DelayedObject import DelayedObject + + +class UmitOptionParser(OptionParser): + def __init__(self, args=False): + OptionParser.__init__(self, version="%%prog %s" % VERSION) + + self.set_usage("%prog [options] [result files]") + + self.add_option("--confdir", + default=base_paths["user_config_dir"], + dest="confdir", + metavar="DIR", + help=_("\ +Use DIR as the user configuration directory. Default: %default")) + + ## Open Scan Results (GUI) + ### Run, opening the specified scan result file, which should be + ### a nmap XML output file. + ### This option should be verified if there is no options, and user + ### specified some positional arguments, which should be considered as + ### scan result files. + self.add_option("-f", "--file", + default=[], + action="append", + type="string", + dest="result_files", + help=_("Specify a scan result file in Nmap XML output \ +format. Can be used more than once to specify several \ +scan result files.")) + + ## Run nmap with args (GUI) + ### Open and run nmap with specified args. The positional + ### args should be used to feed the nmap command + self.add_option("-n", "--nmap", + default=[], + action="callback", + callback=self.__nmap_callback, + help=_("Run %s with the specified args." + ) % NMAP_DISPLAY_NAME) + + ## Execute a profile against a target (GUI) + ### Positional args should be taken as targets to feed this scan + self.add_option("-p", "--profile", + default="", + action="store", + help=_("Begin with the specified profile \ +selected. If combined with the -t (--target) option, \ +automatically run the profile against the specified target.")) + + ## Targets (GUI) + ### Specify a target to be used along with other command line option + ### or simply opens with the first tab target field filled with + ### the target specified with this option + self.add_option("-t", "--target", + default=False, + action="store", + help=_("Specify a target to be used along with other \ +options. If specified alone, open with the target field filled with the \ +specified target")) + + ## Verbosity + self.add_option("-v", "--verbose", + default=0, + action="count", + help=_("Increase verbosity of the output. May be \ +used more than once to get even more verbosity")) + + # Parsing options and arguments + if args: + self.options, self.args = self.parse_args(args) + else: + self.options, self.args = self.parse_args() + + def __nmap_callback(self, option, opt_str, value, parser): + nmap_args = [] + # Iterate over next arguments that were passed at the command line + # that wasn't parsed yet. + while parser.rargs: + # Store the next argument in a specific list + nmap_args.append(parser.rargs[0]) + + # Remove the added argument from rargs to avoid its later + # parsing by optparse + del parser.rargs[0] + + # Set the variable nmap at parser.values, so you may call option.nmap + # and have the nmap_args as result + setattr(parser.values, "nmap", nmap_args) + + def get_confdir(self): + return self.options.confdir + + def get_nmap(self): + """Return a list of nmap arguments or False if this option was not + called by the user""" + + try: + nmap = self.options.nmap + if nmap: + return nmap + except AttributeError: + return False + + def get_profile(self): + """Return a string with the profile name, or False if no profile + option was specified by the user""" + if self.options.profile != "": + return self.options.profile + return False + + def get_target(self): + """Returns a string with the target specified, or False if this option + was not called by the user""" + return self.options.target + + def get_open_results(self): + """Returns a list of strings with the name of the files specified with + the -f (--file) option and every positional argument.""" + files = [] + # Add arguments given with -f. + if self.options.result_files: + files = self.options.result_files[:] + # Add any other arguments. + files += self.args + return files + + def get_verbose(self): + """Returns an integer representing the verbosity level of the + application. Verbosity level starts in 40, which means that only + messages above the ERROR level are going to be reported at the output. + As this value gets lower, the verbosity increases. + """ + return 40 - (self.options.verbose * 10) + +option_parser = DelayedObject(UmitOptionParser) + +if __name__ == "__main__": + opt = UmitOptionParser() + options, args = opt.parse_args() diff --git a/zenmap/zenmapCore/Version.py b/zenmap/zenmapCore/Version.py new file mode 100644 index 0000000..b3fede4 --- /dev/null +++ b/zenmap/zenmapCore/Version.py @@ -0,0 +1 @@ +VERSION = "7.94SVN" diff --git a/zenmap/zenmapCore/__init__.py b/zenmap/zenmapCore/__init__.py new file mode 100644 index 0000000..cf74df4 --- /dev/null +++ b/zenmap/zenmapCore/__init__.py @@ -0,0 +1,56 @@ +#!/usr/bin/env python3 + +# ***********************IMPORTANT NMAP LICENSE TERMS************************ +# * +# * The Nmap Security Scanner is (C) 1996-2023 Nmap Software 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.com) 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/ +# * +# ***************************************************************************/ |