use ipnetwork::IpNetwork;
use std::net::IpAddr;
use std::path::PathBuf;
#[cfg(all(feature = "nse", target_family = "unix"))]
#[link(name = "z")]
unsafe extern "C" {}
pub fn install_tls_provider() {
use std::sync::Once;
static INIT: Once = Once::new();
INIT.call_once(|| {
if rustls::crypto::ring::default_provider()
.install_default()
.is_err()
{
tracing::debug!("rustls default provider already installed; keeping existing");
}
});
}
pub struct NseConfig {
pub target: String,
pub script: String,
pub script_args: Option<String>,
pub script_file: Option<String>,
pub json: bool,
pub verbose: bool,
}
impl NseConfig {
pub fn new(
target: &str,
script: &str,
script_args: Option<&str>,
script_file: Option<&str>,
json: bool,
verbose: bool,
) -> Self {
Self {
target: target.to_string(),
script: script.to_string(),
script_args: script_args.map(|s| s.to_string()),
script_file: script_file.map(|s| s.to_string()),
json,
verbose,
}
}
}
#[derive(Debug, Clone)]
pub struct SandboxConfig {
pub enabled: bool,
pub allowed_dir: Option<PathBuf>,
pub allowed_commands: Vec<String>,
pub log_violations: bool,
pub allowed_networks: Vec<IpNetwork>,
}
impl Default for SandboxConfig {
fn default() -> Self {
Self {
enabled: cfg!(feature = "sandbox"),
allowed_dir: Some(PathBuf::from("/tmp/eggsec-nse")),
allowed_commands: Vec::new(),
log_violations: true,
allowed_networks: Vec::new(),
}
}
}
impl SandboxConfig {
fn allowed_root(&self) -> Option<PathBuf> {
let dir = self.allowed_dir.as_ref()?;
Some(dir.clone())
}
pub fn enabled() -> Self {
Self {
enabled: true,
..Default::default()
}
}
pub fn get_allowed_path(&self, path: &str) -> Option<PathBuf> {
if !self.enabled {
return Some(PathBuf::from(path));
}
let Some(allowed_dir) = self.allowed_root() else {
return Some(PathBuf::from(path));
};
let path_buf = PathBuf::from(path);
if let Ok(canonical) = path_buf.canonicalize() {
if canonical.starts_with(&allowed_dir) {
return Some(canonical);
}
return None;
}
if let Some(parent) = path_buf.parent() {
if let Ok(canonical_parent) = parent.canonicalize() {
if canonical_parent.starts_with(&allowed_dir) {
return Some(canonical_parent.join(path_buf.file_name()?));
}
}
}
None
}
pub fn is_command_allowed(&self, cmd: &str) -> bool {
if !self.enabled {
return true;
}
if self.allowed_commands.is_empty() {
return false;
}
if cmd.contains(';')
|| cmd.contains('|')
|| cmd.contains('&')
|| cmd.contains('$')
|| cmd.contains('`')
|| cmd.contains('\n')
|| cmd.contains('\r')
{
return false;
}
let cmd_name = cmd.split_whitespace().next().unwrap_or(cmd);
self.allowed_commands
.iter()
.any(|allowed| cmd_name == allowed)
}
pub fn is_network_allowed(&self, ip: IpAddr) -> bool {
if !self.enabled {
return true;
}
if self.allowed_networks.is_empty() {
return true;
}
self.allowed_networks
.iter()
.any(|network| network.contains(ip))
}
pub fn is_host_allowed(&self, host: &str) -> bool {
!self.resolve_host(host).is_empty()
}
pub fn resolve_host(&self, host: &str) -> Vec<IpAddr> {
use std::net::ToSocketAddrs;
if !self.enabled {
if let Ok(addrs) = format!("{}:0", host).to_socket_addrs() {
return addrs.map(|a| a.ip()).collect();
}
return Vec::new();
}
if self.allowed_networks.is_empty() {
if let Ok(addrs) = format!("{}:0", host).to_socket_addrs() {
return addrs.map(|a| a.ip()).collect();
}
return Vec::new();
}
let Ok(addrs) = format!("{}:0", host).to_socket_addrs() else {
return Vec::new();
};
addrs
.map(|a| a.ip())
.filter(|ip| self.is_network_allowed(*ip))
.collect()
}
}
#[cfg(feature = "nse")]
pub mod async_executor;
#[cfg(feature = "nse")]
pub mod brokered_stream;
#[cfg(feature = "nse")]
pub mod capabilities;
#[cfg(feature = "nse")]
pub mod context;
#[cfg(feature = "nse")]
pub mod cve;
pub mod effect_manifest;
#[cfg(feature = "nse")]
pub mod executor;
#[cfg(feature = "nse")]
pub mod executor_core;
#[cfg(feature = "nse")]
pub mod format;
pub mod limits;
pub mod output;
pub mod profile;
#[cfg(feature = "nse")]
pub mod providers;
#[cfg(feature = "nse")]
pub mod public_api;
#[cfg(feature = "nse")]
pub mod report;
pub mod resolver;
#[cfg(feature = "nse")]
pub mod run;
#[cfg(feature = "nse")]
pub mod wrappers;
#[cfg(feature = "nse")]
pub mod libraries;
#[cfg(feature = "nse")]
pub use async_executor::AsyncNseExecutor;
#[cfg(feature = "nse")]
pub use capabilities::{
NseCapabilityContext, NseCapabilityDecision, NseCapabilityEvent, NseCapabilityKind,
NseCapabilityRequest,
};
#[cfg(feature = "nse")]
pub use executor::NseExecutor;
#[cfg(feature = "nse")]
pub use executor_core::ExecutorCore;
#[cfg(feature = "nse")]
pub use executor_core::SandboxMetrics;
#[cfg(feature = "nse")]
pub use executor_core::{default_module_policy, default_script_policy};
#[cfg(feature = "nse")]
pub use limits::{
NseCancellationToken, NseExecutionLimits, NseExecutionStats, NseLimitViolation,
NseResourceCounters,
};
pub use profile::{
NseExecutionProfileKind, NseModulePolicy, NseNetworkPolicy, NseScriptPolicy,
ResolvedNseExecutionProfile, ScopeInput,
};
pub use resolver::{
is_builtin_script, validate_nse_module_name, NseLoadDiagnostic, NseLoadError, NseModuleName,
NseScriptSource, ResolvedNseModule, ResolvedNseScript, ScriptResolver,
};
pub use effect_manifest::{
automated_library_eligibility, classified_libraries, classify, eligibility_counts,
eligible_for_profile, is_automated_library_safe, is_automated_profile, EligibilityCounts,
LibraryEffectEntry, NseAutomatedLibraryEligibility,
};
pub use resolver::registry::{
all_libraries, find_library, libraries_by_category, libraries_missing_from_nmap,
libraries_with_side_effects, registry_count, sandbox_policy_for_library, EnforcementStatus,
NseFallbackBehavior, NseLibraryCategory, NseLibraryDescriptor, NseSandboxSideEffect,
};
#[cfg(feature = "nse")]
pub use report::{
NseCapabilityEventSummary, NseCompatibilitySummary, NseEvidenceItem, NseEvidenceKind,
NseExecutionStatsSummary, NseLibraryUseReport, NseLimitsSummary, NseOutputSummary,
NseProfileSummary, NseRequiredModuleReport, NseRequiredModuleSource,
NseResolverDiagnosticSummary, NseResolverSummary, NseRuleEvaluationReport,
NseRunCompatibilityStatus, NseRunFidelity, NseRunReport, NseSandboxSummary,
NseScriptSourceSummary,
};
#[cfg(feature = "nse")]
pub use context::{NseContextSource, NseHostContext, NsePortContext, NseServiceContext};
#[cfg(feature = "nse")]
pub use providers::{
broker_dns_lookup, broker_env_var, broker_fs_create_dir_all, broker_fs_current_dir,
broker_fs_exists, broker_fs_hard_link, broker_fs_metadata, broker_fs_open, broker_fs_read,
broker_fs_read_dir, broker_fs_read_link, broker_fs_read_to_string, broker_fs_remove_dir,
broker_fs_remove_file, broker_fs_rename, broker_fs_resolve, broker_fs_set_current_dir,
broker_fs_set_readonly, broker_fs_set_unix_mode, broker_fs_symlink, broker_fs_symlink_metadata,
broker_fs_write, broker_http_request, broker_is_privileged, broker_network_interfaces,
broker_process_run, broker_process_spawn, broker_random_f64, broker_random_fill,
broker_random_u32, broker_resolve_and_select, broker_tcp_connect, broker_tcp_connect_endpoint,
broker_tcp_receive, broker_tcp_send, broker_temp_dir, broker_udp_connect,
broker_udp_connect_endpoint, broker_udp_receive, broker_udp_send, broker_unix_timestamp,
CountingClockProvider, CountingDnsProvider, CountingEnvironmentProvider,
CountingFilesystemProvider, CountingHttpProvider, CountingProcessProvider,
CountingRandomProvider, CountingTcpSocketProvider, CountingUdpSocketProvider,
DenyFilesystemProvider, DenyProcessProvider, DeterministicRandomProvider, FixedClockProvider,
MapDnsProvider, MapEnvironmentProvider, MemoryTcpConnection, MemoryTcpSocketProvider,
MemoryUdpSocket, MemoryUdpSocketProvider, MockHttpProvider, NativeChildProcess,
NativeClockProvider, NativeDnsProvider, NativeEnvironmentProvider, NativeFileHandle,
NativeFilesystemProvider, NativeHttpProvider, NativeProcessProvider, NativeRandomProvider,
NativeTcpConnection, NativeTcpSocketProvider, NativeUdpSocket, NativeUdpSocketProvider,
NseChildProcess, NseClockProvider, NseDirEntry, NseDnsAnswer, NseDnsProvider, NseDnsQuery,
NseDnsRecord, NseDnsRecordType, NseEnvironmentProvider, NseFileHandle, NseFileMetadata,
NseFileType, NseFilesystemProvider, NseHostServices, NseHttpError, NseHttpMethod,
NseHttpProvider, NseHttpRequest, NseHttpResponse, NseIpAddress, NseNetworkInterface,
NseOpenMode, NseProcessProvider, NseProcessResult, NseProcessSpec, NseProviderError,
NseRandomProvider, NseResolvedEndpoint, NseTcpConnection, NseTcpSocketProvider,
NseTransportProtocol, NseUdpSocket, NseUdpSocketProvider, ScriptedDnsProvider,
};
#[cfg(feature = "nse")]
pub use run::{
execute_nse_run, extract_static_requires, script_name_for_source, NseRunError, NseRunErrorKind,
NseRunRequest,
};
#[cfg(feature = "nse")]
pub async fn run_cli(config: NseConfig) -> anyhow::Result<()> {
run_cli_with_profile(config, None).await
}
#[cfg(feature = "nse")]
pub async fn run_cli_with_profile(
config: NseConfig,
profile: Option<ResolvedNseExecutionProfile>,
) -> anyhow::Result<()> {
let target = config.target.clone();
let script = config.script.clone();
let script_args = config.script_args.clone().unwrap_or_default();
let script_file = config.script_file.clone();
let json = config.json;
let resolved_profile =
profile.unwrap_or_else(|| ResolvedNseExecutionProfile::manual_permissive(Some(&target)));
tracing::info!(
profile = %resolved_profile.kind,
sandbox_enabled = resolved_profile.sandbox.enabled,
audit_label = %resolved_profile.audit_label,
"NSE execution profile resolved"
);
for warning in &resolved_profile.warnings {
tracing::warn!("{}", warning);
}
println!("Running NSE script '{}' against '{}'", script, target);
if resolved_profile
.warnings
.iter()
.any(|w| w.contains("sandbox"))
{
println!("Warning: sandbox enforcement is disabled (feature not compiled)");
}
let script_source = if let Some(ref script_file) = script_file {
crate::resolver::NseScriptSource::File {
path: std::path::PathBuf::from(script_file),
}
} else {
crate::resolver::NseScriptSource::Builtin {
name: script.clone(),
}
};
let request = crate::run::NseRunRequest::new(&target, script_source, resolved_profile)
.with_script_args(&script_args);
let report = tokio::task::spawn_blocking(move || crate::run::execute_nse_run(request))
.await
.map_err(|e| anyhow::anyhow!("Task execution failed: {}", e))?
.map_err(|e| {
if json && e.kind == crate::run::NseRunErrorKind::Resolution {
match serde_json::to_string_pretty(&e.failure_report()) {
Ok(rendered) => println!("{}", rendered),
Err(render_err) => {
tracing::warn!("Failed to render NSE failure report: {}", render_err);
}
}
}
anyhow::anyhow!("{}", e)
})?;
if json {
println!("{}", serde_json::to_string_pretty(&report)?);
} else {
print_human_report(&report);
}
Ok(())
}
#[cfg(feature = "nse")]
fn print_human_report(report: &crate::report::NseRunReport) {
print!("{}", crate::format::format_human_report(report));
}
#[cfg(not(feature = "nse"))]
pub async fn run_cli(_config: NseConfig) -> anyhow::Result<()> {
anyhow::bail!("NSE support requires the 'nse' feature. Build with: cargo build --features nse")
}
#[cfg(not(feature = "nse"))]
pub async fn run_cli_with_profile(
_config: NseConfig,
_profile: Option<ResolvedNseExecutionProfile>,
) -> anyhow::Result<()> {
anyhow::bail!("NSE support requires the 'nse' feature. Build with: cargo build --features nse")
}
#[cfg(feature = "nse")]
pub fn get_builtin_script(name: &str) -> String {
match name {
"default" | "discovery" => r#"
-- Default NSE discovery script
local stdnse = require "stdnse"
stdnse.verbose1("Starting NSE discovery scan...")
local host = nmap.target
if host and host ~= "" then
stdnse.format_output({status = "open", service = "discovered"}, {separator = ", "})
end
local output = stdnse.output_table()
output.host = host or "unknown"
output.status = "discovered"
output.scan_time = os.date("*t")
return output
"#
.to_string(),
"banner" => r#"
-- Banner grabbing script
local stdnse = require "stdnse"
local comm = require "comm"
local socket = require "socket"
local host = nmap.target
local port = tonumber(stdnse.get_script_args("port")) or 80
if not host or host == "" then
return stdnse.output_table()
end
local s = socket.connect(host, port)
if s then
s:send("HEAD / HTTP/1.0\r\n\r\n")
local status, response = s:receive(1024)
s:close()
local output = stdnse.output_table()
output.banner = response or ""
output.host = host
output.port = port
return output
end
return nil
"#
.to_string(),
"http-headers" => r#"
-- HTTP headers discovery script
local stdnse = require "stdnse"
local http = require "http"
local host = nmap.target
local port = tonumber(stdnse.get_script_args("port")) or 80
if not host or host == "" then
return stdnse.output_table()
end
local response = http.get(host, port, "/")
local output = stdnse.output_table()
output.host = host
output.port = port
output.title = response.title or ""
output.status = response.status or 0
return output
"#
.to_string(),
"dns-check" => r#"
-- DNS resolution check script
local stdnse = require "stdnse"
local dns = require "dns"
local host = nmap.target
if not host or host == "" then
return stdnse.output_table()
end
local success = dns.query(host)
local output = stdnse.output_table()
output.host = host
output.resolved = success
return output
"#
.to_string(),
"ssl-cert" => r#"
-- SSL certificate information script
local stdnse = require "stdnse"
local sslcert = require "sslcert"
local tls = require "tls"
local host = nmap.target
local port = tonumber(stdnse.get_script_args("port")) or 443
if not host or host == "" then
return stdnse.output_table()
end
local output = stdnse.output_table()
output.host = host
output.port = port
output.tls = "available"
return output
"#
.to_string(),
_ => {
format!(
r#"
-- Custom NSE script: {}
local stdnse = require "stdnse"
stdnse.verbose1("Executing custom NSE script: {}")
local output = stdnse.output_table()
output.script = "{}"
output.status = "executed"
output.libraries = {{
stdnse = true,
nmap = true,
socket = true,
http = true,
}}
return output
"#,
name, name, name
)
}
}
}