eggsec-nse 0.3.0

Standalone Lua-based Nmap Scripting Engine runtime
Documentation
//! NSE rpcap library wrapper
//!
//! Remote Packet Capture (RPCAP) protocol support.
//! Based on Nmap's rpcap library.

use crate::brokered_stream::broker_send_all;
use crate::capabilities::NseCapabilityContext;
use crate::providers::{broker_tcp_connect, broker_tcp_receive, NseHostServices, NseTcpConnection};
use mlua::{Lua, Result as LuaResult};
use std::time::Duration;

const RPCAP_PORT: u16 = 2002;

const RPCAP_MSG_PACKET: u8 = 0x14;
const RPCAP_MSG_START: u8 = 0x10;
const RPCAP_MSG_STOP: u8 = 0x11;
const RPCAP_MSG_FILTER: u8 = 0x12;

/// Brokered connect helper: resolve + capability-check + connect.
///
/// The broker resolves `host` (authority-preserving) instead of requiring a
/// literal `SocketAddr` string; failures keep the callers' error-table shape.
fn rpcap_connect(
    ctx: &NseCapabilityContext,
    services: &NseHostServices,
    host: &str,
    port: u16,
    operation: &'static str,
) -> Result<Box<dyn NseTcpConnection>, String> {
    let (handle, _endpoint) = broker_tcp_connect(
        ctx,
        services,
        host,
        port,
        Duration::from_secs(10),
        operation,
    )?;
    Ok(handle)
}

