use std::borrow::Cow;
use std::fmt::Write as _;
use std::io::Write;
use std::time::SystemTime;
use crate::export::schema::{
ENGINE_NAME, FindingDto, HostDto, PhaseDto, PortDto, ProbeStatsDto, RangeDto, SCHEMA_VERSION,
SummaryDto, host_status_name, port_state_name, scan_kind_name, total_elapsed_us,
};
use crate::export::write::{TONE_FOUND, TONE_INERT, TONE_NONE, TONE_PARTIAL, Text, esc};
use crate::export::{ExportError, ExportOptions, Exporter, write};
use crate::format::time::rfc3339;
use crate::model::host::{Host, HostStatus};
use crate::model::port::{Port, PortState};
use crate::report::ScanReport;
const DEFAULT_HEADING: &str = "Scan report";
const PORT_COLUMNS: usize = 7;
fn host_tone(status: HostStatus) -> &'static str {
match status {
HostStatus::Up => TONE_FOUND,
HostStatus::Filtered => TONE_PARTIAL,
HostStatus::Down => TONE_INERT,
HostStatus::Unknown => TONE_NONE,
}
}
fn port_tone(state: PortState) -> &'static str {
match state {
PortState::Open => TONE_FOUND,
PortState::OpenFiltered
| PortState::Filtered
| PortState::Unfiltered
| PortState::ClosedFiltered => TONE_PARTIAL,
PortState::Closed => TONE_INERT,
PortState::Unasked => TONE_NONE,
}
}
#[must_use]
#[derive(Debug, Clone, Default)]
pub struct HtmlExporter {
options: ExportOptions,
heading: Option<String>,
}
impl HtmlExporter {
pub fn new(options: ExportOptions) -> Self {
Self {
options,
heading: None,
}
}
pub fn with_heading(mut self, heading: impl Into<String>) -> Self {
self.heading = Some(heading.into());
self
}
pub fn options(&self) -> &ExportOptions {
&self.options
}
fn heading(&self) -> &str {
self.heading.as_deref().unwrap_or(DEFAULT_HEADING)
}
fn title<'a>(&'a self, started_at: &str) -> Cow<'a, str> {
match &self.heading {
Some(heading) => Cow::Borrowed(heading.as_str()),
None => {
let day = started_at.split('T').next().unwrap_or(started_at);
Cow::Owned(format!("zond scan report — {day}"))
}
}
}
}
impl Exporter for HtmlExporter {
fn export(&self, report: &ScanReport, out: &mut dyn Write) -> Result<(), ExportError> {
let started_at = rfc3339(report.started_at());
let generated_at = rfc3339(SystemTime::now());
let summary = SummaryDto::new(&report.summary());
let phases: Vec<PhaseDto<'_>> = report
.phases()
.iter()
.map(|phase| PhaseDto::new(phase, &self.options))
.collect();
let elapsed_us = total_elapsed_us(&phases);
write::head(out, &self.title(&started_at))?;
write_masthead(out, self.heading(), report, &started_at, elapsed_us)?;
write_notices(out, report, &phases, &self.options)?;
write_tiles(out, &summary, &phases)?;
write_distributions(out, &summary)?;
write_hosts(out, report, &self.options)?;
write_scan_detail(out, &phases)?;
write_colophon(out, report, &generated_at)?;
write::foot(out)?;
Ok(())
}
}
fn findings_from(report: &ScanReport) -> String {
if report.engine_version() == crate::report::ENGINE_VERSION {
return String::new();
}
format!(" · findings from {}", Text(report.engine_version()))
}
fn write_masthead(
out: &mut dyn Write,
heading: &str,
report: &ScanReport,
started_at: &str,
elapsed_us: u64,
) -> Result<(), ExportError> {
let count = report.phases().len();
let kinds: Vec<String> = report
.phases()
.iter()
.map(|phase| esc(scan_kind_name(phase.kind())))
.collect();
let subtitle = format!(
"{kinds} · started {started_at} · {elapsed} · {count} {word}",
kinds = kinds.join(" + "),
started_at = Text(started_at),
elapsed = duration(elapsed_us),
word = plural(count, "phase", "phases"),
);
write::masthead(out, heading, &subtitle)
}
fn write_notices(
out: &mut dyn Write,
report: &ScanReport,
phases: &[PhaseDto<'_>],
options: &ExportOptions,
) -> Result<(), ExportError> {
let unprivileged = phases
.iter()
.filter(|phase| phase.privileged == Some(false))
.count();
let idle = phases
.iter()
.any(|phase| phase.settings.idle_scan.is_some());
let evaded = phases.iter().any(|phase| phase.settings.evasion.is_some());
let connected = phases
.iter()
.any(|phase| !phase.reached_by_connect.is_empty());
if !report.is_partial()
&& unprivileged == 0
&& !connected
&& !idle
&& !evaded
&& !options.redaction.is_active()
{
return Ok(());
}
writeln!(out, "<p class=\"notices\">")?;
if idle {
write::notice(
out,
true,
"idle scan",
"no port state here was seen directly; each was inferred from a third party's IP identification counter, which a busy zombie makes unreliable",
)?;
}
if evaded {
write::notice(
out,
true,
"evasion",
"the probes were altered before they went out, so a state here says how the target answered an unusual packet rather than an ordinary one",
)?;
}
if report.is_partial() {
write::notice(
out,
true,
"partial",
&format!(
"these findings are narrower than the scan asked for: {}",
shortfalls(report).join(", ")
),
)?;
}
if unprivileged > 0 {
write::notice(
out,
true,
"unprivileged",
"raw probes were unavailable; those targets were reached over plain connect attempts, which see less",
)?;
}
if connected {
write::notice(
out,
true,
"by connect",
"some targets were out of reach of this machine's raw probes and were reached over plain connect attempts, which see less; each phase lists them",
)?;
}
if options.redaction.is_active() {
write::notice(
out,
false,
"redacted",
"hostnames, hardware addresses and certificate subjects are masked in this copy",
)?;
}
writeln!(out, "</p>")?;
Ok(())
}
fn write_tiles(
out: &mut dyn Write,
summary: &SummaryDto,
phases: &[PhaseDto<'_>],
) -> Result<(), ExportError> {
writeln!(out, "<section class=\"tiles\">")?;
write::tile(out, summary.hosts_total, "hosts", &ranges_note(phases))?;
write::tile(
out,
summary.hosts_alive,
"alive",
&esc("up or filtered — confirmed present"),
)?;
write::tile(
out,
summary.ports_open,
"open ports",
&format!("of {} recorded", summary.ports_total),
)?;
write::tile(
out,
summary.services_identified,
"services",
&esc("identified by fingerprinting"),
)?;
writeln!(out, "</section>")?;
Ok(())
}
fn ranges_note(phases: &[PhaseDto<'_>]) -> String {
let ranges: Vec<String> = phases
.iter()
.flat_map(|phase| phase.targets.ranges.iter())
.map(|range| format!("{}–{}", esc(&range.start), esc(&range.end)))
.collect();
match ranges.len() {
0 => String::new(),
1..=2 => ranges.join(", "),
count => format!("{}, and {} more", ranges[0], count - 1),
}
}
fn write_distributions(out: &mut dyn Write, summary: &SummaryDto) -> Result<(), ExportError> {
let statuses = &summary.hosts_by_status;
let states = &summary.ports_by_state;
writeln!(out, "<section class=\"distributions\">")?;
distribution(
out,
"Host status",
summary.hosts_total,
&[
status_slice(HostStatus::Up, statuses.up),
status_slice(HostStatus::Filtered, statuses.filtered),
status_slice(HostStatus::Down, statuses.down),
status_slice(HostStatus::Unknown, statuses.unknown),
],
)?;
distribution(
out,
"Port state",
summary.ports_total,
&[
state_slice(PortState::Open, states.open),
state_slice(PortState::OpenFiltered, states.open_filtered),
state_slice(PortState::Closed, states.closed),
state_slice(PortState::Unfiltered, states.unfiltered),
state_slice(PortState::Filtered, states.filtered),
state_slice(PortState::ClosedFiltered, states.closed_filtered),
state_slice(PortState::Unasked, states.unasked),
],
)?;
writeln!(out, "</section>")?;
Ok(())
}
struct Slice {
label: &'static str,
tone: &'static str,
count: usize,
}
fn status_slice(status: HostStatus, count: usize) -> Slice {
Slice {
label: host_status_name(status),
tone: host_tone(status),
count,
}
}
fn state_slice(state: PortState, count: usize) -> Slice {
Slice {
label: port_state_name(state),
tone: port_tone(state),
count,
}
}
fn distribution(
out: &mut dyn Write,
title: &str,
total: usize,
slices: &[Slice],
) -> Result<(), ExportError> {
writeln!(
out,
"<div class=\"dist\">\n<h2 class=\"dist-title\">{title}</h2>",
title = Text(title),
)?;
let empty = if total == 0 { " meter-empty" } else { "" };
write!(out, "<div class=\"meter{empty}\">")?;
for slice in slices.iter().filter(|slice| slice.count > 0) {
write!(
out,
"<span class=\"seg {tone}\" style=\"width:{width:.3}%\"></span>",
tone = slice.tone,
width = percent(slice.count, total),
)?;
}
writeln!(out, "</div>\n<ul class=\"legend\">")?;
for slice in slices {
let zero = if slice.count == 0 { " legend-zero" } else { "" };
writeln!(
out,
"<li class=\"legend-item{zero}\"><span class=\"swatch {tone}\"></span><span class=\"legend-label\">{label}</span><span class=\"legend-value\">{count}</span></li>",
tone = slice.tone,
label = Text(slice.label),
count = slice.count,
)?;
}
writeln!(out, "</ul>\n</div>")?;
Ok(())
}
fn write_hosts(
out: &mut dyn Write,
report: &ScanReport,
options: &ExportOptions,
) -> Result<(), ExportError> {
writeln!(
out,
"<section class=\"section\">\n<h2 class=\"section-title\">Hosts <span class=\"section-count\">{count}</span></h2>",
count = report.host_count(),
)?;
if report.host_count() == 0 {
writeln!(out, "<p class=\"empty\">no hosts recorded</p>")?;
}
for host in report.hosts() {
write_host(out, host, options)?;
}
writeln!(out, "</section>")?;
Ok(())
}
fn write_host(
out: &mut dyn Write,
host: &Host,
options: &ExportOptions,
) -> Result<(), ExportError> {
let dto = HostDto::new(host, options);
write!(
out,
"<article class=\"host\">\n<header class=\"host-head\"><span class=\"host-ip\">{ip}</span>",
ip = Text(&dto.primary_ip),
)?;
if let Some(hostname) = &dto.hostname {
write!(out, "<span class=\"host-name\">{}</span>", Text(hostname))?;
}
write!(
out,
"<span class=\"tag {tone}\">{status}</span>",
tone = host_tone(host.status()),
status = Text(dto.status),
)?;
for role in &dto.roles {
write!(out, "<span class=\"tag tag-role\">{}</span>", Text(role))?;
}
writeln!(out, "</header>\n<div class=\"host-body\">")?;
write_host_facts(out, &dto)?;
write_ports(out, host, &dto)?;
writeln!(out, "</div>\n</article>")?;
Ok(())
}
fn write_host_facts(out: &mut dyn Write, dto: &HostDto<'_>) -> Result<(), ExportError> {
writeln!(out, "<dl class=\"facts\">")?;
if !dto.findings.is_empty() {
let mut findings = String::new();
write_finding_facts(&mut findings, &dto.findings);
write!(out, "{findings}")?;
}
if dto.ips.len() > 1 {
let addresses: Vec<String> = dto.ips.iter().map(|ip| esc(ip)).collect();
fact(out, "addresses", &addresses.join(", "))?;
}
if let Some(os) = &dto.os {
let mut detail = vec![format!("{}% confidence", os.accuracy)];
if let Some(family) = os.family {
detail.push(esc(family));
}
if let Some(vendor) = os.vendor {
detail.push(esc(vendor));
}
let name = match os.generation {
Some(generation) => format!("{} {}", esc(os.name), esc(generation)),
None => esc(os.name),
};
fact(out, "os", &format!("{name}{}", dim(&detail)))?;
}
if !dto.ip_protocols.is_empty() {
let named = |state: &str| -> Vec<String> {
dto.ip_protocols
.iter()
.filter(|entry| entry.state == state)
.map(|entry| match entry.name {
Some(name) => esc(name),
None => entry.protocol.to_string(),
})
.collect()
};
let accepted = named("open");
let refused = named("closed");
let mut detail = Vec::new();
if !refused.is_empty() {
detail.push(format!("refuses {}", refused.join(", ")));
}
detail.push(format!("{} asked about", dto.ip_protocols.len()));
let value = match accepted.is_empty() {
false => accepted.join(", "),
true => "none answered".to_string(),
};
fact(out, "ip protocols", &format!("{value}{}", dim(&detail)))?;
}
if let Some(hardware) = &dto.hardware {
let mut value = hardware.mac.as_deref().map(esc).unwrap_or_default();
let mut detail = Vec::new();
if let Some(vendor) = hardware.vendor {
detail.push(esc(vendor));
}
if hardware.macs.len() > 1 {
detail.push(format!("{} addresses seen", hardware.macs.len()));
}
value.push_str(&dim(&detail));
fact(out, "hardware", &value)?;
}
let telemetry = &dto.telemetry;
if let Some(median) = telemetry.rtt_median_us {
let mut detail = Vec::new();
if let (Some(min), Some(max)) = (telemetry.rtt_min_us, telemetry.rtt_max_us) {
detail.push(format!("{} – {}", duration(min), duration(max)));
}
if let Some(jitter) = telemetry.jitter_us {
detail.push(format!("jitter {}", duration(jitter)));
}
detail.push(format!(
"{} {}",
telemetry.samples,
plural(telemetry.samples, "sample", "samples")
));
fact(
out,
"rtt",
&format!("{} median{}", duration(median), dim(&detail)),
)?;
}
if !dto.path.is_empty() {
let mut path = String::new();
for hop in &dto.path {
let address = match hop.address.as_deref() {
Some(address) => address,
None if hop.withheld => "excluded",
None => "*",
};
let mut detail = Vec::new();
if let Some(rtt) = hop.rtt_us {
detail.push(duration(rtt));
}
if hop.inferred {
detail.push("from another trace".to_string());
}
let _ = write!(
path,
"<div>{:>2}. {}{}</div>",
hop.distance,
esc(address),
dim(&detail)
);
}
fact(out, "path", &path)?;
}
let mut evidence = String::new();
for reason in &dto.reasons {
let mut detail: Vec<String> = reason.details.map(esc).into_iter().collect();
match &reason.source_ip {
Some(source) => detail.push(format!("via {}", esc(source))),
None if reason.source_withheld => detail.push("via an excluded address".to_owned()),
None => {}
}
let _ = write!(
evidence,
"<div>{}{}</div>",
Text(&reason.protocol),
dim(&detail)
);
}
fact(out, "evidence", &evidence)?;
fact(
out,
"seen",
&format!(
"{}{}",
esc(&dto.first_seen),
dim(&[format!("last {}", esc(&dto.last_seen))])
),
)?;
writeln!(out, "</dl>")?;
Ok(())
}
fn write_ports(out: &mut dyn Write, host: &Host, dto: &HostDto<'_>) -> Result<(), ExportError> {
if dto.ports.is_empty() {
writeln!(out, "<p class=\"empty\">no ports recorded</p>")?;
return Ok(());
}
writeln!(
out,
"<div class=\"scroll\">\n<table class=\"table\">\n<thead><tr><th>port</th><th>state</th><th>service</th><th>product</th><th>version</th><th class=\"num\">rtt</th><th>evidence</th></tr></thead>\n<tbody>"
)?;
for (port, port_dto) in host.ports().zip(dto.ports.iter()) {
debug_assert_eq!(
port.number(),
port_dto.port,
"the rendered ports and the host's ports have diverged"
);
write_port(out, port, port_dto)?;
}
writeln!(out, "</tbody>\n</table>\n</div>")?;
Ok(())
}
fn write_port(out: &mut dyn Write, port: &Port, dto: &PortDto<'_>) -> Result<(), ExportError> {
let service = dto.service.as_ref();
let discovery = dto.discovery.as_ref();
write!(
out,
"<tr><td class=\"mono\">{number}/{protocol}</td><td><span class=\"tag {tone}\">{state}</span></td>",
number = dto.port,
protocol = Text(dto.protocol),
tone = port_tone(port.state()),
state = Text(dto.state),
)?;
write!(
out,
"<td>{}</td>",
service.map(|service| esc(service.name)).unwrap_or_default()
)?;
write!(
out,
"<td>{}</td>",
service
.and_then(|service| service.product)
.map(esc)
.unwrap_or_default()
)?;
let version = service
.map(|service| {
let mut text = service.version.map(esc).unwrap_or_default();
if let Some(extra) = service.extrainfo {
text.push_str(&dim(&[esc(extra)]));
}
text
})
.unwrap_or_default();
write!(out, "<td>{version}</td>")?;
write!(
out,
"<td class=\"num\">{}</td>",
discovery
.and_then(|discovery| discovery.rtt_us)
.map(duration)
.unwrap_or_default()
)?;
writeln!(
out,
"<td>{}</td></tr>",
discovery
.map(|discovery| esc(&discovery.reason))
.unwrap_or_default()
)?;
write_port_detail(out, dto)
}
fn write_finding_facts(facts: &mut String, findings: &[FindingDto<'_>]) {
for finding in findings {
let mut detail = vec![Text(finding.confidence).to_string()];
if !finding.references.is_empty() {
let references: Vec<String> =
finding.references.iter().map(|r| esc(&r.value)).collect();
detail.push(references.join(", "));
}
let _ = write!(
facts,
"<dt>{severity}</dt><dd>{title}{detail}",
severity = Text(finding.severity),
title = Text(finding.title),
detail = dim(&detail),
);
if let Some(excerpt) = finding.excerpt {
let _ = write!(facts, "<div class=\"mono\">{}</div>", Text(excerpt));
}
if let Some(remediation) = finding.remediation {
let _ = write!(facts, "<div>{}</div>", Text(remediation));
}
facts.push_str("</dd>");
}
}
fn write_port_detail(out: &mut dyn Write, dto: &PortDto<'_>) -> Result<(), ExportError> {
let mut facts = String::new();
write_finding_facts(&mut facts, &dto.findings);
if let Some(service) = &dto.service {
let cpes: Vec<String> = service.cpes.iter().map(|cpe| esc(cpe)).collect();
let _ = write!(
facts,
"<dt>service</dt><dd>{}% confidence{}</dd>",
service.confidence,
dim(&[cpes.join(", ")])
);
}
if let Some(security) = &dto.security {
let mut detail = Vec::new();
if let Some(cipher) = security.cipher_suite {
detail.push(esc(cipher));
}
if !security.alpn.is_empty() {
let alpn: Vec<String> = security.alpn.iter().map(|name| esc(name)).collect();
detail.push(alpn.join(" "));
}
let _ = write!(
facts,
"<dt>tls</dt><dd>{}{}</dd>",
security.tls_version.map(esc).unwrap_or_default(),
dim(&detail)
);
for accepted in &security.accepts {
let mut detail = Vec::new();
if accepted.deprecated {
detail.push(esc("withdrawn"));
}
let insecure = accepted
.suites
.iter()
.filter(|suite| suite.strength != "strong")
.count();
if insecure > 0 {
detail.push(format!(
"{insecure} of {} below strong",
accepted.suites.len()
));
}
if !accepted.unrecognised.is_empty() {
detail.push(format!("{} unnamed", accepted.unrecognised.len()));
}
if let Some(unfinished) = security
.unfinished
.iter()
.find(|unfinished| unfinished.version == accepted.version)
{
detail.push(format!("incomplete, {}", esc(unfinished.interruption)));
}
let suites: Vec<String> = accepted
.suites
.iter()
.map(|suite| match suite.faults.is_empty() {
true => esc(suite.name),
false => format!("{} ({})", esc(suite.name), esc(&suite.faults.join(", "))),
})
.collect();
let _ = write!(
facts,
"<dt>accepts</dt><dd>{}{}<br>{}</dd>",
esc(accepted.version),
dim(&detail),
dim(&[suites.join(" · ")])
);
}
for unfinished in security.unfinished.iter().filter(|unfinished| {
!security
.accepts
.iter()
.any(|accepted| accepted.version == unfinished.version)
}) {
let _ = write!(
facts,
"<dt>unsettled</dt><dd>{}{}</dd>",
esc(unfinished.version),
dim(&[esc(unfinished.interruption)])
);
}
if let Some(certificate) = &security.certificate {
let mut detail = vec![format!("issued by {}", esc(certificate.issuer))];
if !certificate.sans.is_empty() {
let sans: Vec<String> = certificate.sans.iter().map(|san| esc(san)).collect();
detail.push(format!("also {}", sans.join(", ")));
}
detail.push(format!(
"{} {}-bit",
esc(certificate.pubkey_type),
certificate.pubkey_bits
));
let _ = write!(
facts,
"<dt>certificate</dt><dd>{}{}</dd>",
esc(&certificate.common_name),
dim(&detail)
);
let _ = write!(
facts,
"<dt>validity</dt><dd>{} – {}</dd>",
esc(&certificate.validity_start),
esc(&certificate.validity_end)
);
let _ = write!(
facts,
"<dt>fingerprint</dt><dd>{}</dd>",
esc(certificate.fingerprint_sha256)
);
}
}
if let Some(discovery) = &dto.discovery {
let mut detail = Vec::new();
if let Some(ttl) = discovery.ttl {
detail.push(format!("ttl {ttl}"));
}
if let Some(source) = &discovery.source_ip {
detail.push(format!("reply from {}", esc(source)));
}
let _ = write!(
facts,
"<dt>probe</dt><dd>{}{}</dd>",
esc(&discovery.timestamp),
dim(&detail)
);
}
if facts.is_empty() {
return Ok(());
}
writeln!(
out,
"<tr class=\"port-detail\"><td colspan=\"{PORT_COLUMNS}\"><dl class=\"facts\">{facts}</dl></td></tr>"
)?;
Ok(())
}
fn write_scan_detail(out: &mut dyn Write, phases: &[PhaseDto<'_>]) -> Result<(), ExportError> {
writeln!(
out,
"<section class=\"section\">\n<h2 class=\"section-title\">Scan detail <span class=\"section-count\">{count} {word}</span></h2>",
count = phases.len(),
word = plural(phases.len(), "phase", "phases"),
)?;
for phase in phases {
write_phase(out, phase)?;
}
writeln!(out, "</section>")?;
Ok(())
}
fn write_phase(out: &mut dyn Write, phase: &PhaseDto<'_>) -> Result<(), ExportError> {
let privilege = match phase.privileged {
Some(true) => "privileged",
Some(false) => "unprivileged",
None => "privilege not recorded",
};
writeln!(
out,
"<article class=\"phase\">\n<header class=\"phase-head\"><span class=\"phase-kind\">{kind}</span><span class=\"dim\">{started} · {elapsed} · {privilege}</span></header>\n<dl class=\"facts\">",
kind = Text(phase.kind),
started = Text(&phase.started_at),
elapsed = duration(phase.elapsed_us),
)?;
let scope = &phase.targets;
let mut targets = vec![format!(
"{} {}",
esc(&scope.addresses),
plural_str(&scope.addresses, "address", "addresses")
)];
if let Some(probes) = &scope.probes {
targets.push(format!(
"{} {}",
esc(probes),
plural_str(probes, "probe", "probes")
));
}
if !scope.protocols.is_empty() {
targets.push(scope.protocols.join(", "));
}
fact(out, "targets", &targets.join(" · "))?;
let ranges: Vec<String> = scope
.ranges
.iter()
.map(|range| format!("{}–{}", esc(&range.start), esc(&range.end)))
.collect();
fact(out, "ranges", &ranges.join("<br>"))?;
if !scope.links.is_empty() {
let links: Vec<String> = scope.links.iter().map(|name| esc(name)).collect();
fact(out, "links swept", &links.join(", "))?;
}
if !scope.listened.is_empty() {
let listened: Vec<String> = scope.listened.iter().map(|name| esc(name)).collect();
fact(
out,
"links listened on",
&format!(
"{}{}",
listened.join(", "),
dim(&[esc("not coverage: silence here is not absence")])
),
)?;
}
if let Some(ports) = &scope.ports {
let spec = if ports.spec.is_empty() {
String::new()
} else {
dim(&[esc(&ports.spec)])
};
fact(out, "ports", &format!("{}{spec}", esc(ports.kind)))?;
}
if !scope.excluded.is_empty() {
let excluded: Vec<String> = scope
.excluded
.iter()
.map(|range| format!("{}–{}", esc(&range.start), esc(&range.end)))
.collect();
fact(
out,
"excluded",
&format!(
"{}<br><span class=\"dim\">{} {} withheld</span>",
excluded.join("<br>"),
esc(&scope.withheld),
plural_str(&scope.withheld, "address", "addresses"),
),
)?;
}
let retry = &phase.settings.retry;
let mut budget = vec![esc(retry.effort)];
if let Some(attempts) = retry.max_attempts {
budget.push(format!("{attempts} attempts"));
}
if let Some(scale) = retry.timeout_scale {
budget.push(format!("timeout ×{scale}"));
}
if retry.dampen_silent_hosts {
budget.push("silent hosts dampened".to_string());
}
fact(out, "retry", &budget.join(" · "))?;
let settings = &phase.settings;
let rate = match (settings.min_probe_rate, settings.max_probe_rate) {
(Some(min), Some(max)) => format!("min {min} · max {max} probes/s"),
(Some(min), None) => format!("min {min} probes/s"),
(None, Some(max)) => format!("max {max} probes/s"),
(None, None) => "scanner default rate".to_string(),
};
let dns = if settings.dns_enabled {
"dns enabled"
} else {
"dns disabled"
};
let bounds: Vec<String> = [
settings
.host_timeout_us
.map(|us| format!("per host {}", duration(us))),
settings
.scan_timeout_us
.map(|us| format!("whole scan {}", duration(us))),
settings
.host_probe_interval_us
.map(|us| format!("{} between probes at one host", duration(us))),
]
.into_iter()
.flatten()
.collect();
fact(
out,
"wire",
&format!(
"{} · sctp {} · send {} · {rate} · {dns} · os {} · service {} · detection {}",
esc(settings.tcp_technique),
esc(settings.sctp_technique),
esc(settings.send_mode),
esc(settings.os_detection),
esc(settings.service_detection),
esc(settings.detection),
),
)?;
if !bounds.is_empty() {
fact(out, "time limit", &bounds.join(" · "))?;
}
if let Some(idle) = &settings.idle_scan {
let port = idle
.zombie_port
.map(|port| format!("port {port}"))
.unwrap_or_default();
fact(
out,
"idle scan",
&format!(
"{}{}",
esc(&idle.zombie),
dim(&[port, esc("states inferred, not seen")])
),
)?;
}
if let Some(evasion) = &settings.evasion {
fact(out, "evasion", &evasion_detail(evasion))?;
}
if !settings.listen_only_ports.is_empty() {
let ports: crate::model::port::PortSet = settings
.listen_only_ports
.iter()
.map(|&number| (number, crate::model::port::Protocol::Tcp))
.collect();
fact(
out,
"listened only",
&format!(
"tcp {}{}",
esc(&ports.to_string()),
dim(&[esc("sent nothing, since a printer prints what arrives")])
),
)?;
}
if !phase.unroutable.is_empty() {
let addresses: Vec<String> = phase.unroutable.iter().map(|ip| esc(ip)).collect();
fact(
out,
"unreachable",
&format!(
"{}{}",
addresses.join(", "),
dim(&[esc("named, never probed")])
),
)?;
}
if !phase.timed_out.is_empty() {
let addresses: Vec<String> = phase.timed_out.iter().map(|ip| esc(ip)).collect();
fact(
out,
"out of time",
&format!(
"{}{}",
addresses.join(", "),
dim(&[esc("left part-scanned")])
),
)?;
}
if !phase.icmp_rate_limited.is_empty() {
let addresses: Vec<String> = phase.icmp_rate_limited.iter().map(|ip| esc(ip)).collect();
fact(
out,
"ICMP rate-limited",
&format!(
"{}{}",
addresses.join(", "),
dim(&[esc("closed UDP ports may read open|filtered")])
),
)?;
}
if !phase.undecided.is_empty() {
const SHOWN: usize = 6;
let mut ranges: Vec<String> = phase
.undecided
.iter()
.take(SHOWN)
.map(|range| match range.start == range.end {
true => esc(&range.start),
false => format!("{}–{}", esc(&range.start), esc(&range.end)),
})
.collect();
let more = phase.undecided.len().saturating_sub(SHOWN);
if more > 0 {
ranges.push(esc(&format!(
"and {more} more {}",
if more == 1 { "range" } else { "ranges" }
)));
}
let count = addresses_in(&phase.undecided);
fact(
out,
"undecided",
&format!(
"{}{}",
ranges.join(", "),
dim(&[esc(&format!(
"{count} {} with no verdict, not found down",
if count == 1 { "address" } else { "addresses" }
))])
),
)?;
}
if let Some(skip) = phase.liveness_skipped {
let why = match skip {
"assume_up" => "every address probed as up, as asked",
"idle_scan" => "an idle scan asks the target nothing directly",
_ => "probing the ports cost no more; an answer on any found the host",
};
fact(
out,
"liveness pass",
&format!("{}{}", esc("skipped"), dim(&[esc(why)])),
)?;
}
if !phase.silent.is_empty() {
const SHOWN: usize = 6;
let mut ranges: Vec<String> = phase
.silent
.iter()
.take(SHOWN)
.map(|range| match range.start == range.end {
true => esc(&range.start),
false => format!("{}–{}", esc(&range.start), esc(&range.end)),
})
.collect();
let more = phase.silent.len().saturating_sub(SHOWN);
if more > 0 {
ranges.push(esc(&format!(
"and {more} more {}",
if more == 1 { "range" } else { "ranges" }
)));
}
let count = addresses_in(&phase.silent);
fact(
out,
"silent",
&format!(
"{}{}",
ranges.join(", "),
dim(&[esc(&format!(
"{count} {} silent on every port, not listed",
if count == 1 { "address" } else { "addresses" }
))])
),
)?;
}
if !phase.reached_by_connect.is_empty() {
let ranges: Vec<String> = phase
.reached_by_connect
.iter()
.map(|range| match range.start == range.end {
true => esc(&range.start),
false => format!("{}–{}", esc(&range.start), esc(&range.end)),
})
.collect();
fact(
out,
"by connect",
&format!(
"{}{}",
ranges.join(", "),
dim(&[esc("out of reach of raw probes")])
),
)?;
}
if let Some(origin) = &phase.origin {
let label = origin.label.map(esc).into_iter().collect::<Vec<_>>();
fact(
out,
"read from",
&format!("{}{}", esc(origin.engine_version), dim(&label)),
)?;
}
writeln!(out, "</dl>")?;
write_attachments(out, &phase.attachments)?;
if !phase.failures.is_empty() {
writeln!(
out,
"<div class=\"block\">\n<div class=\"block-title\">failures</div>\n<div class=\"scroll\">\n<table class=\"table\">\n<thead><tr><th>scanner</th><th>reason</th><th>at</th></tr></thead>\n<tbody>"
)?;
for failure in &phase.failures {
writeln!(
out,
"<tr><td class=\"mono\">{scanner}</td><td>{reason}</td><td class=\"mono\">{at}</td></tr>",
scanner = Text(failure.scanner),
reason = Text(failure.reason),
at = Text(&failure.at),
)?;
}
writeln!(out, "</tbody>\n</table>\n</div>\n</div>")?;
}
for stats in &phase.probe_stats {
write_probe_stats(out, stats)?;
}
writeln!(out, "</article>")?;
Ok(())
}
fn evasion_detail(evasion: &crate::export::schema::EvasionDto) -> String {
let mut parts: Vec<String> = Vec::new();
if let Some(port) = evasion.source_port {
parts.push(format!("from port {port}"));
}
if let Some(ttl) = evasion.ttl {
parts.push(format!("ttl {ttl}"));
}
if let Some(padding) = evasion.padding {
parts.push(format!("{padding} bytes of padding"));
}
if evasion.bad_tcp_checksum {
parts.push("wrong TCP checksum".to_string());
}
if let Some(mac) = &evasion.spoof_mac {
parts.push(format!("spoofing {}", esc(mac)));
}
if let Some(bytes) = evasion.fragment {
parts.push(format!("fragmented to {bytes} bytes"));
}
if let Some(flags) = &evasion.flags {
parts.push(format!("flags {}", esc(flags)));
}
if !evasion.decoys.is_empty() {
let decoys: Vec<String> = evasion.decoys.iter().map(|ip| esc(ip)).collect();
parts.push(format!("decoys {}", decoys.join(", ")));
}
parts.join(" · ")
}
fn write_attachments(
out: &mut dyn Write,
attachments: &[crate::export::schema::AttachmentDto<'_>],
) -> Result<(), ExportError> {
if attachments.is_empty() {
return Ok(());
}
writeln!(
out,
"<div class=\"block\">\n<div class=\"block-title\">where this ran from</div>\n<div class=\"scroll\">\n<table class=\"table\">\n<thead><tr><th>link</th><th>device</th><th>port</th><th>vlan</th><th>seen</th></tr></thead>\n<tbody>"
)?;
for attachment in attachments {
let device = match (&attachment.device_name, &attachment.device_mac) {
(Some(name), Some(mac)) => format!("{}{}", Text(name), dim(&[esc(mac)])),
(Some(name), None) => Text(name).to_string(),
(None, Some(mac)) => esc(mac),
(None, None) => String::new(),
};
writeln!(
out,
"<tr><td class=\"mono\">{link}</td><td>{device}{source}</td><td class=\"mono\">{port}</td><td class=\"num\">{vlan}</td><td class=\"mono\">{seen}</td></tr>",
link = Text(attachment.link),
source = dim(&[esc(attachment.source)]),
port = attachment.port.map(esc).unwrap_or_default(),
vlan = attachment
.native_vlan
.map(|vlan| vlan.to_string())
.unwrap_or_default(),
seen = Text(&attachment.observed_at),
)?;
}
writeln!(out, "</tbody>\n</table>\n</div>\n</div>")?;
Ok(())
}
fn write_probe_stats(out: &mut dyn Write, stats: &ProbeStatsDto) -> Result<(), ExportError> {
writeln!(
out,
"<div class=\"block\">\n<div class=\"block-title\">{scanner} · {targets} targets</div>\n<dl class=\"facts\">",
scanner = Text(stats.scanner),
targets = Text(&stats.targets),
)?;
let completion = if stats.complete {
"finished what it had to do"
} else {
"cut short"
};
fact(
out,
"stopped",
&format!(
"{}{}",
esc(stats.stop_reason),
dim(&[
esc(completion),
format!("after {}", duration(stats.elapsed_us)),
])
),
)?;
let mut sends = vec![format!("{} attempted", stats.sends_attempted)];
if stats.sends_failed > 0 {
sends.push(format!("{} never left this host", stats.sends_failed));
}
fact(out, "probes", &sends.join(" · "))?;
let mut seen = vec![format!("{} seen", stats.segments_seen)];
if stats.segments_off_target > 0 {
seen.push(format!("{} off target", stats.segments_off_target));
}
if stats.replies_without_rtt > 0 {
seen.push(format!(
"{} without a round trip",
stats.replies_without_rtt
));
}
fact(out, "segments", &seen.join(" · "))?;
let mut timing = Vec::new();
if let Some(first) = stats.first_reply_us {
timing.push(format!("first at {}", duration(first)));
}
if let Some(last) = stats.last_reply_us {
timing.push(format!("last at {}", duration(last)));
}
fact(
out,
"hosts found",
&format!("{}{}", stats.hosts_found, dim(&timing)),
)?;
if let Some(capture) = &stats.capture {
let mut counts = vec![format!("{} received", capture.received)];
if capture.dropped > 0 {
counts.push(format!("{} dropped by the buffer", capture.dropped));
}
if capture.if_dropped > 0 {
counts.push(format!("{} dropped by the interface", capture.if_dropped));
}
if capture.stopped_early > 0 {
counts.push(match capture.stopped_early {
1 => "one capture stopped early and heard nothing after".to_string(),
many => format!("{many} captures stopped early and heard nothing after"),
});
}
fact(out, "capture", &counts.join(" · "))?;
}
writeln!(out, "</dl>")?;
let attempts: Vec<(String, u64)> = stats
.answered_on
.iter()
.map(|entry| {
let label = if entry.or_later {
format!("{}+", entry.attempt)
} else {
entry.attempt.to_string()
};
(label, entry.count)
})
.collect();
histogram(
out,
"hosts by attempt",
&attempts,
stats.answered_unattributed,
)?;
let buckets: Vec<(String, u64)> = stats
.found_at
.iter()
.map(|bucket| {
let label = match bucket.le_ms {
Some(bound) => format!("≤ {bound} ms"),
None => "slower".to_string(),
};
(label, bucket.count)
})
.collect();
histogram(out, "hosts by discovery time", &buckets, 0)?;
writeln!(out, "</div>")?;
Ok(())
}
fn histogram(
out: &mut dyn Write,
title: &str,
rows: &[(String, u64)],
unattributed: u64,
) -> Result<(), ExportError> {
let peak = rows.iter().map(|(_, count)| *count).max().unwrap_or(0);
if peak == 0 && unattributed == 0 {
return Ok(());
}
writeln!(
out,
"<div class=\"block-title\">{title}</div>\n<table class=\"hist\">\n<tbody>",
title = Text(title),
)?;
for (label, count) in rows {
histogram_row(out, label, *count, peak)?;
}
if unattributed > 0 {
histogram_row(out, "unmatched", unattributed, peak)?;
}
writeln!(out, "</tbody>\n</table>")?;
Ok(())
}
fn histogram_row(
out: &mut dyn Write,
label: &str,
count: u64,
peak: u64,
) -> Result<(), ExportError> {
let width = if peak == 0 {
0.0
} else {
count as f64 * 100.0 / peak as f64
};
let zero = if count == 0 { " bar-zero" } else { "" };
writeln!(
out,
"<tr><th>{label}</th><td><span class=\"bar-track\"><span class=\"bar{zero}\" style=\"width:{width:.3}%\"></span></span></td><td class=\"num\">{count}</td></tr>",
label = Text(label),
)?;
Ok(())
}
fn write_colophon(
out: &mut dyn Write,
report: &ScanReport,
generated_at: &str,
) -> Result<(), ExportError> {
writeln!(
out,
r#"<footer class="colophon">
<div>{engine} {version}{findings} · schema {schema} · generated {generated}</div>
<div>self-contained: no scripts, no external requests</div>
</footer>"#,
engine = ENGINE_NAME,
version = crate::report::ENGINE_VERSION,
findings = findings_from(report),
schema = SCHEMA_VERSION,
generated = Text(generated_at),
)?;
Ok(())
}
fn fact(out: &mut dyn Write, key: &str, value: &str) -> Result<(), ExportError> {
if value.is_empty() {
return Ok(());
}
writeln!(out, "<dt>{key}</dt><dd>{value}</dd>", key = Text(key))?;
Ok(())
}
fn shortfalls(report: &ScanReport) -> Vec<&'static str> {
let mut causes = Vec::new();
if report.failures().next().is_some() {
causes.push("a strategy did not run to completion");
}
if report.refusals().next().is_some() {
causes.push("ground was declined");
}
if !report.timed_out().is_empty() {
causes.push("a host's time budget ran out");
}
if !report.undecided().is_empty() {
causes.push("addresses were never decided");
}
if report.left_ports_unasked() {
causes.push("ports went unasked");
}
causes
}
fn addresses_in(ranges: &[RangeDto]) -> u128 {
ranges
.iter()
.filter_map(|range| {
let start: std::net::IpAddr = range.start.parse().ok()?;
let end: std::net::IpAddr = range.end.parse().ok()?;
match (start, end) {
(std::net::IpAddr::V4(start), std::net::IpAddr::V4(end)) => {
Some(u128::from(end.to_bits().checked_sub(start.to_bits())?) + 1)
}
(std::net::IpAddr::V6(start), std::net::IpAddr::V6(end)) => {
end.to_bits().checked_sub(start.to_bits())?.checked_add(1)
}
_ => None,
}
})
.fold(0u128, u128::saturating_add)
}
fn dim(parts: &[String]) -> String {
let parts: Vec<&str> = parts
.iter()
.map(String::as_str)
.filter(|part| !part.is_empty())
.collect();
if parts.is_empty() {
return String::new();
}
format!(" <span class=\"dim\">{}</span>", parts.join(" · "))
}
fn duration(micros: u64) -> String {
match micros {
0..1_000 => format!("{micros} µs"),
1_000..1_000_000 => format!("{:.2} ms", micros as f64 / 1_000.0),
1_000_000..60_000_000 => format!("{:.2} s", micros as f64 / 1_000_000.0),
_ => {
let seconds = micros / 1_000_000;
format!("{} min {} s", seconds / 60, seconds % 60)
}
}
}
fn percent(part: usize, total: usize) -> f64 {
if total == 0 {
return 0.0;
}
part as f64 * 100.0 / total as f64
}
fn plural(count: usize, one: &'static str, many: &'static str) -> &'static str {
if count == 1 { one } else { many }
}
fn plural_str(count: &str, one: &'static str, many: &'static str) -> &'static str {
if count == "1" { one } else { many }
}
#[cfg(test)]
mod tests {
use super::*;
use crate::export::write::STYLE;
use crate::export::{Redaction, fixture};
fn page(exporter: &HtmlExporter) -> String {
let mut bytes = Vec::new();
exporter
.export(&fixture::report(), &mut bytes)
.expect("the export succeeds");
String::from_utf8(bytes).expect("utf-8")
}
fn default_page() -> String {
page(&HtmlExporter::new(ExportOptions::new()))
}
fn classes(page: &str) -> Vec<String> {
let mut found = Vec::new();
let mut rest = page;
while let Some(start) = rest.find("class=\"") {
rest = &rest[start + "class=\"".len()..];
let end = rest.find('"').expect("an unterminated class attribute");
for class in rest[..end].split_whitespace() {
found.push(class.to_string());
}
rest = &rest[end..];
}
found
}
#[test]
fn sends_that_never_left_are_not_all_called_refused() {
let mut stats = fixture::probe_stats();
stats.sends_failed = 3;
let mut bytes = Vec::new();
write_probe_stats(&mut bytes, &ProbeStatsDto::new(&stats)).expect("the block renders");
let block = String::from_utf8(bytes).expect("utf-8");
assert!(block.contains("3 never left this host"), "{block}");
assert!(!block.contains("refused"), "{block}");
}
#[test]
fn the_page_is_one_self_contained_document() {
let page = default_page();
assert!(page.starts_with("<!doctype html>"));
assert!(page.trim_end().ends_with("</html>"));
assert!(page.contains("<meta charset=\"utf-8\">"));
for outside in ["<script", "http://", "https://", "<img", "@import", "url("] {
assert!(
!page.contains(outside),
"the page reaches outside itself: {outside}"
);
}
}
#[test]
fn every_class_written_is_a_class_the_stylesheet_styles() {
for class in classes(&default_page()) {
assert!(
STYLE.contains(&format!(".{class}")),
"nothing styles .{class}"
);
}
}
#[test]
fn every_state_has_a_tone_the_stylesheet_defines() {
let statuses = [
HostStatus::Up,
HostStatus::Filtered,
HostStatus::Down,
HostStatus::Unknown,
];
let states = [
PortState::Open,
PortState::OpenFiltered,
PortState::Closed,
PortState::Unfiltered,
PortState::Filtered,
PortState::ClosedFiltered,
];
for status in statuses {
let tone = host_tone(status);
assert!(
STYLE.contains(&format!(".{tone}")),
"nothing styles .{tone}"
);
}
for state in states {
let tone = port_tone(state);
assert!(
STYLE.contains(&format!(".{tone}")),
"nothing styles .{tone}"
);
}
}
#[test]
fn the_page_shows_what_the_scan_found() {
let page = default_page();
assert!(page.contains("203.0.113.1"));
assert!(page.contains("router.local"));
assert!(page.contains("22/tcp"));
assert!(page.contains("OpenSSH"));
assert!(page.contains("8.9p1"));
assert!(page.contains("Raspberry Pi Trading Ltd"));
assert!(page.contains("Local CA"));
assert!(page.contains("deadline_expired"));
assert!(page.contains("raw socket unavailable"));
}
#[test]
fn what_changes_the_meaning_of_a_state_reaches_the_page() {
let page = default_page();
for expected in [
"idle scan",
"evasion",
"inferred from a third party",
"altered before they went out",
"detection ",
"where this ran from",
] {
assert!(page.contains(expected), "the page never says {expected:?}");
}
}
#[test]
fn what_a_phase_never_decided_reaches_the_page() {
let report = fixture::report();
let undecided: u128 = report
.phases()
.iter()
.flat_map(|phase| phase.undecided())
.map(|range| {
let (start, end) = match range {
crate::model::ip::range::IpRange::V4(range) => (
u128::from(range.start_addr().to_bits()),
u128::from(range.end_addr().to_bits()),
),
crate::model::ip::range::IpRange::V6(range) => {
(range.start_addr().to_bits(), range.end_addr().to_bits())
}
};
end - start + 1
})
.sum();
assert!(undecided > 1, "the fixture leaves addresses undecided");
let page = default_page();
assert!(page.contains("<dt>undecided</dt>"), "{page}");
assert!(
page.contains(&format!("{undecided} addresses with no verdict")),
"the count is what a reader acts on"
);
}
#[test]
fn a_withheld_router_is_not_drawn_as_silence() {
let page = default_page();
assert!(page.contains("<div> 4. excluded"), "{page}");
assert!(
page.contains("<div> 2. *"),
"a silent router still reads as one"
);
}
#[test]
fn second_hand_evidence_says_who_sent_it() {
let page = default_page();
assert!(
page.contains("unreachable, from the path · via 198.51.100.1"),
"{page}"
);
assert!(
page.contains("unreachable · via an excluded address"),
"{page}"
);
}
#[test]
fn an_unfinished_enumeration_says_so_on_the_page() {
let page = default_page();
assert!(
page.contains("<dt>unsettled</dt><dd>TLSv1.1"),
"a version never settled is named"
);
assert!(
page.contains("incomplete, stopped"),
"an accepted version whose walk was cut short says so"
);
}
#[test]
fn an_ordinary_scan_carries_none_of_those_notices() {
let mut plain = Vec::new();
HtmlExporter::new(ExportOptions::new())
.export(&crate::export::fixture::compared().0, &mut plain)
.expect("the page writes");
let page = String::from_utf8(plain).expect("valid UTF-8");
assert!(!page.contains("idle scan"));
assert!(!page.contains("altered before they went out"));
assert!(!page.contains("where this ran from"));
}
#[test]
fn a_narrowed_report_says_so_before_the_findings() {
let page = default_page();
let notice = page.find(">partial<").expect("a partial notice");
let hosts = page.find("Hosts <span").expect("a host section");
assert!(notice < hosts, "the notice sits below the findings");
for cause in [
"a strategy did not run to completion",
"a host's time budget ran out",
"addresses were never decided",
] {
assert!(
page[notice..hosts].contains(&esc(cause)),
"the notice never names {cause:?}, which the fixture has"
);
}
}
#[test]
fn states_are_spelled_the_way_the_document_spells_them() {
let page = default_page();
assert!(page.contains(">open<"));
assert!(page.contains(">up<"));
assert!(page.contains(">filtered<"));
assert!(page.contains(">tcp_syn_ack<"));
}
#[test]
fn redaction_reaches_the_page() {
let page = page(&HtmlExporter::new(
ExportOptions::new().with_redaction(Redaction::Standard),
));
assert!(!page.contains("router.local"));
assert!(page.contains("roXXXXXal"));
assert!(page.contains("2c:cf:67:XX:XX:XX"));
assert!(page.contains("Raspberry Pi Trading Ltd"));
assert!(page.contains(">redacted<"));
}
#[test]
fn a_host_with_no_ports_still_appears() {
let page = default_page();
assert!(page.contains("203.0.113.9"));
assert!(page.contains("no ports recorded"));
}
#[test]
fn a_caller_can_name_the_report() {
let page = page(&HtmlExporter::new(ExportOptions::new()).with_heading("Acme Q3 audit"));
assert!(page.contains("<title>Acme Q3 audit</title>"));
assert!(page.contains("<h1>Acme Q3 audit</h1>"));
assert!(default_page().contains("<title>zond scan report — "));
}
#[test]
fn durations_are_rendered_for_a_person() {
assert_eq!(duration(0), "0 µs");
assert_eq!(duration(999), "999 µs");
assert_eq!(duration(1_450), "1.45 ms");
assert_eq!(duration(677_669), "677.67 ms");
assert_eq!(duration(1_500_000), "1.50 s");
assert_eq!(duration(3_723_000_000), "62 min 3 s");
}
#[test]
fn a_share_of_nothing_is_not_a_division_by_zero() {
assert_eq!(percent(0, 0), 0.0);
assert_eq!(percent(1, 4), 25.0);
}
#[test]
fn a_failing_destination_surfaces_as_an_error() {
struct Full;
impl Write for Full {
fn write(&mut self, _: &[u8]) -> std::io::Result<usize> {
Err(std::io::Error::new(
std::io::ErrorKind::StorageFull,
"no space left on device",
))
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
let error = HtmlExporter::new(ExportOptions::new())
.export(&fixture::report(), &mut Full)
.expect_err("a full disk fails the export");
assert!(matches!(error, ExportError::Io(_)), "got {error:?}");
}
#[test]
fn no_field_of_a_hostile_report_reaches_the_page_unescaped() {
let mut bytes = Vec::new();
HtmlExporter::new(ExportOptions::new())
.export(&fixture::hostile(), &mut bytes)
.expect("the page renders");
let page = String::from_utf8(bytes).expect("utf-8");
assert!(
page.contains("<script>"),
"the payload should be present, escaped - otherwise this test proves \
nothing about a document that simply dropped it"
);
assert!(
!page.contains("<script>"),
"a scanned host's own banner opened a script tag in the report"
);
assert!(
!page.contains(fixture::HOSTILE),
"the payload survived intact somewhere on the page"
);
assert!(
!page.contains('\u{202e}'),
"a right-to-left override reached the page and will reorder it"
);
}
}