use mlua::{Lua, Result as LuaResult, Table, Value};
use parking_lot::Mutex;
use rustc_hash::FxHashMap;
use std::path::PathBuf;
use std::sync::atomic::Ordering;
use std::sync::Arc;
use std::time::Instant;
use crate::capabilities::NseCapabilityContext;
use crate::libraries::shared;
use crate::limits::{
NseCancellationToken, NseExecutionLimits, NseExecutionStats, NseLimitViolation,
NseResourceCounters,
};
use crate::profile::{NseExecutionProfileKind, NseModulePolicy, NseNetworkPolicy, NseScriptPolicy};
use crate::report::{NseLibraryUseReport, NseRequiredModuleReport, NseRequiredModuleSource};
use crate::resolver::ScriptResolver;
#[derive(Debug, Clone, Default)]
pub struct SandboxMetrics {
pub io_handles: usize,
pub io_violations: usize,
pub lfs_violations: usize,
pub os_violations: usize,
}
pub struct ExecutorCore {
pub(crate) lua: Lua,
pub(crate) target: String,
pub(crate) scripts_path: Arc<Mutex<Vec<PathBuf>>>,
pub(crate) output: Mutex<Vec<String>>,
pub(crate) registry: Mutex<FxHashMap<String, Value>>,
pub(crate) required_modules: Arc<Mutex<Vec<NseRequiredModuleReport>>>,
pub(crate) sandbox: crate::SandboxConfig,
pub(crate) limits: NseExecutionLimits,
pub(crate) cancellation: NseCancellationToken,
pub(crate) resource_counters: Arc<NseResourceCounters>,
pub(crate) execution_start: Arc<Mutex<Option<Instant>>>,
pub(crate) lua_instruction_count: Arc<std::sync::atomic::AtomicU64>,
pub(crate) limit_violation: Arc<Mutex<Option<NseLimitViolation>>>,
pub(crate) script_policy: NseScriptPolicy,
pub(crate) module_policy: NseModulePolicy,
pub(crate) profile_kind: NseExecutionProfileKind,
pub(crate) network_policy: NseNetworkPolicy,
pub(crate) capability_context: NseCapabilityContext,
pub(crate) host_services: crate::providers::NseHostServices,
}
impl ExecutorCore {
pub fn new() -> LuaResult<Self> {
crate::install_tls_provider();
Self::with_sandbox(crate::SandboxConfig::default())
}
pub fn with_sandbox(sandbox: crate::SandboxConfig) -> LuaResult<Self> {
Self::with_policy(
sandbox,
NseExecutionLimits::default(),
NseCancellationToken::new(),
default_script_policy(),
default_module_policy(),
)
}
pub fn with_policy(
sandbox: crate::SandboxConfig,
limits: NseExecutionLimits,
cancellation: NseCancellationToken,
script_policy: NseScriptPolicy,
module_policy: NseModulePolicy,
) -> LuaResult<Self> {
Self::with_full_policy(
sandbox,
limits,
cancellation,
script_policy,
module_policy,
NseExecutionProfileKind::ManualPermissive,
NseNetworkPolicy::AllowAllManual,
)
}
pub fn with_full_policy(
sandbox: crate::SandboxConfig,
limits: NseExecutionLimits,
cancellation: NseCancellationToken,
script_policy: NseScriptPolicy,
module_policy: NseModulePolicy,
profile_kind: NseExecutionProfileKind,
network_policy: NseNetworkPolicy,
) -> LuaResult<Self> {
Self::with_full_policy_and_services(
sandbox,
limits,
cancellation,
script_policy,
module_policy,
profile_kind,
network_policy,
crate::providers::NseHostServices::native(),
)
}
pub fn with_full_policy_and_services(
sandbox: crate::SandboxConfig,
limits: NseExecutionLimits,
cancellation: NseCancellationToken,
script_policy: NseScriptPolicy,
module_policy: NseModulePolicy,
profile_kind: NseExecutionProfileKind,
network_policy: NseNetworkPolicy,
host_services: crate::providers::NseHostServices,
) -> LuaResult<Self> {
let lua = Lua::new();
let scripts_path = Arc::new(Mutex::new(vec![]));
let output = Mutex::new(vec![]);
let registry = Mutex::new(FxHashMap::default());
let resource_counters = Arc::new(NseResourceCounters::new());
let capability_context = NseCapabilityContext::new(
profile_kind,
network_policy.clone(),
script_policy.clone(),
module_policy.clone(),
sandbox.clone(),
limits.clone(),
cancellation.clone(),
resource_counters.clone(),
);
let core = Self {
lua,
target: String::new(),
scripts_path: scripts_path.clone(),
output,
registry,
required_modules: Arc::new(Mutex::new(Vec::new())),
sandbox,
limits,
cancellation,
resource_counters,
execution_start: Arc::new(Mutex::new(None)),
lua_instruction_count: Arc::new(std::sync::atomic::AtomicU64::new(0)),
limit_violation: Arc::new(Mutex::new(None)),
script_policy,
module_policy,
profile_kind,
network_policy,
capability_context,
host_services,
};
core.setup_globals()?;
core.register_libraries()?;
core.setup_require(scripts_path)?;
Ok(core)
}
pub fn with_profile(profile: &crate::profile::ResolvedNseExecutionProfile) -> LuaResult<Self> {
crate::install_tls_provider();
Self::with_full_policy(
profile.sandbox.clone(),
profile.limits.clone(),
NseCancellationToken::new(),
profile.script_policy.clone(),
profile.module_policy.clone(),
profile.kind,
profile.network_policy.clone(),
)
}
pub fn with_profile_and_services(
profile: &crate::profile::ResolvedNseExecutionProfile,
host_services: crate::providers::NseHostServices,
) -> LuaResult<Self> {
crate::install_tls_provider();
Self::with_full_policy_and_services(
profile.sandbox.clone(),
profile.limits.clone(),
NseCancellationToken::new(),
profile.script_policy.clone(),
profile.module_policy.clone(),
profile.kind,
profile.network_policy.clone(),
host_services,
)
}
pub fn host_services(&self) -> &crate::providers::NseHostServices {
&self.host_services
}
pub fn capability_context(&self) -> &NseCapabilityContext {
&self.capability_context
}
pub fn lua(&self) -> &Lua {
&self.lua
}
pub fn target(&self) -> &str {
&self.target
}
pub fn set_target(&mut self, target: &str) -> Result<(), String> {
self.target = target.to_string();
self.lua
.globals()
.get::<Table>("nmap")
.map_err(|e| e.to_string())?
.set("target", target)
.map_err(|e| e.to_string())
}
pub fn add_scripts_path(&self, path: PathBuf) {
if path.exists() && path.is_dir() {
self.scripts_path.lock().push(path);
}
}
pub fn add_default_scripts_path(&self) {
self.add_default_scripts_path_with_services(&crate::providers::NseHostServices::native());
}
pub fn add_default_scripts_path_with_services(
&self,
services: &crate::providers::NseHostServices,
) {
if let Ok(Some(home)) = services.environment().var("HOME") {
self.add_scripts_path(PathBuf::from(home).join(".nmap").join("nselib"));
}
#[cfg(unix)]
{
self.add_scripts_path(PathBuf::from("/usr/share/nmap/nselib"));
self.add_scripts_path(PathBuf::from("/usr/local/share/nmap/nselib"));
}
#[cfg(windows)]
{
if let Ok(Some(pf)) = services.environment().var("ProgramFiles") {
self.add_scripts_path(PathBuf::from(pf).join("Nmap").join("nselib"));
}
}
}
pub fn set_script_args(&self, args: &str) -> Result<(), String> {
if args.is_empty() {
return Ok(());
}
let stdnse = self
.lua
.globals()
.get::<Table>("stdnse")
.map_err(|e| e.to_string())?;
stdnse.set("script_args", args).map_err(|e| e.to_string())?;
let args_table = self.lua.create_table().map_err(|e| e.to_string())?;
for pair in args.split(',') {
let pair = pair.trim();
if let Some((key, value)) = pair.split_once('=') {
args_table
.set(key.trim(), value.trim())
.map_err(|e| e.to_string())?;
}
}
stdnse.set("args", args_table).map_err(|e| e.to_string())?;
Ok(())
}
pub fn add_output(&self, output: String) -> Result<(), String> {
let output_bytes = output.len();
if let Some(max_output) = self.limits.max_output_bytes {
let current = self.resource_counters.output_bytes.load(Ordering::Acquire) as usize;
if current + output_bytes > max_output {
*self.limit_violation.lock() = Some(NseLimitViolation::OutputLimitExceeded);
return Err(format!(
"Output limit exceeded: {} + {} > {} bytes",
current, output_bytes, max_output
));
}
}
self.resource_counters
.output_bytes
.fetch_add(output_bytes as u64, Ordering::Relaxed);
let mut out = self.output.lock();
out.push(output.clone());
if let Ok(script_output) = self.lua.globals().get::<Table>("_SCRIPT_OUTPUT") {
if let Err(e) = script_output.set(out.len(), output) {
tracing::warn!("NSE add_output: failed to set script output: {}", e);
}
}
Ok(())
}
pub fn get_output(&self) -> Vec<String> {
self.output.lock().clone()
}
pub fn required_modules(&self) -> Vec<NseRequiredModuleReport> {
self.required_modules.lock().clone()
}
pub fn library_reports(&self) -> Vec<NseLibraryUseReport> {
crate::report::library_use_reports_from_required_modules(&self.required_modules())
}
pub(crate) fn clear_required_modules(&self) {
self.required_modules.lock().clear();
}
pub(crate) fn clear_library_reports(&self) {
self.clear_required_modules();
reset_per_run_globals();
}
pub fn get_sandbox_metrics(&self) -> SandboxMetrics {
let (io_handles, io_violations) = crate::libraries::io::get_io_sandbox_metrics();
SandboxMetrics {
io_handles,
io_violations,
lfs_violations: crate::libraries::lfs::LFS_SANDBOX_VIOLATIONS
.load(std::sync::atomic::Ordering::SeqCst),
os_violations: crate::libraries::os::OS_SANDBOX_VIOLATIONS
.load(std::sync::atomic::Ordering::SeqCst),
}
}
pub fn get_script_output(&self) -> Result<String, String> {
let globals = self.lua.globals();
let script_output = globals
.get::<Table>("_SCRIPT_OUTPUT")
.map_err(|e| e.to_string())?;
let mut result = String::new();
for (_, v) in script_output.pairs::<Value, Value>().flatten() {
let val_str = match v {
Value::String(s) => s.to_string_lossy().to_string(),
_ => match v.to_string() {
Ok(value) => value,
Err(error) => {
tracing::warn!(error = %error, "Failed to stringify Lua script output value");
format!("<unprintable Lua value: {}>", error)
}
},
};
if !result.is_empty() {
result.push('\n');
}
result.push_str(&val_str);
}
Ok(result)
}
pub fn run_script(&self, script: &str) -> LuaResult<String> {
self.clear_library_reports();
if let Err(violation) = self.limits.check_script_size(script.len()) {
*self.limit_violation.lock() = Some(violation.clone());
return Err(mlua::Error::RuntimeError(format!(
"NSE limit violated: {}",
violation
)));
}
if self.cancellation.is_cancelled() {
*self.limit_violation.lock() = Some(NseLimitViolation::ExplicitCancellation);
return Err(mlua::Error::RuntimeError(
"Script execution cancelled".into(),
));
}
*self.execution_start.lock() = Some(Instant::now());
self.lua_instruction_count.store(0, Ordering::Relaxed);
self.resource_counters
.network_operations
.store(0, Ordering::Relaxed);
self.resource_counters
.network_bytes_read
.store(0, Ordering::Relaxed);
self.resource_counters
.network_bytes_written
.store(0, Ordering::Relaxed);
self.resource_counters
.filesystem_operations
.store(0, Ordering::Relaxed);
self.resource_counters
.filesystem_bytes_read
.store(0, Ordering::Relaxed);
self.resource_counters
.output_bytes
.store(0, Ordering::Relaxed);
self.setup_execution_hook();
let result = self.lua.load(script).eval::<Value>();
if let Some(violation) = self.limit_violation.lock().take() {
return Err(mlua::Error::RuntimeError(format!(
"NSE limit violated: {}",
violation
)));
}
match result {
Ok(result) => {
if let Ok(output) = self.get_script_output() {
if !output.is_empty() {
return Ok(output);
}
}
if !result.is_nil() {
return Ok(format!("{:?}", result));
}
Ok("Script executed successfully".to_string())
}
Err(e) => Err(mlua::Error::RuntimeError(format!(
"Lua script execution error: {}",
e
))),
}
}
fn setup_execution_hook(&self) {
let cancellation = self.cancellation.clone();
let deadline = self.limits.wall_clock_timeout.map(|d| {
let guard = self.execution_start.lock();
(*guard).unwrap_or_else(Instant::now) + d
});
let instruction_budget = self.limits.lua_instruction_budget;
let instruction_counter = self.lua_instruction_count.clone();
let violation = self.limit_violation.clone();
self.lua.set_interrupt(move |_lua| {
let count = instruction_counter.fetch_add(1, Ordering::AcqRel) + 1;
if cancellation.is_cancelled() {
*violation.lock() = Some(NseLimitViolation::ExplicitCancellation);
return Err(mlua::Error::RuntimeError(
"Script execution cancelled".into(),
));
}
if let Some(deadline) = deadline {
if Instant::now() >= deadline {
*violation.lock() = Some(NseLimitViolation::WallClockTimeout);
return Err(mlua::Error::RuntimeError(
"Script execution timed out".into(),
));
}
}
if let Some(budget) = instruction_budget {
if count >= budget {
*violation.lock() = Some(NseLimitViolation::LuaInstructionBudgetExceeded);
return Err(mlua::Error::RuntimeError(
"Lua instruction budget exceeded".into(),
));
}
}
Ok(mlua::VmState::Continue)
});
}
pub fn execution_stats(&self) -> NseExecutionStats {
let guard = self.execution_start.lock();
let elapsed = (*guard).map(|s| s.elapsed()).unwrap_or_default();
let instructions = self.lua_instruction_count.load(Ordering::Acquire);
let mut stats = self.resource_counters.snapshot(elapsed, instructions);
stats.limit_violation = self.limit_violation.lock().clone();
stats
}
pub fn limits(&self) -> &NseExecutionLimits {
&self.limits
}
pub fn cancellation_token(&self) -> &NseCancellationToken {
&self.cancellation
}
pub fn resource_counters(&self) -> &NseResourceCounters {
&self.resource_counters
}
pub fn registered_library_names(&self) -> Vec<&'static str> {
vec![
"stdnse",
"nmap",
"http",
"comm",
"sslcert",
"tls",
"shortport",
"socket",
"ssh2",
"ftp",
"smtp",
"mysql",
"postgres",
"mssql",
"redis",
"mongodb",
"ldap",
"snmp",
"smb",
"smb2",
"smbauth",
"rdp",
"vnc",
"ntp",
"memcached",
"imap",
"pop3",
"netbios",
"oracle",
"winrm",
"radius",
"dhcp",
"dhcp6",
"sip",
"tftp",
"upnp",
"tns",
"afp",
"amqp",
"ajp",
"ncp",
"ndmp",
"nrpc",
"citrixxml",
"ospf",
"asn1",
"sasl",
"slaxml",
"re",
"httpspider",
"base64",
"base32",
"datetime",
"rand",
"url",
"creds",
"openssl",
"pcre",
"io",
"os",
"unittest",
"target",
"strbuf",
"tab",
"stringaux",
"bin",
"bit",
"vulns",
"unpwdb",
"brute",
"datafiles",
"json",
"ssh",
"ssh1",
"dns",
"http2",
"httppipeline",
"geoip",
"rpc",
"sslv2",
"msrpc",
"ike",
"ipp",
"coap",
"idna",
"pgsql",
"ipops",
"iax2",
"drda",
"eigrp",
"giop",
"iscsi",
"jdwp",
"rsync",
"socks",
"rtsp",
"tn3270",
"xmpp",
"isns",
"membase",
"bitcoin",
"bittorrent",
"cassandra",
"dicom",
"knx",
"multicast",
"nbd",
"natpmp",
"proxy",
"srvloc",
"wsdd",
"xdmcp",
"bjnp",
"cvs",
"dnssd",
"eap",
"pppoe",
"rpcap",
"rmi",
"ipmi",
"irc",
"versant",
"omp2",
"gps",
"mobileme",
"ls",
"unicode",
"bits",
"formulas",
"anyconnect",
"iec61850mms",
"informix",
"libssh2_utility",
"matchs",
"lpeg_utility",
"lpeg",
"lfs",
"libssh2",
"msrpcperformance",
"msrpctypes",
"oops",
"outlib",
"punycode",
"tableaux",
"vuzedht",
"listop",
"zlib",
]
}
pub fn load_script(&self, name: &str) -> LuaResult<String> {
if self.cancellation.is_cancelled() {
return Err(mlua::Error::RuntimeError(
"Script loading cancelled".to_string(),
));
}
let paths = self.scripts_path.lock();
for base in paths.iter() {
let lua_path = base.join(format!("{}.lua", name));
if lua_path.exists() {
if let Ok(canonical) = lua_path.canonicalize() {
if let Ok(canonical_base) = base.canonicalize() {
if !canonical.starts_with(&canonical_base) {
return Err(mlua::Error::RuntimeError(format!(
"Script '{}' escapes search root",
name
)));
}
}
}
return Ok(std::fs::read_to_string(&lua_path)?);
}
let nse_path = base.join(format!("{}.nse", name));
if nse_path.exists() {
if let Ok(canonical) = nse_path.canonicalize() {
if let Ok(canonical_base) = base.canonicalize() {
if !canonical.starts_with(&canonical_base) {
return Err(mlua::Error::RuntimeError(format!(
"Script '{}' escapes search root",
name
)));
}
}
}
return Ok(std::fs::read_to_string(&nse_path)?);
}
}
Err(mlua::Error::RuntimeError(format!(
"Script '{}' not found in search paths",
name
)))
}
pub fn set_host_info(
&self,
hostname: Option<String>,
ip: String,
mac: Option<String>,
status: Option<String>,
) -> Result<(), String> {
let globals = self.lua.globals();
let nmap = globals.get::<Table>("nmap").map_err(|e| e.to_string())?;
let hostinfo = self.lua.create_table().map_err(|e| e.to_string())?;
hostinfo.set("ip", ip).map_err(|e| e.to_string())?;
if let Some(h) = hostname {
hostinfo.set("hostname", h).map_err(|e| e.to_string())?;
}
if let Some(m) = mac {
hostinfo.set("mac", m).map_err(|e| e.to_string())?;
}
if let Some(s) = status {
hostinfo.set("status", s).map_err(|e| e.to_string())?;
}
nmap.set("_hostinfo", hostinfo).map_err(|e| e.to_string())?;
Ok(())
}
pub fn add_port(
&self,
port: u16,
protocol: &str,
state: &str,
service: Option<String>,
) -> Result<(), String> {
let globals = self.lua.globals();
let nmap = globals.get::<Table>("nmap").map_err(|e| e.to_string())?;
let ports = nmap.get::<Table>("_ports").map_err(|e| e.to_string())?;
let key = format!("{}.{}.{}", self.target, port, protocol);
let info = self.lua.create_table().map_err(|e| e.to_string())?;
info.set("number", port).map_err(|e| e.to_string())?;
info.set("protocol", protocol).map_err(|e| e.to_string())?;
info.set("state", state).map_err(|e| e.to_string())?;
if let Some(svc) = service {
info.set("service", svc).map_err(|e| e.to_string())?;
}
ports.set(key, info).map_err(|e| e.to_string())?;
Ok(())
}
fn setup_globals(&self) -> LuaResult<()> {
let globals = self.lua.globals();
let module_names: &[&str] = &[
"stdnse",
"nmap",
"http",
"comm",
"sslcert",
"tls",
"shortport",
"socket",
"ftp",
"smtp",
"mysql",
"postgres",
"pgsql",
"mssql",
"sybase",
"redis",
"mongodb",
"ldap",
"snmp",
"smb",
"rdp",
"vnc",
"ntp",
"memcached",
"imap",
"pop3",
"netbios",
"oracle",
"winrm",
"radius",
"dhcp",
"dhcp6",
"sip",
"tftp",
"upnp",
"tns",
"afp",
"amqp",
"ajp",
"ncp",
"ndmp",
"nrpc",
"citrixxml",
"ospf",
"asn1",
"sasl",
"slaxml",
"re",
"httpspider",
"base64",
"base32",
"datetime",
"rand",
"url",
"creds",
"openssl",
"pcre",
"io",
"os",
"unittest",
"target",
"strbuf",
"tab",
"stringaux",
"bin",
"bit",
"vulns",
"unpwdb",
"brute",
"datafiles",
"json",
"ssh",
"ssh1",
"ssh2",
"dns",
"http2",
"elasticsearch",
"kafka",
"mqtt",
"websocket",
"telnet",
"sftp",
"whois",
"finger",
"stun",
"packet",
"nsedebug",
"strict",
"geoip",
"rpc",
"smb2",
"smbauth",
"match",
"sslv2",
"msrpc",
"ike",
"ipp",
"coap",
"idna",
"ipOps",
"iax2",
"drda",
"eigrp",
"giop",
"iscsi",
"jdwp",
"rsync",
"socks",
"rtsp",
"tn3270",
"xmpp",
"isns",
"membase",
"bitcoin",
"bittorrent",
"cassandra",
"dicom",
"knx",
"multicast",
"nbd",
"natpmp",
"proxy",
"srvloc",
"wsdd",
"xdmcp",
"bjnp",
"cvs",
"dnssd",
"eap",
"pppoe",
"rpcap",
"rmi",
"ipmi",
"irc",
"versant",
"omp2",
"gps",
"mobileme",
"ls",
"unicode",
"lpeg",
"lfs",
"libssh2",
];
for name in module_names {
globals.set(*name, self.lua.create_table()?)?;
}
globals.set("_REQUIRE_MODULES", self.lua.create_table()?)?;
globals.set("_SCRIPT_OUTPUT", self.lua.create_table()?)?;
Ok(())
}
fn register_libraries(&self) -> LuaResult<()> {
crate::libraries::stdnse::register_stdlib_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::nmap::register_nmap_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::http::register_http_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::comm::register_comm_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
self.gate_then_register("sslcert", |ctx| {
crate::libraries::sslcert::register_sslcert_library_with_services(
&ctx.lua,
&ctx.capability_context,
&ctx.host_services,
)
})?;
self.gate_then_register("tls", |ctx| {
crate::libraries::tls::register_tls_library_with_services(
&ctx.lua,
&ctx.capability_context,
&ctx.host_services,
)
})?;
crate::libraries::shortport::register_shortport_library(&self.lua)?;
crate::libraries::socket::register_socket_library_with_services(
&self.lua,
&self.sandbox,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::ssh2::register_ssh2_library(&self.lua)?;
self.gate_then_register("ftp", |ctx| {
crate::libraries::ftp::register_ftp_library_with_services(
&ctx.lua,
&ctx.capability_context,
&ctx.host_services,
)
})?;
self.gate_then_register("smtp", |ctx| {
crate::libraries::smtp::register_smtp_library_with_services(
&ctx.lua,
&ctx.capability_context,
&ctx.host_services,
)
})?;
self.gate_then_register("mysql", |ctx| {
crate::libraries::mysql::register_mysql_library_with_services(
&ctx.lua,
&ctx.capability_context,
&ctx.host_services,
)
})?;
self.gate_then_register("postgres", |ctx| {
crate::libraries::postgres::register_postgres_library_with_services(
&ctx.lua,
&ctx.capability_context,
&ctx.host_services,
)
})?;
self.gate_then_register("mssql", |ctx| {
crate::libraries::mssql::register_mssql_library_with_services(
&ctx.lua,
&ctx.capability_context,
&ctx.host_services,
)
})?;
self.gate_then_register("redis", |ctx| {
crate::libraries::redis::register_redis_library_with_services(
&ctx.lua,
&ctx.capability_context,
&ctx.host_services,
)
})?;
self.gate_then_register("mongodb", |ctx| {
crate::libraries::mongodb::register_mongodb_library_with_services(
&ctx.lua,
&ctx.capability_context,
&ctx.host_services,
)
})?;
self.gate_then_register("ldap", |ctx| {
crate::libraries::ldap::register_ldap_library_with_services(
&ctx.lua,
&ctx.capability_context,
&ctx.host_services,
)
})?;
self.gate_then_register("snmp", |ctx| {
crate::libraries::snmp::register_snmp_library(&ctx.lua, &ctx.capability_context)
})?;
self.gate_then_register("smb", |ctx| {
crate::libraries::smb::register_smb_library_with_services(
&ctx.lua,
&ctx.capability_context,
&ctx.host_services,
)
})?;
self.gate_then_register("smb2", |ctx| {
crate::libraries::smb2::register_smb2_library_with_services(
&ctx.lua,
&ctx.capability_context,
&ctx.host_services,
)
})?;
crate::libraries::smbauth::register_smbauth_library(&self.lua)?;
self.gate_then_register("rdp", |ctx| {
crate::libraries::rdp::register_rdp_library_with_services(
&ctx.lua,
&ctx.capability_context,
&ctx.host_services,
)
})?;
self.gate_then_register("vnc", |ctx| {
crate::libraries::vnc::register_vnc_library_with_services(
&ctx.lua,
&ctx.capability_context,
&ctx.host_services,
)
})?;
self.gate_then_register("ntp", |ctx| {
crate::libraries::ntp::register_ntp_library(&ctx.lua, &ctx.capability_context)
})?;
crate::libraries::memcached::register_memcached_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
self.gate_then_register("imap", |ctx| {
crate::libraries::imap::register_imap_library_with_services(
&ctx.lua,
&ctx.capability_context,
&ctx.host_services,
)
})?;
crate::libraries::pop3::register_pop3_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::netbios::register_netbios_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::oracle::register_oracle_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::winrm::register_winrm_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::radius::register_radius_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
self.gate_then_register("dhcp", |ctx| {
crate::libraries::dhcp::register_dhcp_library(&ctx.lua, &ctx.capability_context)
})?;
self.gate_then_register("dhcp6", |ctx| {
crate::libraries::dhcp6::register_dhcp6_library(&ctx.lua, &ctx.capability_context)
})?;
crate::libraries::sip::register_sip_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::tftp::register_tftp_library(&self.lua)?;
self.gate_then_register("upnp", |ctx| {
crate::libraries::upnp::register_upnp_library_with_services(
&ctx.lua,
&ctx.capability_context,
&ctx.host_services,
)
})?;
crate::libraries::tns::register_tns_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::afp::register_afp_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::amqp::register_amqp_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::ajp::register_ajp_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::ncp::register_ncp_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::ndmp::register_ndmp_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::nrpc::register_nrpc_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::citrixxml::register_citrixxml_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::ospf::register_ospf_library(&self.lua)?;
crate::libraries::asn1::register_asn1_library(&self.lua)?;
crate::libraries::sasl::register_sasl_library(&self.lua)?;
crate::libraries::slaxml::register_slaxml_library(&self.lua)?;
crate::libraries::re::register_re_library(&self.lua)?;
crate::libraries::httpspider::register_httpspider_library(
&self.lua,
&self.capability_context,
)?;
crate::libraries::base64::register_base64_library(&self.lua)?;
crate::libraries::base32::register_base32_library(&self.lua)?;
crate::libraries::datetime::register_datetime_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::rand::register_rand_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::url::register_url_library(&self.lua)?;
crate::libraries::creds::register_creds_library(&self.lua, &self.capability_context)?;
self.gate_then_register("openssl", |ctx| {
crate::libraries::openssl::register_openssl_library_with_services(
&ctx.lua,
&ctx.capability_context,
&ctx.host_services,
)
})?;
crate::libraries::pcre::register_pcre_library(&self.lua)?;
crate::libraries::io::register_io_library_with_services(
&self.lua,
&self.sandbox,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::os::register_os_library_with_services(
&self.lua,
&self.sandbox,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::unittest::register_unittest_library(&self.lua)?;
crate::libraries::target::register_target_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::strbuf::register_strbuf_library(&self.lua)?;
crate::libraries::tab::register_tab_library(&self.lua)?;
crate::libraries::stringaux::register_stringaux_library(&self.lua)?;
crate::libraries::bin::register_bin_library(&self.lua)?;
crate::libraries::bit::register_bit_library(&self.lua)?;
crate::libraries::vulns::register_vulns_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::unpwdb::register_unpwdb_library(&self.lua, &self.capability_context)?;
self.gate_then_register("brute", |ctx| {
crate::libraries::brute::register_brute_library_with_services(
&ctx.lua,
&ctx.capability_context,
&ctx.host_services,
)
})?;
crate::libraries::datafiles::register_datafiles_library(
&self.lua,
&self.capability_context,
)?;
crate::libraries::json::register_json_library(&self.lua)?;
self.gate_then_register("ssh", |ctx| {
crate::libraries::ssh::register_ssh_library(&ctx.lua, &ctx.capability_context)
})?;
crate::libraries::dns::register_dns_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::http2::register_http2_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::httppipeline::register_httppipeline_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::geoip::register_geoip_library(&self.lua)?;
crate::libraries::rpc::register_rpc_library(&self.lua)?;
crate::libraries::ssh1::register_ssh1_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::sslv2::register_sslv2_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::msrpc::register_msrpc_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::ike::register_ike_library(&self.lua)?;
crate::libraries::ipp::register_ipp_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::coap::register_coap_library(&self.lua)?;
crate::libraries::idna::register_idna_library(&self.lua)?;
crate::libraries::pgsql::register_pgsql_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::ipops::register_ipops_library(&self.lua)?;
crate::libraries::iax2::register_iax2_library(&self.lua)?;
crate::libraries::drda::register_drda_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::eigrp::register_eigrp_library(&self.lua)?;
crate::libraries::giop::register_giop_library(&self.lua)?;
crate::libraries::iscsi::register_iscsi_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::jdwp::register_jdwp_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::rsync::register_rsync_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::socks::register_socks_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::rtsp::register_rtsp_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::tn3270::register_tn3270_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::xmpp::register_xmpp_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::isns::register_isns_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::membase::register_membase_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::bitcoin::register_bitcoin_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::bittorrent::register_bittorrent_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::cassandra::register_cassandra_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::dicom::register_dicom_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::knx::register_knx_library(&self.lua)?;
crate::libraries::multicast::register_multicast_library(&self.lua)?;
crate::libraries::nbd::register_nbd_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::natpmp::register_natpmp_library(&self.lua)?;
crate::libraries::proxy::register_proxy_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::srvloc::register_srvloc_library(&self.lua)?;
crate::libraries::wsdd::register_wsdd_library(&self.lua)?;
self.gate_then_register("xdmcp", |ctx| {
crate::libraries::xdmcp::register_xdmcp_library(&ctx.lua, &ctx.capability_context)
})?;
crate::libraries::bjnp::register_bjnp_library(&self.lua)?;
crate::libraries::cvs::register_cvs_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::dnssd::register_dnssd_library(&self.lua)?;
crate::libraries::eap::register_eap_library(&self.lua)?;
crate::libraries::pppoe::register_pppoe_library(&self.lua)?;
crate::libraries::rpcap::register_rpcap_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::rmi::register_rmi_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::ipmi::register_ipmi_library(&self.lua)?;
crate::libraries::irc::register_irc_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::versant::register_versant_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
self.gate_then_register("omp2", |ctx| {
crate::libraries::omp2::register_omp2_library_with_services(
&ctx.lua,
&ctx.capability_context,
&ctx.host_services,
)
})?;
crate::libraries::gps::register_gps_library(&self.lua)?;
crate::libraries::mobileme::register_mobileme_library(&self.lua)?;
crate::libraries::ls::register_ls_library(&self.lua, &self.capability_context)?;
crate::libraries::unicode::register_unicode_library(&self.lua)?;
crate::libraries::bits::register_bits_library(&self.lua)?;
crate::libraries::formulas::register_formulas_library(&self.lua)?;
crate::libraries::anyconnect::register_anyconnect_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::iec61850mms::register_iec61850mms_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::informix::register_informix_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::libssh2_utility::register_libssh2_utility_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::matchs::register_matchs_library(&self.lua)?;
crate::libraries::lpeg_utility::register_lpeg_utility_library(&self.lua)?;
crate::libraries::lpeg::register_lpeg_library(&self.lua)?;
crate::libraries::lfs::register_lfs_library_with_services(
&self.lua,
&self.sandbox,
&self.capability_context,
&self.host_services,
)?;
self.gate_then_register("libssh2", |ctx| {
crate::libraries::libssh2::register_libssh2_library(&ctx.lua, &ctx.capability_context)
})?;
crate::libraries::msrpcperformance::register_msrpcperformance_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::msrpctypes::register_msrpctypes_library(&self.lua)?;
crate::libraries::oops::register_oops_library_with_services(
&self.lua,
&self.capability_context,
&self.host_services,
)?;
crate::libraries::outlib::register_outlib_library(&self.lua)?;
crate::libraries::punycode::register_punycode_library(&self.lua)?;
crate::libraries::tableaux::register_tableaux_library(&self.lua)?;
crate::libraries::vuzedht::register_vuzedht_library(&self.lua)?;
crate::libraries::listop::register_listop_library(&self.lua)?;
crate::libraries::zlib::register_zlib_library(&self.lua, &self.capability_context)?;
self.scrub_ineligible_globals()?;
self.sync_require_modules()
}
fn scrub_ineligible_globals(&self) -> LuaResult<()> {
if !crate::effect_manifest::is_automated_profile(self.profile_kind) {
return Ok(());
}
let globals = self.lua.globals();
for entry in crate::effect_manifest::LIBRARY_EFFECT_MANIFEST
.iter()
.filter(|e| !crate::effect_manifest::eligible_for_profile(e.name, self.profile_kind))
{
if globals.set(entry.name, mlua::Value::Nil).is_err() {
tracing::warn!(
library = entry.name,
"M007A scrub: failed to remove ineligible global"
);
} else {
tracing::debug!(
library = entry.name,
eligibility = %entry.eligibility,
"M007A scrub: removed ineligible global under automated profile"
);
}
}
Ok(())
}
fn sync_require_modules(&self) -> LuaResult<()> {
shared::sync_require_modules(&self.lua)
}
fn gate_then_register<F>(&self, name: &'static str, register_fn: F) -> LuaResult<()>
where
F: FnOnce(&ExecutorCore) -> LuaResult<()>,
{
let eligibility = crate::effect_manifest::automated_library_eligibility(name);
let profile = self.profile_kind;
let is_safe = crate::effect_manifest::eligible_for_profile(name, profile);
if is_safe {
register_fn(self)
} else if crate::effect_manifest::is_automated_profile(profile) {
let globals = self.lua.globals();
globals.set(name, mlua::Value::Nil)?;
tracing::debug!(
library = name,
?eligibility,
?profile,
"M007A: blocked unsafe library under automated profile"
);
Ok(())
} else {
register_fn(self)
}
}
fn setup_require(&self, _scripts_path: Arc<Mutex<Vec<PathBuf>>>) -> LuaResult<()> {
let cache: Arc<Mutex<FxHashMap<String, Value>>> =
Arc::new(Mutex::new(FxHashMap::default()));
let required_modules = self.required_modules.clone();
let script_policy = self.script_policy.clone();
let module_policy = self.module_policy.clone();
let limits = self.limits.clone();
let cancellation = self.cancellation.clone();
let profile_kind = self.profile_kind;
fn record_required_module(
required_modules: &Arc<Mutex<Vec<NseRequiredModuleReport>>>,
report: NseRequiredModuleReport,
) {
let mut modules = required_modules.lock();
if let Some(existing) = modules
.iter_mut()
.find(|existing| existing.name == report.name)
{
if !existing.loaded && report.loaded {
*existing = report;
}
return;
}
modules.push(report);
}
let require_fn = self.lua.create_function(move |lua, name: String| {
if !crate::effect_manifest::eligible_for_profile(&name, profile_kind) {
let deny_reason = format!(
"library '{}' is not eligible under automated profile '{}'",
name, profile_kind
);
record_required_module(
&required_modules,
NseRequiredModuleReport {
name: name.clone(),
loaded: false,
source: NseRequiredModuleSource::BlockedByPolicy,
error: Some(deny_reason.clone()),
},
);
return Err(mlua::Error::RuntimeError(deny_reason));
}
if cancellation.is_cancelled() {
return Err(mlua::Error::RuntimeError(
"Require cancelled".to_string(),
));
}
{
let g = cache.lock();
if let Some(cached) = g.get(&name) {
record_required_module(
&required_modules,
NseRequiredModuleReport {
name: name.clone(),
loaded: true,
source: NseRequiredModuleSource::BuiltinGlobal,
error: None,
},
);
return Ok(cached.clone());
}
}
let globals = lua.globals();
if let Ok(modules) = globals.get::<Table>("_REQUIRE_MODULES") {
if let Ok(module) = modules.get::<Table>(name.as_str()) {
record_required_module(
&required_modules,
NseRequiredModuleReport {
name: name.clone(),
loaded: true,
source: NseRequiredModuleSource::BuiltinGlobal,
error: None,
},
);
cache
.lock()
.insert(name.clone(), Value::Table(module.clone()));
return Ok(Value::Table(module));
}
}
if let Ok(module) = globals.get::<Table>(name.as_str()) {
if let Ok(modules) = globals.get::<Table>("_REQUIRE_MODULES") {
if let Err(e) = modules.set(name.clone(), module.clone()) {
tracing::warn!("NSE require: failed to cache module '{}' in _REQUIRE_MODULES: {}", name, e);
}
}
record_required_module(
&required_modules,
NseRequiredModuleReport {
name: name.clone(),
loaded: true,
source: NseRequiredModuleSource::BuiltinGlobal,
error: None,
},
);
cache
.lock()
.insert(name.clone(), Value::Table(module.clone()));
return Ok(Value::Table(module));
}
let mut resolver = ScriptResolver::new(
script_policy.clone(),
module_policy.clone(),
limits.clone(),
);
match resolver.resolve_module(&name) {
Ok(Some(resolved)) => {
match lua.load(&resolved.content).eval::<Value>() {
Ok(value) => {
let globals = lua.globals();
if let Ok(modules) = globals.get::<Table>("_REQUIRE_MODULES") {
if let Err(e) = modules.set(name.clone(), value.clone()) {
tracing::warn!("NSE require: failed to cache module '{}' in _REQUIRE_MODULES: {}", name, e);
}
}
record_required_module(
&required_modules,
NseRequiredModuleReport {
name: name.clone(),
loaded: true,
source: NseRequiredModuleSource::Filesystem,
error: None,
},
);
cache.lock().insert(name.clone(), value.clone());
return Ok(value);
}
Err(e) => {
tracing::warn!(
"NSE require: failed to evaluate module '{}' from '{}': {}",
name,
resolved.path.as_deref().map(|p| p.display().to_string()).unwrap_or_else(|| "unknown".to_string()),
e
);
record_required_module(
&required_modules,
NseRequiredModuleReport {
name: name.clone(),
loaded: false,
source: NseRequiredModuleSource::Filesystem,
error: Some(e.to_string()),
},
);
return Err(mlua::Error::RuntimeError(format!(
"module '{}' eval error: {}",
name, e
)));
}
}
}
Ok(None) => {
tracing::debug!(
"NSE require: module '{}' not found in filesystem (policy: filesystem_modules={})",
name,
module_policy.allow_filesystem_modules
);
record_required_module(
&required_modules,
NseRequiredModuleReport {
name: name.clone(),
loaded: false,
source: if !module_policy.allow_filesystem_modules
|| module_policy.allowed_module_roots.is_empty()
{
NseRequiredModuleSource::BlockedByPolicy
} else {
NseRequiredModuleSource::Missing
},
error: Some(if !module_policy.allow_filesystem_modules
|| module_policy.allowed_module_roots.is_empty()
{
"filesystem module loading blocked by policy".to_string()
} else {
"module not found".to_string()
}),
},
);
}
Err(e) => {
tracing::warn!("NSE require: resolver rejected module '{}': {}", name, e);
let error_text = e.to_string();
let source = match &e {
crate::resolver::NseLoadError::InvalidModuleName { .. } => {
NseRequiredModuleSource::InvalidName
}
_ => NseRequiredModuleSource::Unknown,
};
record_required_module(
&required_modules,
NseRequiredModuleReport {
name: name.clone(),
loaded: false,
source,
error: Some(error_text.clone()),
},
);
return Err(mlua::Error::RuntimeError(format!(
"module '{}' not found: {}",
name, error_text
)));
}
}
Err(mlua::Error::RuntimeError(format!(
"module '{}' not found",
name
)))
})?;
self.lua.globals().set("require", require_fn)?;
Ok(())
}
}
pub fn default_script_policy() -> NseScriptPolicy {
NseScriptPolicy {
allow_builtin_scripts: true,
allow_script_files: true,
allowed_script_roots: Vec::new(),
allow_conventional_nmap_paths: true,
max_script_bytes: None,
}
}
pub fn default_module_policy() -> NseModulePolicy {
NseModulePolicy {
allow_builtin_modules: true,
allow_filesystem_modules: true,
allowed_module_roots: Vec::new(),
max_module_bytes: None,
}
}
fn reset_per_run_globals() {
crate::libraries::brute::reset_for_run();
crate::libraries::io::reset_for_run();
crate::libraries::httpspider::reset_for_run();
crate::libraries::smb::reset_for_run();
crate::libraries::pcre::reset_for_run();
crate::libraries::re::reset_for_run();
crate::libraries::openssl::reset_for_run();
crate::libraries::creds::reset_for_run();
crate::libraries::target::reset_for_run();
crate::libraries::unpwdb::reset_for_run();
crate::libraries::unittest::reset_for_run();
crate::libraries::smbauth::reset_for_run();
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_core_creation() {
let core = ExecutorCore::new();
assert!(core.is_ok());
}
#[test]
fn test_set_target() {
let mut core = ExecutorCore::new().unwrap();
assert!(core.set_target("example.com").is_ok());
assert_eq!(core.target(), "example.com");
}
#[test]
fn test_reset_per_run_globals_does_not_panic() {
reset_per_run_globals();
reset_per_run_globals();
}
#[test]
fn test_clear_library_reports_resets_globals() {
let core = ExecutorCore::new().unwrap();
core.clear_library_reports();
}
}