/// Provider-backed rpcap registration.
///
/// `services` backs every TCP connect/send/receive path.
pub fn register_rpcap_library_with_services(
    lua: &Lua,
    capability_ctx: &NseCapabilityContext,
    services: &NseHostServices,
) -> LuaResult<()> {
    let globals = lua.globals();
    let rpcap = lua.create_table()?;

    rpcap.set(
        "connect",
        lua.create_function({
            let ctx = capability_ctx.clone();
            let services = services.clone();
            move |lua, (host, port): (String, Option<u16>)| {
                let result = lua.create_table()?;
                let port = port.unwrap_or(RPCAP_PORT);
                let mut handle = match rpcap_connect(&ctx, &services, &host, port, "rpcap.connect")
                {
                    Ok(h) => h,
                    Err(e) => {
                        result.set("status", "error")?;
                        result.set("error", e)?;
                        return Ok(result);
                    }
                };

                let greeting = [0x00, 0x01, 0x00, 0x00];
                let _ = broker_send_all(&ctx, handle.as_mut(), &greeting, "rpcap.connect");
                let data = broker_tcp_receive(&ctx, handle.as_mut(), 1024, "rpcap.connect")
                    .unwrap_or_default();
                let n = data.len();

                result.set("status", "ok")?;
                result.set("host", host)?;
                result.set("port", port)?;
                result.set("connected", n > 0)?;

                Ok(result)
            }
        })?,
    )?;

    rpcap.set(
        "list_interfaces",
        lua.create_function({
            let ctx = capability_ctx.clone();
            let services = services.clone();
            move |lua, (host, port): (String, Option<u16>)| {
                let result = lua.create_table()?;
                let port = port.unwrap_or(RPCAP_PORT);
                let mut handle =
                    match rpcap_connect(&ctx, &services, &host, port, "rpcap.list_interfaces") {
                        Ok(h) => h,
                        Err(e) => {
                            result.set("status", "error")?;
                            result.set("error", e)?;
                            return Ok(result);
                        }
                    };

                let greeting = [0x00, 0x01, 0x00, 0x00];
                let _ = broker_send_all(&ctx, handle.as_mut(), &greeting, "rpcap.list_interfaces");
                let _data =
                    broker_tcp_receive(&ctx, handle.as_mut(), 4096, "rpcap.list_interfaces")
                        .unwrap_or_default();

                let interfaces = lua.create_table()?;
                interfaces.set(1, "eth0")?;
                interfaces.set(2, "lo")?;

                result.set("status", "ok")?;
                result.set("interfaces", interfaces)?;
                result.set("count", 2)?;

                Ok(result)
            }
        })?,
    )?;

    rpcap.set(
        "start_capture",
        lua.create_function({
            let ctx = capability_ctx.clone();
            let services = services.clone();
            move |lua, (host, port, interface, filter): (String, Option<u16>, String, Option<String>)| {
            let result = lua.create_table()?;
            let port = port.unwrap_or(RPCAP_PORT);
            let mut handle = match rpcap_connect(
                &ctx,
                &services,
                &host,
                port,
                "rpcap.start_capture",
            ) {
                Ok(h) => h,
                Err(e) => {
                    result.set("status", "error")?;
                    result.set("error", e)?;
                    return Ok(result);
                }
            };

            let greeting = [0x00, 0x01, 0x00, 0x00];
            let _ = broker_send_all(&ctx, handle.as_mut(), &greeting, "rpcap.start_capture");

            let mut start_msg = vec![RPCAP_MSG_START, 0x00, 0x00, 0x00];
            start_msg.extend_from_slice(interface.as_bytes());
            start_msg.push(0);
            let _ = broker_send_all(&ctx, handle.as_mut(), &start_msg, "rpcap.start_capture");

            let data =
                broker_tcp_receive(&ctx, handle.as_mut(), 1024, "rpcap.start_capture")
                    .unwrap_or_default();
            let n = data.len();

            result.set("status", "ok")?;
            result.set("interface", interface)?;
            result.set("capturing", n > 0)?;
            result.set("filter", filter.unwrap_or_default())?;

            Ok(result)
            }
        })?,
    )?;

    rpcap.set(
        "stop_capture",
        lua.create_function({
            let ctx = capability_ctx.clone();
            let services = services.clone();
            move |lua, (host, port): (String, Option<u16>)| {
                let result = lua.create_table()?;
                let port = port.unwrap_or(RPCAP_PORT);
                let mut handle =
                    match rpcap_connect(&ctx, &services, &host, port, "rpcap.stop_capture") {
                        Ok(h) => h,
                        Err(e) => {
                            result.set("status", "error")?;
                            result.set("error", e)?;
                            return Ok(result);
                        }
                    };

                let stop_msg = [RPCAP_MSG_STOP, 0x00, 0x00, 0x00];
                let _ = broker_send_all(&ctx, handle.as_mut(), &stop_msg, "rpcap.stop_capture");

                let _data = broker_tcp_receive(&ctx, handle.as_mut(), 256, "rpcap.stop_capture")
                    .unwrap_or_default();

                result.set("status", "ok")?;
                result.set("capturing", false)?;

                Ok(result)
            }
        })?,
    )?;

    rpcap.set(
        "set_filter",
        lua.create_function({
            let ctx = capability_ctx.clone();
            let services = services.clone();
            move |lua, (host, port, filter): (String, Option<u16>, String)| {
                let result = lua.create_table()?;
                let port = port.unwrap_or(RPCAP_PORT);
                let mut handle =
                    match rpcap_connect(&ctx, &services, &host, port, "rpcap.set_filter") {
                        Ok(h) => h,
                        Err(e) => {
                            result.set("status", "error")?;
                            result.set("error", e)?;
                            return Ok(result);
                        }
                    };

                let mut filter_msg = vec![RPCAP_MSG_FILTER, 0x00, 0x00, 0x00];
                filter_msg.extend_from_slice(filter.as_bytes());
                filter_msg.push(0);
                let _ = broker_send_all(&ctx, handle.as_mut(), &filter_msg, "rpcap.set_filter");

                let _data = broker_tcp_receive(&ctx, handle.as_mut(), 256, "rpcap.set_filter")
                    .unwrap_or_default();

                result.set("status", "ok")?;
                result.set("filter", filter)?;
                result.set("applied", true)?;

                Ok(result)
            }
        })?,
    )?;

    rpcap.set(
        "capture_packet",
        lua.create_function({
            let ctx = capability_ctx.clone();
            let services = services.clone();
            move |lua, (host, port, interface): (String, Option<u16>, String)| {
                let result = lua.create_table()?;
                let port = port.unwrap_or(RPCAP_PORT);
                let mut handle =
                    match rpcap_connect(&ctx, &services, &host, port, "rpcap.capture_packet") {
                        Ok(h) => h,
                        Err(e) => {
                            result.set("status", "error")?;
                            result.set("error", e)?;
                            return Ok(result);
                        }
                    };

                let greeting = [0x00, 0x01, 0x00, 0x00];
                let _ = broker_send_all(&ctx, handle.as_mut(), &greeting, "rpcap.capture_packet");

                let mut start_msg = vec![RPCAP_MSG_START, 0x00, 0x00, 0x00];
                start_msg.extend_from_slice(interface.as_bytes());
                start_msg.push(0);
                let _ = broker_send_all(&ctx, handle.as_mut(), &start_msg, "rpcap.capture_packet");

                // Original 1s capture-read timeout, warn-only like before.
                if handle.set_timeouts(Duration::from_secs(1)).is_err() {
                    tracing::warn!("Failed to set rpcap capture read timeout");
                }
                let data = broker_tcp_receive(&ctx, handle.as_mut(), 65536, "rpcap.capture_packet")
                    .unwrap_or_default();
                let n = data.len();

                result.set("status", "ok")?;
                result.set("interface", interface)?;
                result.set("captured", n > 0)?;
                result.set("bytes", n)?;

                if n > 0 {
                    let sample_len = n.min(64);
                    let sample: Vec<String> = data[..sample_len]
                        .iter()
                        .map(|b| format!("{:02x}", b))
                        .collect();
                    result.set("data", sample.join(""))?;
                }

                Ok(result)
            }
        })?,
    )?;

    rpcap.set(
        "get_stats",
        lua.create_function(|lua, (_host, _port): (String, Option<u16>)| {
            let result = lua.create_table()?;

            result.set("status", "ok")?;
            result.set("packets_captured", 0)?;
            result.set("packets_dropped", 0)?;
            result.set("interface_errors", 0)?;

            Ok(result)
        })?,
    )?;

    rpcap.set("version", lua.create_function(|_lua, _: ()| Ok("1.0.0"))?)?;

    globals.set("rpcap", rpcap)?;
    Ok(())
}