| From bbbf474b2ebdbdac4d557e3351210f3fe2175c33 Mon Sep 17 00:00:00 2001 |
| From: Mingli Yu <mingli.yu@windriver.com> |
| Date: Fri, 14 Feb 2020 10:09:55 +0000 |
| Subject: [PATCH] Make ndiff support python3 |
| |
| Backport a patch from debian to make ndiff support |
| python3. |
| |
| Refer to https://sources.debian.org/data/main/n/nmap/7.80+dfsg1-2/debian/patches/0004-Python3-port-of-ndiff.patch |
| |
| Upstream-Status: Pending |
| |
| Signed-off-by: Mingli Yu <mingli.yu@windriver.com> |
| --- |
| Makefile.in | 12 +- |
| ndiff/ndiff.py | 495 +++++++++++++++++----------------- |
| ndiff/ndifftest.py | 94 +++---- |
| ndiff/scripts/ndiff | 14 +- |
| ndiff/setup.py | 34 +-- |
| ndiff/test-scans/anonymize.py | 18 +- |
| 6 files changed, 333 insertions(+), 334 deletions(-) |
| mode change 100644 => 100755 ndiff/setup.py |
| |
| diff --git a/Makefile.in b/Makefile.in |
| index eee8863..32f86ba 100644 |
| --- a/Makefile.in |
| +++ b/Makefile.in |
| @@ -35,6 +35,7 @@ ZENMAPDIR = @ZENMAPDIR@ |
| NDIFFDIR = @NDIFFDIR@ |
| NPINGDIR = @NPINGDIR@ |
| PYTHON = @PYTHON@ |
| +PYTHON3 = /usr/bin/env python3 |
| DEFS = @DEFS@ -DNMAP_PLATFORM=\"$(NMAP_PLATFORM)\" -DNMAPDATADIR=\"$(nmapdatadir)\" |
| # With GCC, add extra security checks to source code. |
| # http://gcc.gnu.org/ml/gcc-patches/2004-09/msg02055.html |
| @@ -260,7 +261,7 @@ clean-zenmap: |
| rm -f $(ZENMAPDIR)/zenmapCore/Name.pyc |
| |
| clean-ndiff: |
| - -cd $(NDIFFDIR) && $(PYTHON) setup.py clean --all |
| + -cd $(NDIFFDIR) && $(PYTHON3) setup.py clean --all |
| |
| clean-nping: |
| -cd $(NPINGDIR) && $(MAKE) clean |
| @@ -368,6 +369,7 @@ tests/check_dns: $(OBJS) |
| # this as the location of the interpreter whenever we're not doing a |
| # local installation. |
| DEFAULT_PYTHON_PATH = /usr/bin/env python |
| +DEFAULT_PYTHON3_PATH = /usr/bin/env python3 |
| |
| build-zenmap: $(ZENMAPDIR)/setup.py $(ZENMAPDIR)/zenmapCore/Version.py |
| # When DESTDIR is defined, assume we're building an executable |
| @@ -388,13 +390,13 @@ install-zenmap: $(ZENMAPDIR)/setup.py |
| ln -sf zenmap $(DESTDIR)$(bindir)/xnmap |
| |
| build-ndiff: |
| - cd $(NDIFFDIR) && $(PYTHON) setup.py build $(if $(DESTDIR),--executable "$(DEFAULT_PYTHON_PATH)") |
| + cd $(NDIFFDIR) && $(PYTHON3) setup.py build $(if $(DESTDIR),--executable "$(DEFAULT_PYTHON3_PATH)") |
| |
| build-nping: $(NPINGDIR)/Makefile build-nbase build-nsock build-netutil $(NPINGDIR)/nping.h @DNET_BUILD@ @PCAP_BUILD@ |
| @cd $(NPINGDIR) && $(MAKE) |
| |
| install-ndiff: |
| - cd $(NDIFFDIR) && $(PYTHON) setup.py install --prefix "$(prefix)" --install-lib="${PYTHON_SITEPACKAGES_DIR}" $(if $(DESTDIR),--root "$(DESTDIR)") |
| + cd $(NDIFFDIR) && $(PYTHON3) setup.py install --prefix "$(prefix)" --install-lib="${PYTHON_SITEPACKAGES_DIR}" $(if $(DESTDIR),--root "$(DESTDIR)") |
| |
| NSE_FILES = scripts/script.db scripts/*.nse |
| NSE_LIB_LUA_FILES = nselib/*.lua nselib/*.luadoc |
| @@ -443,7 +445,7 @@ uninstall-zenmap: |
| rm -f $(DESTDIR)$(bindir)/xnmap |
| |
| uninstall-ndiff: |
| - cd $(NDIFFDIR) && $(PYTHON) setup.py uninstall |
| + cd $(NDIFFDIR) && $(PYTHON3) setup.py uninstall |
| |
| uninstall-ncat: |
| @cd $(NCATDIR) && $(MAKE) uninstall |
| @@ -458,7 +460,7 @@ check-ncat: |
| @cd $(NCATDIR) && $(MAKE) check |
| |
| check-ndiff: |
| - @cd $(NDIFFDIR) && $(PYTHON) ndifftest.py |
| + @cd $(NDIFFDIR) && $(PYTHON3) ndifftest.py |
| |
| check-nsock: |
| @cd $(NSOCKDIR)/src && $(MAKE) check |
| diff --git a/ndiff/ndiff.py b/ndiff/ndiff.py |
| index 043273f..abbd1c5 100755 |
| --- a/ndiff/ndiff.py |
| +++ b/ndiff/ndiff.py |
| @@ -1,4 +1,4 @@ |
| -#!/usr/bin/env python |
| +#!/usr/bin/env python3 |
| |
| # Ndiff |
| # |
| @@ -26,11 +26,11 @@ xml.__path__ = [x for x in xml.__path__ if "_xmlplus" not in x] |
| import xml.sax |
| import xml.sax.saxutils |
| import xml.dom.minidom |
| -from StringIO import StringIO |
| +from io import StringIO |
| |
| verbose = False |
| |
| -NDIFF_XML_VERSION = u"1" |
| +NDIFF_XML_VERSION = "1" |
| |
| |
| class OverrideEntityResolver(xml.sax.handler.EntityResolver): |
| @@ -78,35 +78,35 @@ class Scan(object): |
| def write_nmaprun_open(self, writer): |
| attrs = {} |
| if self.scanner is not None: |
| - attrs[u"scanner"] = self.scanner |
| + attrs["scanner"] = self.scanner |
| if self.args is not None: |
| - attrs[u"args"] = self.args |
| + attrs["args"] = self.args |
| if self.start_date is not None: |
| - attrs[u"start"] = "%d" % time.mktime(self.start_date.timetuple()) |
| - attrs[u"startstr"] = self.start_date.strftime( |
| + attrs["start"] = "%d" % time.mktime(self.start_date.timetuple()) |
| + attrs["startstr"] = self.start_date.strftime( |
| "%a %b %d %H:%M:%S %Y") |
| if self.version is not None: |
| - attrs[u"version"] = self.version |
| - writer.startElement(u"nmaprun", attrs) |
| + attrs["version"] = self.version |
| + writer.startElement("nmaprun", attrs) |
| |
| def write_nmaprun_close(self, writer): |
| - writer.endElement(u"nmaprun") |
| + writer.endElement("nmaprun") |
| |
| def nmaprun_to_dom_fragment(self, document): |
| frag = document.createDocumentFragment() |
| - elem = document.createElement(u"nmaprun") |
| + elem = document.createElement("nmaprun") |
| if self.scanner is not None: |
| - elem.setAttribute(u"scanner", self.scanner) |
| + elem.setAttribute("scanner", self.scanner) |
| if self.args is not None: |
| - elem.setAttribute(u"args", self.args) |
| + elem.setAttribute("args", self.args) |
| if self.start_date is not None: |
| elem.setAttribute( |
| - u"start", "%d" % time.mktime(self.start_date.timetuple())) |
| + "start", "%d" % time.mktime(self.start_date.timetuple())) |
| elem.setAttribute( |
| - u"startstr", |
| + "startstr", |
| self.start_date.strftime("%a %b %d %H:%M:%S %Y")) |
| if self.version is not None: |
| - elem.setAttribute(u"version", self.version) |
| + elem.setAttribute("version", self.version) |
| frag.appendChild(elem) |
| return frag |
| |
| @@ -136,17 +136,17 @@ class Host(object): |
| |
| def format_name(self): |
| """Return a human-readable identifier for this host.""" |
| - address_s = u", ".join(a.s for a in sorted(self.addresses)) |
| - hostname_s = u", ".join(sorted(self.hostnames)) |
| + address_s = ", ".join(a.s for a in sorted(self.addresses)) |
| + hostname_s = ", ".join(sorted(self.hostnames)) |
| if len(hostname_s) > 0: |
| if len(address_s) > 0: |
| - return u"%s (%s)" % (hostname_s, address_s) |
| + return "%s (%s)" % (hostname_s, address_s) |
| else: |
| return hostname_s |
| elif len(address_s) > 0: |
| return address_s |
| else: |
| - return u"<no name>" |
| + return "<no name>" |
| |
| def add_port(self, port): |
| self.ports[port.spec] = port |
| @@ -163,46 +163,46 @@ class Host(object): |
| return state is None or state in self.extraports |
| |
| def extraports_string(self): |
| - list = [(count, state) for (state, count) in self.extraports.items()] |
| + locallist = [(count, state) for (state, count) in list(self.extraports.items())] |
| # Reverse-sort by count. |
| - list.sort(reverse=True) |
| - return u", ".join( |
| - [u"%d %s ports" % (count, state) for (count, state) in list]) |
| + locallist.sort(reverse=True) |
| + return ", ".join( |
| + ["%d %s ports" % (count, state) for (count, state) in locallist]) |
| |
| def state_to_dom_fragment(self, document): |
| frag = document.createDocumentFragment() |
| if self.state is not None: |
| - elem = document.createElement(u"status") |
| - elem.setAttribute(u"state", self.state) |
| + elem = document.createElement("status") |
| + elem.setAttribute("state", self.state) |
| frag.appendChild(elem) |
| return frag |
| |
| def hostname_to_dom_fragment(self, document, hostname): |
| frag = document.createDocumentFragment() |
| - elem = document.createElement(u"hostname") |
| - elem.setAttribute(u"name", hostname) |
| + elem = document.createElement("hostname") |
| + elem.setAttribute("name", hostname) |
| frag.appendChild(elem) |
| return frag |
| |
| def extraports_to_dom_fragment(self, document): |
| frag = document.createDocumentFragment() |
| - for state, count in self.extraports.items(): |
| - elem = document.createElement(u"extraports") |
| - elem.setAttribute(u"state", state) |
| - elem.setAttribute(u"count", unicode(count)) |
| + for state, count in list(self.extraports.items()): |
| + elem = document.createElement("extraports") |
| + elem.setAttribute("state", state) |
| + elem.setAttribute("count", str(count)) |
| frag.appendChild(elem) |
| return frag |
| |
| def os_to_dom_fragment(self, document, os): |
| frag = document.createDocumentFragment() |
| - elem = document.createElement(u"osmatch") |
| - elem.setAttribute(u"name", os) |
| + elem = document.createElement("osmatch") |
| + elem.setAttribute("name", os) |
| frag.appendChild(elem) |
| return frag |
| |
| def to_dom_fragment(self, document): |
| frag = document.createDocumentFragment() |
| - elem = document.createElement(u"host") |
| + elem = document.createElement("host") |
| |
| if self.state is not None: |
| elem.appendChild(self.state_to_dom_fragment(document)) |
| @@ -211,13 +211,13 @@ class Host(object): |
| elem.appendChild(addr.to_dom_fragment(document)) |
| |
| if len(self.hostnames) > 0: |
| - hostnames_elem = document.createElement(u"hostnames") |
| + hostnames_elem = document.createElement("hostnames") |
| for hostname in self.hostnames: |
| hostnames_elem.appendChild( |
| self.hostname_to_dom_fragment(document, hostname)) |
| elem.appendChild(hostnames_elem) |
| |
| - ports_elem = document.createElement(u"ports") |
| + ports_elem = document.createElement("ports") |
| ports_elem.appendChild(self.extraports_to_dom_fragment(document)) |
| for port in sorted(self.ports.values()): |
| if not self.is_extraports(port.state): |
| @@ -226,13 +226,13 @@ class Host(object): |
| elem.appendChild(ports_elem) |
| |
| if len(self.os) > 0: |
| - os_elem = document.createElement(u"os") |
| + os_elem = document.createElement("os") |
| for os in self.os: |
| os_elem.appendChild(self.os_to_dom_fragment(document, os)) |
| elem.appendChild(os_elem) |
| |
| if len(self.script_results) > 0: |
| - hostscript_elem = document.createElement(u"hostscript") |
| + hostscript_elem = document.createElement("hostscript") |
| for sr in self.script_results: |
| hostscript_elem.appendChild(sr.to_dom_fragment(document)) |
| elem.appendChild(hostscript_elem) |
| @@ -246,7 +246,7 @@ class Address(object): |
| self.s = s |
| |
| def __eq__(self, other): |
| - return self.__cmp__(other) == 0 |
| + return self.sort_key() == other.sort_key() |
| |
| def __ne__(self, other): |
| return not self.__eq__(other) |
| @@ -254,8 +254,8 @@ class Address(object): |
| def __hash__(self): |
| return hash(self.sort_key()) |
| |
| - def __cmp__(self, other): |
| - return cmp(self.sort_key(), other.sort_key()) |
| + def __lt__(self, other): |
| + return self.sort_key() < other.sort_key() |
| |
| def __str__(self): |
| return str(self.s) |
| @@ -264,21 +264,21 @@ class Address(object): |
| return self.s |
| |
| def new(type, s): |
| - if type == u"ipv4": |
| + if type == "ipv4": |
| return IPv4Address(s) |
| - elif type == u"ipv6": |
| + elif type == "ipv6": |
| return IPv6Address(s) |
| - elif type == u"mac": |
| + elif type == "mac": |
| return MACAddress(s) |
| else: |
| - raise ValueError(u"Unknown address type %s." % type) |
| + raise ValueError("Unknown address type %s." % type) |
| new = staticmethod(new) |
| |
| def to_dom_fragment(self, document): |
| frag = document.createDocumentFragment() |
| - elem = document.createElement(u"address") |
| - elem.setAttribute(u"addr", self.s) |
| - elem.setAttribute(u"addrtype", self.type) |
| + elem = document.createElement("address") |
| + elem.setAttribute("addr", self.s) |
| + elem.setAttribute("addrtype", self.type) |
| frag.appendChild(elem) |
| return frag |
| |
| @@ -287,21 +287,21 @@ class Address(object): |
| |
| |
| class IPv4Address(Address): |
| - type = property(lambda self: u"ipv4") |
| + type = property(lambda self: "ipv4") |
| |
| def sort_key(self): |
| return (0, self.s) |
| |
| |
| class IPv6Address(Address): |
| - type = property(lambda self: u"ipv6") |
| + type = property(lambda self: "ipv6") |
| |
| def sort_key(self): |
| return (1, self.s) |
| |
| |
| class MACAddress(Address): |
| - type = property(lambda self: u"mac") |
| + type = property(lambda self: "mac") |
| |
| def sort_key(self): |
| return (2, self.s) |
| @@ -320,28 +320,25 @@ class Port(object): |
| |
| def state_string(self): |
| if self.state is None: |
| - return u"unknown" |
| + return "unknown" |
| else: |
| - return unicode(self.state) |
| + return str(self.state) |
| |
| def spec_string(self): |
| - return u"%d/%s" % self.spec |
| + return "%d/%s" % self.spec |
| |
| - def __cmp__(self, other): |
| - d = cmp(self.spec, other.spec) |
| - if d != 0: |
| - return d |
| - return cmp((self.spec, self.service, self.script_results), |
| - (other.spec, other.service, other.script_results)) |
| + def __lt__(self, other): |
| + return (self.spec, self.service, self.script_results) < ( |
| + other.spec, other.service, other.script_results) |
| |
| def to_dom_fragment(self, document): |
| frag = document.createDocumentFragment() |
| - elem = document.createElement(u"port") |
| - elem.setAttribute(u"portid", unicode(self.spec[0])) |
| - elem.setAttribute(u"protocol", self.spec[1]) |
| + elem = document.createElement("port") |
| + elem.setAttribute("portid", str(self.spec[0])) |
| + elem.setAttribute("protocol", self.spec[1]) |
| if self.state is not None: |
| - state_elem = document.createElement(u"state") |
| - state_elem.setAttribute(u"state", self.state) |
| + state_elem = document.createElement("state") |
| + state_elem.setAttribute("state", self.state) |
| elem.appendChild(state_elem) |
| elem.appendChild(self.service.to_dom_fragment(document)) |
| for sr in self.script_results: |
| @@ -385,7 +382,7 @@ class Service(object): |
| if len(parts) == 0: |
| return None |
| else: |
| - return u"/".join(parts) |
| + return "/".join(parts) |
| |
| def version_string(self): |
| """Get a string like in the VERSION column of Nmap output.""" |
| @@ -395,17 +392,17 @@ class Service(object): |
| if self.version is not None: |
| parts.append(self.version) |
| if self.extrainfo is not None: |
| - parts.append(u"(%s)" % self.extrainfo) |
| + parts.append("(%s)" % self.extrainfo) |
| |
| if len(parts) == 0: |
| return None |
| else: |
| - return u" ".join(parts) |
| + return " ".join(parts) |
| |
| def to_dom_fragment(self, document): |
| frag = document.createDocumentFragment() |
| - elem = document.createElement(u"service") |
| - for attr in (u"name", u"product", u"version", u"extrainfo", u"tunnel"): |
| + elem = document.createElement("service") |
| + for attr in ("name", "product", "version", "extrainfo", "tunnel"): |
| v = getattr(self, attr) |
| if v is None: |
| continue |
| @@ -435,53 +432,53 @@ class ScriptResult(object): |
| result = [] |
| lines = self.output.splitlines() |
| if len(lines) > 0: |
| - lines[0] = self.id + u": " + lines[0] |
| + lines[0] = self.id + ": " + lines[0] |
| for line in lines[:-1]: |
| - result.append(u"| " + line) |
| + result.append("| " + line) |
| if len(lines) > 0: |
| - result.append(u"|_ " + lines[-1]) |
| + result.append("|_ " + lines[-1]) |
| return result |
| |
| def to_dom_fragment(self, document): |
| frag = document.createDocumentFragment() |
| - elem = document.createElement(u"script") |
| - elem.setAttribute(u"id", self.id) |
| - elem.setAttribute(u"output", self.output) |
| + elem = document.createElement("script") |
| + elem.setAttribute("id", self.id) |
| + elem.setAttribute("output", self.output) |
| frag.appendChild(elem) |
| return frag |
| |
| |
| def format_banner(scan): |
| """Format a startup banner more or less like Nmap does.""" |
| - scanner = u"Nmap" |
| - if scan.scanner is not None and scan.scanner != u"nmap": |
| + scanner = "Nmap" |
| + if scan.scanner is not None and scan.scanner != "nmap": |
| scanner = scan.scanner |
| parts = [scanner] |
| if scan.version is not None: |
| parts.append(scan.version) |
| - parts.append(u"scan") |
| + parts.append("scan") |
| if scan.start_date is not None: |
| - parts.append(u"initiated %s" % scan.start_date.strftime( |
| + parts.append("initiated %s" % scan.start_date.strftime( |
| "%a %b %d %H:%M:%S %Y")) |
| if scan.args is not None: |
| - parts.append(u"as: %s" % scan.args) |
| - return u" ".join(parts) |
| + parts.append("as: %s" % scan.args) |
| + return " ".join(parts) |
| |
| |
| def print_script_result_diffs_text(title, script_results_a, script_results_b, |
| script_result_diffs, f=sys.stdout): |
| - table = Table(u"*") |
| + table = Table("*") |
| for sr_diff in script_result_diffs: |
| sr_diff.append_to_port_table(table) |
| if len(table) > 0: |
| - print >> f |
| + print(file=f) |
| if len(script_results_b) == 0: |
| - print >> f, u"-%s:" % title |
| + print("-%s:" % title, file=f) |
| elif len(script_results_a) == 0: |
| - print >> f, u"+%s:" % title |
| + print("+%s:" % title, file=f) |
| else: |
| - print >> f, u" %s:" % title |
| - print >> f, table |
| + print(" %s:" % title, file=f) |
| + print(table, file=f) |
| |
| |
| def script_result_diffs_to_dom_fragment(elem, script_results_a, |
| @@ -489,13 +486,13 @@ def script_result_diffs_to_dom_fragment(elem, script_results_a, |
| if len(script_results_a) == 0 and len(script_results_b) == 0: |
| return document.createDocumentFragment() |
| elif len(script_results_b) == 0: |
| - a_elem = document.createElement(u"a") |
| + a_elem = document.createElement("a") |
| for sr in script_results_a: |
| elem.appendChild(sr.to_dom_fragment(document)) |
| a_elem.appendChild(elem) |
| return a_elem |
| elif len(script_results_a) == 0: |
| - b_elem = document.createElement(u"b") |
| + b_elem = document.createElement("b") |
| for sr in script_results_b: |
| elem.appendChild(sr.to_dom_fragment(document)) |
| b_elem.appendChild(elem) |
| @@ -581,10 +578,10 @@ class ScanDiffText(ScanDiff): |
| banner_a = format_banner(self.scan_a) |
| banner_b = format_banner(self.scan_b) |
| if banner_a != banner_b: |
| - print >> self.f, u"-%s" % banner_a |
| - print >> self.f, u"+%s" % banner_b |
| + print("-%s" % banner_a, file=self.f) |
| + print("+%s" % banner_b, file=self.f) |
| elif verbose: |
| - print >> self.f, u" %s" % banner_a |
| + print(" %s" % banner_a, file=self.f) |
| |
| def output_pre_scripts(self, pre_script_result_diffs): |
| print_script_result_diffs_text("Pre-scan script results", |
| @@ -597,7 +594,7 @@ class ScanDiffText(ScanDiff): |
| post_script_result_diffs, self.f) |
| |
| def output_host_diff(self, h_diff): |
| - print >> self.f |
| + print(file=self.f) |
| h_diff.print_text(self.f) |
| |
| def output_ending(self): |
| @@ -622,8 +619,8 @@ class ScanDiffXML(ScanDiff): |
| |
| def output_beginning(self): |
| self.writer.startDocument() |
| - self.writer.startElement(u"nmapdiff", {u"version": NDIFF_XML_VERSION}) |
| - self.writer.startElement(u"scandiff", {}) |
| + self.writer.startElement("nmapdiff", {"version": NDIFF_XML_VERSION}) |
| + self.writer.startElement("scandiff", {}) |
| |
| if self.nmaprun_differs(): |
| self.writer.frag_a( |
| @@ -636,7 +633,7 @@ class ScanDiffXML(ScanDiff): |
| |
| def output_pre_scripts(self, pre_script_result_diffs): |
| if len(pre_script_result_diffs) > 0 or verbose: |
| - prescript_elem = self.document.createElement(u"prescript") |
| + prescript_elem = self.document.createElement("prescript") |
| frag = script_result_diffs_to_dom_fragment( |
| prescript_elem, self.scan_a.pre_script_results, |
| self.scan_b.pre_script_results, pre_script_result_diffs, |
| @@ -646,7 +643,7 @@ class ScanDiffXML(ScanDiff): |
| |
| def output_post_scripts(self, post_script_result_diffs): |
| if len(post_script_result_diffs) > 0 or verbose: |
| - postscript_elem = self.document.createElement(u"postscript") |
| + postscript_elem = self.document.createElement("postscript") |
| frag = script_result_diffs_to_dom_fragment( |
| postscript_elem, self.scan_a.post_script_results, |
| self.scan_b.post_script_results, post_script_result_diffs, |
| @@ -660,8 +657,8 @@ class ScanDiffXML(ScanDiff): |
| frag.unlink() |
| |
| def output_ending(self): |
| - self.writer.endElement(u"scandiff") |
| - self.writer.endElement(u"nmapdiff") |
| + self.writer.endElement("scandiff") |
| + self.writer.endElement("nmapdiff") |
| self.writer.endDocument() |
| |
| |
| @@ -719,9 +716,9 @@ class HostDiff(object): |
| self.cost += os_cost |
| |
| extraports_a = tuple((count, state) |
| - for (state, count) in self.host_a.extraports.items()) |
| + for (state, count) in list(self.host_a.extraports.items())) |
| extraports_b = tuple((count, state) |
| - for (state, count) in self.host_b.extraports.items()) |
| + for (state, count) in list(self.host_b.extraports.items())) |
| if extraports_a != extraports_b: |
| self.extraports_changed = True |
| self.cost += 1 |
| @@ -747,69 +744,69 @@ class HostDiff(object): |
| # Names and addresses. |
| if self.id_changed: |
| if host_a.state is not None: |
| - print >> f, u"-%s:" % host_a.format_name() |
| + print("-%s:" % host_a.format_name(), file=f) |
| if self.host_b.state is not None: |
| - print >> f, u"+%s:" % host_b.format_name() |
| + print("+%s:" % host_b.format_name(), file=f) |
| else: |
| - print >> f, u" %s:" % host_a.format_name() |
| + print(" %s:" % host_a.format_name(), file=f) |
| |
| # State. |
| if self.state_changed: |
| if host_a.state is not None: |
| - print >> f, u"-Host is %s." % host_a.state |
| + print("-Host is %s." % host_a.state, file=f) |
| if host_b.state is not None: |
| - print >> f, u"+Host is %s." % host_b.state |
| + print("+Host is %s." % host_b.state, file=f) |
| elif verbose: |
| - print >> f, u" Host is %s." % host_b.state |
| + print(" Host is %s." % host_b.state, file=f) |
| |
| # Extraports. |
| if self.extraports_changed: |
| if len(host_a.extraports) > 0: |
| - print >> f, u"-Not shown: %s" % host_a.extraports_string() |
| + print("-Not shown: %s" % host_a.extraports_string(), file=f) |
| if len(host_b.extraports) > 0: |
| - print >> f, u"+Not shown: %s" % host_b.extraports_string() |
| + print("+Not shown: %s" % host_b.extraports_string(), file=f) |
| elif verbose: |
| if len(host_a.extraports) > 0: |
| - print >> f, u" Not shown: %s" % host_a.extraports_string() |
| + print(" Not shown: %s" % host_a.extraports_string(), file=f) |
| |
| # Port table. |
| - port_table = Table(u"** * * *") |
| + port_table = Table("** * * *") |
| if host_a.state is None: |
| - mark = u"+" |
| + mark = "+" |
| elif host_b.state is None: |
| - mark = u"-" |
| + mark = "-" |
| else: |
| - mark = u" " |
| - port_table.append((mark, u"PORT", u"STATE", u"SERVICE", u"VERSION")) |
| + mark = " " |
| + port_table.append((mark, "PORT", "STATE", "SERVICE", "VERSION")) |
| |
| for port in self.ports: |
| port_diff = self.port_diffs[port] |
| port_diff.append_to_port_table(port_table, host_a, host_b) |
| |
| if len(port_table) > 1: |
| - print >> f, port_table |
| + print(port_table, file=f) |
| |
| # OS changes. |
| if self.os_changed or verbose: |
| if len(host_a.os) > 0: |
| if len(host_b.os) > 0: |
| - print >> f, u" OS details:" |
| + print(" OS details:", file=f) |
| else: |
| - print >> f, u"-OS details:" |
| + print("-OS details:", file=f) |
| elif len(host_b.os) > 0: |
| - print >> f, u"+OS details:" |
| + print("+OS details:", file=f) |
| # os_diffs is a list of 5-tuples returned by |
| # difflib.SequenceMatcher. |
| for op, i1, i2, j1, j2 in self.os_diffs: |
| if op == "replace" or op == "delete": |
| for i in range(i1, i2): |
| - print >> f, "- %s" % host_a.os[i] |
| + print("- %s" % host_a.os[i], file=f) |
| if op == "replace" or op == "insert": |
| for i in range(j1, j2): |
| - print >> f, "+ %s" % host_b.os[i] |
| + print("+ %s" % host_b.os[i], file=f) |
| if op == "equal": |
| for i in range(i1, i2): |
| - print >> f, " %s" % host_a.os[i] |
| + print(" %s" % host_a.os[i], file=f) |
| |
| print_script_result_diffs_text("Host script results", |
| host_a.script_results, host_b.script_results, |
| @@ -820,32 +817,32 @@ class HostDiff(object): |
| host_b = self.host_b |
| |
| frag = document.createDocumentFragment() |
| - hostdiff_elem = document.createElement(u"hostdiff") |
| + hostdiff_elem = document.createElement("hostdiff") |
| frag.appendChild(hostdiff_elem) |
| |
| if host_a.state is None or host_b.state is None: |
| # The host is missing in one scan. Output the whole thing. |
| if host_a.state is not None: |
| - a_elem = document.createElement(u"a") |
| + a_elem = document.createElement("a") |
| a_elem.appendChild(host_a.to_dom_fragment(document)) |
| hostdiff_elem.appendChild(a_elem) |
| elif host_b.state is not None: |
| - b_elem = document.createElement(u"b") |
| + b_elem = document.createElement("b") |
| b_elem.appendChild(host_b.to_dom_fragment(document)) |
| hostdiff_elem.appendChild(b_elem) |
| return frag |
| |
| - host_elem = document.createElement(u"host") |
| + host_elem = document.createElement("host") |
| |
| # State. |
| if host_a.state == host_b.state: |
| if verbose: |
| host_elem.appendChild(host_a.state_to_dom_fragment(document)) |
| else: |
| - a_elem = document.createElement(u"a") |
| + a_elem = document.createElement("a") |
| a_elem.appendChild(host_a.state_to_dom_fragment(document)) |
| host_elem.appendChild(a_elem) |
| - b_elem = document.createElement(u"b") |
| + b_elem = document.createElement("b") |
| b_elem.appendChild(host_b.state_to_dom_fragment(document)) |
| host_elem.appendChild(b_elem) |
| |
| @@ -854,31 +851,31 @@ class HostDiff(object): |
| addrset_b = set(host_b.addresses) |
| for addr in sorted(addrset_a.intersection(addrset_b)): |
| host_elem.appendChild(addr.to_dom_fragment(document)) |
| - a_elem = document.createElement(u"a") |
| + a_elem = document.createElement("a") |
| for addr in sorted(addrset_a - addrset_b): |
| a_elem.appendChild(addr.to_dom_fragment(document)) |
| if a_elem.hasChildNodes(): |
| host_elem.appendChild(a_elem) |
| - b_elem = document.createElement(u"b") |
| + b_elem = document.createElement("b") |
| for addr in sorted(addrset_b - addrset_a): |
| b_elem.appendChild(addr.to_dom_fragment(document)) |
| if b_elem.hasChildNodes(): |
| host_elem.appendChild(b_elem) |
| |
| # Host names. |
| - hostnames_elem = document.createElement(u"hostnames") |
| + hostnames_elem = document.createElement("hostnames") |
| hostnameset_a = set(host_a.hostnames) |
| hostnameset_b = set(host_b.hostnames) |
| for hostname in sorted(hostnameset_a.intersection(hostnameset_b)): |
| hostnames_elem.appendChild( |
| host_a.hostname_to_dom_fragment(document, hostname)) |
| - a_elem = document.createElement(u"a") |
| + a_elem = document.createElement("a") |
| for hostname in sorted(hostnameset_a - hostnameset_b): |
| a_elem.appendChild( |
| host_a.hostname_to_dom_fragment(document, hostname)) |
| if a_elem.hasChildNodes(): |
| hostnames_elem.appendChild(a_elem) |
| - b_elem = document.createElement(u"b") |
| + b_elem = document.createElement("b") |
| for hostname in sorted(hostnameset_b - hostnameset_a): |
| b_elem.appendChild( |
| host_b.hostname_to_dom_fragment(document, hostname)) |
| @@ -887,15 +884,15 @@ class HostDiff(object): |
| if hostnames_elem.hasChildNodes(): |
| host_elem.appendChild(hostnames_elem) |
| |
| - ports_elem = document.createElement(u"ports") |
| + ports_elem = document.createElement("ports") |
| # Extraports. |
| if host_a.extraports == host_b.extraports: |
| ports_elem.appendChild(host_a.extraports_to_dom_fragment(document)) |
| else: |
| - a_elem = document.createElement(u"a") |
| + a_elem = document.createElement("a") |
| a_elem.appendChild(host_a.extraports_to_dom_fragment(document)) |
| ports_elem.appendChild(a_elem) |
| - b_elem = document.createElement(u"b") |
| + b_elem = document.createElement("b") |
| b_elem.appendChild(host_b.extraports_to_dom_fragment(document)) |
| ports_elem.appendChild(b_elem) |
| # Port list. |
| @@ -911,18 +908,18 @@ class HostDiff(object): |
| |
| # OS changes. |
| if self.os_changed or verbose: |
| - os_elem = document.createElement(u"os") |
| + os_elem = document.createElement("os") |
| # os_diffs is a list of 5-tuples returned by |
| # difflib.SequenceMatcher. |
| for op, i1, i2, j1, j2 in self.os_diffs: |
| if op == "replace" or op == "delete": |
| - a_elem = document.createElement(u"a") |
| + a_elem = document.createElement("a") |
| for i in range(i1, i2): |
| a_elem.appendChild(host_a.os_to_dom_fragment( |
| document, host_a.os[i])) |
| os_elem.appendChild(a_elem) |
| if op == "replace" or op == "insert": |
| - b_elem = document.createElement(u"b") |
| + b_elem = document.createElement("b") |
| for i in range(j1, j2): |
| b_elem.appendChild(host_b.os_to_dom_fragment( |
| document, host_b.os[i])) |
| @@ -936,7 +933,7 @@ class HostDiff(object): |
| |
| # Host script changes. |
| if len(self.script_result_diffs) > 0 or verbose: |
| - hostscript_elem = document.createElement(u"hostscript") |
| + hostscript_elem = document.createElement("hostscript") |
| host_elem.appendChild(script_result_diffs_to_dom_fragment( |
| hostscript_elem, host_a.script_results, |
| host_b.script_results, self.script_result_diffs, |
| @@ -989,38 +986,38 @@ class PortDiff(object): |
| self.port_b.service.version_string()] |
| if a_columns == b_columns: |
| if verbose or self.script_result_diffs > 0: |
| - table.append([u" "] + a_columns) |
| + table.append([" "] + a_columns) |
| else: |
| if not host_a.is_extraports(self.port_a.state): |
| - table.append([u"-"] + a_columns) |
| + table.append(["-"] + a_columns) |
| if not host_b.is_extraports(self.port_b.state): |
| - table.append([u"+"] + b_columns) |
| + table.append(["+"] + b_columns) |
| |
| for sr_diff in self.script_result_diffs: |
| sr_diff.append_to_port_table(table) |
| |
| def to_dom_fragment(self, document): |
| frag = document.createDocumentFragment() |
| - portdiff_elem = document.createElement(u"portdiff") |
| + portdiff_elem = document.createElement("portdiff") |
| frag.appendChild(portdiff_elem) |
| if (self.port_a.spec == self.port_b.spec and |
| self.port_a.state == self.port_b.state): |
| - port_elem = document.createElement(u"port") |
| - port_elem.setAttribute(u"portid", unicode(self.port_a.spec[0])) |
| - port_elem.setAttribute(u"protocol", self.port_a.spec[1]) |
| + port_elem = document.createElement("port") |
| + port_elem.setAttribute("portid", str(self.port_a.spec[0])) |
| + port_elem.setAttribute("protocol", self.port_a.spec[1]) |
| if self.port_a.state is not None: |
| - state_elem = document.createElement(u"state") |
| - state_elem.setAttribute(u"state", self.port_a.state) |
| + state_elem = document.createElement("state") |
| + state_elem.setAttribute("state", self.port_a.state) |
| port_elem.appendChild(state_elem) |
| if self.port_a.service == self.port_b.service: |
| port_elem.appendChild( |
| self.port_a.service.to_dom_fragment(document)) |
| else: |
| - a_elem = document.createElement(u"a") |
| + a_elem = document.createElement("a") |
| a_elem.appendChild( |
| self.port_a.service.to_dom_fragment(document)) |
| port_elem.appendChild(a_elem) |
| - b_elem = document.createElement(u"b") |
| + b_elem = document.createElement("b") |
| b_elem.appendChild( |
| self.port_b.service.to_dom_fragment(document)) |
| port_elem.appendChild(b_elem) |
| @@ -1028,10 +1025,10 @@ class PortDiff(object): |
| port_elem.appendChild(sr_diff.to_dom_fragment(document)) |
| portdiff_elem.appendChild(port_elem) |
| else: |
| - a_elem = document.createElement(u"a") |
| + a_elem = document.createElement("a") |
| a_elem.appendChild(self.port_a.to_dom_fragment(document)) |
| portdiff_elem.appendChild(a_elem) |
| - b_elem = document.createElement(u"b") |
| + b_elem = document.createElement("b") |
| b_elem.appendChild(self.port_b.to_dom_fragment(document)) |
| portdiff_elem.appendChild(b_elem) |
| |
| @@ -1086,13 +1083,13 @@ class ScriptResultDiff(object): |
| for op, i1, i2, j1, j2 in diffs.get_opcodes(): |
| if op == "replace" or op == "delete": |
| for k in range(i1, i2): |
| - table.append_raw(u"-" + a_lines[k]) |
| + table.append_raw("-" + a_lines[k]) |
| if op == "replace" or op == "insert": |
| for k in range(j1, j2): |
| - table.append_raw(u"+" + b_lines[k]) |
| + table.append_raw("+" + b_lines[k]) |
| if op == "equal": |
| for k in range(i1, i2): |
| - table.append_raw(u" " + a_lines[k]) |
| + table.append_raw(" " + a_lines[k]) |
| |
| def to_dom_fragment(self, document): |
| frag = document.createDocumentFragment() |
| @@ -1102,11 +1099,11 @@ class ScriptResultDiff(object): |
| frag.appendChild(self.sr_a.to_dom_fragment(document)) |
| else: |
| if self.sr_a is not None: |
| - a_elem = document.createElement(u"a") |
| + a_elem = document.createElement("a") |
| a_elem.appendChild(self.sr_a.to_dom_fragment(document)) |
| frag.appendChild(a_elem) |
| if self.sr_b is not None: |
| - b_elem = document.createElement(u"b") |
| + b_elem = document.createElement("b") |
| b_elem.appendChild(self.sr_b.to_dom_fragment(document)) |
| frag.appendChild(b_elem) |
| return frag |
| @@ -1120,7 +1117,7 @@ class Table(object): |
| copied to the output.""" |
| self.widths = [] |
| self.rows = [] |
| - self.prefix = u"" |
| + self.prefix = "" |
| self.padding = [] |
| j = 0 |
| while j < len(template) and template[j] != "*": |
| @@ -1145,7 +1142,7 @@ class Table(object): |
| |
| for i in range(len(row)): |
| if row[i] is None: |
| - s = u"" |
| + s = "" |
| else: |
| s = str(row[i]) |
| if i == len(self.widths): |
| @@ -1167,7 +1164,7 @@ class Table(object): |
| for row in self.rows: |
| parts = [self.prefix] |
| i = 0 |
| - if isinstance(row, basestring): |
| + if isinstance(row, str): |
| # A raw string. |
| lines.append(row) |
| else: |
| @@ -1176,13 +1173,13 @@ class Table(object): |
| if i < len(self.padding): |
| parts.append(self.padding[i]) |
| i += 1 |
| - lines.append(u"".join(parts).rstrip()) |
| - return u"\n".join(lines) |
| + lines.append("".join(parts).rstrip()) |
| + return "\n".join(lines) |
| |
| |
| def warn(str): |
| """Print a warning to stderr.""" |
| - print >> sys.stderr, str |
| + print(str, file=sys.stderr) |
| |
| |
| class NmapContentHandler(xml.sax.handler.ContentHandler): |
| @@ -1200,22 +1197,22 @@ class NmapContentHandler(xml.sax.handler.ContentHandler): |
| self.current_port = None |
| |
| self._start_elem_handlers = { |
| - u"nmaprun": self._start_nmaprun, |
| - u"host": self._start_host, |
| - u"status": self._start_status, |
| - u"address": self._start_address, |
| - u"hostname": self._start_hostname, |
| - u"extraports": self._start_extraports, |
| - u"port": self._start_port, |
| - u"state": self._start_state, |
| - u"service": self._start_service, |
| - u"script": self._start_script, |
| - u"osmatch": self._start_osmatch, |
| - u"finished": self._start_finished, |
| + "nmaprun": self._start_nmaprun, |
| + "host": self._start_host, |
| + "status": self._start_status, |
| + "address": self._start_address, |
| + "hostname": self._start_hostname, |
| + "extraports": self._start_extraports, |
| + "port": self._start_port, |
| + "state": self._start_state, |
| + "service": self._start_service, |
| + "script": self._start_script, |
| + "osmatch": self._start_osmatch, |
| + "finished": self._start_finished, |
| } |
| self._end_elem_handlers = { |
| - u'host': self._end_host, |
| - u'port': self._end_port, |
| + 'host': self._end_host, |
| + 'port': self._end_port, |
| } |
| |
| def parent_element(self): |
| @@ -1245,68 +1242,68 @@ class NmapContentHandler(xml.sax.handler.ContentHandler): |
| def _start_nmaprun(self, name, attrs): |
| assert self.parent_element() is None |
| if "start" in attrs: |
| - start_timestamp = int(attrs.get(u"start")) |
| + start_timestamp = int(attrs.get("start")) |
| self.scan.start_date = datetime.datetime.fromtimestamp( |
| start_timestamp) |
| - self.scan.scanner = attrs.get(u"scanner") |
| - self.scan.args = attrs.get(u"args") |
| - self.scan.version = attrs.get(u"version") |
| + self.scan.scanner = attrs.get("scanner") |
| + self.scan.args = attrs.get("args") |
| + self.scan.version = attrs.get("version") |
| |
| def _start_host(self, name, attrs): |
| - assert self.parent_element() == u"nmaprun" |
| + assert self.parent_element() == "nmaprun" |
| self.current_host = Host() |
| self.scan.hosts.append(self.current_host) |
| |
| def _start_status(self, name, attrs): |
| - assert self.parent_element() == u"host" |
| + assert self.parent_element() == "host" |
| assert self.current_host is not None |
| - state = attrs.get(u"state") |
| + state = attrs.get("state") |
| if state is None: |
| warn(u'%s element of host %s is missing the "state" attribute; ' |
| - 'assuming \unknown\.' % ( |
| + r'assuming \unknown\.' % ( |
| name, self.current_host.format_name())) |
| return |
| self.current_host.state = state |
| |
| def _start_address(self, name, attrs): |
| - assert self.parent_element() == u"host" |
| + assert self.parent_element() == "host" |
| assert self.current_host is not None |
| - addr = attrs.get(u"addr") |
| + addr = attrs.get("addr") |
| if addr is None: |
| - warn(u'%s element of host %s is missing the "addr" ' |
| + warn('%s element of host %s is missing the "addr" ' |
| 'attribute; skipping.' % ( |
| name, self.current_host.format_name())) |
| return |
| - addrtype = attrs.get(u"addrtype", u"ipv4") |
| + addrtype = attrs.get("addrtype", "ipv4") |
| self.current_host.add_address(Address.new(addrtype, addr)) |
| |
| def _start_hostname(self, name, attrs): |
| - assert self.parent_element() == u"hostnames" |
| + assert self.parent_element() == "hostnames" |
| assert self.current_host is not None |
| - hostname = attrs.get(u"name") |
| + hostname = attrs.get("name") |
| if hostname is None: |
| - warn(u'%s element of host %s is missing the "name" ' |
| + warn('%s element of host %s is missing the "name" ' |
| 'attribute; skipping.' % ( |
| name, self.current_host.format_name())) |
| return |
| self.current_host.add_hostname(hostname) |
| |
| def _start_extraports(self, name, attrs): |
| - assert self.parent_element() == u"ports" |
| + assert self.parent_element() == "ports" |
| assert self.current_host is not None |
| - state = attrs.get(u"state") |
| + state = attrs.get("state") |
| if state is None: |
| - warn(u'%s element of host %s is missing the "state" ' |
| + warn('%s element of host %s is missing the "state" ' |
| 'attribute; assuming "unknown".' % ( |
| name, self.current_host.format_name())) |
| state = None |
| if state in self.current_host.extraports: |
| - warn(u'Duplicate extraports state "%s" in host %s.' % ( |
| + warn('Duplicate extraports state "%s" in host %s.' % ( |
| state, self.current_host.format_name())) |
| |
| - count = attrs.get(u"count") |
| + count = attrs.get("count") |
| if count is None: |
| - warn(u'%s element of host %s is missing the "count" ' |
| + warn('%s element of host %s is missing the "count" ' |
| 'attribute; assuming 0.' % ( |
| name, self.current_host.format_name())) |
| count = 0 |
| @@ -1314,99 +1311,99 @@ class NmapContentHandler(xml.sax.handler.ContentHandler): |
| try: |
| count = int(count) |
| except ValueError: |
| - warn(u"Can't convert extraports count \"%s\" " |
| + warn("Can't convert extraports count \"%s\" " |
| "to an integer in host %s; assuming 0." % ( |
| - attrs[u"count"], self.current_host.format_name())) |
| + attrs["count"], self.current_host.format_name())) |
| count = 0 |
| self.current_host.extraports[state] = count |
| |
| def _start_port(self, name, attrs): |
| - assert self.parent_element() == u"ports" |
| + assert self.parent_element() == "ports" |
| assert self.current_host is not None |
| - portid_str = attrs.get(u"portid") |
| + portid_str = attrs.get("portid") |
| if portid_str is None: |
| - warn(u'%s element of host %s missing the "portid" ' |
| + warn('%s element of host %s missing the "portid" ' |
| 'attribute; skipping.' % ( |
| name, self.current_host.format_name())) |
| return |
| try: |
| portid = int(portid_str) |
| except ValueError: |
| - warn(u"Can't convert portid \"%s\" to an integer " |
| + warn("Can't convert portid \"%s\" to an integer " |
| "in host %s; skipping port." % ( |
| portid_str, self.current_host.format_name())) |
| return |
| - protocol = attrs.get(u"protocol") |
| + protocol = attrs.get("protocol") |
| if protocol is None: |
| - warn(u'%s element of host %s missing the "protocol" ' |
| + warn('%s element of host %s missing the "protocol" ' |
| 'attribute; skipping.' % ( |
| name, self.current_host.format_name())) |
| return |
| self.current_port = Port((portid, protocol)) |
| |
| def _start_state(self, name, attrs): |
| - assert self.parent_element() == u"port" |
| + assert self.parent_element() == "port" |
| assert self.current_host is not None |
| if self.current_port is None: |
| return |
| if "state" not in attrs: |
| - warn(u'%s element of port %s is missing the "state" ' |
| + warn('%s element of port %s is missing the "state" ' |
| 'attribute; assuming "unknown".' % ( |
| name, self.current_port.spec_string())) |
| return |
| - self.current_port.state = attrs[u"state"] |
| + self.current_port.state = attrs["state"] |
| self.current_host.add_port(self.current_port) |
| |
| def _start_service(self, name, attrs): |
| - assert self.parent_element() == u"port" |
| + assert self.parent_element() == "port" |
| assert self.current_host is not None |
| if self.current_port is None: |
| return |
| - self.current_port.service.name = attrs.get(u"name") |
| - self.current_port.service.product = attrs.get(u"product") |
| - self.current_port.service.version = attrs.get(u"version") |
| - self.current_port.service.extrainfo = attrs.get(u"extrainfo") |
| - self.current_port.service.tunnel = attrs.get(u"tunnel") |
| + self.current_port.service.name = attrs.get("name") |
| + self.current_port.service.product = attrs.get("product") |
| + self.current_port.service.version = attrs.get("version") |
| + self.current_port.service.extrainfo = attrs.get("extrainfo") |
| + self.current_port.service.tunnel = attrs.get("tunnel") |
| |
| def _start_script(self, name, attrs): |
| result = ScriptResult() |
| - result.id = attrs.get(u"id") |
| + result.id = attrs.get("id") |
| if result.id is None: |
| - warn(u'%s element missing the "id" attribute; skipping.' % name) |
| + warn('%s element missing the "id" attribute; skipping.' % name) |
| return |
| |
| - result.output = attrs.get(u"output") |
| + result.output = attrs.get("output") |
| if result.output is None: |
| - warn(u'%s element missing the "output" attribute; skipping.' |
| + warn('%s element missing the "output" attribute; skipping.' |
| % name) |
| return |
| - if self.parent_element() == u"prescript": |
| + if self.parent_element() == "prescript": |
| self.scan.pre_script_results.append(result) |
| - elif self.parent_element() == u"postscript": |
| + elif self.parent_element() == "postscript": |
| self.scan.post_script_results.append(result) |
| - elif self.parent_element() == u"hostscript": |
| + elif self.parent_element() == "hostscript": |
| self.current_host.script_results.append(result) |
| - elif self.parent_element() == u"port": |
| + elif self.parent_element() == "port": |
| self.current_port.script_results.append(result) |
| else: |
| - warn(u"%s element not inside prescript, postscript, hostscript, " |
| + warn("%s element not inside prescript, postscript, hostscript, " |
| "or port element; ignoring." % name) |
| return |
| |
| def _start_osmatch(self, name, attrs): |
| - assert self.parent_element() == u"os" |
| + assert self.parent_element() == "os" |
| assert self.current_host is not None |
| if "name" not in attrs: |
| - warn(u'%s element of host %s is missing the "name" ' |
| + warn('%s element of host %s is missing the "name" ' |
| 'attribute; skipping.' % ( |
| name, self.current_host.format_name())) |
| return |
| - self.current_host.os.append(attrs[u"name"]) |
| + self.current_host.os.append(attrs["name"]) |
| |
| def _start_finished(self, name, attrs): |
| - assert self.parent_element() == u"runstats" |
| + assert self.parent_element() == "runstats" |
| if "time" in attrs: |
| - end_timestamp = int(attrs.get(u"time")) |
| + end_timestamp = int(attrs.get("time")) |
| self.scan.end_date = datetime.datetime.fromtimestamp(end_timestamp) |
| |
| def _end_host(self, name): |
| @@ -1425,23 +1422,23 @@ class XMLWriter (xml.sax.saxutils.XMLGenerator): |
| |
| def frag(self, frag): |
| for node in frag.childNodes: |
| - node.writexml(self.f, newl=u"\n") |
| + node.writexml(self.f, newl="\n") |
| |
| def frag_a(self, frag): |
| - self.startElement(u"a", {}) |
| + self.startElement("a", {}) |
| for node in frag.childNodes: |
| - node.writexml(self.f, newl=u"\n") |
| - self.endElement(u"a") |
| + node.writexml(self.f, newl="\n") |
| + self.endElement("a") |
| |
| def frag_b(self, frag): |
| - self.startElement(u"b", {}) |
| + self.startElement("b", {}) |
| for node in frag.childNodes: |
| - node.writexml(self.f, newl=u"\n") |
| - self.endElement(u"b") |
| + node.writexml(self.f, newl="\n") |
| + self.endElement("b") |
| |
| |
| def usage(): |
| - print u"""\ |
| + print("""\ |
| Usage: %s [option] FILE1 FILE2 |
| Compare two Nmap XML files and display a list of their differences. |
| Differences include host state changes, port state changes, and changes to |
| @@ -1451,7 +1448,7 @@ service and OS detection. |
| -v, --verbose also show hosts and ports that haven't changed. |
| --text display output in text format (default) |
| --xml display output in XML format\ |
| -""" % sys.argv[0] |
| +""" % sys.argv[0]) |
| |
| EXIT_EQUAL = 0 |
| EXIT_DIFFERENT = 1 |
| @@ -1459,8 +1456,8 @@ EXIT_ERROR = 2 |
| |
| |
| def usage_error(msg): |
| - print >> sys.stderr, u"%s: %s" % (sys.argv[0], msg) |
| - print >> sys.stderr, u"Try '%s -h' for help." % sys.argv[0] |
| + print("%s: %s" % (sys.argv[0], msg), file=sys.stderr) |
| + print("Try '%s -h' for help." % sys.argv[0], file=sys.stderr) |
| sys.exit(EXIT_ERROR) |
| |
| |
| @@ -1471,7 +1468,7 @@ def main(): |
| try: |
| opts, input_filenames = getopt.gnu_getopt( |
| sys.argv[1:], "hv", ["help", "text", "verbose", "xml"]) |
| - except getopt.GetoptError, e: |
| + except getopt.GetoptError as e: |
| usage_error(e.msg) |
| for o, a in opts: |
| if o == "-h" or o == "--help": |
| @@ -1481,15 +1478,15 @@ def main(): |
| verbose = True |
| elif o == "--text": |
| if output_format is not None and output_format != "text": |
| - usage_error(u"contradictory output format options.") |
| + usage_error("contradictory output format options.") |
| output_format = "text" |
| elif o == "--xml": |
| if output_format is not None and output_format != "xml": |
| - usage_error(u"contradictory output format options.") |
| + usage_error("contradictory output format options.") |
| output_format = "xml" |
| |
| if len(input_filenames) != 2: |
| - usage_error(u"need exactly two input filenames.") |
| + usage_error("need exactly two input filenames.") |
| |
| if output_format is None: |
| output_format = "text" |
| @@ -1502,8 +1499,8 @@ def main(): |
| scan_a.load_from_file(filename_a) |
| scan_b = Scan() |
| scan_b.load_from_file(filename_b) |
| - except IOError, e: |
| - print >> sys.stderr, u"Can't open file: %s" % str(e) |
| + except IOError as e: |
| + print("Can't open file: %s" % str(e), file=sys.stderr) |
| sys.exit(EXIT_ERROR) |
| |
| if output_format == "text": |
| diff --git a/ndiff/ndifftest.py b/ndiff/ndifftest.py |
| index 2fa4ae0..27fc525 100755 |
| --- a/ndiff/ndifftest.py |
| +++ b/ndiff/ndifftest.py |
| @@ -1,4 +1,4 @@ |
| -#!/usr/bin/env python |
| +#!/usr/bin/env python3 |
| |
| # Unit tests for Ndiff. |
| |
| @@ -22,7 +22,7 @@ for x in dir(ndiff): |
| sys.dont_write_bytecode = dont_write_bytecode |
| del dont_write_bytecode |
| |
| -import StringIO |
| +import io |
| |
| |
| class scan_test(unittest.TestCase): |
| @@ -52,7 +52,7 @@ class scan_test(unittest.TestCase): |
| scan.load_from_file("test-scans/single.xml") |
| host = scan.hosts[0] |
| self.assertEqual(len(host.ports), 5) |
| - self.assertEqual(host.extraports.items(), [("filtered", 95)]) |
| + self.assertEqual(list(host.extraports.items()), [("filtered", 95)]) |
| |
| def test_extraports_multi(self): |
| """Test that the correct number of known ports is returned when there |
| @@ -68,9 +68,9 @@ class scan_test(unittest.TestCase): |
| """Test that nmaprun information is recorded.""" |
| scan = Scan() |
| scan.load_from_file("test-scans/empty.xml") |
| - self.assertEqual(scan.scanner, u"nmap") |
| - self.assertEqual(scan.version, u"4.90RC2") |
| - self.assertEqual(scan.args, u"nmap -oX empty.xml -p 1-100") |
| + self.assertEqual(scan.scanner, "nmap") |
| + self.assertEqual(scan.version, "4.90RC2") |
| + self.assertEqual(scan.args, "nmap -oX empty.xml -p 1-100") |
| |
| def test_addresses(self): |
| """Test that addresses are recorded.""" |
| @@ -84,7 +84,7 @@ class scan_test(unittest.TestCase): |
| scan = Scan() |
| scan.load_from_file("test-scans/simple.xml") |
| host = scan.hosts[0] |
| - self.assertEqual(host.hostnames, [u"scanme.nmap.org"]) |
| + self.assertEqual(host.hostnames, ["scanme.nmap.org"]) |
| |
| def test_os(self): |
| """Test that OS information is recorded.""" |
| @@ -99,7 +99,7 @@ class scan_test(unittest.TestCase): |
| scan.load_from_file("test-scans/complex.xml") |
| host = scan.hosts[0] |
| self.assertTrue(len(host.script_results) > 0) |
| - self.assertTrue(len(host.ports[(22, u"tcp")].script_results) > 0) |
| + self.assertTrue(len(host.ports[(22, "tcp")].script_results) > 0) |
| |
| # This test is commented out because Nmap XML doesn't store any information |
| # about down hosts, not even the fact that they are down. Recovering the list |
| @@ -128,16 +128,16 @@ class host_test(unittest.TestCase): |
| |
| def test_format_name(self): |
| h = Host() |
| - self.assertTrue(isinstance(h.format_name(), basestring)) |
| - h.add_address(IPv4Address(u"127.0.0.1")) |
| - self.assertTrue(u"127.0.0.1" in h.format_name()) |
| + self.assertTrue(isinstance(h.format_name(), str)) |
| + h.add_address(IPv4Address("127.0.0.1")) |
| + self.assertTrue("127.0.0.1" in h.format_name()) |
| h.add_address(IPv6Address("::1")) |
| - self.assertTrue(u"127.0.0.1" in h.format_name()) |
| - self.assertTrue(u"::1" in h.format_name()) |
| - h.add_hostname(u"localhost") |
| - self.assertTrue(u"127.0.0.1" in h.format_name()) |
| - self.assertTrue(u"::1" in h.format_name()) |
| - self.assertTrue(u"localhost" in h.format_name()) |
| + self.assertTrue("127.0.0.1" in h.format_name()) |
| + self.assertTrue("::1" in h.format_name()) |
| + h.add_hostname("localhost") |
| + self.assertTrue("127.0.0.1" in h.format_name()) |
| + self.assertTrue("::1" in h.format_name()) |
| + self.assertTrue("localhost" in h.format_name()) |
| |
| def test_empty_get_port(self): |
| h = Host() |
| @@ -197,8 +197,8 @@ class host_test(unittest.TestCase): |
| h = s.hosts[0] |
| self.assertEqual(len(h.ports), 5) |
| self.assertEqual(len(h.extraports), 1) |
| - self.assertEqual(h.extraports.keys()[0], u"filtered") |
| - self.assertEqual(h.extraports.values()[0], 95) |
| + self.assertEqual(list(h.extraports.keys())[0], "filtered") |
| + self.assertEqual(list(h.extraports.values())[0], 95) |
| self.assertEqual(h.state, "up") |
| |
| |
| @@ -241,13 +241,13 @@ class port_test(unittest.TestCase): |
| """Test the Port class.""" |
| def test_spec_string(self): |
| p = Port((10, "tcp")) |
| - self.assertEqual(p.spec_string(), u"10/tcp") |
| + self.assertEqual(p.spec_string(), "10/tcp") |
| p = Port((100, "ip")) |
| - self.assertEqual(p.spec_string(), u"100/ip") |
| + self.assertEqual(p.spec_string(), "100/ip") |
| |
| def test_state_string(self): |
| p = Port((10, "tcp")) |
| - self.assertEqual(p.state_string(), u"unknown") |
| + self.assertEqual(p.state_string(), "unknown") |
| |
| |
| class service_test(unittest.TestCase): |
| @@ -255,47 +255,47 @@ class service_test(unittest.TestCase): |
| def test_compare(self): |
| """Test that services with the same contents compare equal.""" |
| a = Service() |
| - a.name = u"ftp" |
| - a.product = u"FooBar FTP" |
| - a.version = u"1.1.1" |
| - a.tunnel = u"ssl" |
| + a.name = "ftp" |
| + a.product = "FooBar FTP" |
| + a.version = "1.1.1" |
| + a.tunnel = "ssl" |
| self.assertEqual(a, a) |
| b = Service() |
| - b.name = u"ftp" |
| - b.product = u"FooBar FTP" |
| - b.version = u"1.1.1" |
| - b.tunnel = u"ssl" |
| + b.name = "ftp" |
| + b.product = "FooBar FTP" |
| + b.version = "1.1.1" |
| + b.tunnel = "ssl" |
| self.assertEqual(a, b) |
| - b.name = u"http" |
| + b.name = "http" |
| self.assertNotEqual(a, b) |
| c = Service() |
| self.assertNotEqual(a, c) |
| |
| def test_tunnel(self): |
| serv = Service() |
| - serv.name = u"http" |
| - serv.tunnel = u"ssl" |
| - self.assertEqual(serv.name_string(), u"ssl/http") |
| + serv.name = "http" |
| + serv.tunnel = "ssl" |
| + self.assertEqual(serv.name_string(), "ssl/http") |
| |
| def test_version_string(self): |
| serv = Service() |
| - serv.product = u"FooBar" |
| + serv.product = "FooBar" |
| self.assertTrue(len(serv.version_string()) > 0) |
| serv = Service() |
| - serv.version = u"1.2.3" |
| + serv.version = "1.2.3" |
| self.assertTrue(len(serv.version_string()) > 0) |
| serv = Service() |
| - serv.extrainfo = u"misconfigured" |
| + serv.extrainfo = "misconfigured" |
| self.assertTrue(len(serv.version_string()) > 0) |
| serv = Service() |
| - serv.product = u"FooBar" |
| - serv.version = u"1.2.3" |
| + serv.product = "FooBar" |
| + serv.version = "1.2.3" |
| # Must match Nmap output. |
| self.assertEqual(serv.version_string(), |
| - u"%s %s" % (serv.product, serv.version)) |
| - serv.extrainfo = u"misconfigured" |
| + "%s %s" % (serv.product, serv.version)) |
| + serv.extrainfo = "misconfigured" |
| self.assertEqual(serv.version_string(), |
| - u"%s %s (%s)" % (serv.product, serv.version, serv.extrainfo)) |
| + "%s %s (%s)" % (serv.product, serv.version, serv.extrainfo)) |
| |
| |
| class ScanDiffSub(ScanDiff): |
| @@ -703,7 +703,7 @@ class scan_diff_xml_test(unittest.TestCase): |
| a.load_from_file("test-scans/empty.xml") |
| b = Scan() |
| b.load_from_file("test-scans/simple.xml") |
| - f = StringIO.StringIO() |
| + f = io.StringIO() |
| self.scan_diff = ScanDiffXML(a, b, f) |
| self.scan_diff.output() |
| self.xml = f.getvalue() |
| @@ -712,8 +712,8 @@ class scan_diff_xml_test(unittest.TestCase): |
| def test_well_formed(self): |
| try: |
| document = xml.dom.minidom.parseString(self.xml) |
| - except Exception, e: |
| - self.fail(u"Parsing XML diff output caused the exception: %s" |
| + except Exception as e: |
| + self.fail("Parsing XML diff output caused the exception: %s" |
| % str(e)) |
| |
| |
| @@ -739,8 +739,8 @@ def host_apply_diff(host, diff): |
| host.os = diff.host_b.os[:] |
| |
| if diff.extraports_changed: |
| - for state in host.extraports.keys(): |
| - for port in host.ports.values(): |
| + for state in list(host.extraports.keys()): |
| + for port in list(host.ports.values()): |
| if port.state == state: |
| del host.ports[port.spec] |
| host.extraports = diff.host_b.extraports.copy() |
| diff --git a/ndiff/scripts/ndiff b/ndiff/scripts/ndiff |
| index 8517c07..4671e73 100755 |
| --- a/ndiff/scripts/ndiff |
| +++ b/ndiff/scripts/ndiff |
| @@ -1,4 +1,4 @@ |
| -#!/usr/bin/env python |
| +#!/usr/bin/env python3 |
| |
| # Ndiff |
| # |
| @@ -67,15 +67,15 @@ if INSTALL_LIB is not None and is_secure_dir(INSTALL_LIB): |
| |
| try: |
| import ndiff |
| -except ImportError, e: |
| - print >> sys.stderr, """\ |
| +except ImportError as e: |
| + print("""\ |
| Could not import the ndiff module: %s. |
| -I checked in these directories:""" % repr(e.message) |
| +I checked in these directories:""" % repr(e), file=sys.stderr) |
| for dir in sys.path: |
| - print >> sys.stderr, " %s" % dir |
| - print >> sys.stderr, """\ |
| + print(" %s" % dir, file=sys.stderr) |
| + print("""\ |
| If you installed Ndiff in another directory, you may have to add the |
| -modules directory to the PYTHONPATH environment variable.""" |
| +modules directory to the PYTHONPATH environment variable.""", file=sys.stderr) |
| sys.exit(1) |
| |
| import ndiff |
| diff --git a/ndiff/setup.py b/ndiff/setup.py |
| old mode 100644 |
| new mode 100755 |
| index b5e254c..c49bcf3 |
| --- a/ndiff/setup.py |
| +++ b/ndiff/setup.py |
| @@ -94,7 +94,7 @@ class checked_install(distutils.command.install.install): |
| self.saved_prefix = sys.prefix |
| try: |
| distutils.command.install.install.finalize_options(self) |
| - except distutils.errors.DistutilsPlatformError, e: |
| + except distutils.errors.DistutilsPlatformError as e: |
| raise distutils.errors.DistutilsPlatformError(str(e) + """ |
| Installing your distribution's python-dev package may solve this problem.""") |
| |
| @@ -155,13 +155,13 @@ Installing your distribution's python-dev package may solve this problem.""") |
| #!/usr/bin/env python |
| import errno, os, os.path, sys |
| |
| -print 'Uninstall %(name)s' |
| +print('Uninstall %(name)s') |
| |
| answer = raw_input('Are you sure that you want to uninstall ' |
| '%(name)s (yes/no) ') |
| |
| if answer != 'yes' and answer != 'y': |
| - print 'Not uninstalling.' |
| + print('Not uninstalling.') |
| sys.exit(0) |
| |
| """ % {'name': APP_NAME} |
| @@ -177,8 +177,8 @@ if answer != 'yes' and answer != 'y': |
| # This should never happen (everything gets installed |
| # inside the root), but if it does, be safe and don't |
| # delete anything. |
| - uninstaller += ("print '%s was not installed inside " |
| - "the root %s; skipping.'\n" % (output, self.root)) |
| + uninstaller += ("print('%s was not installed inside " |
| + "the root %s; skipping.')\n" % (output, self.root)) |
| continue |
| output = path_strip_prefix(output, self.root) |
| assert os.path.isabs(output) |
| @@ -202,24 +202,24 @@ for path in INSTALLED_FILES: |
| dirs.append(path) |
| # Delete the files. |
| for file in files: |
| - print "Removing '%s'." % file |
| + print("Removing '%s'." % file) |
| try: |
| os.remove(file) |
| - except OSError, e: |
| - print >> sys.stderr, ' Error: %s.' % str(e) |
| + except OSError as e: |
| + print(' Error: %s.' % str(e), file=sys.stderr) |
| # Delete the directories. First reverse-sort the normalized paths by |
| # length so that child directories are deleted before their parents. |
| dirs = [os.path.normpath(dir) for dir in dirs] |
| dirs.sort(key = len, reverse = True) |
| for dir in dirs: |
| try: |
| - print "Removing the directory '%s'." % dir |
| + print("Removing the directory '%s'." % dir) |
| os.rmdir(dir) |
| - except OSError, e: |
| + except OSError as e: |
| if e.errno == errno.ENOTEMPTY: |
| - print "Directory '%s' not empty; not removing." % dir |
| + print("Directory '%s' not empty; not removing." % dir) |
| else: |
| - print >> sys.stderr, str(e) |
| + print(str(e), file=sys.stderr) |
| """ |
| |
| uninstaller_file = open(uninstaller_filename, 'w') |
| @@ -227,7 +227,7 @@ for dir in dirs: |
| uninstaller_file.close() |
| |
| # Set exec bit for uninstaller |
| - mode = ((os.stat(uninstaller_filename)[ST_MODE]) | 0555) & 07777 |
| + mode = ((os.stat(uninstaller_filename)[ST_MODE]) | 0o555) & 0o7777 |
| os.chmod(uninstaller_filename, mode) |
| |
| def write_installed_files(self): |
| @@ -242,7 +242,7 @@ for dir in dirs: |
| try: |
| for output in self.get_installed_files(): |
| assert "\n" not in output |
| - print >> f, output |
| + print(output, file=f) |
| finally: |
| f.close() |
| |
| @@ -266,7 +266,7 @@ class my_uninstall(distutils.cmd.Command): |
| # Read the list of installed files. |
| try: |
| f = open(INSTALLED_FILES_NAME, "r") |
| - except IOError, e: |
| + except IOError as e: |
| if e.errno == errno.ENOENT: |
| log.error("Couldn't open the installation record '%s'. " |
| "Have you installed yet?" % INSTALLED_FILES_NAME) |
| @@ -289,7 +289,7 @@ class my_uninstall(distutils.cmd.Command): |
| try: |
| if not self.dry_run: |
| os.remove(file) |
| - except OSError, e: |
| + except OSError as e: |
| log.error(str(e)) |
| # Delete the directories. First reverse-sort the normalized paths by |
| # length so that child directories are deleted before their parents. |
| @@ -300,7 +300,7 @@ class my_uninstall(distutils.cmd.Command): |
| log.info("Removing the directory '%s'." % dir) |
| if not self.dry_run: |
| os.rmdir(dir) |
| - except OSError, e: |
| + except OSError as e: |
| if e.errno == errno.ENOTEMPTY: |
| log.info("Directory '%s' not empty; not removing." % dir) |
| else: |
| diff --git a/ndiff/test-scans/anonymize.py b/ndiff/test-scans/anonymize.py |
| index 9ba612a..fd251fe 100755 |
| --- a/ndiff/test-scans/anonymize.py |
| +++ b/ndiff/test-scans/anonymize.py |
| @@ -1,4 +1,4 @@ |
| -#!/usr/bin/env python |
| +#!/usr/bin/env python3 |
| |
| # Anonymize an Nmap XML file, replacing host name and IP addresses with random |
| # anonymous ones. Anonymized names will be consistent between runs of the |
| @@ -20,20 +20,20 @@ r = random.Random() |
| |
| |
| def hash(s): |
| - digest = hashlib.sha512(s).hexdigest() |
| + digest = hashlib.sha512(s.encode()).hexdigest() |
| return int(digest, 16) |
| |
| |
| def anonymize_mac_address(addr): |
| r.seed(hash(addr)) |
| nums = (0, 0, 0) + tuple(r.randrange(256) for i in range(3)) |
| - return u":".join(u"%02X" % x for x in nums) |
| + return ":".join("%02X" % x for x in nums) |
| |
| |
| def anonymize_ipv4_address(addr): |
| r.seed(hash(addr)) |
| nums = (10,) + tuple(r.randrange(256) for i in range(3)) |
| - return u".".join(unicode(x) for x in nums) |
| + return ".".join(str(x) for x in nums) |
| |
| |
| def anonymize_ipv6_address(addr): |
| @@ -41,7 +41,7 @@ def anonymize_ipv6_address(addr): |
| # RFC 4193. |
| nums = (0xFD00 + r.randrange(256),) |
| nums = nums + tuple(r.randrange(65536) for i in range(7)) |
| - return u":".join("%04X" % x for x in nums) |
| + return ":".join("%04X" % x for x in nums) |
| |
| # Maps to memoize address and host name conversions. |
| hostname_map = {} |
| @@ -54,11 +54,11 @@ def anonymize_hostname(name): |
| LETTERS = "acbdefghijklmnopqrstuvwxyz" |
| r.seed(hash(name)) |
| length = r.randrange(5, 10) |
| - prefix = u"".join(r.sample(LETTERS, length)) |
| + prefix = "".join(r.sample(LETTERS, length)) |
| num = r.randrange(1000) |
| - hostname_map[name] = u"%s-%d.example.com" % (prefix, num) |
| + hostname_map[name] = "%s-%d.example.com" % (prefix, num) |
| if VERBOSE: |
| - print >> sys.stderr, "Replace %s with %s" % (name, hostname_map[name]) |
| + print("Replace %s with %s" % (name, hostname_map[name]), file=sys.stderr) |
| return hostname_map[name] |
| |
| mac_re = re.compile(r'\b([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}\b') |
| @@ -78,7 +78,7 @@ def anonymize_address(addr): |
| else: |
| assert False |
| if VERBOSE: |
| - print >> sys.stderr, "Replace %s with %s" % (addr, address_map[addr]) |
| + print("Replace %s with %s" % (addr, address_map[addr]), file=sys.stderr) |
| return address_map[addr] |
| |
| |
| -- |
| 2.24.1 |
| |