├── demo.gif
├── nmap-parse-output-xslt
    ├── host-ports.xslt
    ├── search-product.xslt
    ├── blocked-ports.xslt
    ├── nmap-cmdline.xslt
    ├── hosts-to-port.xslt
    ├── http-title.xslt
    ├── service.xslt
    ├── all-hosts.xslt
    ├── host-ports-protocol.xslt
    ├── banner.xslt
    ├── reachable.xslt
    ├── product.xslt
    ├── hosts.xslt
    ├── service-names.xslt
    ├── port-info.xslt
    ├── ssl-common-name.xslt
    ├── tls-ports.xslt
    ├── exclude.xslt
    ├── show-comments.xslt
    ├── ports.xslt
    ├── include.xslt
    ├── exclude-ports.xslt
    ├── include-ports.xslt
    ├── ports-reachable.xslt
    ├── mark-ports.xslt
    ├── comment-hosts.xslt
    ├── http-info.xslt
    ├── comment-ports.xslt
    ├── http-ports.xslt
    ├── group-by-product.xslt
    ├── group-by-ports.xslt
    ├── group-by-service.xslt
    ├── to-json.xslt
    ├── html-bootstrap.xslt
    └── html.xslt
├── _nmap-parse-output
├── LICENSE
├── ThirdPartyNotices.md
├── nmap-parse-output
└── README.md


/demo.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ernw/nmap-parse-output/HEAD/demo.gif


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/host-ports.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo">
 2 | <npo:comment>
 3 |         Extracts a list of all *open* ports in host:port format.
 4 | </npo:comment>
 5 | <npo:category>extract</npo:category>
 6 | 
 7 |     <xsl:output method="text" />
 8 |     <xsl:strip-space elements="*" />
 9 |     <xsl:template match="/nmaprun/host/ports/port">
10 |         <xsl:if test="state[@state = 'open']">
11 |             <xsl:value-of select="../../address/@addr"/>
12 |             <xsl:text>:</xsl:text>
13 |             <xsl:value-of select="@portid"/>
14 |             <xsl:text>
15 | </xsl:text>
16 |         </xsl:if>
17 |         <xsl:apply-templates/>
18 |     </xsl:template>
19 | 
20 |     <xsl:template match="text()" />
21 | </xsl:stylesheet>
22 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/search-product.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo">
 2 | <npo:comment>
 3 |         Search in product names (case sensitive).
 4 | </npo:comment>
 5 | <npo:category>extract</npo:category>
 6 | 
 7 |     <xsl:output method="text" />
 8 |     <xsl:strip-space elements="*" />
 9 |     <xsl:template match="/nmaprun/host/ports/port">
10 |         <xsl:if test="contains(service/@product, $param1) and state/@state='open'">
11 |             <xsl:value-of select="../../address/@addr"/>
12 |             <xsl:text>:</xsl:text>
13 |             <xsl:value-of select="@portid"/>
14 |             <xsl:text>
15 | </xsl:text>
16 |         </xsl:if>
17 |         <xsl:apply-templates/>
18 |     </xsl:template>
19 | 
20 |     <xsl:template match="text()" />
21 | </xsl:stylesheet>
22 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/blocked-ports.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo">
 2 | <npo:comment>
 3 |         Extracts all ports in host:port format, which either admin-prohibited or tcpwrapped.
 4 | </npo:comment>
 5 | <npo:category>extract</npo:category>
 6 |     <xsl:output method="text" />
 7 |     <xsl:strip-space elements="*" />
 8 |     <xsl:template match="/nmaprun/host/ports/port">
 9 |         <xsl:if test="service[@name = 'tcpwrapped'] or state[@reason = 'admin-prohibited']">
10 |             <xsl:value-of select="../../address/@addr"/>
11 |             <xsl:text>:</xsl:text>
12 |             <xsl:value-of select="@portid"/>
13 |             <xsl:text>
14 | </xsl:text>
15 |         </xsl:if>
16 |         <xsl:apply-templates/>
17 |     </xsl:template>
18 | 
19 |     <xsl:template match="text()" />
20 | </xsl:stylesheet>
21 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/nmap-cmdline.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo">
 2 | <npo:comment>
 3 |         Shows the parameters passed to nmap of the runned scan
 4 | </npo:comment>
 5 | <npo:category>extract</npo:category>
 6 |     <xsl:output method="text" />
 7 |     <xsl:strip-space elements="*" />
 8 |     <xsl:template match="/nmaprun">
 9 |         <xsl:value-of select="@scanner"/>
10 |         <xsl:text> </xsl:text>
11 |         <xsl:value-of select="@args"/>
12 |         <xsl:text>
13 | </xsl:text>
14 |         <xsl:text># </xsl:text>
15 |         <xsl:text>started: </xsl:text><xsl:value-of select="@startstr"/>
16 |         <xsl:text>; version: </xsl:text><xsl:value-of select="@version"/>
17 |         <xsl:text>
18 | </xsl:text>
19 |     </xsl:template>
20 | 
21 |     <xsl:template match="text()" />
22 | </xsl:stylesheet>
23 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/hosts-to-port.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo">
 2 | <npo:comment>[port]
 3 |         Extracts a list of all hosts that have the given port open in 'host (hostname)' format.
 4 | </npo:comment>
 5 | <npo:category>extract</npo:category>
 6 | 
 7 |     <xsl:output method="text" />
 8 |     <xsl:strip-space elements="*" />
 9 |     <xsl:template match="/nmaprun/host/ports/port">
10 |         <xsl:if test="@portid=$param1 and state[@state = 'open']">
11 |             <xsl:value-of select="../../address/@addr"/>
12 |             <xsl:if test="../../hostnames/hostname"> (<xsl:value-of select="../../hostnames/hostname/@name"/>)</xsl:if>
13 |             <xsl:text>
14 | </xsl:text>
15 |         </xsl:if>
16 |         <xsl:apply-templates/>
17 |     </xsl:template>
18 | 
19 |     <xsl:template match="text()" />
20 | </xsl:stylesheet>
21 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/http-title.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo">
 2 | <npo:comment>
 3 |         Extracts a list of HTTP HTML titles in the following format:
 4 |         host:port	HTML title
 5 | </npo:comment>
 6 | <npo:category>extract</npo:category>
 7 | 
 8 |     <xsl:output method="text" />
 9 |     <xsl:strip-space elements="*" />
10 |     <xsl:template match="/nmaprun/host/ports/port/script[@id='http-title']">
11 |             <xsl:value-of select="../../../address/@addr"/>
12 |             <xsl:text>:</xsl:text>
13 |             <xsl:value-of select="../@portid"/>
14 |             <xsl:text>;</xsl:text>
15 |             <xsl:value-of select="elem[@key='title']"/>
16 |             <xsl:text>
17 | </xsl:text>
18 |         <xsl:apply-templates/>
19 |     </xsl:template>
20 | 
21 |     <xsl:template match="text()" />
22 | </xsl:stylesheet>
23 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/service.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo">
 2 | <npo:comment>[service-name]
 3 |         Extracts a list of all *open* ports with a specific service (e.g. http, ms-wbt-server, smtp) in host:port format.
 4 | </npo:comment>
 5 | <npo:category>extract</npo:category>
 6 | 
 7 |     <xsl:output method="text" />
 8 |     <xsl:strip-space elements="*" />
 9 |     <xsl:template match="/nmaprun/host/ports/port">
10 |         <xsl:if test="service/@name=$param1 and state/@state='open'">
11 |             <xsl:value-of select="../../address/@addr"/>
12 |             <xsl:text>:</xsl:text>
13 |             <xsl:value-of select="@portid"/>
14 |             <xsl:text>
15 | </xsl:text>
16 |         </xsl:if>
17 |         <xsl:apply-templates/>
18 |     </xsl:template>
19 | 
20 |     <xsl:template match="text()" />
21 | </xsl:stylesheet>
22 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/all-hosts.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo">
 2 | <npo:comment>
 3 |         Generates a line break separated list of all hosts. Can be used to perform an additional scan on this hosts.
 4 |         Can be useful to generate a list of IPs for masscan with nmap (masscan has a more limited support for IP lists):
 5 |           nmap -Pn -n -sL -iL input.lst -oX all-ips.xml; nmap-parse-output all-ips.xml all-hosts
 6 | </npo:comment>
 7 | <npo:category>extract</npo:category>
 8 | <npo:post-processor>sort | uniq</npo:post-processor>
 9 | 
10 |     <xsl:output method="text" />
11 |     <xsl:strip-space elements="*" />
12 |     
13 |     <xsl:template match="/nmaprun/host/address">
14 |         <xsl:value-of select="@addr"/>
15 |         <xsl:text>
16 | </xsl:text>
17 |     </xsl:template>
18 |     
19 |     <xsl:template match="text()" />
20 | </xsl:stylesheet>
21 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/host-ports-protocol.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo">
 2 | <npo:comment>
 3 |         Extracts a list of all *open* ports in host:port format and marks the protocol type (tcp, udp)
 4 | </npo:comment>
 5 | <npo:category>extract</npo:category>
 6 | 
 7 |     <xsl:output method="text" />
 8 |     <xsl:strip-space elements="*" />
 9 |     <xsl:template match="/nmaprun/host/ports/port">
10 |         <xsl:if test="state[@state = 'open']">
11 |             <xsl:value-of select="../../address/@addr"/>
12 |             <xsl:text>:</xsl:text>
13 |             <xsl:value-of select="@portid"/>
14 |             <xsl:text> </xsl:text>
15 |             <xsl:value-of select="@protocol"/>
16 |             <xsl:text>
17 | </xsl:text>
18 |         </xsl:if>
19 |         <xsl:apply-templates/>
20 |     </xsl:template>
21 | 
22 |     <xsl:template match="text()" />
23 | </xsl:stylesheet>
24 | 


--------------------------------------------------------------------------------
/_nmap-parse-output:
--------------------------------------------------------------------------------
 1 | #/usr/bin/env bash
 2 | 
 3 | _nmap-parse-output_completions()
 4 | {
 5 |   local NPO_SCRIPT="$(whereis -b nmap-parse-output | cut -d ' ' -f 2)"
 6 |   if [ -h "$NPO_SCRIPT" ]; then
 7 |     local NPO_SCRIPT="$(readlink "$NPO_SCRIPT")"
 8 |   fi
 9 |   local NMAP_PARSE_OUTPUT_DIR="$( dirname "$NPO_SCRIPT" )/nmap-parse-output-xslt"
10 |   
11 |   if [ -n "$ZSH_VERSION" ]; then
12 |     # ZSH
13 |     local COMP0="${COMP_WORDS[0]}"
14 |     local COMP1="${COMP_WORDS[1]}"
15 |   elif [ -n "$BASH_VERSION" ]; then
16 |     # Bash
17 |     local COMP0="${COMP_WORDS[1]}"
18 |     local COMP1="${COMP_WORDS[2]}"
19 |   else
20 |     echo "unsupported shell"
21 |   fi
22 | 
23 |   if [ "${COMP_CWORD}" = "1" ]; then
24 |     # nmap output filename
25 |     COMPREPLY=($(compgen -f "$COMP0"))
26 |   elif [ "${COMP_CWORD}" = "2" ]; then
27 |     # command
28 |     COMPREPLY=($(compgen -W "$(ls -1 $NMAP_PARSE_OUTPUT_DIR/ | sed 's/\.xslt/ /')" "$COMP1"))
29 |   fi
30 | }
31 | 
32 | complete -F _nmap-parse-output_completions nmap-parse-output
33 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/banner.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo">
 2 | <npo:comment>[service-name]
 3 |         Extracts a list of all ports with a specific service (e.g. http, ms-wbt-server, smtp) in host:port format.
 4 |         Note: This command is intended for the masscan XML output only.
 5 | </npo:comment>
 6 | <npo:category>extract</npo:category>
 7 |     <xsl:output method="text" />
 8 |     <xsl:strip-space elements="*" />
 9 |     <xsl:template match="/nmaprun/host/ports/port">
10 |         <xsl:if test="service/@name=$param1">
11 |             <xsl:value-of select="../../address/@addr"/>
12 |             <xsl:text>:</xsl:text>
13 |             <xsl:value-of select="@portid"/>
14 |             <xsl:text>	</xsl:text>
15 |             <xsl:value-of select="service/@banner"/>
16 |             <xsl:text>
17 | </xsl:text>
18 |         </xsl:if>
19 |         <xsl:apply-templates/>
20 |     </xsl:template>
21 | 
22 |     <xsl:template match="text()" />
23 | </xsl:stylesheet>
24 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/reachable.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo">
 2 | <npo:comment>
 3 |         Removes all hosts where all ports a filtered. Can be used to generate a smaller HTML report.
 4 |         Example usage to generate HTML report:
 5 |             nmap-parse-output scan.xml reachable | nmap-parse-output - html &gt; scan.html
 6 | </npo:comment>
 7 | <npo:category>manipulate</npo:category>
 8 | <xsl:output method="xml" indent="yes"/>
 9 | <xsl:strip-space elements="*" />
10 | 
11 | <xsl:template match="@*|node()">
12 |  <xsl:copy>
13 |   <xsl:apply-templates select="@*|node()"/>
14 |  </xsl:copy>
15 | </xsl:template>
16 | 
17 | <xsl:template match="/nmaprun/host[descendant::status[@state='down']]" />
18 | <!-- Ensure that to omit only hosts where _all_ ports are filtered -->
19 | <xsl:template match="/nmaprun/host[not(./ports/port/state/@state='open') and not(./ports/port/state/@state='closed')]" />
20 | <!-- and ./ports/extraports/@state='filtered'] -->
21 | 
22 | </xsl:stylesheet>
23 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/product.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo">
 2 | <npo:comment>
 3 |         Extracts all detected product names.
 4 | </npo:comment>
 5 | <npo:category>extract</npo:category>
 6 | 
 7 |     <xsl:output method="text" />
 8 |     <xsl:strip-space elements="*" />
 9 | 
10 |     <xsl:key name="serviceid" match="/nmaprun/host/ports/port/service/@product" use="." />
11 |     
12 |     <xsl:template match="/">
13 |         <!-- distinct port numbers, see https://stackoverflow.com/questions/2291567/how-to-use-xslt-to-create-distinct-values -->
14 |         <xsl:for-each select="/nmaprun/host/ports/port/service/@product[generate-id() = generate-id(key('serviceid',.)[1])]">
15 |             <xsl:value-of select="."/>
16 |             <xsl:text>
17 | </xsl:text>
18 |         </xsl:for-each>
19 |         
20 | <!--        TODO: filter for filtered ports? <xsl:if test="state[@state != 'filtered']"> -->
21 |     </xsl:template>
22 | 
23 |     <xsl:template match="text()" />
24 | </xsl:stylesheet>
25 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/hosts.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo">
 2 | <npo:comment>
 3 |         Generates a line break separated list of all hosts with open ports. Can be used to perform an additional scan on this hosts.
 4 | </npo:comment>
 5 | <npo:category>extract</npo:category>
 6 | <npo:post-processor>sort | uniq</npo:post-processor>
 7 | 
 8 |     <xsl:output method="text" />
 9 |     <xsl:strip-space elements="*" />
10 |     
11 |     <xsl:template match="/nmaprun/host/ports/port">
12 |     
13 |         <xsl:if test="state/@state='open'">
14 |             <xsl:value-of select="../../address/@addr"/>
15 |             <xsl:text>
16 | </xsl:text>
17 |         </xsl:if>
18 |         <!-- distinct port numbers, see https://stackoverflow.com/questions/2291567/how-to-use-xslt-to-create-distinct-values -->
19 | <!--        <xsl:for-each select="/nmaprun/host/ports/portaddress/@addr[generate-id() = generate-id(key('hostid',.)[1])]"> -->
20 |     </xsl:template>
21 | 
22 |     <xsl:template match="text()" />
23 | </xsl:stylesheet>
24 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/service-names.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo">
 2 | <npo:comment>
 3 |         Extracts all detected service names (on open ports).
 4 | </npo:comment>
 5 | <npo:category>extract</npo:category>
 6 | 
 7 |     <xsl:output method="text" />
 8 |     <xsl:strip-space elements="*" />
 9 | 
10 |     <xsl:key name="serviceid" match="/nmaprun/host/ports/port/service/@name" use="." />
11 |     
12 |     <xsl:template match="/">
13 |         <!-- distinct port numbers, see https://stackoverflow.com/questions/2291567/how-to-use-xslt-to-create-distinct-values -->
14 |         <xsl:for-each select="/nmaprun/host/ports/port[state/@state='open']/service/@name[generate-id() = generate-id(key('serviceid',.)[1])]">
15 |             <xsl:value-of select="."/>
16 |             <xsl:text>
17 | </xsl:text>
18 |         </xsl:for-each>
19 |         
20 | <!--        TODO: filter for filtered ports? <xsl:if test="state[@state != 'filtered']"> -->
21 |     </xsl:template>
22 | 
23 |     <xsl:template match="text()" />
24 | </xsl:stylesheet>
25 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/port-info.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo">
 2 | <npo:comment>[port]
 3 |         Extracts a list of extra information about the given port in the following format:
 4 |         port;service-name;http-server-header;http title
 5 | </npo:comment>
 6 | <npo:category>extract</npo:category>
 7 | <npo:post-processor>sort | uniq</npo:post-processor>
 8 |     <xsl:output method="text" />
 9 |     <xsl:strip-space elements="*" />
