use crate::error::{Error, Result};
use base64::{engine::general_purpose::STANDARD as B64, Engine};
use credssp::{CredSspClient, CredSspStep, Credentials, ServiceTicket};
pub const CREDSSP_SCHEME: &str = "CredSSP";
#[derive(Debug)]
pub enum PumpStep {
Send(Vec<u8>),
Done,
}
pub struct CredSspPump {
inner: CredSspClient,
done: bool,
}
impl CredSspPump {
pub fn ntlm(user: &str, pass: &str, target_spn: &str, server_pubkey: Vec<u8>) -> Self {
let (domain, user) = crate::auth::split_user(user);
let creds = Credentials::ntlm(&domain, &user, pass, "WORKSTATION");
let inner = CredSspClient::new(creds, target_spn.to_string(), server_pubkey);
Self { inner, done: false }
}
pub fn kerberos(
realm: &str,
user: &str,
target_spn: &str,
server_pubkey: Vec<u8>,
ticket: ServiceTicket,
) -> Self {
let creds = Credentials::kerberos(realm, user, "WORKSTATION");
let inner = CredSspClient::with_kerberos_ticket(
creds,
target_spn.to_string(),
server_pubkey,
ticket,
);
Self { inner, done: false }
}
pub fn next(&mut self, server_reply: Option<&[u8]>) -> Result<PumpStep> {
if self.done {
return Ok(PumpStep::Done);
}
match self.inner.step(server_reply) {
CredSspStep::SendToken(bytes) => Ok(PumpStep::Send(bytes)),
CredSspStep::Done => {
self.done = true;
Ok(PumpStep::Done)
}
CredSspStep::Error(msg) => Err(Error::CredSsp(msg)),
}
}
pub fn is_done(&self) -> bool {
self.done
}
#[doc(hidden)]
pub fn set_krb_subkey_for_testing(&mut self, key: [u8; 32]) {
self.inner.set_krb_subkey_for_testing(key);
}
}
pub fn credssp_header(tsrequest: &[u8]) -> String {
format!("{CREDSSP_SCHEME} {}", B64.encode(tsrequest))
}
pub fn parse_credssp_header(www_authenticate: &str) -> Result<Vec<u8>> {
for part in www_authenticate.split(',') {
let part = part.trim();
if let Some(rest) = part.strip_prefix(CREDSSP_SCHEME) {
let rest = rest.trim();
if rest.is_empty() {
return Ok(Vec::new());
}
return B64.decode(rest).map_err(Error::from);
}
}
Err(Error::Auth(format!(
"no CredSSP token in {www_authenticate:?}"
)))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn header_roundtrips_via_parse() {
let bytes = b"\x30\x82\x00\x0Adummy-tsreq";
let hdr = credssp_header(bytes);
assert!(hdr.starts_with("CredSSP "));
let back = parse_credssp_header(&hdr).unwrap();
assert_eq!(back, bytes);
}
#[test]
fn parse_credssp_header_handles_multi_scheme() {
let bytes = b"abcd";
let hdr = format!("Negotiate, CredSSP {}", B64.encode(bytes));
let back = parse_credssp_header(&hdr).unwrap();
assert_eq!(back, bytes);
}
#[test]
fn parse_credssp_header_bare_scheme_yields_empty() {
let back = parse_credssp_header("CredSSP").unwrap();
assert!(back.is_empty());
}
#[test]
fn parse_credssp_header_rejects_missing_scheme() {
assert!(parse_credssp_header("Negotiate xyz").is_err());
}
}