Attachment #603560 for bug #702288

Lines 4-10 compiler: Link Here

(-)a/.travis.yml (-1 / +7 lines)
4	- clang	4	- clang
5	# Change this to your needs	5	# Change this to your needs
6	sudo: false	6	sudo: false
7	script: mkdir /tmp/n && ./configure $SSL_FLAG $LUA_FLAG --prefix=/tmp/n && make && make check && make install && /tmp/n/bin/nmap -A localhost	7	script:
		8	- "mkdir /tmp/n"
		9	- "./configure $SSL_FLAG $LUA_FLAG --prefix=/tmp/n"
		10	- "make"
		11	- "make check"
		12	- "make install"
		13	- "/tmp/n/bin/nmap -A localhost"
8		14
9	env:	15	env:
10	- SSL_FLAG="--without-openssl" LUA_FLAG="--without-liblua"	16	- SSL_FLAG="--without-openssl" LUA_FLAG="--without-liblua"




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

# 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

	ln -sf zenmap $(DESTDIR)$(bindir)/xnmap

build-ndiff:
	cd $(NDIFFDIR) && $(PYTHON) 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)

	@cd $(NCATDIR) && $(MAKE) check

check-ndiff:
	@cd $(NDIFFDIR) && $(PYTHON3) ndifftest.py

check-nsock:
	@cd $(NSOCKDIR)/src && $(MAKE) check




#!/usr/bin/env python3

# Ndiff
#

import xml.sax
import xml.sax.saxutils
import xml.dom.minidom
from io import StringIO

verbose = False

NDIFF_XML_VERSION = "1"