10 |     <xsl:template match="/nmaprun/host/ports/port">
11 |         <xsl:if test="@portid=$param1 and state[@state = 'open']">
12 |             <xsl:value-of select="service/@name"/><xsl:text>;</xsl:text>
13 |             <xsl:value-of select="service/@product"/><xsl:text>;</xsl:text>
14 |             <xsl:value-of select="script[@id='http-server-header']/@output"/><xsl:text>;</xsl:text>
15 |             <xsl:value-of select="script[@id='http-title']/elem[@key='title']"/>
16 |             <xsl:text>
17 | </xsl:text>
18 |         </xsl:if>
19 |         <xsl:apply-templates/>
20 |     </xsl:template>
21 | 
22 |     <xsl:template match="text()" />
23 | </xsl:stylesheet>
24 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/ssl-common-name.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo">
 2 | <npo:comment>
 3 |         Extracts a list of TLS/SSL ports with the commonName and Subject Alternative Name in the following format:
 4 |         host:port	commonName	X509v3 Subject Alternative Name
 5 | </npo:comment>
 6 | <npo:category>extract</npo:category>
 7 | 
 8 |     <xsl:output method="text" />
 9 |     <xsl:strip-space elements="*" />
10 |     <xsl:template match="/nmaprun/host/ports/port/script[@id='ssl-cert']">
11 |             <xsl:value-of select="../../../address/@addr"/>
12 |             <xsl:text>:</xsl:text>
13 |             <xsl:value-of select="../@portid"/>
14 |             <xsl:text>	</xsl:text>
15 |             <xsl:value-of select="table[@key='subject']/elem[@key='commonName']"/>
16 |             <xsl:text>	</xsl:text>
17 |             <xsl:value-of select="table[@key='extensions']/table[elem[@key='name']='X509v3 Subject Alternative Name']/elem[@key='value']"/>
18 |             <xsl:text>
19 | </xsl:text>
20 |         <xsl:apply-templates/>
21 |     </xsl:template>
22 | 
23 |     <xsl:template match="text()" />
24 | </xsl:stylesheet>
25 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/tls-ports.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo">
 2 | <npo:comment>
 3 |         Extracts a list of all TLS ports in host:port format. Works only reliable after a script scan. Can be used to do a testssl.sh scan.
 4 |         Example testssl.sh command (generates a text and HTML report for each host):
 5 |             for f in `cat ~/ssl-hosts.txt`; do ./testssl.sh --logfile ~/testssl.sh-results/$f.log --htmlfile ~/testssl.sh-results/$f.html $f; done
 6 | </npo:comment>
 7 | <npo:category>extract</npo:category>
 8 | 
 9 |     <xsl:output method="text" />
10 |     <xsl:strip-space elements="*" />
11 |     <!-- Reliable SSL/TLS detection: Sometimes only one of the three TLS detection attributes is set. -->
12 |     <xsl:template match="/nmaprun/host/ports/port[state/@state='open' and (service/@tunnel='ssl' or script[@id='ssl-cert'] or script[@id='ssl-date'])]">
13 |         <xsl:value-of select="../../address/@addr"/>
14 |         <xsl:text>:</xsl:text>
15 |         <xsl:value-of select="@portid"/>
16 |         <xsl:text>
17 | </xsl:text>
18 |         <xsl:apply-templates/>
19 |     </xsl:template>
20 | 
21 |     <xsl:template match="text()" />
22 | </xsl:stylesheet>
23 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/exclude.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" 
 2 |     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 3 |     xmlns:npo="http://xmlns.sven.to/npo"
 4 |     xmlns:str="http://exslt.org/strings"
 5 |     extension-element-prefixes="str npo">
 6 | <npo:comment>[hosts]
 7 |         Excludes a list of hosts from scan result by its IP address. Expects a comma-separated list as input.
 8 |         You can pipe the output, for instance:
 9 |             nmap-parse-output scan.xml exclude '192.168.1.1,192.168.1.20' | nmap-parse-output - service-names
10 | </npo:comment>
11 | <npo:category>manipulate</npo:category>
12 | <!-- see http://exslt.org/str/index.html -->
13 | 
14 | 
15 | <xsl:variable name="exclude-hosts" select="str:tokenize($param1, ',')" />
16 | 
17 | <xsl:output method="xml" indent="yes"/>
18 | <xsl:strip-space elements="*" />
19 | 
20 | <xsl:template match="@*|node()">
21 |  <xsl:copy>
22 |   <xsl:apply-templates select="@*|node()"/>
23 |  </xsl:copy>
24 | </xsl:template>
25 | 
26 | <!-- Filter: -->
27 | <xsl:template match="/nmaprun/host">
28 |     <xsl:if test="not($exclude-hosts = ./address/@addr)">
29 |         <xsl:copy>
30 |             <xsl:apply-templates select="@*|node()"/>
31 |         </xsl:copy>
32 |     </xsl:if>
33 | </xsl:template>
34 | 
35 | </xsl:stylesheet>
36 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/show-comments.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" 
 2 |     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 3 |     xmlns:npo="http://xmlns.sven.to/npo"
 4 |     xmlns:str="http://exslt.org/strings"
 5 |     extension-element-prefixes="str npo">
 6 | <npo:comment>
 7 |         Shows comments added by the comment-* commands.
 8 | </npo:comment>
 9 | <npo:category>extract</npo:category>
10 | <!-- see http://exslt.org/str/index.html -->
11 | 
12 |     <xsl:output method="text" />
13 |     <xsl:strip-space elements="*" />
14 |     <xsl:template match="/nmaprun/host/npo-comment">
15 |             <xsl:value-of select="../address/@addr"/>
16 |             <xsl:text>	</xsl:text>
17 |             <xsl:value-of select="."/>
18 |             <xsl:text>
19 | </xsl:text>
20 |         <xsl:apply-templates/>
21 |     </xsl:template>
22 |     <xsl:template match="/nmaprun/host/ports/port/npo-comment">
23 |             <xsl:value-of select="../../../address/@addr"/>
24 |             <xsl:text>:</xsl:text>
25 |             <xsl:value-of select="../@portid"/>
26 |             <xsl:text>	</xsl:text>
27 |             <xsl:value-of select="."/>
28 |             <xsl:text>
29 | </xsl:text>
30 |         <xsl:apply-templates/>
31 |     </xsl:template>
32 |     <xsl:template match="text()" />
33 | </xsl:stylesheet>
34 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/ports.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo">
 2 | <npo:comment>
 3 |         Generates a comma-separated list of all open ports. Can be used to verify if open ports reachable from another host or generate port lists for specific environments. Closed/filtered ports are not shown in the list.
 4 | </npo:comment>
 5 | <npo:category>extract</npo:category>
 6 | 
 7 |     <xsl:output method="text" />
 8 |     <xsl:strip-space elements="*" />
 9 | 
10 |     <xsl:key name="portid" match="/nmaprun/host/ports/port/state[@state = 'open']/../@portid" use="." />
11 |     
12 |     <xsl:template match="/">
13 |         <!-- distinct port numbers, see https://stackoverflow.com/questions/2291567/how-to-use-xslt-to-create-distinct-values -->
14 |         <xsl:for-each select="/nmaprun/host/ports/port/state[@state = 'open']/../@portid[generate-id() = generate-id(key('portid',.)[1])]">
15 |             <xsl:if test="position() != 1">
16 |                 <xsl:text>,</xsl:text>
17 |             </xsl:if>
18 |             <xsl:value-of select="."/>
19 |         </xsl:for-each>
20 |         
21 | <!--        TODO: filter for filtered ports? <xsl:if test="state[@state != 'filtered']"> -->
22 |     </xsl:template>
23 | 
24 |     <xsl:template match="text()" />
25 | </xsl:stylesheet>
26 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/include.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" 
 2 |     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 3 |     xmlns:npo="http://xmlns.sven.to/npo"
 4 |     xmlns:str="http://exslt.org/strings"
 5 |     extension-element-prefixes="str npo">
 6 | <npo:comment>[hosts]
 7 |         Filter a scan by a list of hosts so that only the specified hosts are in the output.
 8 |         Filter a list of hosts from scan result by its IP address. Expects a comma-separated list as input.
 9 |         You can pipe the output, for instance:
10 |             nmap-parse-output scan.xml include '192.168.1.1,192.168.1.20' | nmap-parse-output - service-names
11 | </npo:comment>
12 | <npo:category>manipulate</npo:category>
13 | <!-- see http://exslt.org/str/index.html -->
14 | 
15 | 
16 | <xsl:variable name="include-hosts" select="str:tokenize($param1, ',')" />
17 | 
18 | <xsl:output method="xml" indent="yes"/>
19 | <xsl:strip-space elements="*" />
20 | 
21 | <xsl:template match="@*|node()">
22 |  <xsl:copy>
23 |   <xsl:apply-templates select="@*|node()"/>
24 |  </xsl:copy>
25 | </xsl:template>
26 | 
27 | <!-- Filter: -->
28 | <xsl:template match="/nmaprun/host">
29 |     <xsl:if test="$include-hosts = ./address/@addr">
30 |         <xsl:copy>
31 |             <xsl:apply-templates select="@*|node()"/>
32 |         </xsl:copy>
33 |     </xsl:if>
34 | </xsl:template>
35 | 
36 | </xsl:stylesheet>
37 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/exclude-ports.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" 
 2 |     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 3 |     xmlns:npo="http://xmlns.sven.to/npo"
 4 |     xmlns:str="http://exslt.org/strings"
 5 |     extension-element-prefixes="str npo">
 6 | <npo:comment>[ports]
 7 |         Excludes a list of ports or ports of a specific host (in address:port format) from a scan result. Expects a comma-separated list as input.
 8 |         You can pipe the output, for instance:
 9 |             nmap-parse-output scan.xml exclude '80,443,192.168.0.2:80' | nmap-parse-output - service-names
10 | </npo:comment>
11 | <npo:category>manipulate</npo:category>
12 | <!-- see http://exslt.org/str/index.html -->
13 | 
14 | 
15 | <xsl:variable name="exclude-ports" select="str:tokenize($param1, ',')" />
16 | 
17 | <xsl:output method="xml" indent="yes"/>
18 | <xsl:strip-space elements="*" />
19 | 
20 | <xsl:template match="@*|node()">
21 |  <xsl:copy>
22 |   <xsl:apply-templates select="@*|node()"/>
23 |  </xsl:copy>
24 | </xsl:template>
25 | 
26 | <xsl:template match="/nmaprun/host/ports/port">
27 |     <xsl:if test="not($exclude-ports = ./@portid) and not($exclude-ports = concat(../../address/@addr, ':', ./@portid))">
28 |         <xsl:copy>
29 |             <xsl:apply-templates select="@*|node()"/>
30 |         </xsl:copy>
31 |     </xsl:if>
32 | </xsl:template>
33 | 
34 | </xsl:stylesheet>
35 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/include-ports.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" 
 2 |     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 3 |     xmlns:npo="http://xmlns.sven.to/npo"
 4 |     xmlns:str="http://exslt.org/strings"
 5 |     extension-element-prefixes="str npo">
 6 | <npo:comment>[ports]
 7 |         Filter a scan by a list of ports or ports of a specific host (in address:port format) so that only the specified ports are in the output. Expects a comma-separated list as input.
 8 |         You can pipe the output, for instance:
 9 |             nmap-parse-output scan.xml include-ports '80,443,192.168.0.2:8080' | nmap-parse-output - http-title
10 | </npo:comment>
11 | <npo:category>manipulate</npo:category>
12 | <!-- see http://exslt.org/str/index.html -->
13 | 
14 | 
15 | <xsl:variable name="include-ports" select="str:tokenize($param1, ',')" />
16 | 
17 | <xsl:output method="xml" indent="yes"/>
18 | <xsl:strip-space elements="*" />
19 | 
20 | <xsl:template match="@*|node()">
21 |  <xsl:copy>
22 |   <xsl:apply-templates select="@*|node()"/>
23 |  </xsl:copy>
24 | </xsl:template>
25 | 
26 | <xsl:template match="/nmaprun/host/ports/port">
27 |     <xsl:if test="($include-ports = ./@portid) or ($include-ports = concat(../../address/@addr, ':', ./@portid))">
28 |         <xsl:copy>
29 |             <xsl:apply-templates select="@*|node()"/>
30 |         </xsl:copy>
31 |     </xsl:if>
32 | </xsl:template>
33 | 
34 | </xsl:stylesheet>
35 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/ports-reachable.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo">
 2 | <npo:comment>
 3 |         Generates a comma-separated list of all reachable ports (open and closed, unfiltered). Can be used to verify if ports reachable from another host or generate port lists for specific environments.
 4 | </npo:comment>
 5 | <npo:category>extract</npo:category>
 6 | 
 7 |     <xsl:output method="text" />
 8 |     <xsl:strip-space elements="*" />
 9 | 
10 |     <xsl:key name="portid" match="/nmaprun/host/ports/port/state[@state = 'open' or @state = 'closed' or @state = 'unfiltered']/../@portid" use="." />
11 |     
12 |     <xsl:template match="/">
13 |         <!-- distinct port numbers, see https://stackoverflow.com/questions/2291567/how-to-use-xslt-to-create-distinct-values -->
14 |         <xsl:for-each select="/nmaprun/host/ports/port/state[@state = 'open' or @state = 'closed' or @state = 'unfiltered']/../@portid[generate-id() = generate-id(key('portid',.)[1])]">
15 |             <xsl:if test="position() != 1">
16 |                 <xsl:text>,</xsl:text>
17 |             </xsl:if>
18 |             <xsl:value-of select="."/>
19 |         </xsl:for-each>
20 |         
21 | <!--        TODO: filter for filtered ports? <xsl:if test="state[@state != 'filtered']"> -->
22 |     </xsl:template>
23 | 
24 |     <xsl:template match="text()" />
25 | </xsl:stylesheet>
26 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/mark-ports.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" 
 2 |     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 3 |     xmlns:npo="http://xmlns.sven.to/npo"
 4 |     xmlns:str="http://exslt.org/strings"
 5 |     extension-element-prefixes="str npo">
 6 | <npo:comment>[ports] [color]
 7 |         Marks a list of ports or hosts with port (in address:port format) with the given color in scan result. Expects a comma-separated list as input. The comment will be displayed in the HTML report.
 8 |         Example:
 9 |             nmap-parse-output scan.xml mark-ports '80,10.0.0.1:8080' red | nmap-parse-output - html > report.html
10 | </npo:comment>
11 | <npo:category>manipulate</npo:category>
12 | <!-- see http://exslt.org/str/index.html -->
13 | 
14 | 
15 | <xsl:variable name="mark-ports" select="str:tokenize($param1, ',')" />
16 | 
17 | <xsl:output method="xml" indent="yes"/>
18 | <xsl:strip-space elements="*" />
19 | 
20 | <xsl:template match="@*|node()">
21 |  <xsl:copy>
22 |   <xsl:apply-templates select="@*|node()"/>
23 |  </xsl:copy>
24 | </xsl:template>
25 | 
26 | <xsl:template match="/nmaprun/host/ports/port">
27 |     <xsl:copy>
28 |         <xsl:apply-templates select="@*|node()"/>
29 |         <xsl:if test="$mark-ports = ./@portid or $mark-ports = concat(../../address/@addr, ':', ./@portid)">
30 |             <npo-color-annotation><xsl:value-of select="$param2"/></npo-color-annotation>
31 |         </xsl:if>
32 |     </xsl:copy>
33 | </xsl:template>
34 | 
35 | </xsl:stylesheet>
36 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/comment-hosts.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" 
 2 |     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 3 |     xmlns:npo="http://xmlns.sven.to/npo"
 4 |     xmlns:str="http://exslt.org/strings"
 5 |     extension-element-prefixes="str npo">
 6 | <npo:comment>[hosts] [comment]
 7 |         Comments a list of hosts in scan result. Expects a comma-separated list as input. The comment will be displayed in the HTML report.
 8 |         Example:
 9 |             nmap-parse-output scan.xml comment-hosts '10.0.0.1,192.168.10.1' 'allowed services' | nmap-parse-output - html > report.html
10 |         You can comment hosts from another scan, too:
11 |             nmap-parse-output scan.xml comment-hosts $(./nmap-parse-output.sh scan-subnet.xml hosts | tr "\n" ",") 'this host was scanned in subnet, too.'
12 | </npo:comment>
13 | <npo:category>manipulate</npo:category>
14 | <!-- see http://exslt.org/str/index.html -->
15 | 
16 | 
17 | <xsl:variable name="comment-hosts" select="str:tokenize($param1, ',')" />
18 | 
19 | <xsl:output method="xml" indent="yes"/>
20 | <xsl:strip-space elements="*" />
21 | 
22 | <xsl:template match="@*|node()">
23 |  <xsl:copy>
24 |   <xsl:apply-templates select="@*|node()"/>
25 |  </xsl:copy>
26 | </xsl:template>
27 | 
28 | <xsl:template match="/nmaprun/host">
29 |     <xsl:copy>
30 |         <xsl:apply-templates select="@*|node()"/>
31 |         <xsl:if test="$comment-hosts = address/@addr">
32 |             <npo-comment><xsl:value-of select="$param2"/></npo-comment>
33 |         </xsl:if>
34 |     </xsl:copy>
35 | </xsl:template>
36 | 
37 | </xsl:stylesheet>
38 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2018, Sven Nobis <mail@sven.to>
 2 | All rights reserved.
 3 | 
 4 | Redistribution and use in source and binary forms, with or without
 5 | modification, are permitted provided that the following conditions are met:
 6 |     * Redistributions of source code must retain the above copyright
 7 |       notice, this list of conditions and the following disclaimer.
 8 |     * Redistributions in binary form must reproduce the above copyright
 9 |       notice, this list of conditions and the following disclaimer in the
10 |       documentation and/or other materials provided with the distribution.
11 |     * Neither the name of the <organization> nor the
12 |       names of its contributors may be used to endorse or promote products
13 |       derived from this software without specific prior written permission.
14 | 
15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
16 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
18 | DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
19 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
20 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
21 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
22 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
24 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/http-info.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo">
 2 | <npo:comment>
 3 |         Extracts a list of extra information about the HTTP ports from a script scan in the following format:
 4 |         host:port   service-name    service-tunnel  product  http-server-header  http-title   redirect_url
 5 | </npo:comment>
 6 | <npo:category>extract</npo:category>
 7 | <npo:post-processor>sort | uniq</npo:post-processor>
 8 |     <xsl:output method="text" />
 9 |     <xsl:strip-space elements="*" />
