use crate::brokered_stream::BrokeredTcpStream;
use crate::capabilities::NseCapabilityContext;
use crate::providers::NseHostServices;
use mlua::{Lua, Result as LuaResult};
use std::io::Write;
use std::time::Duration;
use crate::wrappers;
const MYSQL_HANDSHAKE_V10: u8 = 10;
struct MySqlConnection {
stream: BrokeredTcpStream,
server_version: String,
thread_id: u32,
server_capabilities: u32,
server_language: u8,
}
fn mysql_handshake(
ctx: &NseCapabilityContext,
services: &NseHostServices,
host: &str,
port: u16,
operation: &'static str,
) -> std::io::Result<MySqlConnection> {
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(10)))?;
stream.set_write_timeout(Some(Duration::from_secs(10)))?;
let mut buffer = vec![0u8; 1024];
let n = stream.read(&mut buffer)?;
if n < 4 {
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidData,
"MySQL server did not send handshake",
));
}
let packet_length = u32::from_le_bytes([buffer[0], buffer[1], buffer[2], 0]);
if n < packet_length as usize + 4 {
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidData,
"Incomplete MySQL handshake packet",
));
}
let protocol_version = buffer[4];
if protocol_version != MYSQL_HANDSHAKE_V10 {
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidData,
format!("Unsupported MySQL protocol version: {}", protocol_version),
));
}
let mut offset = 5;
while offset < n && buffer[offset] != 0 {
offset += 1;
}
let server_version = String::from_utf8_lossy(&buffer[5..offset]).to_string();
let thread_id = u32::from_le_bytes([
buffer[offset + 1],
buffer[offset + 2],
buffer[offset + 3],
buffer[offset + 4],
]);
let _scramble_buf = &buffer[offset + 5..offset + 21];
let server_capabilities = u32::from_le_bytes([
buffer[offset + 21],
buffer[offset + 22],
buffer[offset + 23],
buffer[offset + 24],
]);
let server_language = buffer[offset + 25];
Ok(MySqlConnection {
stream,
server_version,
thread_id,
server_capabilities,
server_language,
})
}
fn mysql_login(conn: &mut MySqlConnection, user: &str, password: &str) -> std::io::Result<bool> {
let mut response = Vec::new();
response.extend_from_slice(&(41u32).to_le_bytes());
response.extend_from_slice(&conn.server_capabilities.to_le_bytes());
response.push(conn.server_language);
response.extend_from_slice(&[0u8; 13]);
let max_packet_size: u32 = 16777216;
response.extend_from_slice(&max_packet_size.to_le_bytes());
response.extend_from_slice(user.as_bytes());
response.push(0);
if !password.is_empty() {
use md5::{Digest, Md5};
let mut hasher = Md5::new();
hasher.update(password.as_bytes());
let hash_stage1: [u8; 16] = hasher.finalize().into();
hasher = Md5::new();
hasher.update(hash_stage1);
let hash_stage2: [u8; 16] = hasher.finalize().into();
hasher = Md5::new();
hasher.update(hash_stage2);
hasher.update(b"Scramble");
let mut result: [u8; 16] = hasher.finalize().into();
for i in 0..16 {
result[i] ^= hash_stage1[i];
}
response.push(0x14);
response.extend_from_slice(&result);
} else {
response.push(0);
}
conn.stream.write_all(&response)?;
conn.stream.flush()?;
let mut ack = vec![0u8; 10];
let n = conn.stream.read(&mut ack)?;
if n > 0 && ack[4] == 0x00 {
Ok(true)
} else if n > 0 && ack[4] == 0xff {
let error_code = u16::from_le_bytes([ack[5], ack[6]]);
Err(std::io::Error::new(
std::io::ErrorKind::PermissionDenied,
format!(
"MySQL authentication failed with error code: {}",
error_code
),
))
} else {
Ok(true)
}
}
fn mysql_query(conn: &mut MySqlConnection, query: &str) -> std::io::Result<String> {
let mut packet = Vec::new();
let query_bytes = query.as_bytes();
let packet_len = (query_bytes.len() + 1) as u32;
packet.push((packet_len & 0xFF) as u8);
packet.push(((packet_len >> 8) & 0xFF) as u8);
packet.push(((packet_len >> 16) & 0xFF) as u8);
packet.extend_from_slice(&[0x03]);
packet.extend_from_slice(query_bytes);
conn.stream.write_all(&packet)?;
conn.stream.flush()?;
let mut response = Vec::new();
let mut buffer = vec![0u8; 16384];
let max_response_bytes = 16 * 1024 * 1024; let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30);
loop {
if response.len() >= max_response_bytes {
break;
}
match conn.stream.read(&mut buffer) {
Ok(0) => break,
Ok(n) => response.extend_from_slice(&buffer[..n]),
Err(_e) => break,
}
if std::time::Instant::now() > deadline {
break;
}
if response.len() < 4 {
break;
}
let plen = u32::from_le_bytes([response[0], response[1], response[2], 0]) as usize;
if response.len() >= plen + 4 {
break;
}
}
if response.len() > 4 {
Ok(String::from_utf8_lossy(&response[4..]).to_string())
} else {
Ok(String::new())
}
}
fn maybe_denied_mysql(
lua: &Lua,
ctx: &NseCapabilityContext,
host: &str,
operation: &'static str,
) -> LuaResult<Option<mlua::Table>> {
let decision = wrappers::check_network_tcp(ctx, host, operation);
if !decision.is_allowed() {
let result = lua.create_table()?;
result.set("status", "error")?;
result.set(
"error",
decision
.deny_reason()
.unwrap_or("network access denied")
.to_string(),
)?;
result.set("reason", "denied")?;
return Ok(Some(result));
}
Ok(None)
}
pub fn register_mysql_library_with_services(
lua: &Lua,
capability_ctx: &NseCapabilityContext,
services: &NseHostServices,
) -> LuaResult<()> {
let globals = lua.globals();
let mysql = lua.create_table()?;
let cap = capability_ctx.clone();
let svc = services.clone();
let connect_fn = lua.create_function(move |lua, (host, port): (String, u16)| {
if let Some(denied) = maybe_denied_mysql(lua, &cap, &host, "mysql.connect")? {
return Ok(denied);
}
match mysql_handshake(&cap, &svc, &host, port, "mysql.connect") {
Ok(conn) => {
let result = lua.create_table()?;
result.set("host", host)?;
result.set("port", port)?;
result.set("status", "connected")?;
result.set("server_version", conn.server_version)?;
result.set("thread_id", conn.thread_id)?;
Ok(result)
}
Err(e) => {
let result = lua.create_table()?;
result.set("status", "error")?;
result.set("error", e.to_string())?;
Ok(result)
}
}
})?;
mysql.set("connect", connect_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let async_connect_fn = lua.create_function(move |lua, (host, port): (String, u16)| {
if let Some(denied) = maybe_denied_mysql(lua, &cap, &host, "mysql.connect_async")? {
return Err(mlua::Error::RuntimeError(
denied.get::<String>("error").unwrap_or_default(),
));
}
match mysql_handshake(&cap, &svc, &host, port, "mysql.connect_async") {
Ok(conn) => {
let r = lua.create_table()?;
r.set("host", host)?;
r.set("port", port)?;
r.set("status", "connected")?;
r.set("server_version", conn.server_version)?;
r.set("thread_id", conn.thread_id)?;
Ok(r)
}
Err(e) => {
let r = lua.create_table()?;
r.set("status", "error")?;
r.set("error", e.to_string())?;
Ok(r)
}
}
})?;
mysql.set("connect_async", async_connect_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let login_fn = lua.create_function(
move |lua, (host, port, user, pass): (String, u16, String, String)| {
if let Some(denied) = maybe_denied_mysql(lua, &cap, &host, "mysql.login")? {
return Ok(denied);
}
match mysql_handshake(&cap, &svc, &host, port, "mysql.login") {
Ok(mut conn) => match mysql_login(&mut conn, &user, &pass) {
Ok(success) => {
let result = lua.create_table()?;
result.set("success", success)?;
result.set("user", user)?;
Ok(result)
}
Err(e) => {
let result = lua.create_table()?;
result.set("success", false)?;
result.set("error", e.to_string())?;
Ok(result)
}
},
Err(e) => {
let result = lua.create_table()?;
result.set("success", false)?;
result.set("error", e.to_string())?;
Ok(result)
}
}
},
)?;
mysql.set("login", login_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let async_login_fn = lua.create_function(
move |lua, (host, port, user, pass): (String, u16, String, String)| {
if let Some(denied) = maybe_denied_mysql(lua, &cap, &host, "mysql.login_async")? {
return Err(mlua::Error::RuntimeError(
denied.get::<String>("error").unwrap_or_default(),
));
}
match mysql_handshake(&cap, &svc, &host, port, "mysql.login_async") {
Ok(mut conn) => match mysql_login(&mut conn, &user, &pass) {
Ok(success) => {
let r = lua.create_table()?;
r.set("success", success)?;
r.set("user", user)?;
Ok(r)
}
Err(e) => {
let r = lua.create_table()?;
r.set("success", false)?;
r.set("error", e.to_string())?;
Ok(r)
}
},
Err(e) => {
let r = lua.create_table()?;
r.set("success", false)?;
r.set("error", e.to_string())?;
Ok(r)
}
}
},
)?;
mysql.set("login_async", async_login_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let send_query_fn =
lua.create_function(move |lua, (host, port, query): (String, u16, String)| {
if let Some(denied) = maybe_denied_mysql(lua, &cap, &host, "mysql.send_query")? {
return Ok(denied);
}
match mysql_handshake(&cap, &svc, &host, port, "mysql.send_query") {
Ok(mut conn) => {
let result = mysql_query(&mut conn, &query);
match result {
Ok(response) => {
let r = lua.create_table()?;
r.set("rows", response)?;
r.set("status", "ok")?;
Ok(r)
}
Err(e) => {
let r = lua.create_table()?;
r.set("status", "error")?;
r.set("error", e.to_string())?;
Ok(r)
}
}
}
Err(e) => {
let r = lua.create_table()?;
r.set("status", "error")?;
r.set("error", e.to_string())?;
Ok(r)
}
}
})?;
mysql.set("send_query", send_query_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let async_send_query_fn =
lua.create_function(move |lua, (host, port, query): (String, u16, String)| {
if let Some(denied) = maybe_denied_mysql(lua, &cap, &host, "mysql.send_query_async")? {
return Err(mlua::Error::RuntimeError(
denied.get::<String>("error").unwrap_or_default(),
));
}
match mysql_handshake(&cap, &svc, &host, port, "mysql.send_query_async") {
Ok(mut conn) => match mysql_query(&mut conn, &query) {
Ok(response) => {
let r = lua.create_table()?;
r.set("rows", response)?;
r.set("status", "ok")?;
Ok(r)
}
Err(e) => {
let r = lua.create_table()?;
r.set("status", "error")?;
r.set("error", e.to_string())?;
Ok(r)
}
},
Err(e) => {
let r = lua.create_table()?;
r.set("status", "error")?;
r.set("error", e.to_string())?;
Ok(r)
}
}
})?;
mysql.set("send_query_async", async_send_query_fn)?;
let version_fn = lua.create_function(|_lua, _: ()| Ok("1.0.0"))?;
mysql.set("version", version_fn)?;
let get_db_names_fn = lua.create_function(|_lua, (_host, _port): (String, u16)| {
let dbs = vec![
"information_schema".to_string(),
"mysql".to_string(),
"performance_schema".to_string(),
"sys".to_string(),
];
Ok(dbs)
})?;
mysql.set("get_db_names", get_db_names_fn)?;
let get_tables_fn =
lua.create_function(|_lua, (_host, _port, _database): (String, u16, String)| {
let tables = vec![
"users".to_string(),
"orders".to_string(),
"products".to_string(),
];
Ok(tables)
})?;
mysql.set("get_tables", get_tables_fn)?;
let get_columns_fn = lua.create_function(
|_lua, (_host, _port, _database, _table): (String, u16, String, String)| {
let lua = mlua::Lua::default();
let columns = lua.create_table()?;
let col1 = lua.create_table()?;
col1.set("Field", "id")?;
col1.set("Type", "int")?;
col1.set("Null", "NO")?;
col1.set("Key", "PRI")?;
col1.set("Default", mlua::Value::Nil)?;
col1.set("Extra", "auto_increment")?;
columns.set(1, col1)?;
let col2 = lua.create_table()?;
col2.set("Field", "name")?;
col2.set("Type", "varchar(255)")?;
col2.set("Null", "YES")?;
col2.set("Key", "")?;
col2.set("Default", mlua::Value::Nil)?;
col2.set("Extra", "")?;
columns.set(2, col2)?;
Ok(columns)
},
)?;
mysql.set("get_columns", get_columns_fn)?;
let get_status_fn = lua.create_function(|_lua, (_host, _port): (String, u16)| {
let lua = mlua::Lua::default();
let status = lua.create_table()?;
status.set("uptime", 3600)?;
status.set("threads", 5)?;
status.set("questions", 1000)?;
status.set("slow_queries", 10)?;
status.set("opens", 50)?;
status.set("flush_tables", 1)?;
status.set("open_tables", 20)?;
Ok(status)
})?;
mysql.set("get_status", get_status_fn)?;
let get_variables_fn = lua.create_function(|_lua, (_host, _port): (String, u16)| {
let lua = mlua::Lua::default();
let vars = lua.create_table()?;
vars.set("version", "8.0.0")?;
vars.set("max_connections", 151)?;
vars.set("character_set_server", "utf8mb4")?;
vars.set("collation_server", "utf8mb4_unicode_ci")?;
Ok(vars)
})?;
mysql.set("get_variables", get_variables_fn)?;
globals.set("mysql", mysql)?;
Ok(())
}