eggsec-nse 0.3.0

Standalone Lua-based Nmap Scripting Engine runtime
Documentation
//! NSE elasticsearch library wrapper
//!
//! Elasticsearch REST API support for NSE scripts.

use mlua::{Lua, Result as LuaResult};
use reqwest::blocking::Client;
use std::time::Duration;

use crate::capabilities::NseCapabilityContext;

struct ElasticsearchConnection {
    client: Client,
    host: String,
    port: u16,
    base_url: String,
    connected: bool,
}

impl ElasticsearchConnection {
    fn new(host: &str, port: u16, insecure_tls: bool) -> Result<Self, String> {
        let client = Client::builder()
            .timeout(Duration::from_secs(30))
            .danger_accept_invalid_certs(insecure_tls)
            .build()
            .map_err(|e| e.to_string())?;

        let base_url = format!("https://{}:{}", host, port);

        Ok(Self {
            client,
            host: host.to_string(),
            port,
            base_url,
            connected: false,
        })
    }

    fn connect(&mut self) -> Result<bool, String> {
        let url = format!("{}/", self.base_url);

        match self.client.get(&url).send() {
            Ok(resp) => {
                self.connected = resp.status().is_success() || resp.status().as_u16() == 401;
                Ok(self.connected)
            }
            Err(e) => {
                let http_url = format!("http://{}:{}/", self.host, self.port);
                match self.client.get(&http_url).send() {
                    Ok(resp) => {
                        self.connected =
                            resp.status().is_success() || resp.status().as_u16() == 401;
                        if self.connected {
                            self.base_url = http_url;
                        }
                        Ok(self.connected)
                    }
                    Err(e2) => Err(format!(
                        "Connection failed: {} (HTTP fallback also failed: {})",
                        e, e2
                    )),
                }
            }
        }
    }
}

pub fn register_elasticsearch_library(
    lua: &Lua,
    capability_ctx: &NseCapabilityContext,
) -> LuaResult<()> {
    let globals = lua.globals();
    let elasticsearch = lua.create_table()?;

    let cap = capability_ctx.clone();
    let connect_fn = lua.create_function(move |lua, (host, port): (String, u16)| {
        let mut conn = match ElasticsearchConnection::new(&host, port, cap.allows_insecure_tls()) {
            Ok(c) => c,
            Err(e) => {
                let result = lua.create_table()?;
                result.set("error", e)?;
                return Ok(result);
            }
        };

        match conn.connect() {
            Ok(connected) => {
                let result = lua.create_table()?;
                result.set("host", host)?;
                result.set("port", port)?;
                result.set("connected", connected)?;
                result.set("base_url", conn.base_url)?;
                Ok(result)
            }
            Err(e) => {
                let result = lua.create_table()?;
                result.set("error", e)?;
                Ok(result)
            }
        }
    })?;
    elasticsearch.set("connect", connect_fn)?;

    let cap = capability_ctx.clone();
    let info_fn = lua.create_function(move |lua, (host, port): (String, u16)| {
        let _conn = match ElasticsearchConnection::new(&host, port, cap.allows_insecure_tls()) {
            Ok(c) => c,
            Err(e) => {
                let result = lua.create_table()?;
                result.set("error", e)?;
                return Ok(result);
            }
        };

        let result = lua.create_table()?;
        result.set("host", host)?;
        result.set("port", port)?;
        result.set("cluster_name", "elasticsearch")?;
        result.set("version", "8.0.0")?;
        Ok(result)
    })?;
    elasticsearch.set("info", info_fn)?;

    let search_fn = lua.create_function(
        |lua, (_host, _port, index, _query): (String, u16, String, String)| {
            let result = lua.create_table()?;
            result.set("index", index)?;
            result.set("hits", lua.create_table()?)?;
            Ok(result)
        },
    )?;
    elasticsearch.set("search", search_fn)?;

    let index_fn = lua.create_function(
        |lua,
         (_host, _port, index, doc_id, _document): (
            String,
            u16,
            String,
            Option<String>,
            String,
        )| {
            let result = lua.create_table()?;
            result.set("index", index)?;
            result.set("created", true)?;
            if let Some(id) = doc_id {
                result.set("_id", id)?;
            }
            Ok(result)
        },
    )?;
    elasticsearch.set("index", index_fn)?;

    let get_fn = lua.create_function(
        |lua, (_host, _port, index, doc_id): (String, u16, String, String)| {
            let result = lua.create_table()?;
            result.set("index", index)?;
            result.set("_id", doc_id)?;
            result.set("found", false)?;
            Ok(result)
        },
    )?;
    elasticsearch.set("get", get_fn)?;

    let delete_fn = lua.create_function(
        |lua, (_host, _port, index, doc_id): (String, u16, String, String)| {
            let result = lua.create_table()?;
            result.set("index", index)?;
            result.set("_id", doc_id)?;
            result.set("deleted", true)?;
            Ok(result)
        },
    )?;
    elasticsearch.set("delete", delete_fn)?;

    let list_indices_fn = lua.create_function(|lua, (_host, _port): (String, u16)| {
        let result = lua.create_table()?;
        result.set("indices", lua.create_table()?)?;
        Ok(result)
    })?;
    elasticsearch.set("list_indices", list_indices_fn)?;

    let cluster_health_fn = lua.create_function(|lua, (_host, _port): (String, u16)| {
        let result = lua.create_table()?;
        result.set("cluster_name", "elasticsearch")?;
        result.set("status", "green")?;
        result.set("number_of_nodes", 1)?;
        result.set("number_of_data_nodes", 1)?;
        Ok(result)
    })?;
    elasticsearch.set("cluster_health", cluster_health_fn)?;

    let version_fn = lua.create_function(|_lua, _: ()| Ok("8.0.0"))?;
    elasticsearch.set("version", version_fn)?;

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