10 |     <xsl:template match="/nmaprun/host/ports/port">
11 |         <xsl:if test="script/@id='http-methods' and state[@state = 'open']">
12 |             <xsl:value-of select="../../address/@addr"/>
13 |             <xsl:text>:</xsl:text>
14 |             <xsl:value-of select="@portid"/><xsl:text>	</xsl:text>
15 |             <xsl:value-of select="service/@name"/><xsl:text>	</xsl:text>
16 |             <xsl:value-of select="service/@tunnel"/><xsl:text>	</xsl:text>
17 |             <xsl:value-of select="service/@product"/><xsl:text>	</xsl:text>
18 |             <xsl:value-of select="script[@id='http-server-header']/@output"/><xsl:text>	</xsl:text>
19 |             <xsl:value-of select="script[@id='http-title']/elem[@key='title']"/><xsl:text>	</xsl:text>
20 |             <xsl:value-of select="script[@id='http-title']/elem[@key='redirect_url']"/>
21 |             <xsl:text>
22 | </xsl:text>
23 |         </xsl:if>
24 |         <xsl:apply-templates/>
25 |     </xsl:template>
26 | 
27 |     <xsl:template match="text()" />
28 | </xsl:stylesheet>
29 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/comment-ports.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" 
 2 |     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 3 |     xmlns:npo="http://xmlns.sven.to/npo"
 4 |     xmlns:str="http://exslt.org/strings"
 5 |     extension-element-prefixes="str npo">
 6 | <npo:comment>[ports] [comment]
 7 |         Comments a list of ports or hosts with port (in address:port format) in scan result. Expects a comma-separated list as input. The comment will be displayed in the HTML report.
 8 |         Example:
 9 |             nmap-parse-output scan.xml comment-ports '80,10.0.0.1:8080' 'allowed services' | nmap-parse-output - html > report.html
10 |         You can comment services, too:
11 |             nmap-parse-output scan.xml comment-ports $(./nmap-parse-output.sh scan.xml service http | tr "\n" ",") 'this is a http port'
12 | </npo:comment>
13 | <npo:category>manipulate</npo:category>
14 | <!-- see http://exslt.org/str/index.html -->
15 | 
16 | 
17 | <xsl:variable name="comment-ports" select="str:tokenize($param1, ',')" />
18 | 
19 | <xsl:output method="xml" indent="yes"/>
20 | <xsl:strip-space elements="*" />
21 | 
22 | <xsl:template match="@*|node()">
23 |  <xsl:copy>
24 |   <xsl:apply-templates select="@*|node()"/>
25 |  </xsl:copy>
26 | </xsl:template>
27 | 
28 | <xsl:template match="/nmaprun/host/ports/port">
29 |     <xsl:copy>
30 |         <xsl:apply-templates select="@*|node()"/>
31 |         <xsl:if test="$comment-ports = ./@portid or $comment-ports = concat(../../address/@addr, ':', ./@portid)">
32 |             <npo-comment><xsl:value-of select="$param2"/></npo-comment>
33 |         </xsl:if>
34 |     </xsl:copy>
35 | </xsl:template>
36 | 
37 | </xsl:stylesheet>
38 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/http-ports.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo">
 2 | <npo:comment>
 3 |         Generates a line separated list of all HTTP(s) ports. Script scan output is recommended.
 4 |         Currently, the following services are detected as HTTP: http, https, http-alt, https-alt, http-proxy, sip, rtsp, soap, vnc-http, caldav (potentially incomplete) and to get a more reliable result all ports which which have output in the http-methods script. 
 5 |         On ports where HTTPs and HTTP is responding, the HTTPs port is preferred.
 6 | </npo:comment>
 7 | <npo:category>extract</npo:category>
 8 |     <xsl:output method="text" />
 9 |     <xsl:strip-space elements="*" />
10 |     <xsl:template match="/nmaprun/host/ports/port[state/@state='open']">
11 |         <xsl:if test="service/@name='http' or service/@name='https' or service/@name='http-alt' or service/@name='http-proxy' or service/@name='soap' or service/@name='sip' or service/@name='rtsp' or service/@name='vnc-http'  or service/@name='caldav' or script/@id='http-methods'">
12 |             <xsl:choose>
13 |                 <xsl:when test="service/@tunnel='ssl' or script[@id='ssl-cert'] or script[@id='ssl-date']">
14 |                     <xsl:text>https://</xsl:text>
15 |                 </xsl:when>
16 |                 <xsl:otherwise>
17 |                     <xsl:text>http://</xsl:text>
18 |                 </xsl:otherwise>
19 |             </xsl:choose>
20 |             <xsl:value-of select="../../address/@addr"/>
21 |             <xsl:text>:</xsl:text>
22 |             <xsl:value-of select="@portid"/>
23 |             <xsl:text>
24 | </xsl:text>
25 |         </xsl:if>
26 |         <xsl:apply-templates/>
27 |     </xsl:template>
28 | 
29 |     <xsl:template match="text()" />
30 | </xsl:stylesheet>
31 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/group-by-product.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo"
 2 |     xmlns:func="http://exslt.org/functions"
 3 |     xmlns:set="http://exslt.org/sets"
 4 |     extension-element-prefixes="func npo set">
 5 | <npo:comment>
 6 |         Groups open ports by product name and generates a human-readable list in the markdown format. The command ignores ports with empty product name.
 7 | </npo:comment>
 8 | <npo:category>extract</npo:category>
 9 | 
10 |     <xsl:output method="text" />
11 |     <xsl:strip-space elements="*" />
12 | 
13 |     <func:function name="npo:product-name">
14 |         <xsl:param name="port" />
15 |         <xsl:variable name="result">
16 |             <xsl:value-of select="$port/service/@product" />
17 |         </xsl:variable>
18 |         <func:result select="$result" />
19 |     </func:function>
20 | 
21 |     <xsl:key name="key" match="/nmaprun/host/ports/port[state/@state = 'open' and service/@product]"
22 |       use="npo:product-name(.)"/>
23 | 
24 |     <xsl:template match="/nmaprun">
25 |         <xsl:for-each select=
26 |      "host/ports/port[generate-id(.)=generate-id(key('key', npo:product-name(.))[1])]">
27 |             <xsl:text>- Product </xsl:text>
28 |             <xsl:value-of select="npo:product-name(.)"/>
29 |             <xsl:text> on:
30 | </xsl:text>
31 |             <xsl:for-each select="key('key', npo:product-name(.))">
32 |                 <xsl:text>  - </xsl:text>
33 |                 <xsl:value-of select="../../address/@addr"/>
34 |                 <xsl:text>:</xsl:text>
35 |                 <xsl:value-of select="@portid"/>
36 |                 <xsl:if test="../../hostnames/hostname"> (<xsl:value-of select="../../hostnames/hostname/@name"/>)</xsl:if>
37 |                 <xsl:if test="service/@version">; version: <xsl:value-of select="service/@version"/></xsl:if><xsl:text>
38 | </xsl:text>
39 | 
40 |             </xsl:for-each>
41 |         </xsl:for-each>
42 |     </xsl:template>
43 | 
44 |     <xsl:template match="text()" />
45 | </xsl:stylesheet>
46 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/group-by-ports.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo"
 2 |     xmlns:func="http://exslt.org/functions"
 3 |     xmlns:set="http://exslt.org/sets"
 4 |     extension-element-prefixes="func npo set">
 5 | <npo:comment>
 6 |         Groups hosts by open TCP ports and generates a human-readable list in the markdown format.
 7 | </npo:comment>
 8 | <npo:category>extract</npo:category>
 9 | 
10 |     <xsl:output method="text" />
11 |     <xsl:strip-space elements="*" />
12 | 
13 |     <func:function name="npo:portlist">
14 |         <xsl:param name="host" />
15 |         <xsl:variable name="result">
16 |             <xsl:for-each select="$host/ports/port[@protocol = 'tcp']/state[@state = 'open']/../@portid">
17 |                 <xsl:if test="position() != 1">
18 |                     <xsl:text>,</xsl:text>
19 |                 </xsl:if>
20 |                 <xsl:value-of select="."/>
21 |             </xsl:for-each>
22 |         </xsl:variable>
23 |         <func:result select="$result" />
24 |     </func:function>
25 | 
26 |     <xsl:key name="key" match="/nmaprun/host"
27 |       use="npo:portlist(.)"/>
28 | 
29 |     <xsl:template match="/nmaprun">
30 |         <xsl:for-each select=
31 |      "host[generate-id(.)=generate-id(key('key', npo:portlist(.))[1])]">
32 |             <xsl:choose>
33 |                 <xsl:when test="npo:portlist(.) = ''">
34 |                     <xsl:text>- No open TCP ports</xsl:text>
35 |                 </xsl:when>
36 |                 <xsl:otherwise>
37 |                     <xsl:text>- Open TCP ports </xsl:text>
38 |                     <xsl:value-of select="npo:portlist(.)"/>
39 |                 </xsl:otherwise>
40 |             </xsl:choose>
41 |             
42 |             <xsl:text> on:
43 | </xsl:text>
44 |             <xsl:for-each select="key('key', npo:portlist(.))">
45 |                 <xsl:text>  - </xsl:text><xsl:value-of select="address/@addr"/><xsl:if test="hostnames/hostname"> (<xsl:value-of select="hostnames/hostname/@name"/>)</xsl:if><xsl:text>
46 | </xsl:text>
47 |             </xsl:for-each>
48 |         </xsl:for-each>
49 |     </xsl:template>
50 | 
51 |     <xsl:template match="text()" />
52 | </xsl:stylesheet>
53 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/group-by-service.xslt:
--------------------------------------------------------------------------------
 1 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo"
 2 |     xmlns:func="http://exslt.org/functions"
 3 |     xmlns:set="http://exslt.org/sets"
 4 |     extension-element-prefixes="func npo set">
 5 | <npo:comment>
 6 |         Groups open ports by service name and generates a human-readable list in the markdown format.
 7 | </npo:comment>
 8 | <npo:category>extract</npo:category>
 9 | 
10 |     <xsl:output method="text" />
11 |     <xsl:strip-space elements="*" />
12 | 
13 |     <func:function name="npo:service-name">
14 |         <xsl:param name="port" />
15 |         <xsl:variable name="result">
16 |             <xsl:value-of select="$port/service/@name" />
17 |         </xsl:variable>
18 |         <func:result select="$result" />
19 |     </func:function>
20 | 
21 |     <xsl:key name="key" match="/nmaprun/host/ports/port[state/@state = 'open']"
22 |       use="npo:service-name(.)"/>
23 | 
24 |     <xsl:template match="/nmaprun">
25 |         <xsl:for-each select=
26 |      "host/ports/port[generate-id(.)=generate-id(key('key', npo:service-name(.))[1])]">
27 |             <xsl:choose>
28 |                 <xsl:when test="npo:service-name(.) = ''">
29 |                     <xsl:text>- No service detected</xsl:text>
30 |                 </xsl:when>
31 |                 <xsl:otherwise>
32 |                     <xsl:text>- Service </xsl:text>
33 |                     <xsl:value-of select="npo:service-name(.)"/>
34 |                 </xsl:otherwise>
35 |             </xsl:choose>
36 |             
37 |             <xsl:text> on:
38 | </xsl:text>
39 |             <xsl:for-each select="key('key', npo:service-name(.))">
40 |                 <xsl:text>  - </xsl:text>
41 |                 <xsl:value-of select="../../address/@addr"/>
42 |                 <xsl:text>:</xsl:text>
43 |                 <xsl:value-of select="@portid"/>
44 |                 <xsl:if test="../../hostnames/hostname"> (<xsl:value-of select="../../hostnames/hostname/@name"/>)</xsl:if>
45 |                 <xsl:if test="service/@product">; product: <xsl:value-of select="service/@product"/></xsl:if>
46 |                 <xsl:if test="service/@version">; version: <xsl:value-of select="service/@version"/></xsl:if>
47 |                 <xsl:text>
48 | </xsl:text>
49 |             </xsl:for-each>
50 |         </xsl:for-each>
51 |     </xsl:template>
52 | 
53 |     <xsl:template match="text()" />
54 | </xsl:stylesheet>
55 | 


