use futures_util::{SinkExt, StreamExt};
use tinyscram::ClientSession;
use tokio::net::TcpStream;
use tokio_util::codec::Framed;
use crate::errors;
use crate::proto::backend::BackendMessage;
use crate::proto::codec::BackendCodec;
use crate::proto::frontend::FrontendMessage;
use super::server::map_scram;
fn sasl_initial_response(client_first: &[u8]) -> Vec<u8> {
let mechanism = b"SCRAM-SHA-256\0";
let mut buf = Vec::with_capacity(mechanism.len() + 4 + client_first.len());
buf.extend_from_slice(mechanism);
buf.extend_from_slice(&(client_first.len() as i32).to_be_bytes());
buf.extend_from_slice(client_first);
buf
}
pub async fn authenticate(
framed: &mut Framed<TcpStream, BackendCodec>,
password: &str,
) -> Result<(), errors::AuthError> {
let mut session = ClientSession::new("", password);
let client_first = session.client_first();
framed
.send(FrontendMessage::PasswordMessage(sasl_initial_response(
&client_first,
)))
.await?;
let server_first = match framed.next().await.transpose()? {
Some(BackendMessage::AuthenticationSaslContinue { data }) => data,
Some(BackendMessage::ErrorResponse(err)) => {
return Err(errors::AuthError::VerifierFetch(format!(
"SCRAM auth error: {}",
err.message().unwrap_or("unknown")
)));
}
other => {
return Err(errors::AuthError::Protocol(format!(
"expected AuthenticationSASLContinue, got {other:?}"
)));
}
};
let (mut session, client_final) = tokio::task::spawn_blocking(move || {
let mut s = session;
let result = s.handle_server_first(&server_first);
(s, result)
})
.await
.map_err(|e| errors::AuthError::Protocol(format!("pbkdf2 task failed: {e}")))?;
let client_final = client_final.map_err(map_scram)?;
framed
.send(FrontendMessage::PasswordMessage(client_final))
.await?;
match framed.next().await.transpose()? {
Some(BackendMessage::AuthenticationSaslFinal { data }) => {
session.handle_server_final(&data).map_err(map_scram)?;
}
Some(BackendMessage::ErrorResponse(err)) => {
return Err(errors::AuthError::VerifierFetch(format!(
"SCRAM auth failed: {}",
err.message().unwrap_or("unknown")
)));
}
other => {
return Err(errors::AuthError::Protocol(format!(
"expected AuthenticationSASLFinal, got {other:?}"
)));
}
}
match framed.next().await.transpose()? {
Some(BackendMessage::AuthenticationOk) => Ok(()),
Some(BackendMessage::ErrorResponse(err)) => Err(errors::AuthError::VerifierFetch(format!(
"auth failed after SCRAM: {}",
err.message().unwrap_or("unknown")
))),
other => Err(errors::AuthError::Protocol(format!(
"expected AuthenticationOk, got {other:?}"
))),
}
}