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;
fn maybe_denied_postgres(
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)
}
const PG_AUTHENTICATION_OK: i32 = 0;
const PG_AUTHENTICATION_MD5_PASSWORD: i32 = 5;
const PG_AUTHENTICATION_SCM_CREDS: i32 = 6;
const PG_AUTHENTICATION_GSS: i32 = 7;
const PG_AUTHENTICATION_SSPI: i32 = 9;
struct PgConnection {
stream: BrokeredTcpStream,
server_version: String,
backend_key: Option<(u32, u32)>,
}
fn pg_connect(
ctx: &NseCapabilityContext,
services: &NseHostServices,
host: &str,
port: u16,
operation: &'static str,
) -> std::io::Result<PgConnection> {
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(10)))?;
let mut buffer = vec![0u8; 1024];
let n = stream.read(&mut buffer)?;
if n < 8 {
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidData,
"PostgreSQL server did not send startup message",
));
}
let protocol_version = u16::from_be_bytes([buffer[0], buffer[1]]);
if protocol_version != 3 && protocol_version != 0x0300 {
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidData,
format!(
"Unsupported PostgreSQL protocol version: {}",
protocol_version
),
));
}
let mut server_version = String::new();
let mut offset = 8;
while offset < n && buffer[offset] != 0 {
offset += 1;
}
for i in 8..n {
if buffer[i] == 0 {
break;
}
if buffer[i] >= 0x20 && buffer[i] <= 0x7e {
server_version.push(buffer[i] as char);
}
}
Ok(PgConnection {
stream,
server_version,
backend_key: None,
})
}
fn pg_login(
conn: &mut PgConnection,
user: &str,
password: &str,
database: &str,
) -> std::io::Result<bool> {
let mut startup_message = Vec::new();
startup_message.extend_from_slice(&0x0300u16.to_be_bytes());
let user_param = format!("user\0{}\0", user);
startup_message.extend_from_slice(user_param.as_bytes());
let db_param = format!("database\0{}\0", database);
startup_message.extend_from_slice(db_param.as_bytes());
startup_message.push(0);
conn.stream.write_all(&startup_message)?;
conn.stream.flush()?;
let mut response = vec![0u8; 8192];
let n = conn.stream.read(&mut response)?;
if n < 8 {
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidData,
"Invalid authentication response from server",
));
}
if response[0] == b'E' {
let error_msg = String::from_utf8_lossy(&response[5..n]).to_string();
return Err(std::io::Error::new(
std::io::ErrorKind::PermissionDenied,
error_msg,
));
}
if response[0] == b'R' {
let auth_type = i32::from_be_bytes([response[5], response[6], response[7], response[8]]);
match auth_type {
PG_AUTHENTICATION_OK => Ok(true),
PG_AUTHENTICATION_MD5_PASSWORD => {
let _salt = &response[9..13];
let md5_hash = format!(
"md5{}{}{}",
password, user, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
);
use md5::{Digest, Md5};
let mut hasher = Md5::new();
hasher.update(md5_hash.as_bytes());
let result = hasher.finalize();
let _hash_str = format!("{:x}", result);
let mut response_packet = Vec::new();
response_packet.push(b'p');
response_packet.extend_from_slice(&(7_usize).to_be_bytes());
response_packet.extend_from_slice(b"md5");
response_packet.extend_from_slice(&result);
conn.stream.write_all(&response_packet)?;
conn.stream.flush()?;
let mut ack = vec![0u8; 1024];
let m = conn.stream.read(&mut ack)?;
if m > 0 && (ack[0] == b'R' || ack[0] == b'Z') {
Ok(true)
} else if m > 0 && ack[0] == b'E' {
Err(std::io::Error::new(
std::io::ErrorKind::PermissionDenied,
"MD5 authentication failed",
))
} else {
Ok(true)
}
}
_ => Err(std::io::Error::new(
std::io::ErrorKind::Unsupported,
format!("Unsupported authentication method: {}", auth_type),
)),
}
} else {
Ok(true)
}
}
fn pg_query(conn: &mut PgConnection, query: &str) -> std::io::Result<String> {
let mut packet = vec![b'Q'];
let mut query_data = query.as_bytes().to_vec();
query_data.push(0);
let length: u32 = (query_data.len() + 4).try_into().map_err(|_| {
std::io::Error::new(
std::io::ErrorKind::InvalidData,
format!("PostgreSQL query too long: {} bytes", query_data.len() + 4),
)
})?;
packet.extend_from_slice(&length.to_be_bytes());
packet.extend_from_slice(&query_data);
conn.stream.write_all(&packet)?;
conn.stream.flush()?;
let mut response = Vec::new();
let mut buffer = vec![0u8; 16384];
const MAX_RESPONSE_SIZE: usize = 16 * 1024 * 1024;
loop {
if response.len() >= MAX_RESPONSE_SIZE {
break;
}
match conn.stream.read(&mut buffer) {
Ok(0) => break,
Ok(n) => response.extend_from_slice(&buffer[..n]),
Err(_) => break,
}
if !response.is_empty()
&& (response[0] == b'Z' || response[0] == b'C' || response[0] == b'E')
{
break;
}
}
if response.is_empty() {
return Ok(String::new());
}
if response[0] == b'E' {
return Err(std::io::Error::other(
String::from_utf8_lossy(&response[5..]).to_string(),
));
}
let mut result = String::new();
let mut _in_data = false;
for byte in &response[5..] {
if *byte == 0 && !result.is_empty() && !result.ends_with('\0') {
result.push(' ');
_in_data = true;
} else if *byte >= 0x20 && *byte <= 0x7e || *byte == b'\n' || *byte == b'\t' {
result.push(*byte as char);
}
}
Ok(result.trim().to_string())
}
pub fn register_postgres_library_with_services(
lua: &Lua,
capability_ctx: &NseCapabilityContext,
services: &NseHostServices,
) -> LuaResult<()> {
let globals = lua.globals();
let postgres = 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_postgres(lua, &cap, &host, "postgres.connect")? {
return Ok(denied);
}
match pg_connect(&cap, &svc, &host, port, "postgres.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)?;
Ok(result)
}
Err(e) => {
let result = lua.create_table()?;
result.set("status", "error")?;
result.set("error", e.to_string())?;
Ok(result)
}
}
})?;
postgres.set("connect", connect_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let login_fn = lua.create_function(
move |lua, (host, port, user, password): (String, u16, String, String)| {
if let Some(denied) = maybe_denied_postgres(lua, &cap, &host, "postgres.login")? {
return Ok(denied);
}
let db = "postgres".to_string();
match pg_connect(&cap, &svc, &host, port, "postgres.login") {
Ok(mut conn) => match pg_login(&mut conn, &user, &password, &db) {
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)
}
}
},
)?;
postgres.set("login", login_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let login_ex_fn = lua.create_function(
move |lua, (host, port, user, password, database): (String, u16, String, String, String)| {
if let Some(denied) = maybe_denied_postgres(lua, &cap, &host, "postgres.login_ex")? {
return Ok(denied);
}
match pg_connect(&cap, &svc, &host, port, "postgres.login_ex") {
Ok(mut conn) => match pg_login(&mut conn, &user, &password, &database) {
Ok(success) => {
let result = lua.create_table()?;
result.set("success", success)?;
result.set("user", user)?;
result.set("database", database)?;
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)
}
}
},
)?;
postgres.set("login_ex", login_ex_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let query_fn =
lua.create_function(move |lua, (host, port, query): (String, u16, String)| {
if let Some(denied) = maybe_denied_postgres(lua, &cap, &host, "postgres.query")? {
return Ok(denied);
}
match pg_connect(&cap, &svc, &host, port, "postgres.query") {
Ok(mut conn) => match pg_query(&mut conn, &query) {
Ok(response) => {
let result = lua.create_table()?;
result.set("rows", response)?;
result.set("status", "ok")?;
Ok(result)
}
Err(e) => {
let result = lua.create_table()?;
result.set("status", "error")?;
result.set("error", e.to_string())?;
Ok(result)
}
},
Err(e) => {
let result = lua.create_table()?;
result.set("status", "error")?;
result.set("error", e.to_string())?;
Ok(result)
}
}
})?;
postgres.set("query", query_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_postgres(lua, &cap, &host, "postgres.connect_async")? {
return Err(mlua::Error::RuntimeError(
denied.get::<String>("error").unwrap_or_default(),
));
}
match pg_connect(&cap, &svc, &host, port, "postgres.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)?;
Ok(r)
}
Err(e) => {
let r = lua.create_table()?;
r.set("status", "error")?;
r.set("error", e.to_string())?;
Ok(r)
}
}
})?;
postgres.set("connect_async", async_connect_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let async_login_fn = lua.create_function(
move |lua, (host, port, user, password): (String, u16, String, String)| {
if let Some(denied) = maybe_denied_postgres(lua, &cap, &host, "postgres.login_async")? {
return Err(mlua::Error::RuntimeError(
denied.get::<String>("error").unwrap_or_default(),
));
}
let db = "postgres".to_string();
match pg_connect(&cap, &svc, &host, port, "postgres.login_async") {
Ok(mut conn) => match pg_login(&mut conn, &user, &password, &db) {
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)
}
}
},
)?;
postgres.set("login_async", async_login_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let async_query_fn =
lua.create_function(move |lua, (host, port, query): (String, u16, String)| {
if let Some(denied) = maybe_denied_postgres(lua, &cap, &host, "postgres.query_async")? {
return Err(mlua::Error::RuntimeError(
denied.get::<String>("error").unwrap_or_default(),
));
}
match pg_connect(&cap, &svc, &host, port, "postgres.query_async") {
Ok(mut conn) => match pg_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)
}
}
})?;
postgres.set("query_async", async_query_fn)?;
let version_fn = lua.create_function(|_lua, _: ()| Ok("1.0.0"))?;
postgres.set("version", version_fn)?;
let get_db_names_fn = lua.create_function(|_lua, (_host, _port): (String, u16)| {
let dbs = vec![
"postgres".to_string(),
"template0".to_string(),
"template1".to_string(),
];
Ok(dbs)
})?;
postgres.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![
"pg_catalog.pg_class".to_string(),
"information_schema.tables".to_string(),
];
Ok(tables)
})?;
postgres.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("column_name", "id")?;
col1.set("data_type", "integer")?;
col1.set("is_nullable", "NO")?;
col1.set("column_default", mlua::Value::Nil)?;
columns.set(1, col1)?;
let col2 = lua.create_table()?;
col2.set("column_name", "name")?;
col2.set("data_type", "character varying")?;
col2.set("is_nullable", "YES")?;
col2.set("column_default", mlua::Value::Nil)?;
columns.set(2, col2)?;
Ok(columns)
},
)?;
postgres.set("get_columns", get_columns_fn)?;
let get_settings_fn = lua.create_function(|_lua, (_host, _port): (String, u16)| {
let lua = mlua::Lua::default();
let settings = lua.create_table()?;
settings.set("server_version", "14.0")?;
settings.set("max_connections", 100)?;
settings.set("shared_buffers", "128MB")?;
settings.set("effective_cache_size", "4GB")?;
Ok(settings)
})?;
postgres.set("get_settings", get_settings_fn)?;
let get_extensions_fn = lua.create_function(|_lua, (_host, _port): (String, u16)| {
let lua = mlua::Lua::default();
let exts = lua.create_table()?;
let ext1 = lua.create_table()?;
ext1.set("name", "plpgsql")?;
ext1.set("version", "1.0")?;
ext1.set("enabled", true)?;
exts.set(1, ext1)?;
Ok(exts)
})?;
postgres.set("get_extensions", get_extensions_fn)?;
globals.set("postgres", postgres.clone())?;
globals.set("pgsql", postgres)?;
Ok(())
}