--------------------------------------------------------------------------------
/ThirdPartyNotices.md:
--------------------------------------------------------------------------------
 1 | # nmap-parse-output
 2 | 
 3 | ## THIRD-PARTY SOFTWARE NOTICES AND INFORMATION
 4 | 
 5 | This project incorporates components from the projects listed below. The original copyright notices and the licenses under which ERNW received such components are set forth below.
 6 | 
 7 | 1. [Nmap Bootstrap XSL](https://github.com/honze-net/nmap-bootstrap-xsl)
 8 | 2. [XSLTJSON Lite v0.2](https://github.com/bramstein/xsltjson)
 9 | 3. [nmap.xsl](https://github.com/nmap/nmap)
10 | 
11 | ### 1. Nmap Bootstrap XSL
12 | 
13 | Used in [command html-bootstrap](nmap-parse-output-xslt/html-bootstrap.xslt)
14 | 
15 | https://github.com/honze-net/nmap-bootstrap-xsl
16 | 
17 | ```
18 | Creative Commons BY-SA
19 | Andreas Hontzia (@honze_net)
20 | ```
21 | ### 2. XSLTJSON Lite v0.2
22 | 
23 | Used in [command to-json](nmap-parse-output-xslt/to-json.xslt)
24 | 
25 | https://github.com/bramstein/xsltjson/blob/master/conf/xml-to-jsonml.xsl
26 | 
27 | ```
28 | XSLTJSON Lite v0.2 - Transform arbitrary XML to JSONML	
29 | 
30 | Licensed under the new BSD License.
31 | Copyright 2009, Bram Stein
32 | All rights reserved.
33 | ```
34 | 
35 | ### 3. nmap.xsl
36 | 
37 | Used in [command to-json](nmap-parse-output-xslt/html.xslt)
38 | 
39 | https://github.com/nmap/nmap/blob/master/docs/nmap.xsl
40 | 
41 | ```
42 | =========================================================================
43 |             nmap.xsl stylesheet version 0.9c
44 |             last change: 2010-12-28
45 |             Benjamin Erb, http://www.benjamin-erb.de
46 | ==============================================================================
47 |     Copyright (c) 2004-2006 Benjamin Erb
48 |     All rights reserved.
49 | 
50 |     Redistribution and use in source and binary forms, with or without
51 |     modification, are permitted provided that the following conditions
52 |     are met:
53 |     1. Redistributions of source code must retain the above copyright
54 |        notice, this list of conditions and the following disclaimer.
55 |     2. Redistributions in binary form must reproduce the above copyright
56 |        notice, this list of conditions and the following disclaimer in the
57 |        documentation and/or other materials provided with the distribution.
58 |     3. The name of the author may not be used to endorse or promote products
59 |        derived from this software without specific prior written permission.
60 | 
61 |     THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
62 |     IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
63 |     OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
64 |     IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
65 |     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
66 |     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
67 |     DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
68 |     THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
69 |     (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
70 |     THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
71 | ==========================================================================
72 | ```
73 | 


--------------------------------------------------------------------------------
/nmap-parse-output:
--------------------------------------------------------------------------------
  1 | #!/bin/bash
  2 | NPO_VERSION=1.5.1
  3 | 
  4 | # get script path
  5 | SOURCE="${BASH_SOURCE[0]}"
  6 | while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink
  7 |   DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
  8 |   SOURCE="$(readlink "$SOURCE")"
  9 |   [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE" # if $SOURCE was a relative symlink, we need to resolve it relative to the path where the symlink file was located
 10 | done
 11 | SCRIPT_DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
 12 | 
 13 | XSLT_DIR=$SCRIPT_DIR/nmap-parse-output-xslt
 14 | 
 15 | # functions (mostly for help)
 16 | function xml_node_text() {
 17 |   xmllint --xpath "//*[local-name()='$2' and namespace-uri()='http://xmlns.sven.to/npo']/text()" $1 2>/dev/null
 18 | }
 19 | 
 20 | function print_command_category() {
 21 |   echo "$1 Commands:"
 22 |   for fullf in $XSLT_DIR/*.xslt; do
 23 |     if [ "$(xml_node_text $fullf category)" == "$2" ]
 24 |     then
 25 |       f=$(basename $fullf)
 26 |       echo -e -n "  ${f%.*} "
 27 |       xml_node_text $fullf comment || echo -e "\n\t(No documentation)"
 28 |     fi
 29 |   done
 30 |   echo 
 31 | }
 32 | 
 33 | function help() {
 34 |   echo "Usage: $0 [options]... <nmap-xml-output> <command> [command-parameters]..."
 35 |   echo 
 36 |   echo "Converts/manipulates/extracts data from nmap scan XML output."
 37 |   echo 
 38 |   echo "Options:"
 39 |   echo -e "  -u, --unfinished-scan\t\t\t try to read an unfinished scan output"
 40 |   echo
 41 |   print_command_category "Extract Data" "extract"
 42 |   print_command_category "Manipulate Scan" "manipulate"
 43 |   print_command_category "Convert Scan" "convert"
 44 |   print_command_category "Misc" ""
 45 |   
 46 |   echo "[v$NPO_VERSION]"
 47 |   
 48 |   exit 1
 49 | }
 50 | 
 51 | # check if xsltproc is installed
 52 | command -v xsltproc >/dev/null 2>&1 || { echo "Please install xsltproc.  Aborting." >&2; exit 1; }
 53 | 
 54 | # parse global options
 55 | UNFINISHED_SCAN=""
 56 | 
 57 | while [ $# -gt 0 ]
 58 | do
 59 |   CURRENT_PARAM=$1
 60 | 
 61 |   case "$1" in
 62 |           --help|-h)
 63 |               help
 64 |               ;;
 65 |           --unfinished-scan|-u)
 66 |               UNFINISHED_SCAN="</nmaprun>"
 67 |               ;;
 68 |           *)
 69 |               break
 70 |   esac
 71 |   
 72 |   shift
 73 | done
 74 | 
 75 | # NMAP_XML_OUTPUT and COMMAND was not provided; print help:
 76 | [ $# -lt 2 ] && help
 77 | 
 78 | # check if input is readable
 79 | NMAP_XML_OUTPUT=$1
 80 | [ -f "$NMAP_XML_OUTPUT" -o "$NMAP_XML_OUTPUT" = "-" ] || { echo "Can't read nmap file: $NMAP_XML_OUTPUT.  Aborting." >&2; exit 1; }
 81 | 
 82 | XSLT=$XSLT_DIR/$2.xslt
 83 | [ -f $XSLT ] || { echo "Unknown command: $2.  Aborting." >&2; exit 1; }
 84 | 
 85 | # read post process command from xslt
 86 | POST_PIPE=$(xml_node_text $XSLT post-processor)
 87 | if [ -z "$POST_PIPE" ]
 88 | then
 89 |   POST_PIPE="cat - "
 90 | else
 91 |   POST_PIPE="cat - | $POST_PIPE"
 92 | fi
 93 | 
 94 | # pass remaining parameters to xslt
 95 | EXTRA_PARAMS=()
 96 | i=0
 97 | shift
 98 | shift
 99 | while [ $# -gt 0 ]
100 | do
101 |   ((i++))
102 |   EXTRA_PARAMS+=(--stringparam "param$i" "$1")
103 |   shift
104 | done
105 | 
106 | # process command on scan XML output
107 | { cat "$NMAP_XML_OUTPUT"; echo "$UNFINISHED_SCAN"; } | \
108 |   xsltproc "${EXTRA_PARAMS[@]}" "$XSLT" - | \
109 |   bash -c "$POST_PIPE"
110 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/to-json.xslt:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <xsl:stylesheet version="1.0" 
  3 | 	xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  4 | 	xmlns:json="http://json.org/" xmlns:npo="http://xmlns.sven.to/npo">
  5 | <npo:comment>
  6 |         Converts a nmap scan output to JSON
  7 | </npo:comment>
  8 | <npo:category>convert</npo:category>
  9 | 
 10 | 	<!--
 11 | 	   XSLTJSON Lite v0.2 - Transform arbitrary XML to JSONML	
 12 | 
 13 | 	   Licensed under the new BSD License.
 14 | 	   Copyright 2009, Bram Stein
 15 | 	   All rights reserved.
 16 | 	   
 17 | 	   https://github.com/bramstein/xsltjson/blob/master/conf/xml-to-jsonml.xsl
 18 | 	-->
 19 | 	<xsl:output indent="no" omit-xml-declaration="yes" method="text" encoding="utf-8"/>
 20 | 	<xsl:strip-space elements="*"/>
 21 | 
 22 | 	<json:search name="string">
 23 | 		<json:replace src="\" dst="\\"/>
 24 | 		<json:replace src="&quot;" dst="\&quot;"/>
 25 | 		<json:replace src="&#xA;" dst="\n"/>
 26 | 		<json:replace src="&#xD;" dst="\r"/>
 27 | 		<json:replace src="&#x9;" dst="\t"/>
 28 | 		<json:replace src="\n" dst="\n"/>
 29 | 		<json:replace src="\r" dst="\r"/>
 30 | 		<json:replace src="\t" dst="\t"/>
 31 | 	</json:search>
 32 | 
 33 | 	<xsl:template match="node()">
 34 | 		<xsl:text>[</xsl:text>	
 35 | 
 36 | 		<xsl:call-template name="encode-value">
 37 | 			<xsl:with-param name="value" select="name()"/>
 38 | 		</xsl:call-template>	
 39 | 	
 40 | 		<xsl:if test="@*">
 41 | 			<xsl:text>,</xsl:text>
 42 | 			<xsl:text>{</xsl:text>
 43 | 			<xsl:for-each select="@*">
 44 | 				<xsl:apply-templates select="."/>
 45 | 				<xsl:if test="position() != last()">
 46 | 					<xsl:text>,</xsl:text>
 47 | 				</xsl:if>
 48 | 			</xsl:for-each>
 49 | 			<xsl:text>}</xsl:text>
 50 | 		</xsl:if>
 51 | 		<xsl:if test="node()">
 52 | 			<xsl:text>,</xsl:text>
 53 | 			<xsl:for-each select="node()">
 54 | 				<xsl:apply-templates select="."/>
 55 | 				<xsl:if test="position() != last()">
 56 | 					<xsl:text>,</xsl:text>
 57 | 				</xsl:if>
 58 | 			</xsl:for-each>
 59 | 		</xsl:if>
 60 | 		<xsl:text>]</xsl:text>
 61 | 	</xsl:template>
 62 | 
 63 | 	<xsl:template match="text()" priority="10">
 64 | 		<xsl:call-template name="encode-value">
 65 | 			<xsl:with-param name="value" select="."/>
 66 | 		</xsl:call-template>
 67 | 	</xsl:template>
 68 | 
 69 | 	<xsl:template match="@*">
 70 | 		<xsl:call-template name="encode-value">
 71 | 			<xsl:with-param name="value" select="name()"/>
 72 | 		</xsl:call-template>
 73 | 		<xsl:text>:</xsl:text>
 74 | 		<xsl:call-template name="encode-value">
 75 | 			<xsl:with-param name="value" select="."/>
 76 | 		</xsl:call-template>
 77 | 	</xsl:template>
 78 | 
 79 | 	<xsl:template name="replace-string">
 80 | 		<xsl:param name="input"/>
 81 | 		<xsl:param name="src"/>
 82 | 		<xsl:param name="dst"/>
 83 | 		<xsl:choose>
 84 | 			<xsl:when test="contains($input, $src)">
 85 | 				<xsl:value-of select="concat(substring-before($input, $src), $dst)"/>
 86 | 				<xsl:call-template name="replace-string">
 87 | 					<xsl:with-param name="input" select="substring-after($input, $src)"/>
 88 | 					<xsl:with-param name="src" select="$src"/>
 89 | 					<xsl:with-param name="dst" select="$dst"/>
 90 | 				</xsl:call-template>
 91 | 			</xsl:when>
 92 | 			<xsl:otherwise>
 93 | 				<xsl:value-of select="$input"/>
 94 | 			</xsl:otherwise>
 95 | 		</xsl:choose>
 96 | 	</xsl:template>
 97 | 
 98 | 	<xsl:template name="encode">
 99 | 		<xsl:param name="input"/>
100 | 		<xsl:param name="index">1</xsl:param>
101 | 
102 | 		<xsl:variable name="text">
103 | 			<xsl:call-template name="replace-string">
104 | 				<xsl:with-param name="input" select="$input"/>
105 | 				<xsl:with-param name="src" select="document('')//json:search/json:replace[$index]/@src"/>
106 | 				<xsl:with-param name="dst" select="document('')//json:search/json:replace[$index]/@dst"/>
107 | 			</xsl:call-template>
108 | 		</xsl:variable>
109 | 
110 | 		<xsl:choose>
111 | 			<xsl:when test="$index &lt; count(document('')//json:search/json:replace)">
112 | 				<xsl:call-template name="encode">
113 | 					<xsl:with-param name="input" select="$text"/>
114 | 					<xsl:with-param name="index" select="$index + 1"/>
115 | 				</xsl:call-template>
116 | 			</xsl:when>
117 | 			<xsl:otherwise>
118 | 				<xsl:value-of select="$text"/>
119 | 			</xsl:otherwise>
120 | 		</xsl:choose>
121 | 	</xsl:template>
122 | 
123 | 	<xsl:template name="encode-value">
124 | 		<xsl:param name="value"/>
125 | 		<xsl:choose>
126 | 			<xsl:when test="(normalize-space($value) != $value or string(number($value)) = 'NaN' or (substring($value , string-length($value), 1) = '.') or (substring($value, 1, 1) = '0') and not($value = '0')) and not($value = 'false') and not($value = 'true') and not($value = 'null')">
127 | 				<xsl:text>"</xsl:text>
128 | 				<xsl:call-template name="encode">
129 | 					<xsl:with-param name="input" select="$value"/>
130 | 				</xsl:call-template>
131 | 				<xsl:text>"</xsl:text>
132 | 			</xsl:when>
133 | 			<xsl:otherwise>
134 | 				<xsl:value-of select="$value"/>
135 | 			</xsl:otherwise>
136 | 		</xsl:choose>
137 | 	</xsl:template>
138 | </xsl:stylesheet>
139 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/html-bootstrap.xslt:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <!--
  3 | Nmap Bootstrap XSL
  4 | Creative Commons BY-SA
  5 | Andreas Hontzia (@honze_net)
  6 | -->
  7 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo">
  8 | <npo:comment>
  9 |         Converts the XML output into a fancy HTML report based on Bootstrap.
 10 |         Note: This HTML report requests JS/CSS libs from CDNs. However, the generated file uses the no-referrer meta tag and subresource integrity to protect the confidentiality.
 11 | </npo:comment>
 12 | <npo:category>convert</npo:category>
 13 |   <xsl:output method="html" encoding="utf-8" indent="yes" doctype-system="about:legacy-compat"/>
 14 |   <xsl:template match="/">
 15 |     <html lang="en">
 16 |       <head>
 17 |         <meta name="referrer" content="no-referrer"/> 
 18 |         <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous"/>
 19 |         <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap-theme.min.css" integrity="sha384-rHyoN1iRsVXV4nD0JutlnGaslCJuC7uwjduW9SVrLvRYooPp2bWYgmgJQIXwl/Sp" crossorigin="anonymous"/>
 20 |         <link rel="stylesheet" href="https://cdn.datatables.net/1.10.19/css/dataTables.bootstrap.min.css" type="text/css" integrity="sha384-VEpVDzPR2x8NbTDZ8NFW4AWbtT2g/ollEzX/daZdW/YvUBlbgVtsxMftnJ84k0Cn" crossorigin="anonymous"/>
 21 |         <script src="https://code.jquery.com/jquery-3.3.1.js" integrity="sha384-fJU6sGmyn07b+uD1nMk7/iSb4yvaowcueiQhfVgQuD98rfva8mcr1eSvjchfpMrH" crossorigin="anonymous"></script>
 22 |         <script src="https://cdn.datatables.net/1.10.19/js/jquery.dataTables.min.js" integrity="sha384-rgWRqC0OFPisxlUvl332tiM/qmaNxnlY46eksSZD84t+s2vZlqGeHrncwIRX7CGp" crossorigin="anonymous"></script>
 23 |         <script src="https://cdn.datatables.net/1.10.19/js/dataTables.bootstrap.min.js" integrity="sha384-7PXRkl4YJnEpP8uU4ev9652TTZSxrqC8uOpcV1ftVEC7LVyLZqqDUAaq+Y+lGgr9" crossorigin="anonymous"></script>
 24 |         <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js" integrity="sha384-Tc5IQib027qvyjSMfHjOMaLkfuWVxZxUPnCJA7l2mCWNIpG9mGCD8wGNIcPD7Txa" crossorigin="anonymous"></script>
 25 |         <style>
 26 |           .target:before {
 27 |             content: "";
 28 |             display: block;
 29 |             height: 50px;
 30 |             margin: -20px 0 0;
 31 |           }
 32 |           @media only screen and (min-width:1900px) {
 33 |             .container {
 34 |               width: 1800px;
 35 |               }
 36 |           }
 37 |           .footer {
 38 |             margin-top:60px;
 39 |             padding-top:60px;
 40 |             width: 100%;
 41 |             height: 180px;
 42 |             background-color: #f5f5f5;
 43 |           }
 44 |         </style>
 45 |         <title>Scan Report Nmap <xsl:value-of select="/nmaprun/@version"/></title>
 46 |       </head>
 47 |       <body>
 48 |         <nav class="navbar navbar-default navbar-fixed-top">
 49 |           <div class="container-fluid">
 50 |             <div class="navbar-header">
 51 |               <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1" aria-expanded="false">
 52 |                 <span class="sr-only">Toggle navigation</span>
 53 |                 <span class="icon-bar"></span>
 54 |                 <span class="icon-bar"></span>
 55 |                 <span class="icon-bar"></span>
 56 |               </button>
 57 |               <a class="navbar-brand" href="#"><span class="glyphicon glyphicon-home"></span></a>
 58 |             </div>
 59 |             <div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
 60 |               <ul class="nav navbar-nav">
 61 |                 <li><a href="#scannedhosts">Scanned Hosts</a></li>
 62 |                 <li><a href="#onlinehosts">Online Hosts</a></li>
 63 |                 <li><a href="#openservices">Open Services</a></li>
 64 |               </ul>
 65 |             </div>
 66 |           </div>
 67 |         </nav>
 68 |         <div class="container">
 69 |           <div class="jumbotron">
 70 |             <h1>Scan Report<br/><small>Nmap <xsl:value-of select="/nmaprun/@version"/></small></h1>
 71 |             <pre style="white-space:pre-wrap; word-wrap:break-word;"><xsl:value-of select="/nmaprun/@args"/></pre>
 72 |             <p class="lead">
 73 |               <xsl:value-of select="/nmaprun/@startstr"/> – <xsl:value-of select="/nmaprun/runstats/finished/@timestr"/><br/>
 74 |               <xsl:value-of select="/nmaprun/runstats/hosts/@total"/> hosts scanned.
 75 |               <xsl:value-of select="/nmaprun/runstats/hosts/@up"/> hosts up.
 76 |               <xsl:value-of select="/nmaprun/runstats/hosts/@down"/> hosts down.
 77 |             </p>
 78 |             <div class="progress">
 79 |               <div class="progress-bar progress-bar-success" style="width: 0%">
 80 |                 <xsl:attribute name="style">width:<xsl:value-of select="/nmaprun/runstats/hosts/@up div /nmaprun/runstats/hosts/@total * 100"/>%;</xsl:attribute>
 81 |                 <xsl:value-of select="/nmaprun/runstats/hosts/@up"/>
 82 |                 <span class="sr-only"></span>
 83 |               </div>
 84 |               <div class="progress-bar progress-bar-danger" style="width: 0%">
 85 |                 <xsl:attribute name="style">width:<xsl:value-of select="/nmaprun/runstats/hosts/@down div /nmaprun/runstats/hosts/@total * 100"/>%;</xsl:attribute>
 86 |                 <xsl:value-of select="/nmaprun/runstats/hosts/@down"/>
 87 |                 <span class="sr-only"></span>
 88 |               </div>
 89 |             </div>
 90 |           </div>
 91 |           <h2 id="scannedhosts" class="target">Scanned Hosts<xsl:if test="/nmaprun/runstats/hosts/@down > 1024"><small> (offline hosts are hidden)</small></xsl:if></h2>
 92 |           <div class="table-responsive">
 93 |             <table id="table-overview" class="table table-striped dataTable" role="grid">
 94 |               <thead>
 95 |                 <tr>
 96 |                   <th>State</th>
 97 |                   <th>Address</th>
 98 |                   <th>Hostname</th>
 99 |                   <th>TCP (open)</th>
100 |                   <th>UDP (open)</th>
101 |                 </tr>
102 |               </thead>
103 |               <tbody>
104 |                 <xsl:choose>
105 |                   <xsl:when test="/nmaprun/runstats/hosts/@down > 1024">
106 |                     <xsl:for-each select="/nmaprun/host[status/@state='up']">
107 |                       <tr>
108 |                         <td><span class="label label-danger"><xsl:if test="status/@state='up'"><xsl:attribute name="class">label label-success</xsl:attribute></xsl:if><xsl:value-of select="status/@state"/></span></td>
109 |                         <td><xsl:value-of select="address/@addr"/></td>
110 |                         <td><xsl:value-of select="hostnames/hostname/@name"/></td>
111 |                         <td><xsl:value-of select="count(ports/port[state/@state='open' and @protocol='tcp'])"/></td>
112 |                         <td><xsl:value-of select="count(ports/port[state/@state='open' and @protocol='udp'])"/></td>
113 |                       </tr>
114 |                     </xsl:for-each>
115 |                   </xsl:when>
116 |                   <xsl:otherwise>
117 |                     <xsl:for-each select="/nmaprun/host">
118 |                       <tr>
119 |                         <td><span class="label label-danger"><xsl:if test="status/@state='up'"><xsl:attribute name="class">label label-success</xsl:attribute></xsl:if><xsl:value-of select="status/@state"/></span></td>
120 |                         <td><xsl:value-of select="address/@addr"/></td>
121 |                         <td><xsl:value-of select="hostnames/hostname/@name"/></td>
122 |                         <td><xsl:value-of select="count(ports/port[state/@state='open' and @protocol='tcp'])"/></td>
123 |                         <td><xsl:value-of select="count(ports/port[state/@state='open' and @protocol='udp'])"/></td>
124 |                       </tr>
125 |                     </xsl:for-each>
126 |                   </xsl:otherwise>
127 |                 </xsl:choose>
128 |               </tbody>
129 |             </table>
130 |           </div>
131 |           <script>
132 |             $(document).ready(function() {
133 |               $('#table-overview').DataTable();
134 |             });
135 |           </script>
136 |           <h2 id="onlinehosts" class="target">Online Hosts</h2>
137 |           <xsl:for-each select="/nmaprun/host[status/@state='up']">
138 |             <div class="panel panel-default">
139 |               <div class="panel-heading">
140 |                 <h3 class="panel-title"><xsl:value-of select="address/@addr"/><xsl:if test="count(hostnames/hostname) > 0"> - <xsl:value-of select="hostnames/hostname/@name"/></xsl:if></h3>
141 |               </div>
142 |               <div class="panel-body">
143 |                 <xsl:if test="count(hostnames/hostname) > 0">
144 |                   <h4>Hostnames</h4>
145 |                   <ul>
146 |                     <xsl:for-each select="hostnames/hostname">
147 |                       <li><xsl:value-of select="@name"/> (<xsl:value-of select="@type"/>)</li>
148 |                     </xsl:for-each>
149 |                   </ul>
150 |                 </xsl:if>
151 |                 <h4>Ports</h4>
152 |                 <div class="table-responsive">
153 |                   <table class="table table-bordered">
154 |                     <thead>
155 |                       <tr>
156 |                         <th>Port</th>
157 |                         <th>Protocol</th>
158 |                         <th>State<br/>Reason</th>
159 |                         <th>Service</th>
160 |                         <th>Product</th>
161 |                         <th>Version</th>
162 |                         <th>Extra Info</th>
163 |                       </tr>
164 |                     </thead>
165 |                     <tbody>
166 |                       <xsl:for-each select="ports/port">
167 |                         <xsl:choose>
168 |                           <xsl:when test="state/@state = 'open'">
169 |                             <tr class="success">
170 |                               <td title="Port"><xsl:value-of select="@portid"/></td>
171 |                               <td title="Protocol"><xsl:value-of select="@protocol"/></td>
172 |                               <td title="State / Reason"><xsl:value-of select="state/@state"/><br/><xsl:value-of select="state/@reason"/></td>
173 |                               <td title="Service"><xsl:value-of select="service/@name"/></td>
174 |                               <td title="Product"><xsl:value-of select="service/@product"/></td>
175 |                               <td title="Version"><xsl:value-of select="service/@version"/></td>
176 |                               <td title="Extra Info"><xsl:value-of select="service/@extrainfo"/></td>
177 |                             </tr>
178 |                             <tr>
179 |                               <td colspan="7">
180 |                                 <a><xsl:attribute name="href">https://nvd.nist.gov/vuln/search/results?form_type=Advanced&amp;cves=on&amp;cpe_version=<xsl:value-of select="service/cpe"/></xsl:attribute><xsl:value-of select="service/cpe"/></a>
181 |                                 <xsl:for-each select="script">
182 |                                   <h5><xsl:value-of select="@id"/></h5>
183 |                                   <pre style="white-space:pre-wrap; word-wrap:break-word;"><xsl:value-of select="@output"/></pre>
184 |                                 </xsl:for-each>
185 |                               </td>
186 |                             </tr>
187 |                           </xsl:when>
188 |                           <xsl:when test="state/@state = 'filtered'">
189 |                             <tr class="warning">
190 |                               <td><xsl:value-of select="@portid"/></td>
191 |                               <td><xsl:value-of select="@protocol"/></td>
192 |                               <td><xsl:value-of select="state/@state"/><br/><xsl:value-of select="state/@reason"/></td>
193 |                               <td><xsl:value-of select="service/@name"/></td>
194 |                               <td><xsl:value-of select="service/@product"/></td>
195 |                               <td><xsl:value-of select="service/@version"/></td>
196 |                               <td><xsl:value-of select="service/@extrainfo"/></td>
197 |                             </tr>
198 |                           </xsl:when>
199 |                           <xsl:when test="state/@state = 'closed'">
200 |                             <tr class="active">
201 |                               <td><xsl:value-of select="@portid"/></td>
202 |                               <td><xsl:value-of select="@protocol"/></td>
203 |                               <td><xsl:value-of select="state/@state"/><br/><xsl:value-of select="state/@reason"/></td>
204 |                               <td><xsl:value-of select="service/@name"/></td>
205 |                               <td><xsl:value-of select="service/@product"/></td>
206 |                               <td><xsl:value-of select="service/@version"/></td>
207 |                               <td><xsl:value-of select="service/@extrainfo"/></td>
208 |                             </tr>
209 |                           </xsl:when>
210 |                           <xsl:otherwise>
211 |                             <tr class="info">
212 |                               <td><xsl:value-of select="@portid"/></td>
213 |                               <td><xsl:value-of select="@protocol"/></td>
214 |                               <td><xsl:value-of select="state/@state"/><br/><xsl:value-of select="state/@reason"/></td>
215 |                               <td><xsl:value-of select="service/@name"/></td>
216 |                               <td><xsl:value-of select="service/@product"/></td>
217 |                               <td><xsl:value-of select="service/@version"/></td>
218 |                               <td><xsl:value-of select="service/@extrainfo"/></td>
219 |                             </tr>
220 |                           </xsl:otherwise>
221 |                         </xsl:choose>
222 |                       </xsl:for-each>
223 |                     </tbody>
224 |                   </table>
225 |                 </div>
226 |                 <xsl:if test="count(hostscript/script) > 0">
227 |                   <h4>Host Script</h4>
228 |                 </xsl:if>
229 |                 <xsl:for-each select="hostscript/script">
230 |                   <h5><xsl:value-of select="@id"/></h5>
231 |                   <pre style="white-space:pre-wrap; word-wrap:break-word;"><xsl:value-of select="@output"/></pre>
232 |                 </xsl:for-each>
233 |               </div>
234 |             </div>
235 |           </xsl:for-each>
236 |           <h2 id="openservices" class="target">Open Services</h2>
237 |           <div class="table-responsive">
238 |             <table id="table-services" class="table table-striped dataTable" role="grid">
239 |               <thead>
240 |                 <tr>
241 |                   <th>Address</th>
242 |                   <th>Port</th>
243 |                   <th>Protocol</th>
244 |                   <th>Service</th>
245 |                   <th>Product</th>
246 |                   <th>Version</th>
247 |                   <th>CPE</th>
248 |                   <th>Extra info</th>
249 |                 </tr>
250 |               </thead>
251 |               <tbody>
252 |                 <xsl:for-each select="/nmaprun/host">
253 |                   <xsl:for-each select="ports/port[state/@state='open']">
254 |                     <tr>
255 |                       <td><xsl:value-of select="../../address/@addr"/><xsl:if test="count(../../hostnames/hostname) > 0"> - <xsl:value-of select="../../hostnames/hostname/@name"/></xsl:if></td>
256 |                       <td><xsl:value-of select="@portid"/></td>
257 |                       <td><xsl:value-of select="@protocol"/></td>
258 |                       <td><xsl:value-of select="service/@name"/></td>
259 |                       <td><xsl:value-of select="service/@product"/></td>
260 |                       <td><xsl:value-of select="service/@version"/></td>
261 |                       <td><xsl:value-of select="service/cpe"/></td>
262 |                       <td><xsl:value-of select="service/@extrainfo"/></td>
263 |                     </tr>
264 |                   </xsl:for-each>
265 |                 </xsl:for-each>
266 |               </tbody>
267 |             </table>
268 |           </div>
269 |           <script>
270 |             $(document).ready(function() {
271 |               $('#table-services').DataTable();
272 |             });
273 |           </script>
274 |         </div>
275 |         <footer class="footer">
276 |           <div class="container">
277 |             <p class="text-muted">
278 |               This report was generated with <a href="https://github.com/honze-net/nmap-bootstrap-xsl">Nmap Bootstrap XSL</a>.<br/>
279 |               Licensed under <a href="https://creativecommons.org/licenses/by-sa/4.0/">Creative Commons BY-SA</a>.<br/>
280 |               Designed and built by Andreas Hontzia (<a href="https://www.twitter.com/honze_net">@honze_net</a>).<br/>
281 |             </p>
282 |           </div>
283 |         </footer>
284 |       </body>
285 |     </html>
286 |   </xsl:template>
287 | </xsl:stylesheet>
288 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # nmap-parse-output
  2 | 
  3 | Converts/manipulates/extracts data from a nmap scan output.
  4 | 
  5 | Needs [xsltproc](http://xmlsoft.org/XSLT/xsltproc.html) as dependency.
  6 | 
  7 | **Demo**
  8 | 
  9 | ![Demo](demo.gif)
 10 | 
 11 | **Table of Contents**
 12 | - [nmap-parse-output](#nmap-parse-output)
 13 |   - [Examples](#examples)
 14 |   - [Usage](#usage)
 15 |   - [Changelog](#changelog)
 16 |   - [Contribute](#contribute)
 17 |     - [Adding new Commands](#adding-new-commands)
 18 |   - [Installation](#installation)
 19 |     - [Bash Completion](#bash-completion)
 20 |     - [ZSH Completion](#zsh-completion)
 21 |     - [Distro package](#distro-prackage)
 22 | 
 23 | ## Examples
 24 | 
 25 | Write HTML output to scan.html:
 26 | 
 27 |     $ ./nmap-parse-output scan.xml html > scan.html
 28 | 
 29 | Generates a list of all HTTP(s) ports:
 30 | 
 31 |     $ ./nmap-parse-output scan.xml http-ports   
 32 |     http://192.168.0.1:8081
 33 |     https://192.168.0.1:8443
 34 | 
 35 | List all names of detected services and get a list of hosts with the port for the service http-proxy:
 36 | 
 37 |     $ ./nmap-parse-output scan.xml service-names
 38 |     http
 39 |     https
 40 |     http-proxy
 41 |     ms-wbt-server
 42 |     smtp
 43 |     $ ./nmap-parse-output scan.xml service http-proxy
 44 |     192.168.0.24:8085
 45 |     192.168.0.25:9000
 46 | 
 47 | Exclude some hosts from a scan and generate a list of ports:
 48 | 
 49 |     $ ./nmap-parse-output scan.xml exclude '192.168.1.1,192.168.1.20' | nmap-parse-output - ports
 50 |     22,80,443,8080
 51 | 
 52 | Filter `scan-all.xml` to include only hosts scanned in `scan-subnet.xml` and write the output to `filtered-scan.xml`:
 53 | 
 54 |     $ ./nmap-parse-output scan-all.xml include $(./nmap-parse-output.sh scan-subnet.xml hosts | tr "\n" ",") > filtered-scan.xml
 55 | 
 56 | Generate a subreport with results only from the networks 10.0.1.0/24 and 10.80.0.0/24 from `big-scan-result.xml`:
 57 | 
 58 |     $ ./nmap-parse-output big-scan-result.xml \
 59 |       include $(nmap -Pn -n -sL 10.0.1.0/24 10.80.0.0/24 -oX - | nmap-parse-output - all-hosts | tr "\n" ',') \
 60 |       > networks-10.0.1.0-24-and-10.80.0.0-24.xml
 61 | 
 62 | Add comments to a scan, mark specific ports red, and generate a HTML report with the annotations:
 63 | 
 64 |     $ ./nmap-parse-output scan.xml comment-ports '8080,10.0.20.4:443' 'this port should be filtered'
 65 |       | ./nmap-parse-output - mark-ports '8080,10.0.20.4:443' red
 66 |       | ./nmap-parse-output - comment-hosts '10.0.20.1' 'look further into this host'
 67 |       | ./nmap-parse-output - html > test.html
 68 | 
 69 | Remove all ports found in `scan-before.xml` from `scan-after.xml` and write the output to `filtered-scan.xml`:
 70 | 
 71 |     $ ./nmap-parse-output scan-after.xml exclude-ports $(./nmap-parse-output.sh scan-before.xml host-ports | tr "\n" ",") > filtered-scan.xml
 72 | 
 73 | Group hosts by open TCP ports:
 74 | 
 75 |     $ ./nmap-parse-output scan.xml group-by-ports
 76 |     - Open TCP ports 22,443 on:
 77 |       - 192.168.1.73 (web.local)
 78 |       - 192.168.1.74 (web2.local)
 79 |     - Open TCP ports 8080 on:
 80 |       - 192.168.1.135
 81 |     - No open TCP ports on:
 82 |       - 192.168.1.71 (db.local)
 83 |       - 192.168.1.81
 84 | 
 85 | Rerun TCP scan for all alive hosts but only scan open ports found in the previous scan:
 86 | 
 87 |       $ for host in ./nmap-parse-output scan.xml hosts; do nmap -sSVC -p $(./nmap-parse-output scan.xml include $host | nmap-parse-output - ports) -oA $host.xml -vv -Pn; done
 88 | 
 89 | ## Usage
 90 | 
 91 |       Usage: ./nmap-parse-output [options]... <nmap-xml-output> <command> [command-parameters]...
 92 |       
 93 |       Converts/manipulates/extracts data from nmap scan XML output.
 94 |       
 95 |       Options:
 96 |         -u, --unfinished-scan			 try to read an unfinished scan output
 97 |       
 98 |       Extract Data Commands:
 99 |         all-hosts 
100 |               Generates a line break separated list of all hosts. Can be used to perform an additional scan on this hosts.
101 |               Can be useful to generate a list of IPs for masscan with nmap (masscan has a more limited support for IP lists):
102 |                 nmap -Pn -n -sL -iL input.lst -oX all-ips.xml; nmap-parse-output all-ips.xml all-hosts
103 |       
104 |         banner [service-name]
105 |               Extracts a list of all ports with a specific service (e.g. http, ms-wbt-server, smtp) in host:port format.
106 |               Note: This command is intended for the masscan XML output only.
107 |       
108 |         blocked-ports 
109 |               Extracts all ports in host:port format, which either admin-prohibited or tcpwrapped.
110 |       
111 |         group-by-ports 
112 |               Groups hosts by open TCP ports and generates a human-readable list in the markdown format.
113 |       
114 |         group-by-product 
115 |               Groups open ports by product name and generates a human-readable list in the markdown format. The command ignores ports with empty product name.
116 |       
117 |         group-by-service 
118 |               Groups open ports by service name and generates a human-readable list in the markdown format.
119 |       
120 |         host-ports-protocol 
121 |               Extracts a list of all *open* ports in host:port format and marks the protocol type (tcp, udp)
122 |       
123 |         host-ports 
124 |               Extracts a list of all *open* ports in host:port format.
125 |       
126 |         hosts-to-port [port]
127 |               Extracts a list of all hosts that have the given port open in 'host (hostname)' format.
128 |       
129 |         hosts 
130 |               Generates a line break separated list of all hosts with open ports. Can be used to perform an additional scan on this hosts.
131 |       
132 |         http-info 
133 |               Extracts a list of extra information about the HTTP ports from a script scan in the following format:
134 |               host:port   service-name    service-tunnel  product  http-server-header  http-title   redirect_url
135 |       
136 |         http-ports 
137 |               Generates a line separated list of all HTTP(s) ports. Script scan output is recommended.
138 |               Currently, the following services are detected as HTTP: http, https, http-alt, https-alt, http-proxy, sip, rtsp, soap, vnc-http, caldav (potentially incomplete) and to get a more reliable result all ports which which have output in the http-methods script. 
139 |               On ports where HTTPs and HTTP is responding, the HTTPs port is preferred.
140 |       
141 |         http-title 
142 |               Extracts a list of HTTP HTML titles in the following format:
143 |               host:port	HTML title
144 |       
145 |         nmap-cmdline 
146 |               Shows the parameters passed to nmap of the runned scan
147 |       
148 |         port-info [port]
149 |               Extracts a list of extra information about the given port in the following format:
150 |               port;service-name;http-server-header;http title
151 |       
152 |         ports-reachable 
153 |               Generates a comma-separated list of all reachable ports (open and closed, unfiltered). Can be used to verify if ports reachable from another host or generate port lists for specific environments.
154 |       
155 |         ports 
156 |               Generates a comma-separated list of all open ports. Can be used to verify if open ports reachable from another host or generate port lists for specific environments. Closed/filtered ports are not shown in the list.
157 |       
158 |         product 
159 |               Extracts all detected product names.
160 |       
161 |         search-product 
162 |               Search in product names (case sensitive).
163 |       
164 |         service-names 
165 |               Extracts all detected service names (on open ports).
166 |       
167 |         service [service-name]
168 |               Extracts a list of all *open* ports with a specific service (e.g. http, ms-wbt-server, smtp) in host:port format.
169 |       
170 |         show-comments 
171 |               Shows comments added by the comment-* commands.
172 |       
173 |         ssl-common-name 
174 |               Extracts a list of TLS/SSL ports with the commonName and Subject Alternative Name in the following format:
175 |               host:port	commonName	X509v3 Subject Alternative Name
176 |       
177 |         tls-ports 
178 |               Extracts a list of all TLS ports in host:port format. Works only reliable after a script scan. Can be used to do a testssl.sh scan.
179 |               Example testssl.sh command (generates a text and HTML report for each host):
180 |                   for f in `cat ~/ssl-hosts.txt`; do ./testssl.sh --logfile ~/testssl.sh-results/$f.log --htmlfile ~/testssl.sh-results/$f.html $f; done
181 |       
182 |       
183 |       Manipulate Scan Commands:
184 |         comment-hosts [hosts] [comment]
185 |               Comments a list of hosts in scan result. Expects a comma-separated list as input. The comment will be displayed in the HTML report.
186 |               Example:
187 |                   nmap-parse-output scan.xml comment-hosts '10.0.0.1,192.168.10.1' 'allowed services' | nmap-parse-output - html &gt; report.html
188 |               You can comment hosts from another scan, too:
189 |                   nmap-parse-output scan.xml comment-hosts $(./nmap-parse-output.sh scan-subnet.xml hosts | tr "\n" ",") 'this host was scanned in subnet, too.'
190 |       
191 |         comment-ports [ports] [comment]
192 |               Comments a list of ports or hosts with port (in address:port format) in scan result. Expects a comma-separated list as input. The comment will be displayed in the HTML report.
193 |               Example:
194 |                   nmap-parse-output scan.xml comment-ports '80,10.0.0.1:8080' 'allowed services' | nmap-parse-output - html &gt; report.html
195 |               You can comment services, too:
196 |                   nmap-parse-output scan.xml comment-ports $(./nmap-parse-output.sh scan.xml service http | tr "\n" ",") 'this is a http port'
197 |       
198 |         exclude-ports [ports]
199 |               Excludes a list of ports or ports of a specific host (in address:port format) from a scan result. Expects a comma-separated list as input.
200 |               You can pipe the output, for instance:
201 |                   nmap-parse-output scan.xml exclude '80,443,192.168.0.2:80' | nmap-parse-output - service-names
202 |       
203 |         exclude [hosts]
204 |               Excludes a list of hosts from scan result by its IP address. Expects a comma-separated list as input.
205 |               You can pipe the output, for instance:
206 |                   nmap-parse-output scan.xml exclude '192.168.1.1,192.168.1.20' | nmap-parse-output - service-names
207 |       
208 |         include-ports [ports]
209 |               Filter a scan by a list of ports or ports of a specific host (in address:port format) so that only the specified ports are in the output. Expects a comma-separated list as input.
210 |               You can pipe the output, for instance:
211 |                   nmap-parse-output scan.xml include-ports '80,443,192.168.0.2:8080' | nmap-parse-output - http-title
212 |       
213 |         include [hosts]
214 |               Filter a scan by a list of hosts so that only the specified hosts are in the output.
215 |               Filter a list of hosts from scan result by its IP address. Expects a comma-separated list as input.
216 |               You can pipe the output, for instance:
217 |                   nmap-parse-output scan.xml include '192.168.1.1,192.168.1.20' | nmap-parse-output - service-names
218 |       
219 |         mark-ports [ports] [color]
220 |               Marks a list of ports or hosts with port (in address:port format) with the given color in scan result. Expects a comma-separated list as input. The comment will be displayed in the HTML report.
221 |               Example:
222 |                   nmap-parse-output scan.xml mark-ports '80,10.0.0.1:8080' red | nmap-parse-output - html &gt; report.html
223 |       
224 |         reachable 
225 |               Removes all hosts where all ports a filtered. Can be used to generate a smaller HTML report.
226 |               Example usage to generate HTML report:
227 |                   nmap-parse-output scan.xml reachable | nmap-parse-output - html &gt; scan.html
228 |       
229 |       
230 |       Convert Scan Commands:
231 |         html-bootstrap 
232 |               Converts the XML output into a fancy HTML report based on Bootstrap.
233 |               Note: This HTML report requests JS/CSS libs from CDNs. However, the generated file uses the no-referrer meta tag and subresource integrity to protect the confidentiality.
234 |       
235 |         html 
236 |               Converts a XML output into a HTML report
237 |       
238 |         to-json 
239 |               Converts a nmap scan output to JSON
240 |       
241 |       
242 |       Misc Commands:
243 |       
244 |       [v1.5.1]
245 | 
246 | ## Changelog
247 | 
248 | * v1.5.1
249 |   * More reliable SSL/TLS detection
250 |   * More reliable HTTP(s) port detection
251 |   * Added group-by-service command
252 |   * Added group-by-product command
253 |   * Added http-info command
254 |   * Added http-server-header to port-info command
255 |   * Added hostname to group-by-ports command
256 | * v1.4.6
257 |   * Added search-product command
258 |   * Added group-by-ports command
259 |   * Added examples for generating subreports, group-by-ports command, and rerun scans
260 | * v1.4.5
261 |   * Show only service-names of open ports
262 |   * Splitted ports command in: ports and ports-reachable
263 |   * Added show-comments command
264 | * v1.4.4
265 |   * Fixed bug in [bash completion](_nmap-parse-output) when installed system-wide
266 |   * Improved documentation
267 | * v1.4.3
268 |   * Fixed bug in [include-ports command](nmap-parse-output-xslt/include-ports.xslt)
269 | * v1.4.2
270 |   * Added [nmap-bootstrap-xsl](https://github.com/honze-net/nmap-bootstrap-xsl) as [html-bootstrap command](nmap-parse-output-xslt/html-bootstrap.xslt)
271 |   * Added [nmap-cmdline command](nmap-parse-output-xslt/nmap-cmdline.xslt)
272 |   * Added [host-ports-protocol command](nmap-parse-output-xslt/host-ports-protocol.xslt)
273 | * v1.4.1
274 |   * Improved error handling
275 |   * Bugfix in ports command
276 | * v1.4.0
277 |   * Support for unfinished scans
278 |   * Commands are categorized as convert, manipulate, extract and misc now
279 | * v1.3.0
280 |   * First public release
281 | 
282 | ## Contribute
283 | 
284 | ### Adding new Commands
285 | 
286 | Commands are written as [XSLT](https://en.wikipedia.org/wiki/XSLT). See [nmap-parse-output-xslt/](nmap-parse-output-xslt/) if you want to add new commands. A good way is mostly copying an existing script that does something similar.
287 | 
288 | The documentation printed in the help page can be written with the ``<comment>`` tag (XML namespace: http://xmlns.sven.to/npo). A command can have one of the following categories: convert, manipulate or extract. You can set it with the ``<category>`` tag. It is not necessary to set a category, uncategorized commands are will be shown as a misc command in the help page. Commands with an invalid category will not be shown on the help page.
289 | 
290 | Parameters will be passed as variables named ``$param1``, ``$param2`` and so on. An post processing command can be added with the ``<post-processor>`` tag.
291 | 
292 | Example XSLT file:
293 | 
294 |     <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:npo="http://xmlns.sven.to/npo">
295 |     <npo:comment>
296 |             <!-- Added documentation here -->
297 |     </npo:comment>
298 |     <npo:category>extract</npo:category>
299 |     <npo:post-processor>sort | uniq</npo:post-processor>
300 |     
301 |     <xsl:output method="text" />
302 |     <xsl:strip-space elements="*" />
303 |     
304 |     <xsl:template match="/nmaprun/host/ports/port">
305 |         <!-- add your template here -->
306 |         <xsl:if test="state/@state = $param1">
307 |             <xsl:value-of select="../../address/@addr"/>
308 |             <xsl:text>, </xsl:text>
309 |         </xsl:if>
310 |     </xsl:template>
311 |     
312 |     <xsl:template match="text()" />
313 |     </xsl:stylesheet>
314 | 
315 | More information about XSLT and writing new commands can be found here:
316 | - http://xmlsoft.org/XSLT/
317 | - http://www.w3.org/TR/xslt
318 | - http://www.exslt.org/
319 | - http://xmlsoft.org/XSLT/xsltproc.html
320 | 
321 | ## Installation
322 | 
323 | Requierements:
324 | * bash
325 | * [xsltproc](http://xmlsoft.org/XSLT/xsltproc.html)
326 | 
327 | Check out the repository and run it:
328 | 
329 |       git clone https://github.com/ernw/nmap-parse-output.git
330 |       cd nmap-parse-output
331 |       ./nmap-parse-output
332 | 
333 | You can create a link to the ``nmap-parse-output`` script in your local bin directory or add the directory into your path if you want to execute it directly. Add the following line into your ``~/.bash_profile`` or your ``~/.zshrc`` file:
334 | 
335 |       export PATH="$PATH:$PATH_TO_YOUR_NMAP_PARSE_OUTPUT_DIR"
336 | 
337 | ### Bash Completion
338 | 
339 | Bash completion can be enabled by adding the following line to your `~/.bash_profile` or `.bashrc`:
340 | 
341 |     source ~/path/to/nmap-parse-output/_nmap-parse-output
342 | 
343 | ### ZSH Completion
344 | 
345 | ZSH completion can be enabled by adding the following line to your `~/.zshrc`:
346 | 
347 |     autoload bashcompinit && bashcompinit && source ~/path/to/nmap-parse-output/_nmap-parse-output
348 | 
349 | ### Distro Packages
350 | 
351 | [![Packaging status](https://repology.org/badge/vertical-allrepos/nmap-parse-output.svg)](https://repology.org/project/nmap-parse-output/versions)
352 | 


--------------------------------------------------------------------------------
/nmap-parse-output-xslt/html.xslt:
--------------------------------------------------------------------------------
   1 | <?xml version="1.0"?>
   2 | <!-- =========================================================================
   3 |             nmap.xsl stylesheet version 0.9c
   4 |             last change: 2010-12-28
   5 |             Benjamin Erb, http://www.benjamin-erb.de
   6 | ==============================================================================
   7 |     Copyright (c) 2004-2006 Benjamin Erb
   8 |     All rights reserved.
   9 | 
  10 |     Redistribution and use in source and binary forms, with or without
  11 |     modification, are permitted provided that the following conditions
  12 |     are met:
  13 |     1. Redistributions of source code must retain the above copyright
  14 |        notice, this list of conditions and the following disclaimer.
  15 |     2. Redistributions in binary form must reproduce the above copyright
  16 |        notice, this list of conditions and the following disclaimer in the
  17 |        documentation and/or other materials provided with the distribution.
  18 |     3. The name of the author may not be used to endorse or promote products
  19 |        derived from this software without specific prior written permission.
  20 | 
  21 |     THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  22 |     IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  23 |     OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  24 |     IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  25 |     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  26 |     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27 |     DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28 |     THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29 |     (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  30 |     THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31 | ========================================================================== -->
  32 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:npo="http://xmlns.sven.to/npo">
  33 | <xsl:output 
  34 |   method="html" 
  35 |   indent="yes" 
  36 |   encoding="UTF-8" 
  37 | 	doctype-public="-//W3C//DTD HTML 4.01//EN"
  38 | 	doctype-system="http://www.w3.org/TR/html4/strict.dtd"
  39 |   
  40 | />
  41 | <npo:comment>
  42 |         Converts a XML output into a HTML report
  43 | </npo:comment>
  44 | <npo:category>convert</npo:category>
  45 | 
  46 | <!-- global variables      -->
  47 | <!-- ............................................................ -->
  48 | <xsl:variable name="nmap_xsl_version">0.9c</xsl:variable>
  49 | <!-- ............................................................ -->
  50 | <xsl:variable name="start"><xsl:value-of select="/nmaprun/@startstr" /></xsl:variable>
  51 | <xsl:variable name="end"><xsl:value-of select="/nmaprun/runstats/finished/@timestr" /> </xsl:variable>
  52 | <xsl:variable name="totaltime"><xsl:value-of select="/nmaprun/runstats/finished/@time -/nmaprun/@start" /></xsl:variable>
  53 | <xsl:key name="portstatus" match="@state" use="."/>
  54 | <!-- ............................................................ -->
  55 | 
  56 | 
  57 | <xsl:template match="/">
  58 | 	<xsl:apply-templates/>
  59 | </xsl:template>
  60 | 
  61 | 
  62 | <!-- root -->
  63 | <!-- ............................................................ -->
  64 | <xsl:template match="/nmaprun">
  65 | <html>
  66 | <head>
  67 | 
  68 | 
  69 | <xsl:comment>generated with nmap.xsl - version <xsl:value-of select="$nmap_xsl_version" /> by Benjamin Erb - http://www.benjamin-erb.de/nmap_xsl.php </xsl:comment>
  70 | 
  71 | <style type="text/css">
  72 | /* stylesheet print */
  73 | @media print
  74 | {
  75 |   #menu {
  76 |     display:none;
  77 |   }
  78 | 
  79 |   body {
  80 |     font-family: Verdana, Helvetica, sans-serif;
  81 |   }
  82 |   
  83 |   h1 {
  84 |     font-size: 13pt;
  85 |     font-weight:bold;
  86 |     margin:4pt 0pt 0pt 0pt;
  87 |     padding:0;
  88 |   }
  89 | 
  90 |   h2 {
  91 |     font-size: 12pt;
  92 |     font-weight:bold;
  93 |     margin:3pt 0pt 0pt 0pt;
  94 |     padding:0;
  95 |   }
  96 | 
  97 |   h3, a:link, a:visited {
  98 |     font-size: 9pt;
  99 |     font-weight:bold;
 100 |     margin:1pt 0pt 0pt 20pt;
 101 |     padding:0;
 102 |     text-decoration: none;
 103 |     color: #000000;
 104 |   }
 105 | 
 106 |   p,ul {
 107 |     font-size: 9pt;
 108 |     margin:1pt 0pt 8pt 40pt;
 109 |     padding:0;
 110 |     text-align:left;
 111 |   }
 112 | 
 113 |   li {
 114 |     font-size: 9pt;
 115 |     margin:0;
 116 |     padding:0;
 117 |     text-align:left;
 118 |   }
 119 | 
 120 |   table {
 121 |     margin:1pt 0pt 8pt 40pt;
 122 |     border:0px;
 123 |     width:90%
 124 |   }
 125 | 
 126 |   td {
 127 |     border:0px;
 128 |     border-top:1px solid black;
 129 |     font-size: 9pt;
 130 |   }
 131 | 
 132 |   .head td {
 133 |     border:0px;
 134 |     font-weight:bold;
 135 |     font-size: 9pt;
 136 |   }
 137 |   .noprint { display: none; }
 138 | }
 139 | 
 140 | /* stylesheet screen */
 141 | @media screen
 142 | {
 143 |   body {
 144 |     font-family: Verdana, Helvetica, sans-serif;
 145 |     margin: 0px;
 146 |     background-color: #FFFFFF;
 147 |     color: #000000;
 148 |     text-align: center;
 149 |   }
 150 | 
 151 |   #container {
 152 |     text-align:left;
 153 |     margin: 10px auto;
 154 |     width: 90%;
 155 |   }
 156 | 
 157 |   h1 {
 158 |     font-family: Verdana, Helvetica, sans-serif;
 159 |     font-weight:bold;
 160 |     font-size: 14pt;
 161 |     color: #FFFFFF;
 162 |     background-color:#2A0D45;
 163 |     margin:10px 0px 0px 0px;
 164 |     padding:5px 4px 5px 4px;
 165 |     width: 100%;
 166 |     border:1px solid black;
 167 |     text-align: left;
 168 |   }
 169 | 
 170 |   h2 {
 171 |     font-family: Verdana, Helvetica, sans-serif;
 172 |     font-weight:bold;
 173 |     font-size: 11pt;
 174 |     color: #000000;
 175 |     margin:30px 0px 0px 0px;
 176 |     padding:4px;
 177 |     width: 100%;
 178 |     background-color:#F0F8FF;
 179 |     text-align: left;
 180 |   }
 181 | 
 182 |   h2.green {
 183 |     color: #000000;
 184 |     background-color:#CCFFCC;
 185 |     border-color:#006400;
 186 |   }
 187 | 
 188 |   h2.red {
 189 |     color: #000000;
 190 |     background-color:#FFCCCC;
 191 |     border-color:#8B0000;
 192 |   }
 193 |    
 194 |   h3 {
 195 |     font-family: Verdana, Helvetica, sans-serif;
 196 |     font-weight:bold;
 197 |     font-size: 10pt;
 198 |     color:#000000;
 199 |     background-color: #FFFFFF;
 200 |     width: 75%;
 201 |     text-align: left;
 202 |   }
 203 | 
 204 |   p {
 205 |     font-family: Verdana, Helvetica, sans-serif;
 206 |     font-size: 8pt;
 207 |     color:#000000;
 208 |     background-color: #FFFFFF;
 209 |     width: 75%;
 210 |     text-align: left;
 211 |   }
 212 | 
 213 |   p i {
 214 |     font-family: Verdana, Helvetica, sans-serif;
 215 |     font-size: 8pt;
 216 |     color:#000000;
 217 |     background-color: #CCCCCC;
 218 |   }
 219 | 
 220 |   ul {
 221 |     font-family: Verdana, Helvetica, sans-serif;
 222 |     font-size: 8pt;
 223 |     color:#000000;
 224 |     background-color: #FFFFFF;
 225 |     width: 75%;
 226 |     text-align: left;
 227 |   }
 228 | 
 229 |   a {
 230 |     font-family: Verdana, Helvetica, sans-serif;
 231 |     text-decoration: none;
 232 |     font-size: 8pt;
 233 |     color:#000000;
 234 |     font-weight:bold;
 235 |     background-color: #FFFFFF;
 236 |     color: #000000;
 237 |   }
 238 | 
 239 |   li a {
 240 |     font-family: Verdana, Helvetica, sans-serif;
 241 |     text-decoration: none;
 242 |     font-size: 10pt;
 243 |     color:#000000;
 244 |     font-weight:bold;
 245 |     background-color: #FFFFFF;
 246 |     color: #000000;
 247 |   }
 248 | 
 249 |   a:hover {
 250 |     text-decoration: underline;
 251 |   }
 252 | 
 253 |   a.up {
 254 |       color:#006400;
 255 |   }
 256 | 
 257 |   table {
 258 |     width: 80%;
 259 |     border:0px;
 260 |     color: #000000;
 261 |     background-color: #000000;
 262 |     margin:10px;
 263 |   }
 264 | 
 265 |   tr {
 266 |     vertical-align:top;
 267 |     font-family: Verdana, Helvetica, sans-serif;
 268 |     font-size: 8pt;
 269 |     color:#000000;
 270 |     background-color: #FFFFFF;
 271 |   }
 272 | 
 273 |   tr.head {
 274 |     background-color: #E1E1E1;
 275 |     color: #000000;
 276 |     font-weight:bold;
 277 |   }
 278 | 
 279 |   tr.open {
 280 |     background-color: #CCFFCC;
 281 |     color: #000000;
 282 |   }
 283 | 	
 284 |   tr.script {
 285 |     background-color: #EFFFF7;
 286 |     color: #000000;
 287 |   }
 288 | 
 289 |   tr.filtered {
 290 |     background-color: #F2F2F2;
 291 |     color: #000000;
 292 |   }
 293 | 
 294 |   tr.closed {
 295 |     background-color: #F2F2F2;
 296 |     color: #000000;
 297 |   }
 298 |     
 299 |   td {
 300 |     padding:2px;
 301 |   }
 302 |         
 303 |   #menu li {
 304 |     display         : inline;
 305 |     margin          : 0;
 306 |     /*margin-right    : 10px;*/
 307 |     padding         : 0;
 308 |     list-style-type : none;
 309 |   }    
 310 |  
 311 |   #menubox {
 312 |     position: fixed;
 313 |     bottom: 0px;
 314 |     right: 0px;
 315 |     width: 120px;
 316 |   }
 317 |   
 318 |   
 319 |   <![CDATA[
 320 |   /* This section handle's IE's refusal to honor the fixed CSS attribute */
 321 |   
 322 |   * html div#menubox {
 323 |     position: absolute;
 324 |     top:expression(eval(
 325 |       document.compatMode && document.compatMode=='CSS1Compat') ?
 326 |       documentElement.scrollTop+(documentElement.clientHeight-this.clientHeight) 
 327 |       : document.body.scrollTop +(document.body.clientHeight-this.clientHeight));
 328 |   }
 329 |   /* This fixes the jerky effect when scrolling in IE*/
 330 |   * html,* html body {
 331 |     background: #fff url(nosuchfile) fixed;
 332 |   }
 333 | 
 334 |   ]]>
 335 |  
 336 |   .up {
 337 |     color: #000000;
 338 |     background-color:#CCFFCC;
 339 |   }
 340 |   
 341 |   .down {
 342 |     color:#626262;
 343 |     background-color: #F2F2F2;
 344 |   }
 345 | 
 346 |   .print_only { display: none; }
 347 |   .hidden { display: none; }
 348 |   .unhidden { display: block; }
 349 |   
 350 | }
 351 | </style>
 352 | 
 353 |   <title>Nmap Scan Report - Scanned at <xsl:value-of select="$start" /></title>
 354 | 	
 355 |    
 356 |     <script type="text/javascript">
 357 |      
 358 |       <![CDATA[
 359 |                 
 360 |       function toggle(divID) {
 361 |         var item = document.getElementById(divID);
 362 |         if (item) {
 363 |           item.className=(item.className=='hidden')?'unhidden':'hidden';
 364 |         }
 365 |       }
 366 |            
 367 |       function togglePorts(tableID,portState) {
 368 |         var table = document.getElementById(tableID);    
 369 |         var tbody = table.getElementsByTagName("tbody")[0];
 370 |         var rows = tbody.getElementsByTagName("tr");
 371 |         for (var i=0; i < rows.length; i++) {
 372 |           var value = rows[i].getElementsByTagName("td")[2].firstChild.nodeValue;
 373 |           if (value == portState) {
 374 |             rows[i].style.display = (rows[i].style.display == 'none')?'':'none';
 375 |           }
 376 |         }
 377 |       }
 378 |       
 379 |       function toggleAll(portState) {
 380 |         var allTables = document.getElementsByTagName("table");
 381 |         for (var c=0; c < allTables.length; c++) {
 382 |           if (allTables[c].id != "") {
 383 |             togglePorts(allTables[c].id, portState)
 384 |           }
 385 |         }
 386 |       }
 387 |       
 388 |       function init (){
 389 |         toggleAll('closed');
 390 |         toggleAll('filtered');     
 391 |       }     
 392 |             
 393 |       window.onload = init; 
 394 |       
 395 |       ]]>
 396 |     
 397 |     </script>
 398 |     	
 399 | </head>
 400 | 
 401 | <body>
 402 |   <a name="top" />
 403 |   <div id="container">
 404 | 
 405 |     <h1>Nmap Scan Report - Scanned at <xsl:value-of select="$start" /></h1>
 406 |     
 407 |     <ul id="menu">
 408 |       <li><a href="#scansummary">Scan Summary</a></li>
 409 | 
 410 |       <xsl:if test="prescript/script/@id">
 411 |         <li>
 412 |           <xsl:text> | </xsl:text>
 413 |           <a href="#prescript">Pre-Scan Script Output</a>
 414 |         </li>
 415 |       </xsl:if>
 416 | 			
 417 |       <xsl:for-each select="host">
 418 |         <xsl:sort select="substring ( address/@addr, 1, string-length ( substring-before ( address/@addr, '.' ) ) )* (256*256*256) + substring ( substring-after ( address/@addr, '.' ), 1, string-length ( substring-before ( substring-after ( address/@addr, '.' ), '.' ) ) )* (256*256) + substring ( substring-after ( substring-after ( address/@addr, '.' ), '.' ), 1, string-length ( substring-before ( substring-after ( substring-after ( address/@addr, '.' ), '.' ), '.' ) ) ) * 256 + substring ( substring-after ( substring-after ( substring-after ( address/@addr, '.' ), '.' ), '.' ), 1 )" order="ascending" data-type="number"/>
 419 | 
 420 |         <li>
 421 |           <xsl:text> | </xsl:text>
 422 |           <xsl:element name="a">
 423 |             <xsl:attribute name="href">#host_<xsl:value-of select="translate(address/@addr, '.', '_') " /></xsl:attribute>
 424 |             <xsl:attribute name="class">
 425 |               <xsl:choose>
 426 |                 <xsl:when test="status/@state = 'up'">up</xsl:when>
 427 |                 <xsl:otherwise>down</xsl:otherwise>
 428 |               </xsl:choose>
 429 |             </xsl:attribute>
 430 |                     
 431 |             <xsl:variable name="var_address" select="address/@addr" />
 432 |             <xsl:if test="count(hostnames/hostname) > 0">
 433 |               <xsl:for-each select="hostnames">
 434 |                 <xsl:choose>
 435 | 
 436 |                   <xsl:when test="hostname/@type='user'">
 437 |                     <xsl:value-of select="hostname/@name"/>
 438 |                     (<xsl:value-of select="$var_address"/>)
 439 |                   </xsl:when>
 440 | 
 441 |                   <xsl:otherwise>
 442 |                     <xsl:for-each select="hostname/@name[hostname/@type='PTR']"/>
 443 |                     <xsl:value-of select="hostname/@name"/> (<xsl:value-of select="$var_address"/>)
 444 |                   </xsl:otherwise>
 445 | 
 446 |                 </xsl:choose>
 447 |               </xsl:for-each>
 448 |             </xsl:if>
 449 | 
 450 |             <xsl:if test="count(hostnames/hostname) = 0">
 451 |               <xsl:value-of select="address/@addr"/>
 452 |             </xsl:if>
 453 |           </xsl:element>
 454 | 
 455 | 
 456 |         </li>
 457 |       </xsl:for-each>
 458 | 
 459 |       <xsl:if test="postscript/script/@id">
 460 |         <li> <xsl:text> | </xsl:text> <a href="#postscript">Post-Scan Script Output</a> </li>
 461 |       </xsl:if>
 462 |     </ul>
 463 | 
 464 |     <xsl:element name="a">
 465 |       <xsl:attribute name="name">scansummary</xsl:attribute>
 466 |     </xsl:element>
 467 |     
 468 |     <hr class="print_only" />
 469 |     
 470 |     <h2>Scan Summary</h2>
 471 | 
 472 |     <p>
 473 |       Nmap <xsl:value-of select="@version" /> was initiated at <xsl:value-of select="$start" /> with these arguments:<br/>
 474 |       <i><xsl:value-of select="@args" /></i><br/>
 475 |     </p>
 476 |     <p>
 477 |     Verbosity: <xsl:value-of select="verbose/@level" />; Debug level <xsl:value-of select="debugging/@level" />
 478 |     </p>
 479 | 
 480 |     <p>
 481 |     <xsl:value-of select="/nmaprun/runstats/finished/@summary" />
 482 |     </p>
 483 | 
 484 |     <xsl:apply-templates select="prescript"/>
 485 | 
 486 |     <xsl:apply-templates select="host">
 487 |       <xsl:sort select="substring ( address/@addr, 1, string-length ( substring-before ( address/@addr, '.' ) ) )* (256*256*256) + substring ( substring-after ( address/@addr, '.' ), 1, string-length ( substring-before ( substring-after ( address/@addr, '.' ), '.' ) ) )* (256*256) + substring ( substring-after ( substring-after ( address/@addr, '.' ), '.' ), 1, string-length ( substring-before ( substring-after ( substring-after ( address/@addr, '.' ), '.' ), '.' ) ) ) * 256 + substring ( substring-after ( substring-after ( substring-after ( address/@addr, '.' ), '.' ), '.' ), 1 )" order="ascending" data-type="number"/>
 488 |     </xsl:apply-templates>
 489 | 	
 490 |     <xsl:apply-templates select="postscript"/>
 491 |    
 492 |   </div>
 493 |     
 494 |   <div id="menubox" class="noprint">
 495 |     <a href="#top"><small>Go to top</small></a> <br />
 496 |     <a href="javascript:toggleAll('closed');"><small>Toggle Closed Ports</small></a><br />
 497 |     <a href="javascript:toggleAll('filtered');"><small>Toggle Filtered Ports</small></a>
 498 |   </div>
 499 | </body>
 500 | </html>
 501 | </xsl:template>
 502 | <!-- ............................................................ -->
 503 | 
 504 | <!-- host -->
 505 | <!-- ............................................................ -->
 506 | <xsl:template match="host">
 507 | 
 508 |   <hr class="print_only" />
 509 |   
 510 |   <xsl:variable name="var_address" select="address/@addr" />
 511 |   
 512 |   <xsl:element name="a">
 513 |     <xsl:attribute name="name">host_<xsl:value-of select="translate(address/@addr, '.', '_') " /></xsl:attribute>
 514 |   </xsl:element>
 515 | 
 516 |   <xsl:choose>
 517 | 
 518 |     <xsl:when test="status/@state = 'up'">
 519 |       <h2 class="up"><xsl:value-of select="address/@addr"/>
 520 | 
 521 |       <xsl:if test="count(hostnames/hostname) > 0">
 522 |         <xsl:for-each select="hostnames/hostname">
 523 |           <xsl:sort select="@name" order="ascending" data-type="text"/>
 524 |             <xsl:text> / </xsl:text><xsl:value-of select="@name"/>
 525 |         </xsl:for-each>
 526 |       </xsl:if>
 527 | 
 528 |       <span class="print_only">(online)</span>
 529 |       </h2>
 530 | 
 531 |     </xsl:when>
 532 | 
 533 |     <xsl:otherwise>
 534 |       <h2 class="down"><xsl:value-of select="address/@addr"/>
 535 | 
 536 |       <xsl:if test="count(hostnames/hostname) > 0">
 537 |         <xsl:for-each select="hostnames/hostname">
 538 |           <xsl:sort select="@name" order="ascending" data-type="text"/>
 539 |             <xsl:text> / </xsl:text><xsl:value-of select="@name"/>
 540 |         </xsl:for-each>
 541 |       </xsl:if>
 542 | 
 543 |       <xsl:element name="a">
 544 |         <xsl:attribute name="href">javascript:toggle('hostblock_<xsl:value-of select="$var_address"/>');</xsl:attribute>
 545 |         <xsl:attribute name="class">host_down</xsl:attribute>
 546 |         <span class="noprint"><small> (click to expand)</small></span>
 547 |       </xsl:element>
 548 |       <span class="print_only">(offline)</span></h2>
 549 |     </xsl:otherwise>
 550 | 
 551 |   </xsl:choose>
 552 | 
 553 |   
 554 |   <xsl:element name="div">
 555 |     <xsl:attribute name="id">hostblock_<xsl:value-of select="$var_address"/></xsl:attribute>
 556 |     <xsl:choose>
 557 | 
 558 |       <xsl:when test="status/@state = 'up'">
 559 |         <xsl:attribute name="class">unhidden</xsl:attribute>
 560 |       </xsl:when>
 561 | 
 562 |       <xsl:otherwise>
 563 |         <xsl:attribute name="class">hidden</xsl:attribute>
 564 |       </xsl:otherwise>
 565 |     </xsl:choose>
 566 | 
 567 | 
 568 |   <xsl:if test="count(address) > 0">
 569 |     <h3>Address</h3>
 570 | 
 571 |       <ul>
 572 |         <xsl:for-each select="address">
 573 |           <li><xsl:value-of select="@addr"/>
 574 |             <xsl:if test="@vendor">
 575 |               <xsl:text> - </xsl:text>
 576 |                 <xsl:value-of select="@vendor"/>
 577 |               <xsl:text> </xsl:text>
 578 |             </xsl:if>
 579 |             (<xsl:value-of select="@addrtype"/>)
 580 |           </li>
 581 |         </xsl:for-each>
 582 |       </ul>
 583 |   </xsl:if>
 584 |     
 585 | 	
 586 |   <xsl:apply-templates/>
 587 | 
 588 |   <br />
 589 |   
 590 |   <xsl:element name="a">
 591 |     <xsl:attribute name="href">javascript:toggle('metrics_<xsl:value-of select="$var_address"/>');</xsl:attribute>
 592 |     Misc Metrics <span class="noprint"><small> (click to expand)</small></span>
 593 |   </xsl:element>
 594 |   
 595 |   
 596 |   <xsl:element name="div">
 597 |     <xsl:attribute name="id">metrics_<xsl:value-of select="$var_address"/></xsl:attribute>
 598 |     <xsl:attribute name="class">hidden</xsl:attribute>
 599 | 		
 600 |     <table cellspacing="1">
 601 |       <tr class="head">
 602 |         <td>Metric</td>
 603 |         <td>Value</td>
 604 |       </tr>
 605 | 		
 606 |       <tr>
 607 |         <td>Ping Results</td>
 608 |         <td><xsl:value-of select="status/@reason"/>
 609 |           <xsl:if test="status/@reasonsrc">
 610 |             <xsl:text> from </xsl:text>
 611 |             <xsl:value-of select="status/@reasonsrc"/>
 612 |           </xsl:if>
 613 |         </td>
 614 |       </tr>
 615 | 			
 616 |     <xsl:if test="uptime/@seconds != ''">
 617 |       <tr>
 618 |         <td>System Uptime</td>
 619 |         <td><xsl:value-of select="uptime/@seconds" /> seconds  (last reboot: <xsl:value-of select="uptime/@lastboot" />)
 620 |         </td>
 621 |       </tr>
 622 |     </xsl:if>
 623 | 		
 624 |     <xsl:if test="distance/@value != ''">
 625 |       <tr>
 626 |         <td>Network Distance</td>
 627 |         <td><xsl:value-of select="distance/@value" /> hops</td>
 628 |       </tr>
 629 |     </xsl:if>
 630 | 		
 631 | 		
 632 |     <xsl:if test="tcpsequence/@index != ''">
 633 |       <tr>
 634 |         <td>TCP Sequence Prediction</td>
 635 |         <td>Difficulty=<xsl:value-of select="tcpsequence/@index" /> (<xsl:value-of select="tcpsequence/@difficulty" />)</td>
 636 |       </tr>
 637 |     </xsl:if>
 638 | 		
 639 |     <xsl:if test="ipidsequence/@class != ''">
 640 |       <tr>
 641 |         <td>IP ID Sequence Generation</td>
 642 |         <td><xsl:value-of select="ipidsequence/@class" /></td>
 643 |       </tr>
 644 |     </xsl:if>
 645 | 		
 646 |       </table>
 647 |     </xsl:element>
 648 | 
 649 |   </xsl:element>
 650 | 	
 651 | </xsl:template>
 652 | <!-- ............................................................ -->
 653 | 
 654 | <!-- nmap-parse-output: comments -->
 655 | <!-- ............................................................ -->
 656 | <xsl:template match="npo-comment">
 657 |   <h3>Comment</h3><p><xsl:value-of select="."/></p>
 658 | </xsl:template>
 659 | <!-- ............................................................ -->
 660 | 
 661 | 
 662 | <!-- hostnames -->
 663 | <!-- ............................................................ -->
 664 | <xsl:template match="hostnames">
 665 |   <xsl:if test="hostname/@name != ''"><h3>Hostnames</h3><ul>	<xsl:apply-templates/></ul></xsl:if>
 666 | </xsl:template>
 667 | <!-- ............................................................ -->
 668 | 
 669 | <!-- hostname -->
 670 | <!-- ............................................................ -->
 671 | <xsl:template match="hostname">
 672 |   <li><xsl:value-of select="@name"/> (<xsl:value-of select="@type"/>)</li>
 673 | </xsl:template>
 674 | <!-- ............................................................ -->
 675 | 
 676 | <!-- ports -->
 677 | <!-- ............................................................ -->
 678 | <xsl:template match="ports">
 679 |   <xsl:variable name="var_address" select="../address/@addr" />
 680 |   <h3>Ports</h3>
 681 |   <xsl:for-each select="extraports">
 682 |     <xsl:if test="@count > 0">
 683 |       <p>The <xsl:value-of select="@count" /> ports scanned but not shown below are in state: <b><xsl:value-of select="@state" /></b></p>
 684 |     </xsl:if>
 685 | 
 686 |     <ul>
 687 |       <xsl:for-each select="extrareasons">
 688 |         <xsl:if test="@count > 0">
 689 |           <li><p><xsl:value-of select="@count" /> ports replied with: <b><xsl:value-of select="@reason" /></b></p></li>
 690 |         </xsl:if>
 691 |       </xsl:for-each>
 692 |     </ul>
 693 |   </xsl:for-each>
 694 | 
 695 |   <xsl:if test="count(port) > 0">
 696 |   
 697 |     
 698 |     <xsl:for-each select="port/state/@state[generate-id()=generate-id(key('portstatus',.))]" />
 699 |     <xsl:variable name="closed_count" select="count(port/state[@state='closed'])" />
 700 |     <xsl:variable name="filtered_count" select="count(port/state[@state='filtered'])" />
 701 |      
 702 |   
 703 |     <xsl:element name="table">
 704 |       <xsl:attribute name="id">porttable_<xsl:value-of select="$var_address"/></xsl:attribute>
 705 |       <xsl:attribute name="cellspacing">1</xsl:attribute>
 706 |     
 707 |     <tr class="head">
 708 |         <td colspan="2">Port</td>
 709 |         <td>State 
 710 |           <xsl:element name="a">
 711 |             <xsl:attribute name="href">javascript:togglePorts('porttable_<xsl:value-of select="$var_address"/>','closed');</xsl:attribute>
 712 |             <span class="noprint"><small> (toggle closed [<xsl:value-of select="$closed_count"/>] </small></span>
 713 |           </xsl:element>
 714 |           <xsl:element name="a">
 715 |             <xsl:attribute name="href">javascript:togglePorts('porttable_<xsl:value-of select="$var_address"/>','filtered');</xsl:attribute>
 716 |             <span class="noprint"><small> | filtered [<xsl:value-of select="$filtered_count"/>])</small></span>
 717 |           </xsl:element>
 718 |         </td>
 719 |         <td>Service</td>
 720 |         <td>Reason</td>
 721 |         <td>Product</td>
 722 |         <td>Version</td>
 723 |         <td>Extra info</td>
 724 |       </tr>
 725 | 
 726 |       <xsl:apply-templates/>
 727 |     </xsl:element>
 728 |   </xsl:if>
 729 | </xsl:template>
 730 | <!-- ............................................................ -->
 731 | 
 732 | <!-- port -->
 733 | <!-- ............................................................ -->
 734 | <xsl:template match="port">
 735 | 
 736 |   <xsl:choose>
 737 |     <xsl:when test="state/@state = 'open'">
 738 |       <!-- nmap-parse-output: mark port with specific color -->
 739 |       <xsl:variable name="bg-color"><xsl:choose>
 740 |         <xsl:when test="npo-color-annotation">
 741 |           <xsl:value-of select="npo-color-annotation" />
 742 |         </xsl:when>
 743 |         <xsl:otherwise>
 744 |           <xsl:value-of select="'#CCFFCC'" />
 745 |         </xsl:otherwise>
 746 |       </xsl:choose></xsl:variable>
 747 |       <!-- TODO: check if bg-color is a color name or hex value -->
 748 |       <tr class="open" style="background-color: {$bg-color};">
 749 |         <td><xsl:value-of select="@portid" /></td>
 750 |         <td><xsl:value-of select="@protocol" /></td>
 751 |         <td><xsl:value-of select="state/@state" /></td>
 752 |         <td><xsl:value-of select="service/@name" /><xsl:text>&#xA0;</xsl:text></td>
 753 | 	<td><xsl:value-of select="state/@reason"/>
 754 |           <xsl:if test="state/@reason_ip">
 755 |             <xsl:text> from </xsl:text>
 756 |             <xsl:value-of select="state/@reason_ip"/>
 757 |           </xsl:if>
 758 |         </td>
 759 |         <td><xsl:value-of select="service/@product" /><xsl:text>&#xA0;</xsl:text></td>
 760 |         <td><xsl:value-of select="service/@version" /><xsl:text>&#xA0;</xsl:text></td>
 761 |         <td><xsl:value-of select="service/@extrainfo" /><xsl:text>&#xA0;</xsl:text></td>
 762 |       </tr>
 763 | 
 764 |       <!-- nmap-parse-output: comment (TODO: integrate this more smoothly) -->
 765 |       <xsl:if test="npo-comment">
 766 |         <tr class="script">
 767 |           <td></td>
 768 |           <td><i><xsl:text>Comment &#xA0;</xsl:text></i></td>
 769 |           <td colspan="6">
 770 |             <pre><xsl:value-of select="npo-comment"/> <xsl:text>&#xA0;</xsl:text></pre>
 771 |           </td>
 772 |         </tr>
 773 |       </xsl:if>
 774 | 
 775 |       <xsl:for-each select="script">
 776 |         <tr class="script">
 777 |           <td></td>
 778 |           <td><xsl:value-of select="@id"/> <xsl:text>&#xA0;</xsl:text></td>
 779 |           <td colspan="6">
 780 |             <pre><xsl:value-of select="@output"/> <xsl:text>&#xA0;</xsl:text></pre>
 781 |           </td>
 782 |         </tr>
 783 | 
 784 |       </xsl:for-each>
 785 |     </xsl:when>
 786 | 
 787 |     <xsl:when test="state/@state = 'filtered'">
 788 |       <tr class="filtered">
 789 |         <td><xsl:value-of select="@portid" /></td>
 790 |         <td><xsl:value-of select="@protocol" /></td>
 791 |         <td><xsl:value-of select="state/@state" /></td>
 792 |         <td><xsl:value-of select="service/@name" /><xsl:text>&#xA0;</xsl:text></td>
 793 |         <td><xsl:value-of select="state/@reason"/>
 794 |           <xsl:if test="state/@reason_ip">
 795 |             <xsl:text> from </xsl:text>
 796 |             <xsl:value-of select="state/@reason_ip"/>
 797 |           </xsl:if>
 798 |         </td>
 799 |         <td><xsl:value-of select="service/@product" /><xsl:text>&#xA0;</xsl:text></td>
 800 |         <td><xsl:value-of select="service/@version" /><xsl:text>&#xA0;</xsl:text></td>
 801 |         <td><xsl:value-of select="service/@extrainfo" /><xsl:text>&#xA0;</xsl:text></td>
 802 |       </tr>
 803 |     </xsl:when>
 804 | 
 805 |     <xsl:when test="state/@state = 'closed'">
 806 |       <tr class="closed">
 807 |         <td><xsl:value-of select="@portid" /></td>
 808 |         <td><xsl:value-of select="@protocol" /></td>
 809 |         <td><xsl:value-of select="state/@state" /></td>
 810 |         <td><xsl:value-of select="service/@name" /><xsl:text>&#xA0;</xsl:text></td>
 811 |         <td><xsl:value-of select="state/@reason"/>
 812 |           <xsl:if test="state/@reason_ip">
 813 |             <xsl:text> from </xsl:text>
 814 |             <xsl:value-of select="state/@reason_ip"/>
 815 |           </xsl:if>
 816 |         </td>
 817 |         <td><xsl:value-of select="service/@product" /><xsl:text>&#xA0;</xsl:text></td>
 818 |         <td><xsl:value-of select="service/@version" /><xsl:text>&#xA0;</xsl:text></td>
 819 |         <td><xsl:value-of select="service/@extrainfo" /><xsl:text>&#xA0;</xsl:text></td>
 820 |       </tr>
 821 |     </xsl:when>
 822 | 
 823 |     <xsl:otherwise>
 824 |       <tr>
 825 |         <td><xsl:value-of select="@portid" /></td>
 826 |         <td><xsl:value-of select="@protocol" /></td>
 827 |         <td><xsl:value-of select="state/@state" /></td>
 828 |         <td><xsl:value-of select="service/@name" /><xsl:text>&#xA0;</xsl:text></td>
 829 |         <td><xsl:value-of select="state/@reason"/>
 830 |           <xsl:if test="state/@reason_ip">
 831 |             <xsl:text> from </xsl:text>
 832 |             <xsl:value-of select="state/@reason_ip"/>
 833 |           </xsl:if>
 834 | 	</td>
 835 |         <td><xsl:value-of select="service/@product" /><xsl:text>&#xA0;</xsl:text></td>
 836 |         <td><xsl:value-of select="service/@version" /><xsl:text>&#xA0;</xsl:text></td>
 837 |         <td><xsl:value-of select="service/@extrainfo" /><xsl:text>&#xA0;</xsl:text></td>
 838 |       </tr>
 839 |     </xsl:otherwise>
 840 | 
 841 |   </xsl:choose>
 842 | </xsl:template>
 843 | <!-- ............................................................ -->
 844 | 
 845 | <!-- os -->
 846 | <!-- ............................................................ -->
 847 | <xsl:template match="os">
 848 |   <h3>Remote Operating System Detection</h3>
 849 | 		
 850 |   <xsl:if test="count(osmatch) = 0"><p>Unable to identify operating system.</p></xsl:if>
 851 | 
 852 |   <ul>
 853 |     <xsl:for-each select="portused">
 854 |       <li>Used port: <b><xsl:value-of select="@portid" />/<xsl:value-of select="@proto" /> </b> (<b><xsl:value-of select="@state" /></b>)  </li>
 855 |     </xsl:for-each>
 856 |     
 857 |     <xsl:for-each select="osmatch">
 858 |       <li>OS match: <b><xsl:value-of select="@name" /> </b> (<b><xsl:value-of select="@accuracy" />%</b>)</li>
 859 |     </xsl:for-each>
 860 |   </ul>
 861 |   
 862 |   <xsl:apply-templates select="osfingerprint"/>
 863 | 
 864 | </xsl:template>
 865 | <!-- ............................................................ -->
 866 | 
 867 | 
 868 | <!-- osfingerprint -->
 869 | <!-- ............................................................ -->
 870 | <xsl:template match="osfingerprint">
 871 | 
 872 |   <xsl:variable name="var_address" select="../../address/@addr" /> 
 873 | 
 874 |   <xsl:choose>
 875 |     <xsl:when test="count(../osmatch)=0">
 876 |       
 877 |       <ul>
 878 |         <li>Cannot determine exact operating system.  Fingerprint provided below.</li>
 879 |         <li>If you know what OS is running on it, see https://nmap.org/submit/</li>
 880 |       </ul>
 881 |       <table cellspacing="1">
 882 |         <tr class="head">
 883 |           <td>Operating System fingerprint</td>
 884 |         </tr>
 885 |         <tr>
 886 |           <td><pre><xsl:value-of select="@fingerprint" /></pre></td>
 887 |         </tr>
 888 |       </table>
 889 |       
 890 |     </xsl:when>
 891 | 
 892 |     <xsl:otherwise>
 893 |       <ul>
 894 |         <li class="noprint">OS identified but the fingerprint was requested at scan time. 
 895 |           
 896 |         <xsl:element name="a">
 897 |           <xsl:attribute name="href">javascript:toggle('osblock_<xsl:value-of select="$var_address"/>');</xsl:attribute>
 898 |           <span class="noprint"><small> (click to expand)</small></span>
 899 |         </xsl:element>
 900 |         </li>
 901 |       </ul>
 902 | 
 903 |       <xsl:element name="div">
 904 |         <xsl:attribute name="id">osblock_<xsl:value-of select="$var_address"/></xsl:attribute>
 905 |         <xsl:attribute name="class">hidden</xsl:attribute>
 906 | 
 907 |         <table class="noprint" cellspacing="1">
 908 |           <tr class="head">
 909 |             <td>Operating System fingerprint</td>
 910 |           </tr>
 911 |           <tr>
 912 |             <td><pre><xsl:value-of select="@fingerprint" /></pre></td>
 913 |           </tr>
 914 |         </table>      
 915 |       
 916 |       </xsl:element>
 917 |       
 918 |     </xsl:otherwise>
 919 | 
 920 |   </xsl:choose>
 921 | 
 922 |   </xsl:template>
 923 | <!-- ............................................................ -->
 924 | 
 925 | <!-- Pre-Scan script -->
 926 | <!-- ............................................................ -->
 927 | <xsl:template match="prescript">
 928 | 
 929 |   <hr class="print_only" />
 930 |   
 931 |   <xsl:element name="a">
 932 |     <xsl:attribute name="name">prescript</xsl:attribute>
 933 |   </xsl:element>
 934 | 
 935 |   <h2>Pre-Scan Script Output</h2>
 936 | 
 937 |   <table>
 938 |     <tr class="head">
 939 |       <td>Script Name</td>
 940 |       <td>Output</td>
 941 |     </tr>
 942 |     <xsl:for-each select="script">
 943 | 
 944 |     <tr class="script">
 945 |       <td>
 946 |         <xsl:value-of select="@id"/> <xsl:text>&#xA0;</xsl:text>
 947 |       </td>
 948 |       <td>
 949 |         <pre>
 950 |           <xsl:value-of select="@output"/> <xsl:text></xsl:text>
 951 |         </pre>
 952 |       </td>
 953 |     </tr>
 954 | 
 955 |   </xsl:for-each>
 956 |   </table>
 957 | </xsl:template>
 958 | <!-- ............................................................ -->
 959 | 
 960 | <!-- Post-Scan script -->
 961 | <!-- ............................................................ -->
 962 | <xsl:template match="postscript">
 963 | 
 964 |   <hr class="print_only" />
 965 |   
 966 |   <xsl:element name="a">
 967 |     <xsl:attribute name="name">postscript</xsl:attribute>
 968 |   </xsl:element>
 969 | 
 970 |   <h2>Post-Scan Script Putput</h2>
 971 | 	
 972 |   <table>
 973 |     <tr class="head">
 974 |       <td>Script Name</td>
 975 |       <td>Output</td>
 976 |     </tr>
 977 | 
 978 |   <xsl:for-each select="script">
 979 |     <tr class="script">
 980 |       <td>
 981 |         <xsl:value-of select="@id"/> <xsl:text>&#xA0;</xsl:text>
 982 |       </td>
 983 |       <td>
 984 |         <pre>
 985 |           <xsl:value-of select="@output"/> <xsl:text></xsl:text>
 986 |         </pre>
 987 |       </td>
 988 |     </tr>
 989 | 
 990 |   </xsl:for-each>
 991 |   </table>
 992 | </xsl:template>
 993 | <!-- ............................................................ -->
 994 | 
 995 | 
 996 | <!-- Host Script Scan -->
 997 | <!-- ............................................................ -->
 998 | <xsl:template match="hostscript">
 999 |   <h3>Host Script Output</h3>