class OverrideEntityResolver(xml.sax.handler.EntityResolver):

    def write_nmaprun_open(self, writer):
        attrs = {}
        if self.scanner is not None:
            attrs["scanner"] = self.scanner
        if self.args is not None:
            attrs["args"] = self.args
        if self.start_date is not None:
            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["version"] = self.version
        writer.startElement("nmaprun", attrs)

    def write_nmaprun_close(self, writer):
        writer.endElement("nmaprun")

    def nmaprun_to_dom_fragment(self, document):
        frag = document.createDocumentFragment()
        elem = document.createElement("nmaprun")
        if self.scanner is not None:
            elem.setAttribute("scanner", self.scanner)
        if self.args is not None:
            elem.setAttribute("args", self.args)
        if self.start_date is not None:
            elem.setAttribute(
                    "start", "%d" % time.mktime(self.start_date.timetuple()))
            elem.setAttribute(
                    "startstr",
                    self.start_date.strftime("%a %b %d %H:%M:%S %Y"))
        if self.version is not None:
            elem.setAttribute("version", self.version)
        frag.appendChild(elem)
        return frag



    def format_name(self):
        """Return a human-readable identifier for this host."""
        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 "%s (%s)" % (hostname_s, address_s)
            else:
                return hostname_s
        elif len(address_s) > 0:
            return address_s
        else:
            return "<no name>"

    def add_port(self, port):
        self.ports[port.spec] = port

        return state is None or state in self.extraports

    def extraports_string(self):
        locallist = [(count, state) for (state, count) in list(self.extraports.items())]
        # Reverse-sort by count.
        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("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("hostname")
        elem.setAttribute("name", hostname)
        frag.appendChild(elem)
        return frag

    def extraports_to_dom_fragment(self, document):
        frag = document.createDocumentFragment()
        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("osmatch")
        elem.setAttribute("name", os)
        frag.appendChild(elem)
        return frag

    def to_dom_fragment(self, document):
        frag = document.createDocumentFragment()
        elem = document.createElement("host")

        if self.state is not None:
            elem.appendChild(self.state_to_dom_fragment(document))

            elem.appendChild(addr.to_dom_fragment(document))

        if len(self.hostnames) > 0:
            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("ports")
        ports_elem.appendChild(self.extraports_to_dom_fragment(document))
        for port in sorted(self.ports.values()):
            if not self.is_extraports(port.state):

            elem.appendChild(ports_elem)

        if len(self.os) > 0:
            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("hostscript")
            for sr in self.script_results:
                hostscript_elem.appendChild(sr.to_dom_fragment(document))
            elem.appendChild(hostscript_elem)

        self.s = s

    def __eq__(self, other):
        return self.sort_key() == other.sort_key()

    def __ne__(self, other):
        return not self.__eq__(other)

    def __hash__(self):
        return hash(self.sort_key())

    def __lt__(self, other):
        return self.sort_key() < other.sort_key()

    def __str__(self):
        return str(self.s)

        return self.s

    def new(type, s):
        if type == "ipv4":
            return IPv4Address(s)
        elif type == "ipv6":
            return IPv6Address(s)
        elif type == "mac":
            return MACAddress(s)
        else:
            raise ValueError("Unknown address type %s." % type)
    new = staticmethod(new)

    def to_dom_fragment(self, document):
        frag = document.createDocumentFragment()
        elem = document.createElement("address")
        elem.setAttribute("addr", self.s)
        elem.setAttribute("addrtype", self.type)
        frag.appendChild(elem)
        return frag




class IPv4Address(Address):
    type = property(lambda self: "ipv4")

    def sort_key(self):
        return (0, self.s)


class IPv6Address(Address):
    type = property(lambda self: "ipv6")

    def sort_key(self):
        return (1, self.s)


class MACAddress(Address):
    type = property(lambda self: "mac")

    def sort_key(self):
        return (2, self.s)


    def state_string(self):
        if self.state is None:
            return "unknown"
        else:
            return str(self.state)

    def spec_string(self):
        return "%d/%s" % self.spec

    def __lt__(self, other):
        return (self.spec, self.service, self.script_results) < (
            other.spec, other.service, other.script_results)
            return d
        return cmp((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("port")
        elem.setAttribute("portid", str(self.spec[0]))
        elem.setAttribute("protocol", self.spec[1])
        if self.state is not None:
            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:

        if len(parts) == 0:
            return None
        else:
            return "/".join(parts)

    def version_string(self):
        """Get a string like in the VERSION column of Nmap output."""

        if self.version is not None:
            parts.append(self.version)
        if self.extrainfo is not None:
            parts.append("(%s)" % self.extrainfo)

        if len(parts) == 0:
            return None
        else:
            return " ".join(parts)

    def to_dom_fragment(self, document):
        frag = document.createDocumentFragment()
        elem = document.createElement("service")
        for attr in ("name", "product", "version", "extrainfo", "tunnel"):
            v = getattr(self, attr)
            if v is None:
                continue

        result = []
        lines = self.output.splitlines()
        if len(lines) > 0:
            lines[0] = self.id + ": " + lines[0]
        for line in lines[:-1]:
            result.append("|  " + line)
        if len(lines) > 0:
            result.append("|_ " + lines[-1])
        return result

    def to_dom_fragment(self, document):
        frag = document.createDocumentFragment()
        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 = "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("scan")
    if scan.start_date is not None:
        parts.append("initiated %s" % scan.start_date.strftime(
            "%a %b %d %H:%M:%S %Y"))
    if scan.args is not None:
        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("*")
    for sr_diff in script_result_diffs:
        sr_diff.append_to_port_table(table)
    if len(table) > 0:
        print(file=f)
        if len(script_results_b) == 0:
            print("-%s:" % title, file=f)
        elif len(script_results_a) == 0:
            print("+%s:" % title, file=f)
        else:
            print(" %s:" % title, file=f)
        print(table, file=f)


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("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("b")
        for sr in script_results_b:
            elem.appendChild(sr.to_dom_fragment(document))
        b_elem.appendChild(elem)

        banner_a = format_banner(self.scan_a)
        banner_b = format_banner(self.scan_b)
        if banner_a != banner_b:
            print("-%s" % banner_a, file=self.f)
            print("+%s" % banner_b, file=self.f)
        elif verbose:
            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",

            post_script_result_diffs, self.f)

    def output_host_diff(self, h_diff):
        print(file=self.f)
        h_diff.print_text(self.f)

    def output_ending(self):


    def output_beginning(self):
        self.writer.startDocument()
        self.writer.startElement("nmapdiff", {"version": NDIFF_XML_VERSION})
        self.writer.startElement("scandiff", {})

        if self.nmaprun_differs():
            self.writer.frag_a(


    def output_pre_scripts(self, pre_script_result_diffs):
        if len(pre_script_result_diffs) > 0 or verbose:
            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,


    def output_post_scripts(self, post_script_result_diffs):
        if len(post_script_result_diffs) > 0 or verbose:
            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,

        frag.unlink()

    def output_ending(self):
        self.writer.endElement("scandiff")
        self.writer.endElement("nmapdiff")
        self.writer.endDocument()



        self.cost += os_cost

        extraports_a = tuple((count, state)
                for (state, count) in list(self.host_a.extraports.items()))
        extraports_b = tuple((count, state)
                for (state, count) in list(self.host_b.extraports.items()))
        if extraports_a != extraports_b:
            self.extraports_changed = True
            self.cost += 1

        # Names and addresses.
        if self.id_changed:
            if host_a.state is not None:
                print("-%s:" % host_a.format_name(), file=f)
            if self.host_b.state is not None:
                print("+%s:" % host_b.format_name(), file=f)
        else:
            print(" %s:" % host_a.format_name(), file=f)

        # State.
        if self.state_changed:
            if host_a.state is not None:
                print("-Host is %s." % host_a.state, file=f)
            if host_b.state is not None:
                print("+Host is %s." % host_b.state, file=f)
        elif verbose:
            print(" Host is %s." % host_b.state, file=f)

        # Extraports.
        if self.extraports_changed:
            if len(host_a.extraports) > 0:
                print("-Not shown: %s" % host_a.extraports_string(), file=f)
            if len(host_b.extraports) > 0:
                print("+Not shown: %s" % host_b.extraports_string(), file=f)
        elif verbose:
            if len(host_a.extraports) > 0:
                print(" Not shown: %s" % host_a.extraports_string(), file=f)

        # Port table.
        port_table = Table("** * * *")
        if host_a.state is None:
            mark = "+"
        elif host_b.state is None:
            mark = "-"
        else:
            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(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(" OS details:", file=f)
                else:
                    print("-OS details:", file=f)
            elif len(host_b.os) > 0:
                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("-  %s" % host_a.os[i], file=f)
                if op == "replace" or op == "insert":
                    for i in range(j1, j2):
                        print("+  %s" % host_b.os[i], file=f)
                if op == "equal":
                    for i in range(i1, i2):
                        print("   %s" % host_a.os[i], file=f)

        print_script_result_diffs_text("Host script results",
            host_a.script_results, host_b.script_results,

        host_b = self.host_b

        frag = document.createDocumentFragment()
        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("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("b")
                b_elem.appendChild(host_b.to_dom_fragment(document))
                hostdiff_elem.appendChild(b_elem)
            return frag

        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("a")
            a_elem.appendChild(host_a.state_to_dom_fragment(document))
            host_elem.appendChild(a_elem)
            b_elem = document.createElement("b")
            b_elem.appendChild(host_b.state_to_dom_fragment(document))
            host_elem.appendChild(b_elem)


        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("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("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("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("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("b")
        for hostname in sorted(hostnameset_b - hostnameset_a):
            b_elem.appendChild(
                    host_b.hostname_to_dom_fragment(document, hostname))

        if hostnames_elem.hasChildNodes():
            host_elem.appendChild(hostnames_elem)

        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("a")
            a_elem.appendChild(host_a.extraports_to_dom_fragment(document))
            ports_elem.appendChild(a_elem)
            b_elem = document.createElement("b")
            b_elem.appendChild(host_b.extraports_to_dom_fragment(document))
            ports_elem.appendChild(b_elem)
        # Port list.


        # OS changes.
        if self.os_changed or verbose:
            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("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("b")
                    for i in range(j1, j2):
                        b_elem.appendChild(host_b.os_to_dom_fragment(
                            document, host_b.os[i]))


        # Host script changes.
        if len(self.script_result_diffs) > 0 or verbose:
            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,

            self.port_b.service.version_string()]
        if a_columns == b_columns:
            if verbose or self.script_result_diffs > 0:
                table.append([" "] + a_columns)
        else:
            if not host_a.is_extraports(self.port_a.state):
                table.append(["-"] + a_columns)
            if not host_b.is_extraports(self.port_b.state):
                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("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("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("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("a")
                a_elem.appendChild(
                        self.port_a.service.to_dom_fragment(document))
                port_elem.appendChild(a_elem)
                b_elem = document.createElement("b")
                b_elem.appendChild(
                        self.port_b.service.to_dom_fragment(document))
                port_elem.appendChild(b_elem)

                port_elem.appendChild(sr_diff.to_dom_fragment(document))
            portdiff_elem.appendChild(port_elem)
        else:
            a_elem = document.createElement("a")
            a_elem.appendChild(self.port_a.to_dom_fragment(document))
            portdiff_elem.appendChild(a_elem)
            b_elem = document.createElement("b")
            b_elem.appendChild(self.port_b.to_dom_fragment(document))
            portdiff_elem.appendChild(b_elem)


            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("-" + a_lines[k])
                if op == "replace" or op == "insert":
                    for k in range(j1, j2):
                        table.append_raw("+" + b_lines[k])
                if op == "equal":
                    for k in range(i1, i2):
                        table.append_raw(" " + a_lines[k])

    def to_dom_fragment(self, document):
        frag = document.createDocumentFragment()

            frag.appendChild(self.sr_a.to_dom_fragment(document))
        else:
            if self.sr_a is not None:
                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("b")
                b_elem.appendChild(self.sr_b.to_dom_fragment(document))
                frag.appendChild(b_elem)
        return frag

        copied to the output."""
        self.widths = []
        self.rows = []
        self.prefix = ""
        self.padding = []
        j = 0
        while j < len(template) and template[j] != "*":


        for i in range(len(row)):
            if row[i] is None:
                s = ""
            else:
                s = str(row[i])
            if i == len(self.widths):

        for row in self.rows:
            parts = [self.prefix]
            i = 0
            if isinstance(row, str):
                # A raw string.
                lines.append(row)
            else:

                    if i < len(self.padding):
                        parts.append(self.padding[i])
                    i += 1
                lines.append("".join(parts).rstrip())
        return "\n".join(lines)


def warn(str):
    """Print a warning to stderr."""
    print(str, file=sys.stderr)


class NmapContentHandler(xml.sax.handler.ContentHandler):

        self.current_port = None

        self._start_elem_handlers = {
            "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 = {
            'host': self._end_host,
            'port': self._end_port,
        }

    def parent_element(self):

    def _start_nmaprun(self, name, attrs):
        assert self.parent_element() is None
        if "start" in attrs:
            start_timestamp = int(attrs.get("start"))
            self.scan.start_date = datetime.datetime.fromtimestamp(
                    start_timestamp)
        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() == "nmaprun"
        self.current_host = Host()
        self.scan.hosts.append(self.current_host)

    def _start_status(self, name, attrs):
        assert self.parent_element() == "host"
        assert self.current_host is not None
        state = attrs.get("state")
        if state is None:
            warn(u'%s element of host %s is missing the "state" attribute; '
                    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() == "host"
        assert self.current_host is not None
        addr = attrs.get("addr")
        if addr is None:
            warn('%s element of host %s is missing the "addr" '
                    'attribute; skipping.' % (
                        name, self.current_host.format_name()))
            return
        addrtype = attrs.get("addrtype", "ipv4")
        self.current_host.add_address(Address.new(addrtype, addr))

    def _start_hostname(self, name, attrs):
        assert self.parent_element() == "hostnames"
        assert self.current_host is not None
        hostname = attrs.get("name")
        if hostname is None:
            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() == "ports"
        assert self.current_host is not None
        state = attrs.get("state")
        if state is None:
            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('Duplicate extraports state "%s" in host %s.' % (
                state, self.current_host.format_name()))

        count = attrs.get("count")
        if count is None:
            warn('%s element of host %s is missing the "count" '
                    'attribute; assuming 0.' % (
                        name, self.current_host.format_name()))
            count = 0

            try:
                count = int(count)
            except ValueError:
                warn("Can't convert extraports count \"%s\" "
                        "to an integer in host %s; assuming 0." % (
                            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() == "ports"
        assert self.current_host is not None
        portid_str = attrs.get("portid")
        if portid_str is None:
            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("Can't convert portid \"%s\" to an integer "
                    "in host %s; skipping port." % (
                        portid_str, self.current_host.format_name()))
            return
        protocol = attrs.get("protocol")
        if protocol is None:
            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() == "port"
        assert self.current_host is not None
        if self.current_port is None:
            return
        if "state" not in attrs:
            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["state"]
        self.current_host.add_port(self.current_port)

    def _start_service(self, name, attrs):
        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("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("id")
        if result.id is None:
            warn('%s element missing the "id" attribute; skipping.' % name)
            return

        result.output = attrs.get("output")
        if result.output is None:
            warn('%s element missing the "output" attribute; skipping.'
                    % name)
            return
        if self.parent_element() == "prescript":
            self.scan.pre_script_results.append(result)
        elif self.parent_element() == "postscript":
            self.scan.post_script_results.append(result)
        elif self.parent_element() == "hostscript":
            self.current_host.script_results.append(result)
        elif self.parent_element() == "port":
            self.current_port.script_results.append(result)
        else:
            warn("%s element not inside prescript, postscript, hostscript, "
                    "or port element; ignoring." % name)
            return

    def _start_osmatch(self, name, attrs):
        assert self.parent_element() == "os"
        assert self.current_host is not None
        if "name" not in attrs:
            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["name"])

    def _start_finished(self, name, attrs):
        assert self.parent_element() == "runstats"
        if "time" in attrs:
            end_timestamp = int(attrs.get("time"))
            self.scan.end_date = datetime.datetime.fromtimestamp(end_timestamp)

    def _end_host(self, name):


    def frag(self, frag):
        for node in frag.childNodes:
            node.writexml(self.f, newl="\n")

    def frag_a(self, frag):
        self.startElement("a", {})
        for node in frag.childNodes:
            node.writexml(self.f, newl="\n")
        self.endElement("a")

    def frag_b(self, frag):
        self.startElement("b", {})
        for node in frag.childNodes:
            node.writexml(self.f, newl="\n")
        self.endElement("b")


def usage():
    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

  -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])

EXIT_EQUAL = 0
EXIT_DIFFERENT = 1



def usage_error(msg):
    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)



    try:
        opts, input_filenames = getopt.gnu_getopt(
                sys.argv[1:], "hv", ["help", "text", "verbose", "xml"])
    except getopt.GetoptError as e:
        usage_error(e.msg)
    for o, a in opts:
        if o == "-h" or o == "--help":

            verbose = True
        elif o == "--text":
            if output_format is not None and output_format != "text":
                usage_error("contradictory output format options.")
            output_format = "text"
        elif o == "--xml":
            if output_format is not None and output_format != "xml":
                usage_error("contradictory output format options.")
            output_format = "xml"

    if len(input_filenames) != 2:
        usage_error("need exactly two input filenames.")

    if output_format is None:
        output_format = "text"

        scan_a.load_from_file(filename_a)
        scan_b = Scan()
        scan_b.load_from_file(filename_b)
    except IOError as e:
        print("Can't open file: %s" % str(e), file=sys.stderr)
        sys.exit(EXIT_ERROR)

    if output_format == "text":




#!/usr/bin/env python3

# Unit tests for Ndiff.


sys.dont_write_bytecode = dont_write_bytecode
del dont_write_bytecode

import io


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(list(host.extraports.items()), [("filtered", 95)])

    def test_extraports_multi(self):
        """Test that the correct number of known ports is returned when there

        """Test that nmaprun information is recorded."""
        scan = Scan()
        scan.load_from_file("test-scans/empty.xml")
        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."""

        scan = Scan()
        scan.load_from_file("test-scans/simple.xml")
        host = scan.hosts[0]
        self.assertEqual(host.hostnames, ["scanme.nmap.org"])

    def test_os(self):
        """Test that OS information is recorded."""

        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, "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


    def test_format_name(self):
        h = Host()
        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("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()

        h = s.hosts[0]
        self.assertEqual(len(h.ports), 5)
        self.assertEqual(len(h.extraports), 1)
        self.assertEqual(list(h.extraports.keys())[0], "filtered")
        self.assertEqual(list(h.extraports.values())[0], 95)
        self.assertEqual(h.state, "up")



    """Test the Port class."""
    def test_spec_string(self):
        p = Port((10, "tcp"))
        self.assertEqual(p.spec_string(), "10/tcp")
        p = Port((100, "ip"))
        self.assertEqual(p.spec_string(), "100/ip")

    def test_state_string(self):
        p = Port((10, "tcp"))
        self.assertEqual(p.state_string(), "unknown")


class service_test(unittest.TestCase):

    def test_compare(self):
        """Test that services with the same contents compare equal."""
        a = Service()
        a.name = "ftp"
        a.product = "FooBar FTP"
        a.version = "1.1.1"
        a.tunnel = "ssl"
        self.assertEqual(a, a)
        b = Service()
        b.name = "ftp"
        b.product = "FooBar FTP"
        b.version = "1.1.1"
        b.tunnel = "ssl"
        self.assertEqual(a, b)
        b.name = "http"
        self.assertNotEqual(a, b)
        c = Service()
        self.assertNotEqual(a, c)

    def test_tunnel(self):
        serv = Service()
        serv.name = "http"
        serv.tunnel = "ssl"
        self.assertEqual(serv.name_string(), "ssl/http")

    def test_version_string(self):
        serv = Service()
        serv.product = "FooBar"
        self.assertTrue(len(serv.version_string()) > 0)
        serv = Service()
        serv.version = "1.2.3"
        self.assertTrue(len(serv.version_string()) > 0)
        serv = Service()
        serv.extrainfo = "misconfigured"
        self.assertTrue(len(serv.version_string()) > 0)
        serv = Service()
        serv.product = "FooBar"
        serv.version = "1.2.3"
        # Must match Nmap output.
        self.assertEqual(serv.version_string(),
                "%s %s" % (serv.product, serv.version))
        serv.extrainfo = "misconfigured"
        self.assertEqual(serv.version_string(),
                "%s %s (%s)" % (serv.product, serv.version, serv.extrainfo))


class ScanDiffSub(ScanDiff):

        a.load_from_file("test-scans/empty.xml")
        b = Scan()
        b.load_from_file("test-scans/simple.xml")
        f = io.StringIO()
        self.scan_diff = ScanDiffXML(a, b, f)
        self.scan_diff.output()
        self.xml = f.getvalue()

    def test_well_formed(self):
        try:
            document = xml.dom.minidom.parseString(self.xml)
        except Exception as e:
            self.fail("Parsing XML diff output caused the exception: %s"
                    % str(e))



        host.os = diff.host_b.os[:]

    if diff.extraports_changed:
        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()




#!/usr/bin/env python3

# Ndiff
#


try:
    import ndiff
except ImportError as e:
    print("""\
Could not import the ndiff module: %s.
I checked in these directories:""" % repr(e), file=sys.stderr)
    for dir in sys.path:
        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.""", file=sys.stderr)
    sys.exit(1)

import ndiff




        self.saved_prefix = sys.prefix
        try:
            distutils.command.install.install.finalize_options(self)
        except distutils.errors.DistutilsPlatformError as e:
            raise distutils.errors.DistutilsPlatformError(str(e) + """
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')

answer = raw_input('Are you sure that you want to uninstall '
    '%(name)s (yes/no) ')

if answer != 'yes' and answer != 'y':
    print('Not uninstalling.')
    sys.exit(0)

""" % {'name': APP_NAME}

                    # 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))
                    continue
                output = path_strip_prefix(output, self.root)
                assert os.path.isabs(output)

        dirs.append(path)
# Delete the files.
for file in files:
    print("Removing '%s'." % file)
    try:
        os.remove(file)
    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)
        os.rmdir(dir)
    except OSError as e:
        if e.errno == errno.ENOTEMPTY:
            print("Directory '%s' not empty; not removing." % dir)
        else:
            print(str(e), file=sys.stderr)
"""

        uninstaller_file = open(uninstaller_filename, 'w')

        uninstaller_file.close()

        # Set exec bit for uninstaller
        mode = ((os.stat(uninstaller_filename)[ST_MODE]) | 0o555) & 0o7777
        os.chmod(uninstaller_filename, mode)

    def write_installed_files(self):

        try:
            for output in self.get_installed_files():
                assert "\n" not in output
                print(output, file=f)
        finally:
            f.close()


        # Read the list of installed files.
        try:
            f = open(INSTALLED_FILES_NAME, "r")
        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)

            try:
                if not self.dry_run:
                    os.remove(file)
            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.

                log.info("Removing the directory '%s'." % dir)
                if not self.dry_run:
                    os.rmdir(dir)
            except OSError as e:
                if e.errno == errno.ENOTEMPTY:
                    log.info("Directory '%s' not empty; not removing." % dir)
                else:




#!/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



def hash(s):
    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 ":".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 ".".join(str(x) for x in nums)


def anonymize_ipv6_address(addr):

    # RFC 4193.
    nums = (0xFD00 + r.randrange(256),)
    nums = nums + tuple(r.randrange(65536) for i in range(7))
    return ":".join("%04X" % x for x in nums)

# Maps to memoize address and host name conversions.
hostname_map = {}

    LETTERS = "acbdefghijklmnopqrstuvwxyz"
    r.seed(hash(name))
    length = r.randrange(5, 10)
    prefix = "".join(r.sample(LETTERS, length))
    num = r.randrange(1000)
    hostname_map[name] = "%s-%d.example.com" % (prefix, num)
    if VERBOSE:
        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')

    else:
        assert False
    if VERBOSE:
        print("Replace %s with %s" % (addr, address_map[addr]), file=sys.stderr)
    return address_map[addr]



Return to bug 702288

Lines 35-40 ZENMAPDIR = @ZENMAPDIR@ Link Here

(-)a/Makefile.in (-2 / +4 lines)
35	NDIFFDIR = @NDIFFDIR@	35	NDIFFDIR = @NDIFFDIR@
36	NPINGDIR = @NPINGDIR@	36	NPINGDIR = @NPINGDIR@
37	PYTHON = @PYTHON@	37	PYTHON = @PYTHON@
		38	PYTHON3 = /usr/bin/env python3
38	DEFS = @DEFS@ -DNMAP_PLATFORM=\"$(NMAP_PLATFORM)\" -DNMAPDATADIR=\"$(nmapdatadir)\"	39	DEFS = @DEFS@ -DNMAP_PLATFORM=\"$(NMAP_PLATFORM)\" -DNMAPDATADIR=\"$(nmapdatadir)\"
39	# With GCC, add extra security checks to source code.	40	# With GCC, add extra security checks to source code.
40	# http://gcc.gnu.org/ml/gcc-patches/2004-09/msg02055.html	41	# http://gcc.gnu.org/ml/gcc-patches/2004-09/msg02055.html
Lines 368-373 tests/check_dns: $(OBJS) Link Here
368	# this as the location of the interpreter whenever we're not doing a	369	# this as the location of the interpreter whenever we're not doing a
369	# local installation.	370	# local installation.
370	DEFAULT_PYTHON_PATH = /usr/bin/env python	371	DEFAULT_PYTHON_PATH = /usr/bin/env python
		372	DEFAULT_PYTHON3_PATH = /usr/bin/env python3
371		373
372	build-zenmap: $(ZENMAPDIR)/setup.py $(ZENMAPDIR)/zenmapCore/Version.py	374	build-zenmap: $(ZENMAPDIR)/setup.py $(ZENMAPDIR)/zenmapCore/Version.py
373	# When DESTDIR is defined, assume we're building an executable	375	# When DESTDIR is defined, assume we're building an executable
Lines 388-394 install-zenmap: $(ZENMAPDIR)/setup.py Link Here
388	ln -sf zenmap $(DESTDIR)$(bindir)/xnmap	390	ln -sf zenmap $(DESTDIR)$(bindir)/xnmap
389		391
390	build-ndiff:	392	build-ndiff:
391	cd $(NDIFFDIR) && $(PYTHON) setup.py build $(if $(DESTDIR),--executable "$(DEFAULT_PYTHON_PATH)")	393	cd $(NDIFFDIR) && $(PYTHON) setup.py build $(if $(DESTDIR),--executable "$(DEFAULT_PYTHON3_PATH)")
392		394
393	build-nping: $(NPINGDIR)/Makefile build-nbase build-nsock build-netutil $(NPINGDIR)/nping.h @DNET_BUILD@ @PCAP_BUILD@	395	build-nping: $(NPINGDIR)/Makefile build-nbase build-nsock build-netutil $(NPINGDIR)/nping.h @DNET_BUILD@ @PCAP_BUILD@
394	@cd $(NPINGDIR) && $(MAKE)	396	@cd $(NPINGDIR) && $(MAKE)
Lines 458-464 check-ncat: Link Here
458	@cd $(NCATDIR) && $(MAKE) check	460	@cd $(NCATDIR) && $(MAKE) check
459		461
460	check-ndiff:	462	check-ndiff:
461	@cd $(NDIFFDIR) && $(PYTHON) ndifftest.py	463	@cd $(NDIFFDIR) && $(PYTHON3) ndifftest.py
462		464
463	check-nsock:	465	check-nsock:
464	@cd $(NSOCKDIR)/src && $(MAKE) check	466	@cd $(NSOCKDIR)/src && $(MAKE) check

Lines 1-4 Link Here

(-)a/ndiff/ndifftest.py (-47 / +47 lines)
1	#!/usr/bin/env python	1	#!/usr/bin/env python3
2		2
3	# Unit tests for Ndiff.	3	# Unit tests for Ndiff.
4		4
Lines 22-28 for x in dir(ndiff): Link Here
22	sys.dont_write_bytecode = dont_write_bytecode	22	sys.dont_write_bytecode = dont_write_bytecode
23	del dont_write_bytecode	23	del dont_write_bytecode
24		24
25	import StringIO	25	import io
26		26
27		27
28	class scan_test(unittest.TestCase):	28	class scan_test(unittest.TestCase):
Lines 52-58 class scan_test(unittest.TestCase): Link Here
52	scan.load_from_file("test-scans/single.xml")	52	scan.load_from_file("test-scans/single.xml")
53	host = scan.hosts[0]	53	host = scan.hosts[0]
54	self.assertEqual(len(host.ports), 5)	54	self.assertEqual(len(host.ports), 5)
55	self.assertEqual(host.extraports.items(), [("filtered", 95)])	55	self.assertEqual(list(host.extraports.items()), [("filtered", 95)])
56		56
57	def test_extraports_multi(self):	57	def test_extraports_multi(self):
58	"""Test that the correct number of known ports is returned when there	58	"""Test that the correct number of known ports is returned when there
Lines 68-76 class scan_test(unittest.TestCase): Link Here
68	"""Test that nmaprun information is recorded."""	68	"""Test that nmaprun information is recorded."""
69	scan = Scan()	69	scan = Scan()
70	scan.load_from_file("test-scans/empty.xml")	70	scan.load_from_file("test-scans/empty.xml")
71	self.assertEqual(scan.scanner, u"nmap")	71	self.assertEqual(scan.scanner, "nmap")
72	self.assertEqual(scan.version, u"4.90RC2")	72	self.assertEqual(scan.version, "4.90RC2")
73	self.assertEqual(scan.args, u"nmap -oX empty.xml -p 1-100")	73	self.assertEqual(scan.args, "nmap -oX empty.xml -p 1-100")
74		74
75	def test_addresses(self):	75	def test_addresses(self):
76	"""Test that addresses are recorded."""	76	"""Test that addresses are recorded."""
Lines 84-90 class scan_test(unittest.TestCase): Link Here
84	scan = Scan()	84	scan = Scan()
85	scan.load_from_file("test-scans/simple.xml")	85	scan.load_from_file("test-scans/simple.xml")
86	host = scan.hosts[0]	86	host = scan.hosts[0]
87	self.assertEqual(host.hostnames, [u"scanme.nmap.org"])	87	self.assertEqual(host.hostnames, ["scanme.nmap.org"])
88		88
89	def test_os(self):	89	def test_os(self):
90	"""Test that OS information is recorded."""	90	"""Test that OS information is recorded."""
Lines 99-105 class scan_test(unittest.TestCase): Link Here
99	scan.load_from_file("test-scans/complex.xml")	99	scan.load_from_file("test-scans/complex.xml")
100	host = scan.hosts[0]	100	host = scan.hosts[0]
101	self.assertTrue(len(host.script_results) > 0)	101	self.assertTrue(len(host.script_results) > 0)
102	self.assertTrue(len(host.ports[(22, u"tcp")].script_results) > 0)	102	self.assertTrue(len(host.ports[(22, "tcp")].script_results) > 0)
103		103
104	# This test is commented out because Nmap XML doesn't store any information	104	# This test is commented out because Nmap XML doesn't store any information
105	# about down hosts, not even the fact that they are down. Recovering the list	105	# about down hosts, not even the fact that they are down. Recovering the list
Lines 128-143 class host_test(unittest.TestCase): Link Here
128		128
129	def test_format_name(self):	129	def test_format_name(self):
130	h = Host()	130	h = Host()
131	self.assertTrue(isinstance(h.format_name(), basestring))	131	self.assertTrue(isinstance(h.format_name(), str))
132	h.add_address(IPv4Address(u"127.0.0.1"))	132	h.add_address(IPv4Address("127.0.0.1"))
133	self.assertTrue(u"127.0.0.1" in h.format_name())	133	self.assertTrue("127.0.0.1" in h.format_name())
134	h.add_address(IPv6Address("::1"))	134	h.add_address(IPv6Address("::1"))
135	self.assertTrue(u"127.0.0.1" in h.format_name())	135	self.assertTrue("127.0.0.1" in h.format_name())
136	self.assertTrue(u"::1" in h.format_name())	136	self.assertTrue("::1" in h.format_name())
137	h.add_hostname(u"localhost")	137	h.add_hostname("localhost")
138	self.assertTrue(u"127.0.0.1" in h.format_name())	138	self.assertTrue("127.0.0.1" in h.format_name())
139	self.assertTrue(u"::1" in h.format_name())	139	self.assertTrue("::1" in h.format_name())
140	self.assertTrue(u"localhost" in h.format_name())	140	self.assertTrue("localhost" in h.format_name())
141		141
142	def test_empty_get_port(self):	142	def test_empty_get_port(self):
143	h = Host()	143	h = Host()
Lines 197-204 class host_test(unittest.TestCase): Link Here
197	h = s.hosts[0]	197	h = s.hosts[0]
198	self.assertEqual(len(h.ports), 5)	198	self.assertEqual(len(h.ports), 5)
199	self.assertEqual(len(h.extraports), 1)	199	self.assertEqual(len(h.extraports), 1)
200	self.assertEqual(h.extraports.keys()[0], u"filtered")	200	self.assertEqual(list(h.extraports.keys())[0], "filtered")
201	self.assertEqual(h.extraports.values()[0], 95)	201	self.assertEqual(list(h.extraports.values())[0], 95)
202	self.assertEqual(h.state, "up")	202	self.assertEqual(h.state, "up")
203		203
204		204
Lines 241-253 class port_test(unittest.TestCase): Link Here
241	"""Test the Port class."""	241	"""Test the Port class."""
242	def test_spec_string(self):	242	def test_spec_string(self):
243	p = Port((10, "tcp"))	243	p = Port((10, "tcp"))
244	self.assertEqual(p.spec_string(), u"10/tcp")	244	self.assertEqual(p.spec_string(), "10/tcp")
245	p = Port((100, "ip"))	245	p = Port((100, "ip"))
246	self.assertEqual(p.spec_string(), u"100/ip")	246	self.assertEqual(p.spec_string(), "100/ip")
247		247
248	def test_state_string(self):	248	def test_state_string(self):
249	p = Port((10, "tcp"))	249	p = Port((10, "tcp"))
250	self.assertEqual(p.state_string(), u"unknown")	250	self.assertEqual(p.state_string(), "unknown")
251		251
252		252
253	class service_test(unittest.TestCase):	253	class service_test(unittest.TestCase):
Lines 255-301 class service_test(unittest.TestCase): Link Here
255	def test_compare(self):	255	def test_compare(self):
256	"""Test that services with the same contents compare equal."""	256	"""Test that services with the same contents compare equal."""
257	a = Service()	257	a = Service()
258	a.name = u"ftp"	258	a.name = "ftp"
259	a.product = u"FooBar FTP"	259	a.product = "FooBar FTP"
260	a.version = u"1.1.1"	260	a.version = "1.1.1"
261	a.tunnel = u"ssl"	261	a.tunnel = "ssl"
262	self.assertEqual(a, a)	262	self.assertEqual(a, a)
263	b = Service()	263	b = Service()
264	b.name = u"ftp"	264	b.name = "ftp"
265	b.product = u"FooBar FTP"	265	b.product = "FooBar FTP"
266	b.version = u"1.1.1"	266	b.version = "1.1.1"
267	b.tunnel = u"ssl"	267	b.tunnel = "ssl"
268	self.assertEqual(a, b)	268	self.assertEqual(a, b)
269	b.name = u"http"	269	b.name = "http"
270	self.assertNotEqual(a, b)	270	self.assertNotEqual(a, b)
271	c = Service()	271	c = Service()
272	self.assertNotEqual(a, c)	272	self.assertNotEqual(a, c)
273		273
274	def test_tunnel(self):	274	def test_tunnel(self):
275	serv = Service()	275	serv = Service()
276	serv.name = u"http"	276	serv.name = "http"
277	serv.tunnel = u"ssl"	277	serv.tunnel = "ssl"
278	self.assertEqual(serv.name_string(), u"ssl/http")	278	self.assertEqual(serv.name_string(), "ssl/http")
279		279
280	def test_version_string(self):	280	def test_version_string(self):
281	serv = Service()	281	serv = Service()
282	serv.product = u"FooBar"	282	serv.product = "FooBar"
283	self.assertTrue(len(serv.version_string()) > 0)	283	self.assertTrue(len(serv.version_string()) > 0)
284	serv = Service()	284	serv = Service()
285	serv.version = u"1.2.3"	285	serv.version = "1.2.3"
286	self.assertTrue(len(serv.version_string()) > 0)	286	self.assertTrue(len(serv.version_string()) > 0)
287	serv = Service()	287	serv = Service()
288	serv.extrainfo = u"misconfigured"	288	serv.extrainfo = "misconfigured"
289	self.assertTrue(len(serv.version_string()) > 0)	289	self.assertTrue(len(serv.version_string()) > 0)
290	serv = Service()	290	serv = Service()
291	serv.product = u"FooBar"	291	serv.product = "FooBar"
292	serv.version = u"1.2.3"	292	serv.version = "1.2.3"
293	# Must match Nmap output.	293	# Must match Nmap output.
294	self.assertEqual(serv.version_string(),	294	self.assertEqual(serv.version_string(),
295	u"%s %s" % (serv.product, serv.version))	295	"%s %s" % (serv.product, serv.version))
296	serv.extrainfo = u"misconfigured"	296	serv.extrainfo = "misconfigured"
297	self.assertEqual(serv.version_string(),	297	self.assertEqual(serv.version_string(),
298	u"%s %s (%s)" % (serv.product, serv.version, serv.extrainfo))	298	"%s %s (%s)" % (serv.product, serv.version, serv.extrainfo))
299		299
300		300
301	class ScanDiffSub(ScanDiff):	301	class ScanDiffSub(ScanDiff):
Lines 703-709 class scan_diff_xml_test(unittest.TestCase): Link Here
703	a.load_from_file("test-scans/empty.xml")	703	a.load_from_file("test-scans/empty.xml")
704	b = Scan()	704	b = Scan()
705	b.load_from_file("test-scans/simple.xml")	705	b.load_from_file("test-scans/simple.xml")
706	f = StringIO.StringIO()	706	f = io.StringIO()
707	self.scan_diff = ScanDiffXML(a, b, f)	707	self.scan_diff = ScanDiffXML(a, b, f)
708	self.scan_diff.output()	708	self.scan_diff.output()
709	self.xml = f.getvalue()	709	self.xml = f.getvalue()
Lines 712-719 class scan_diff_xml_test(unittest.TestCase): Link Here
712	def test_well_formed(self):	712	def test_well_formed(self):
713	try:	713	try:
714	document = xml.dom.minidom.parseString(self.xml)	714	document = xml.dom.minidom.parseString(self.xml)
715	except Exception, e:	715	except Exception as e:
716	self.fail(u"Parsing XML diff output caused the exception: %s"	716	self.fail("Parsing XML diff output caused the exception: %s"
717	% str(e))	717	% str(e))
718		718
719		719
Lines 739-746 def host_apply_diff(host, diff): Link Here
739	host.os = diff.host_b.os[:]	739	host.os = diff.host_b.os[:]
740		740
741	if diff.extraports_changed:	741	if diff.extraports_changed:
742	for state in host.extraports.keys():	742	for state in list(host.extraports.keys()):
743	for port in host.ports.values():	743	for port in list(host.ports.values()):
744	if port.state == state:	744	if port.state == state:
745	del host.ports[port.spec]	745	del host.ports[port.spec]
746	host.extraports = diff.host_b.extraports.copy()	746	host.extraports = diff.host_b.extraports.copy()

Lines 1-4 Link Here

(-)a/ndiff/scripts/ndiff (-7 / +7 lines)
1	#!/usr/bin/env python	1	#!/usr/bin/env python3
2		2
3	# Ndiff	3	# Ndiff
4	#	4	#
Lines 67-81 if INSTALL_LIB is not None and is_secure_dir(INSTALL_LIB): Link Here
67		67
68	try:	68	try:
69	import ndiff	69	import ndiff
70	except ImportError, e:	70	except ImportError as e:
71	print >> sys.stderr, """\	71	print("""\
72	Could not import the ndiff module: %s.	72	Could not import the ndiff module: %s.
73	I checked in these directories:""" % repr(e.message)	73	I checked in these directories:""" % repr(e), file=sys.stderr)
74	for dir in sys.path:	74	for dir in sys.path:
75	print >> sys.stderr, " %s" % dir	75	print(" %s" % dir, file=sys.stderr)
76	print >> sys.stderr, """\	76	print("""\
77	If you installed Ndiff in another directory, you may have to add the	77	If you installed Ndiff in another directory, you may have to add the
78	modules directory to the PYTHONPATH environment variable."""	78	modules directory to the PYTHONPATH environment variable.""", file=sys.stderr)
79	sys.exit(1)	79	sys.exit(1)
80		80
81	import ndiff	81	import ndiff

Lines 94-100 class checked_install(distutils.command.install.install): Link Here

(-)a/ndiff/setup.py (-17 / +17 lines)
94	self.saved_prefix = sys.prefix	94	self.saved_prefix = sys.prefix
95	try:	95	try:
96	distutils.command.install.install.finalize_options(self)	96	distutils.command.install.install.finalize_options(self)
97	except distutils.errors.DistutilsPlatformError, e:	97	except distutils.errors.DistutilsPlatformError as e:
98	raise distutils.errors.DistutilsPlatformError(str(e) + """	98	raise distutils.errors.DistutilsPlatformError(str(e) + """
99	Installing your distribution's python-dev package may solve this problem.""")	99	Installing your distribution's python-dev package may solve this problem.""")
100		100
Lines 155-167 Installing your distribution's python-dev package may solve this problem.""") Link Here
155	#!/usr/bin/env python	155	#!/usr/bin/env python
156	import errno, os, os.path, sys	156	import errno, os, os.path, sys
157		157
158	print 'Uninstall %(name)s'	158	print('Uninstall %(name)s')
159		159
160	answer = raw_input('Are you sure that you want to uninstall '	160	answer = raw_input('Are you sure that you want to uninstall '
161	'%(name)s (yes/no) ')	161	'%(name)s (yes/no) ')
162		162
163	if answer != 'yes' and answer != 'y':	163	if answer != 'yes' and answer != 'y':
164	print 'Not uninstalling.'	164	print('Not uninstalling.')
165	sys.exit(0)	165	sys.exit(0)
166		166
167	""" % {'name': APP_NAME}	167	""" % {'name': APP_NAME}
Lines 177-184 if answer != 'yes' and answer != 'y': Link Here
177	# This should never happen (everything gets installed	177	# This should never happen (everything gets installed
178	# inside the root), but if it does, be safe and don't	178	# inside the root), but if it does, be safe and don't
179	# delete anything.	179	# delete anything.
180	uninstaller += ("print '%s was not installed inside "	180	uninstaller += ("print('%s was not installed inside "
181	"the root %s; skipping.'\n" % (output, self.root))	181	"the root %s; skipping.')\n" % (output, self.root))
182	continue	182	continue
183	output = path_strip_prefix(output, self.root)	183	output = path_strip_prefix(output, self.root)
184	assert os.path.isabs(output)	184	assert os.path.isabs(output)
Lines 202-225 for path in INSTALLED_FILES: Link Here
202	dirs.append(path)	202	dirs.append(path)
203	# Delete the files.	203	# Delete the files.
204	for file in files:	204	for file in files:
205	print "Removing '%s'." % file	205	print("Removing '%s'." % file)
206	try:	206	try:
207	os.remove(file)	207	os.remove(file)
208	except OSError, e:	208	except OSError as e:
209	print >> sys.stderr, ' Error: %s.' % str(e)	209	print(' Error: %s.' % str(e), file=sys.stderr)
210	# Delete the directories. First reverse-sort the normalized paths by	210	# Delete the directories. First reverse-sort the normalized paths by
211	# length so that child directories are deleted before their parents.	211	# length so that child directories are deleted before their parents.
212	dirs = [os.path.normpath(dir) for dir in dirs]	212	dirs = [os.path.normpath(dir) for dir in dirs]
213	dirs.sort(key = len, reverse = True)	213	dirs.sort(key = len, reverse = True)
214	for dir in dirs:	214	for dir in dirs:
215	try:	215	try:
216	print "Removing the directory '%s'." % dir	216	print("Removing the directory '%s'." % dir)
217	os.rmdir(dir)	217	os.rmdir(dir)
218	except OSError, e:	218	except OSError as e:
219	if e.errno == errno.ENOTEMPTY:	219	if e.errno == errno.ENOTEMPTY:
220	print "Directory '%s' not empty; not removing." % dir	220	print("Directory '%s' not empty; not removing." % dir)
221	else:	221	else:
222	print >> sys.stderr, str(e)	222	print(str(e), file=sys.stderr)
223	"""	223	"""
224		224
225	uninstaller_file = open(uninstaller_filename, 'w')	225	uninstaller_file = open(uninstaller_filename, 'w')
Lines 227-233 for dir in dirs: Link Here
227	uninstaller_file.close()	227	uninstaller_file.close()
228		228
229	# Set exec bit for uninstaller	229	# Set exec bit for uninstaller
230	mode = ((os.stat(uninstaller_filename)[ST_MODE]) \| 0555) & 07777	230	mode = ((os.stat(uninstaller_filename)[ST_MODE]) \| 0o555) & 0o7777
231	os.chmod(uninstaller_filename, mode)	231	os.chmod(uninstaller_filename, mode)
232		232
233	def write_installed_files(self):	233	def write_installed_files(self):
Lines 242-248 for dir in dirs: Link Here
242	try:	242	try:
243	for output in self.get_installed_files():	243	for output in self.get_installed_files():
244	assert "\n" not in output	244	assert "\n" not in output
245	print >> f, output	245	print(output, file=f)
246	finally:	246	finally:
247	f.close()	247	f.close()
248		248
Lines 266-272 class my_uninstall(distutils.cmd.Command): Link Here
266	# Read the list of installed files.	266	# Read the list of installed files.
267	try:	267	try:
268	f = open(INSTALLED_FILES_NAME, "r")	268	f = open(INSTALLED_FILES_NAME, "r")
269	except IOError, e:	269	except IOError as e:
270	if e.errno == errno.ENOENT:	270	if e.errno == errno.ENOENT:
271	log.error("Couldn't open the installation record '%s'. "	271	log.error("Couldn't open the installation record '%s'. "
272	"Have you installed yet?" % INSTALLED_FILES_NAME)	272	"Have you installed yet?" % INSTALLED_FILES_NAME)
Lines 289-295 class my_uninstall(distutils.cmd.Command): Link Here
289	try:	289	try:
290	if not self.dry_run:	290	if not self.dry_run:
291	os.remove(file)	291	os.remove(file)
292	except OSError, e:	292	except OSError as e:
293	log.error(str(e))	293	log.error(str(e))
294	# Delete the directories. First reverse-sort the normalized paths by	294	# Delete the directories. First reverse-sort the normalized paths by
295	# length so that child directories are deleted before their parents.	295	# length so that child directories are deleted before their parents.
Lines 300-306 class my_uninstall(distutils.cmd.Command): Link Here
300	log.info("Removing the directory '%s'." % dir)	300	log.info("Removing the directory '%s'." % dir)
301	if not self.dry_run:	301	if not self.dry_run:
302	os.rmdir(dir)	302	os.rmdir(dir)
303	except OSError, e:	303	except OSError as e:
304	if e.errno == errno.ENOTEMPTY:	304	if e.errno == errno.ENOTEMPTY:
305	log.info("Directory '%s' not empty; not removing." % dir)	305	log.info("Directory '%s' not empty; not removing." % dir)
306	else:	306	else:

Lines 1-4 Link Here

(-)a/ndiff/test-scans/anonymize.py (-9 / +9 lines)
1	#!/usr/bin/env python	1	#!/usr/bin/env python3
2		2
3	# Anonymize an Nmap XML file, replacing host name and IP addresses with random	3	# Anonymize an Nmap XML file, replacing host name and IP addresses with random
4	# anonymous ones. Anonymized names will be consistent between runs of the	4	# anonymous ones. Anonymized names will be consistent between runs of the
Lines 20-39 r = random.Random() Link Here
20		20
21		21
22	def hash(s):	22	def hash(s):
23	digest = hashlib.sha512(s).hexdigest()	23	digest = hashlib.sha512(s.encode()).hexdigest()
24	return int(digest, 16)	24	return int(digest, 16)
25		25
26		26
27	def anonymize_mac_address(addr):	27	def anonymize_mac_address(addr):
28	r.seed(hash(addr))	28	r.seed(hash(addr))
29	nums = (0, 0, 0) + tuple(r.randrange(256) for i in range(3))	29	nums = (0, 0, 0) + tuple(r.randrange(256) for i in range(3))
30	return u":".join(u"%02X" % x for x in nums)	30	return ":".join("%02X" % x for x in nums)
31		31
32		32
33	def anonymize_ipv4_address(addr):	33	def anonymize_ipv4_address(addr):
34	r.seed(hash(addr))	34	r.seed(hash(addr))
35	nums = (10,) + tuple(r.randrange(256) for i in range(3))	35	nums = (10,) + tuple(r.randrange(256) for i in range(3))
36	return u".".join(unicode(x) for x in nums)	36	return ".".join(str(x) for x in nums)
37		37
38		38
39	def anonymize_ipv6_address(addr):	39	def anonymize_ipv6_address(addr):
Lines 41-47 def anonymize_ipv6_address(addr): Link Here
41	# RFC 4193.	41	# RFC 4193.
42	nums = (0xFD00 + r.randrange(256),)	42	nums = (0xFD00 + r.randrange(256),)
43	nums = nums + tuple(r.randrange(65536) for i in range(7))	43	nums = nums + tuple(r.randrange(65536) for i in range(7))
44	return u":".join("%04X" % x for x in nums)	44	return ":".join("%04X" % x for x in nums)
45		45
46	# Maps to memoize address and host name conversions.	46	# Maps to memoize address and host name conversions.
47	hostname_map = {}	47	hostname_map = {}
Lines 54-64 def anonymize_hostname(name): Link Here
54	LETTERS = "acbdefghijklmnopqrstuvwxyz"	54	LETTERS = "acbdefghijklmnopqrstuvwxyz"
55	r.seed(hash(name))	55	r.seed(hash(name))
56	length = r.randrange(5, 10)	56	length = r.randrange(5, 10)
57	prefix = u"".join(r.sample(LETTERS, length))	57	prefix = "".join(r.sample(LETTERS, length))
58	num = r.randrange(1000)	58	num = r.randrange(1000)
59	hostname_map[name] = u"%s-%d.example.com" % (prefix, num)	59	hostname_map[name] = "%s-%d.example.com" % (prefix, num)
60	if VERBOSE:	60	if VERBOSE:
61	print >> sys.stderr, "Replace %s with %s" % (name, hostname_map[name])	61	print("Replace %s with %s" % (name, hostname_map[name]), file=sys.stderr)
62	return hostname_map[name]	62	return hostname_map[name]
63		63
64	mac_re = re.compile(r'\b([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}\b')	64	mac_re = re.compile(r'\b([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}\b')
Lines 78-84 def anonymize_address(addr): Link Here
78	else:	78	else:
79	assert False	79	assert False
80	if VERBOSE:	80	if VERBOSE:
81	print >> sys.stderr, "Replace %s with %s" % (addr, address_map[addr])	81	print("Replace %s with %s" % (addr, address_map[addr]), file=sys.stderr)
82	return address_map[addr]	82	return address_map[addr]
83		83
84		84