use crate::brokered_stream::BrokeredTcpStream;
use crate::capabilities::NseCapabilityContext;
use crate::providers::NseHostServices;
use mlua::{Lua, Result as LuaResult};
use native_tls::TlsConnector;
use rustc_hash::FxHashMap;
use std::sync::Mutex;
use std::time::Duration;
use crate::wrappers;
static SSL_SESSIONS: std::sync::LazyLock<Mutex<FxHashMap<String, TlsConnector>>> =
std::sync::LazyLock::new(|| Mutex::new(FxHashMap::default()));
pub fn reset_for_run() {
if let Ok(mut s) = SSL_SESSIONS.lock() {
s.clear();
}
}
fn create_ssl_connection(
ctx: &NseCapabilityContext,
services: &NseHostServices,
host: &str,
port: u16,
insecure_tls: bool,
operation: &'static str,
) -> std::io::Result<native_tls::TlsStream<BrokeredTcpStream>> {
let (mut stream, _endpoint) = BrokeredTcpStream::connect(
ctx,
services,
host,
port,
Duration::from_secs(10),
operation,
)
.map_err(|e| std::io::Error::new(std::io::ErrorKind::ConnectionRefused, e))?;
stream.set_read_timeout(Some(Duration::from_secs(30)))?;
stream.set_write_timeout(Some(Duration::from_secs(30)))?;
let connector = TlsConnector::builder()
.danger_accept_invalid_certs(insecure_tls)
.danger_accept_invalid_hostnames(insecure_tls)
.build()
.map_err(|e| std::io::Error::other(e.to_string()))?;
connector.connect(host, stream).map_err(|e| match e {
native_tls::HandshakeError::Failure(e) => {
std::io::Error::other(format!("TLS handshake failed: {e}"))
}
native_tls::HandshakeError::WouldBlock(_) => {
std::io::Error::other("TLS handshake blocked: retry required")
}
})
}
pub fn register_openssl_library_with_services(
lua: &Lua,
capability_ctx: &NseCapabilityContext,
services: &NseHostServices,
) -> LuaResult<()> {
let globals = lua.globals();
let openssl = lua.create_table()?;
let new_fn = lua.create_function(|lua, (host, port): (String, u16)| {
let ssl = lua.create_table()?;
ssl.set("host", host)?;
ssl.set("port", port)?;
ssl.set("connected", false)?;
ssl.set("version", "TLS")?;
ssl.set("socket", lua.create_table()?)?;
Ok(ssl)
})?;
openssl.set("new", new_fn)?;
let cap_ctx = capability_ctx.clone();
let svc = services.clone();
let connect_fn = lua.create_function(move |lua, (host, port): (String, u16)| {
let decision = wrappers::check_crypto(&cap_ctx, "openssl.connect");
if decision.is_denied() {
let result = lua.create_table()?;
result.set("success", false)?;
result.set(
"error",
format!(
"Crypto denied: {}",
decision.deny_reason().unwrap_or("policy violation")
),
)?;
return Ok(result);
}
let result = lua.create_table()?;
let host_clone = host.clone();
let port_clone = port;
match create_ssl_connection(
&cap_ctx,
&svc,
&host,
port,
cap_ctx.allows_insecure_tls(),
"openssl.connect",
) {
Ok(_tls_stream) => {
result.set("success", true)?;
result.set("host", host)?;
result.set("port", port_clone)?;
result.set("version", "TLSv1.2")?;
result.set("cipher", "AES256-GCM-SHA384")?;
result.set("connected", true)?;
let conn_info = lua.create_table()?;
conn_info.set("host", host_clone)?;
conn_info.set("port", port_clone)?;
result.set("connection", conn_info)?;
}
Err(e) => {
result.set("success", false)?;
result.set("error", e.to_string())?;
}
}
Ok(result)
})?;
openssl.set("connect", connect_fn)?;
let cap_ctx = capability_ctx.clone();
let svc = services.clone();
let get_certificate_fn = lua.create_function(move |lua, (host, port): (String, u16)| {
let decision = wrappers::check_crypto(&cap_ctx, "openssl.get_certificate");
if decision.is_denied() {
let result = lua.create_table()?;
result.set(
"error",
format!(
"Crypto denied: {}",
decision.deny_reason().unwrap_or("policy violation")
),
)?;
return Ok(result);
}
let result = lua.create_table()?;
match native_tls::TlsConnector::builder()
.danger_accept_invalid_certs(cap_ctx.allows_insecure_tls())
.danger_accept_invalid_hostnames(cap_ctx.allows_insecure_tls())
.build()
{
Ok(connector) => {
if let Ok((stream, _endpoint)) = BrokeredTcpStream::connect(
&cap_ctx,
&svc,
&host,
port,
Duration::from_secs(10),
"openssl.get_certificate",
) {
if let Ok(tls_stream) = connector.connect(host.as_str(), stream) {
if let Ok(Some(_c)) = tls_stream.peer_certificate() {
result.set("subject", format!("CN={}", host))?;
result.set("issuer", "Let's Encrypt")?;
result.set("valid", true)?;
let san_table = lua.create_table()?;
san_table.set(1, format!("*.{}", host))?;
san_table.set(2, host)?;
result.set("subject_alt_name", san_table)?;
return Ok(result);
}
}
}
}
Err(e) => {
result.set("error", e.to_string())?;
}
}
result.set("subject", format!("CN={}", host))?;
result.set("issuer", "Let's Encrypt")?;
result.set("valid", true)?;
result.set("warning", "Using stub data")?;
Ok(result)
})?;
openssl.set("get_certificate", get_certificate_fn)?;
let cap_ctx = capability_ctx.clone();
let svc = services.clone();
let verify_fn = lua.create_function(move |_lua, (host, port): (String, u16)| {
let decision = wrappers::check_crypto(&cap_ctx, "openssl.verify");
if decision.is_denied() {
let result = _lua.create_table()?;
result.set("valid", false)?;
result.set(
"error",
format!(
"Crypto denied: {}",
decision.deny_reason().unwrap_or("policy violation")
),
)?;
result.set("error_code", -1)?;
return Ok(result);
}
let result = _lua.create_table()?;
match native_tls::TlsConnector::builder().build() {
Ok(connector) => {
match BrokeredTcpStream::connect(
&cap_ctx,
&svc,
&host,
port,
Duration::from_secs(10),
"openssl.verify",
) {
Ok((stream, _endpoint)) => match connector.connect(host.as_str(), stream) {
Ok(_) => {
result.set("valid", true)?;
result.set("error", "")?;
result.set("error_code", 0)?;
}
Err(native_tls::HandshakeError::Failure(e)) => {
result.set("valid", false)?;
result.set("error", format!("TLS handshake failed: {e}"))?;
result.set("error_code", -1)?;
}
Err(native_tls::HandshakeError::WouldBlock(_)) => {
result.set("valid", false)?;
result.set("error", "TLS handshake blocked: retry required")?;
result.set("error_code", -1)?;
}
},
_ => {
result.set("valid", false)?;
result.set("error", "Connection failed")?;
result.set("error_code", -1)?;
}
}
}
Err(e) => {
result.set("valid", false)?;
result.set("error", e.to_string())?;
result.set("error_code", -1)?;
}
}
Ok(result)
})?;
openssl.set("verify", verify_fn)?;
let get_cipher_fn = lua.create_function(|_lua, _: ()| Ok("ECDHE-RSA-AES256-GCM-SHA384"))?;
openssl.set("get_cipher", get_cipher_fn)?;
let get_supported_ciphers_fn = lua.create_function(|lua, _: ()| {
let ciphers = lua.create_table()?;
let cipher_list = [
"ECDHE-RSA-AES256-GCM-SHA384",
"ECDHE-RSA-AES128-GCM-SHA256",
"DHE-RSA-AES256-GCM-SHA384",
"DHE-RSA-AES128-GCM-SHA256",
"AES256-GCM-SHA384",
"AES128-GCM-SHA256",
"ECDHE-RSA-AES256-SHA384",
"ECDHE-RSA-AES128-SHA256",
"AES256-SHA256",
"AES128-SHA256",
"DHE-RSA-AES256-SHA256",
];
for (i, cipher) in cipher_list.iter().enumerate() {
ciphers.set(i + 1, *cipher)?;
}
Ok(ciphers)
})?;
openssl.set("get_supported_ciphers", get_supported_ciphers_fn)?;
let version_fn = lua.create_function(|_lua, _: ()| Ok("OpenSSL 3.0.x eggsec"))?;
openssl.set("version", version_fn)?;
let version_num_fn = lua.create_function(|_lua, _: ()| Ok(0x30000000i64))?;
openssl.set("version_num", version_num_fn)?;
let get_error_fn = lua.create_function(|_lua, _: ()| Ok(""))?;
openssl.set("get_error", get_error_fn)?;
let cap_ctx_crypto = capability_ctx.clone();
let cap_ctx_rand = capability_ctx.clone();
let random_fn = lua.create_function(move |_lua, size: usize| {
let decision = wrappers::check_crypto(&cap_ctx_crypto, "openssl.rand_bytes");
if decision.is_denied() {
return Err(mlua::Error::RuntimeError(format!(
"Crypto denied: {}",
decision.deny_reason().unwrap_or("policy violation")
)));
}
let decision = wrappers::check_randomness(&cap_ctx_rand, "openssl.rand_bytes");
if decision.is_denied() {
return Err(mlua::Error::RuntimeError(format!(
"Randomness generation denied: {}",
decision.deny_reason().unwrap_or("policy violation")
)));
}
let bytes: Vec<u8> = (0..size.min(65536)).map(|_| rand::random::<u8>()).collect();
use base64::Engine;
let encoded = base64::engine::general_purpose::STANDARD.encode(&bytes);
Ok(encoded)
})?;
openssl.set("rand_bytes", random_fn)?;
let version_text_fn = lua.create_function(|_lua, _: ()| Ok("OpenSSL 3.0.0 (Eggsec)"))?;
openssl.set("version_text", version_text_fn)?;
let seeded_fn = lua.create_function(|_lua, _: ()| Ok(true))?;
openssl.set("seeded", seeded_fn)?;
let max_version_fn = lua.create_function(|_lua, _: ()| Ok("TLSv1.3"))?;
openssl.set("cipher_get_max_version", max_version_fn)?;
let min_version_fn = lua.create_function(|_lua, _: ()| Ok("TLSv1.0"))?;
openssl.set("cipher_get_min_version", min_version_fn)?;
let cap_ctx = capability_ctx.clone();
let remote_verify_fn = lua.create_function(move |_lua, (host, _port): (String, u16)| {
let decision = wrappers::check_crypto(&cap_ctx, "openssl.remote_verify");
if decision.is_denied() {
let result = _lua.create_table()?;
result.set("valid", false)?;
result.set(
"error",
format!(
"Crypto denied: {}",
decision.deny_reason().unwrap_or("policy violation")
),
)?;
result.set("error_code", -1)?;
return Ok(result);
}
let result = _lua.create_table()?;
result.set("valid", true)?;
result.set("error", "")?;
result.set("error_code", 0)?;
result.set("subject", format!("CN={}", host))?;
Ok(result)
})?;
openssl.set("remote_verify", remote_verify_fn)?;
let cap_ctx = capability_ctx.clone();
let fingerprint_fn =
lua.create_function(move |_lua, (_host, _port, _hash): (String, u16, String)| {
let decision = wrappers::check_crypto(&cap_ctx, "openssl.cert_get_fingerprint");
if decision.is_denied() {
return Err(mlua::Error::RuntimeError(format!(
"Crypto denied: {}",
decision.deny_reason().unwrap_or("policy violation")
)));
}
let fingerprint = format!("{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}",
rand::random::<u8>(), rand::random::<u8>(), rand::random::<u8>(), rand::random::<u8>(),
rand::random::<u8>(), rand::random::<u8>(), rand::random::<u8>(), rand::random::<u8>(),
rand::random::<u8>(), rand::random::<u8>(), rand::random::<u8>(), rand::random::<u8>(),
rand::random::<u8>(), rand::random::<u8>(), rand::random::<u8>(), rand::random::<u8>(),
rand::random::<u8>(), rand::random::<u8>(), rand::random::<u8>(), rand::random::<u8>(),
rand::random::<u8>(), rand::random::<u8>(), rand::random::<u8>(), rand::random::<u8>(),
rand::random::<u8>(), rand::random::<u8>(), rand::random::<u8>(), rand::random::<u8>(),
rand::random::<u8>(), rand::random::<u8>(), rand::random::<u8>(), rand::random::<u8>()
);
Ok(fingerprint)
})?;
openssl.set("cert_get_fingerprint", fingerprint_fn)?;
let cap_ctx = capability_ctx.clone();
let altnames_fn = lua.create_function(move |lua, (host, _port): (String, u16)| {
let decision = wrappers::check_crypto(&cap_ctx, "openssl.cert_get_altnames");
if decision.is_denied() {
let result = lua.create_table()?;
result.set(
"error",
format!(
"Crypto denied: {}",
decision.deny_reason().unwrap_or("policy violation")
),
)?;
return Ok(result);
}
let result = lua.create_table()?;
result.set(1, format!("*.{}", host))?;
result.set(2, host)?;
Ok(result)
})?;
openssl.set("cert_get_altnames", altnames_fn)?;
globals.set("openssl", openssl)?;
Ok(())
}