1000 | 
1001 |     <table>
1002 |       <tr class="head">
1003 |         <td>Script Name</td>
1004 |         <td>Output</td>
1005 |       </tr>
1006 | 
1007 |   <xsl:for-each select="script">
1008 |       <tr class="script">
1009 |         <td>
1010 |           <xsl:value-of select="@id"/> <xsl:text>&#xA0;</xsl:text>
1011 |         </td>
1012 |         <td>
1013 |           <pre>
1014 |             <xsl:value-of select="@output"/> <xsl:text>&#xA0;</xsl:text>
1015 |           </pre>
1016 |         </td>
1017 |       </tr>
1018 |   </xsl:for-each>
1019 | 
1020 |     </table>
1021 | </xsl:template>
1022 | <!-- ............................................................ -->
1023 | 
1024 | <!-- smurf -->
1025 | <!-- ............................................................ -->
1026 | <xsl:template match="smurf">
1027 |   <xsl:if test="@responses != ''"><h3>Smurf Responses</h3>
1028 |     <ul>
1029 |       <li><xsl:value-of select="@responses" /> responses counted</li>
1030 |     </ul>
1031 |   </xsl:if>
1032 | </xsl:template>
1033 | <!-- ............................................................ -->
1034 | 
1035 | 
1036 | <!-- traceroute -->
1037 | <!-- ............................................................ -->
1038 | 
1039 | <xsl:template match="trace">
1040 |   <xsl:if test="@port">
1041 |   <xsl:variable name="var_address" select="../address/@addr" /> 
1042 |  
1043 | 
1044 |   
1045 |  <xsl:element name="a">
1046 |     <xsl:attribute name="href">javascript:toggle('trace_<xsl:value-of select="$var_address"/>');</xsl:attribute>
1047 |     Traceroute Information <span class="noprint"><small> (click to expand)</small></span>
1048 |   </xsl:element>
1049 | 
1050 |   <xsl:element name="div">
1051 |     <xsl:attribute name="id">trace_<xsl:value-of select="$var_address"/></xsl:attribute>
1052 |     <xsl:attribute name="class">hidden</xsl:attribute>
1053 | 
1054 |   
1055 |     <xsl:choose>
1056 |       <xsl:when test="@port">
1057 |         <ul><li>Traceroute data generated using port <xsl:value-of select="@port" />/<xsl:value-of select="@proto" /></li></ul>
1058 |       </xsl:when>
1059 |     </xsl:choose>
1060 |   
1061 |     <table cellspacing="1">
1062 |       <tr class="head">
1063 |         <td>Hop</td>
1064 |         <td>Rtt</td>
1065 |         <td>IP</td>
1066 |         <td>Host</td>
1067 |       </tr>
1068 |       <xsl:for-each select="hop">
1069 |         <xsl:choose>
1070 |             <xsl:when test="@rtt = '--'">
1071 |               <tr class="filtered">
1072 |                 <td><xsl:value-of select="@ttl" /></td>
1073 |                 <td>--</td>
1074 |                 <td><xsl:value-of select="@ipaddr" /></td>
1075 |                 <td><xsl:value-of select="@host" /></td>
1076 |               </tr>
1077 |             </xsl:when>
1078 | 
1079 |             <xsl:when test="@rtt > 0">
1080 |               <tr class="open">
1081 |                 <td><xsl:value-of select="@ttl" /></td>
1082 |                 <td><xsl:value-of select="@rtt" /></td>
1083 |                 <td><xsl:value-of select="@ipaddr" /></td>
1084 |                 <td><xsl:value-of select="@host" /></td>
1085 |               </tr>
1086 |             </xsl:when>
1087 | 
1088 |             <xsl:otherwise>
1089 |               <tr class="closed">
1090 |                 <td><xsl:value-of select="@ttl" /></td>
1091 |                 <td></td><td></td><td></td>
1092 |               </tr>
1093 |             </xsl:otherwise>
1094 |           </xsl:choose>
1095 |       </xsl:for-each>
1096 |     </table>
1097 |   </xsl:element>
1098 | 
1099 |   </xsl:if>
1100 | </xsl:template>
1101 | <!-- ............................................................ -->
1102 | </xsl:stylesheet>
1103 | 


--------------------------------------------------------------------------------