use mlua::{Lua, Result as LuaResult, Table};
use std::sync::Arc;
use crate::capabilities::NseCapabilityContext;
use crate::providers::{broker_dns_lookup, NseDnsAnswer, NseDnsRecordType, NseHostServices};
static DNSBL_SERVERS: &[&str] = &[
"zen.spamhaus.org",
"bl.spamcop.net",
"cbl.abuseat.org",
"b.barracudacentral.org",
"dnsbl.cyberlogic.net",
"dnsbl.inps.de",
"nikula.example.bl.speedtronic.net",
];
static DNSBL_CATEGORIES: &[(&str, &str)] = &[
("spam", "Spam source"),
("open_proxy", "Open proxy"),
("web_spam", "Web spam"),
("tor_exit", "Tor exit node"),
("malware", "Malware distribution"),
("phishing", "Phishing site"),
("bot", "Bot/C&C"),
];
fn reverse_ip(ip: &str) -> String {
ip.split('.').rev().collect::<Vec<_>>().join(".")
}
fn classify_codes(answer: &NseDnsAnswer) -> (bool, Vec<&'static str>, String) {
let mut listed = false;
let mut categories: Vec<&'static str> = Vec::new();
let mut details = String::new();
for address in answer.addresses() {
let ip_str = address.to_string();
if !ip_str.starts_with("127.") {
continue;
}
listed = true;
let code: u8 = ip_str
.split('.')
.next_back()
.and_then(|s| s.parse().ok())
.unwrap_or(0);
match code {
1 => {
categories.push("spam");
details.push_str("Spam source ");
}
2 => {
categories.push("open_proxy");
details.push_str("Open Proxy ");
}
3 => {
categories.push("web_spam");
details.push_str("Web Spam ");
}
4 => {
categories.push("tor_exit");
details.push_str("Tor Exit Node ");
}
5..=7 => {
categories.push("malware");
details.push_str("Malware ");
}
8 => {
categories.push("phishing");
details.push_str("Phishing ");
}
9..=10 => {
categories.push("bot");
details.push_str("Bot/C&C ");
}
_ => {
details.push_str(&format!("Code {} ", code));
}
}
}
(listed, categories, details.trim().to_string())
}
pub fn register_dnsbl_library(lua: &Lua) -> LuaResult<()> {
let profile = crate::profile::ResolvedNseExecutionProfile::manual_permissive(None);
let ctx = NseCapabilityContext::from_profile(
&profile,
Arc::new(crate::limits::NseResourceCounters::new()),
);
register_dnsbl_library_with_services(lua, &ctx, &NseHostServices::native())
}
pub fn register_dnsbl_library_with_services(
lua: &Lua,
capability_ctx: &NseCapabilityContext,
services: &NseHostServices,
) -> LuaResult<()> {
let globals = lua.globals();
let dnsbl = lua.create_table()?;
let check_fn = lua.create_function({
let cap_ctx = capability_ctx.clone();
let svc = services.clone();
move |lua, (ip, server): (String, Option<String>)| {
let result = lua.create_table()?;
let target = if let Some(srv) = server {
format!("{}.{}", reverse_ip(&ip), srv)
} else {
format!("{}.zen.spamhaus.org", reverse_ip(&ip))
};
match broker_dns_lookup(&cap_ctx, &svc, &target, NseDnsRecordType::A, "dnsbl.check") {
Ok(answer) => {
let (listed, categories, details) = classify_codes(&answer);
result.set("listed", listed)?;
result.set("ip", ip)?;
let cats = lua.create_table()?;
for (i, cat) in categories.iter().enumerate() {
cats.set(i + 1, *cat)?;
}
result.set("categories", cats)?;
result.set("details", details)?;
}
Err(e) => {
tracing::debug!(target = %target, error = %e, "dnsbl.check resolution failed");
result.set("listed", false)?;
result.set("ip", ip)?;
result.set("categories", lua.create_table()?)?;
result.set("details", "Not listed")?;
}
}
Ok(result)
}
})?;
dnsbl.set("check", check_fn.clone())?;
let check_multi_fn = lua.create_function({
let cap_ctx = capability_ctx.clone();
let svc = services.clone();
move |lua, (ip, servers): (String, Option<Table>)| {
let result = lua.create_table()?;
let server_list: Vec<String> = if let Some(srv_table) = servers {
let mut list = Vec::new();
for entry in srv_table.pairs::<i32, String>() {
match entry {
Ok((_, srv)) => list.push(srv),
Err(e) => {
tracing::debug!(error = %e, "dnsbl.check_multi skipped unreadable entry")
}
}
}
if list.is_empty() {
DNSBL_SERVERS.iter().map(|s| s.to_string()).collect()
} else {
list
}
} else {
DNSBL_SERVERS.iter().map(|s| s.to_string()).collect()
};
let mut any_listed = false;
let all_results = lua.create_table()?;
for srv in server_list {
let target = format!("{}.{}", reverse_ip(&ip), srv);
let srv_result = lua.create_table()?;
srv_result.set("server", srv.clone())?;
match broker_dns_lookup(
&cap_ctx,
&svc,
&target,
NseDnsRecordType::A,
"dnsbl.check_multi",
) {
Ok(answer) => {
let (listed, _, _) = classify_codes(&answer);
let categories: Vec<u8> = answer
.addresses()
.iter()
.map(|a| a.to_string())
.filter(|ip_str| ip_str.starts_with("127."))
.filter_map(|ip_str| {
ip_str
.split('.')
.next_back()
.and_then(|s| s.parse::<u8>().ok())
})
.collect();
srv_result.set("listed", listed)?;
let cats = lua.create_table()?;
for (i, code) in categories.iter().enumerate() {
cats.set(i + 1, *code)?;
}
srv_result.set("codes", cats)?;
if listed {
any_listed = true;
}
}
Err(e) => {
tracing::debug!(
target = %target,
error = %e,
"dnsbl.check_multi resolution failed"
);
srv_result.set("listed", false)?;
}
}
let len = all_results.len().unwrap_or(0) as usize;
all_results.set(len + 1, srv_result)?;
}
result.set("ip", ip)?;
result.set("listed", any_listed)?;
result.set("results", all_results)?;
Ok(result)
}
})?;
dnsbl.set("check_multi", check_multi_fn)?;
let get_servers_fn = lua.create_function(|lua, _: ()| {
let servers = lua.create_table()?;
for (i, srv) in DNSBL_SERVERS.iter().enumerate() {
servers.set(i + 1, *srv)?;
}
Ok(servers)
})?;
dnsbl.set("get_servers", get_servers_fn)?;
let get_categories_fn = lua.create_function(|lua, _: ()| {
let categories = lua.create_table()?;
for (name, desc) in DNSBL_CATEGORIES {
let entry = lua.create_table()?;
entry.set("name", *name)?;
entry.set("description", *desc)?;
let len = categories.len().unwrap_or(0) as usize;
categories.set(len + 1, entry)?;
}
Ok(categories)
})?;
dnsbl.set("get_categories", get_categories_fn)?;
let version_fn = lua.create_function(|_lua, _: ()| Ok("1.0.0"))?;
dnsbl.set("version", version_fn)?;
dnsbl.set("check_async", check_fn)?;
globals.set("dnsbl", dnsbl)?;
Ok(())
}