eggsec-nse 0.3.0

Standalone Lua-based Nmap Scripting Engine runtime
Documentation
//! NSE ike library wrapper
//!
//! IKE (Internet Key Exchange) protocol detection for NSE scripts.
//! Based on Nmap's ike library.

use mlua::{Lua, Result as LuaResult};
use std::net::UdpSocket;
use std::time::Duration;

pub fn register_ike_library(lua: &Lua) -> LuaResult<()> {
    let globals = lua.globals();
    let ike = lua.create_table()?;

    ike.set(
        "probe",
        lua.create_function(|lua, (host, port): (String, u16)| {
            let result = lua.create_table()?;

            let addr = format!("{}:{}", host, port);
            let socket = match UdpSocket::bind("0.0.0.0:0") {
                Ok(s) => s,
                Err(e) => {
                    result.set("status", "error")?;
                    result.set("error", e.to_string())?;
                    return Ok(result);
                }
            };

            socket.set_read_timeout(Some(Duration::from_secs(5))).ok();

            // IKE SA init request
            let ike_packet = [
                0x01, // IKE SA init
                0x10, // Version
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // SPI
                0x00, 0x00, 0x00,
                0x28, // Length
                      // ... rest of IKE packet
            ];

            socket.send_to(&ike_packet, &addr).ok();

            let mut response = [0u8; 1024];
            match socket.recv_from(&mut response) {
                Ok((_bytes, _src)) => {
                    result.set("status", "ok")?;
                    result.set("host", host)?;
                    result.set("port", port)?;
                    result.set("ike", true)?;
                }
                Err(_) => {
                    result.set("status", "timeout")?;
                }
            }

            Ok(result)
        })?,
    )?;

    ike.set(
        "detect",
        lua.create_function(|lua, (_host, _port): (String, u16)| {
            let result = lua.create_table()?;
            result.set("status", "ok")?;
            result.set("ike", false)?;
            result.set("vendor_ids", lua.create_table()?)?;
            Ok(result)
        })?,
    )?;

    ike.set(
        "parse_payloads",
        lua.create_function(|lua, _data: String| {
            let result = lua.create_table()?;
            result.set("status", "not_implemented")?;
            Ok(result)
        })?,
    )?;

    ike.set(
        "parse_sa",
        lua.create_function(|lua, _data: String| {
            let result = lua.create_table()?;
            result.set("status", "not_implemented")?;
            Ok(result)
        })?,
    )?;

    ike.set(
        "parse_ke",
        lua.create_function(|lua, _data: String| {
            let result = lua.create_table()?;
            result.set("status", "not_implemented")?;
            Ok(result)
        })?,
    )?;

    ike.set(
        "parse_nonce",
        lua.create_function(|lua, _data: String| {
            let result = lua.create_table()?;
            result.set("status", "not_implemented")?;
            Ok(result)
        })?,
    )?;

    ike.set(
        "parse_id",
        lua.create_function(|lua, _data: String| {
            let result = lua.create_table()?;
            result.set("status", "not_implemented")?;
            Ok(result)
        })?,
    )?;

    ike.set(
        "parse_cert",
        lua.create_function(|lua, _data: String| {
            let result = lua.create_table()?;
            result.set("status", "not_implemented")?;
            Ok(result)
        })?,
    )?;

    ike.set(
        "parse_certreq",
        lua.create_function(|lua, _data: String| {
            let result = lua.create_table()?;
            result.set("status", "not_implemented")?;
            Ok(result)
        })?,
    )?;

    ike.set(
        "parse_auth",
        lua.create_function(|lua, _data: String| {
            let result = lua.create_table()?;
            result.set("status", "not_implemented")?;
            Ok(result)
        })?,
    )?;

    ike.set(
        "get_vendor",
        lua.create_function(|_lua, vendor_id: String| {
            let vendors = [
                ("1e2b5168", "Cisco"),
                ("1b005dd6", "Microsoft"),
                ("afcad713", "Dead Peer Detection"),
                ("2c3e9284", "Juniper"),
                ("8b07c4bb", "NSA"),
                ("4a5c7e2d", "D-Link"),
            ];

            for (id, name) in vendors {
                if vendor_id.to_lowercase().starts_with(id) {
                    return Ok(name.to_string());
                }
            }
            Ok("Unknown".to_string())
        })?,
    )?;

    ike.set(
        "get_transforms",
        lua.create_function(|lua, _: ()| {
            let transforms = lua.create_table()?;

            let enc_algs = lua.create_table()?;
            enc_algs.set(1, "DES")?;
            enc_algs.set(2, "IDEA")?;
            enc_algs.set(3, "3DES")?;
            enc_algs.set(4, "RC5")?;
            enc_algs.set(5, "AES")?;
            transforms.set("encryption", enc_algs)?;

            let hash_algs = lua.create_table()?;
            hash_algs.set(1, "MD5")?;
            hash_algs.set(2, "SHA1")?;
            hash_algs.set(3, "SHA2-256")?;
            hash_algs.set(4, "SHA2-384")?;
            transforms.set("hash", hash_algs)?;

            let auth_methods = lua.create_table()?;
            auth_methods.set(1, "PSK")?;
            auth_methods.set(2, "DSS")?;
            auth_methods.set(3, "RSA")?;
            auth_methods.set(4, "ECDSA")?;
            transforms.set("authentication", auth_methods)?;

            let groups = lua.create_table()?;
            groups.set(1, "768-bit MODP")?;
            groups.set(2, "1024-bit MODP")?;
            groups.set(5, "1536-bit MODP")?;
            groups.set(14, "2048-bit MODP")?;
            groups.set(15, "3072-bit MODP")?;
            groups.set(16, "4096-bit MODP")?;
            transforms.set("group", groups)?;

            Ok(transforms)
        })?,
    )?;

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

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