pub mod cms;
pub(crate) mod der_walk;
pub mod dh;
pub mod enveloped;
pub mod error;
pub mod kdf;
#[cfg(feature = "network")]
pub mod network;
pub mod oid;
pub mod pac;
pub mod pkinit;
pub use error::{Error, Result};
use der::asn1::GeneralizedTime;
use der::DecodePem;
use rsa::{pkcs1::DecodeRsaPrivateKey, pkcs8::DecodePrivateKey, RsaPrivateKey};
use x509_cert::Certificate;
#[derive(Debug, Clone, Default)]
pub struct AsRepResult {
pub ticket: Vec<u8>,
pub session_key: Vec<u8>,
pub pac_credential_info: Option<Vec<u8>>,
pub debug_as_req_der: Vec<u8>,
}
#[derive(Debug, Clone)]
pub struct PkinitClient {
pub realm: String,
pub kdc: String,
}
impl PkinitClient {
pub fn new(realm: impl Into<String>, kdc: impl Into<String>) -> Self {
Self {
realm: realm.into(),
kdc: kdc.into(),
}
}
pub fn request_tgt_with_cert(
&self,
cert_pem: &[u8],
key_pem: &[u8],
upn: &str,
) -> Result<AsRepResult> {
let cert = Certificate::from_pem(cert_pem)
.map_err(|e| Error::X509(format!("parse client cert: {e}")))?;
let key = load_rsa_key(key_pem)?;
let ctime = GeneralizedTime::from_date_time(
der::DateTime::new(2026, 1, 1, 0, 0, 0)
.map_err(|e| Error::Unsupported(format!("time: {e}")))?,
);
let nonce: u32 = 0xDEADBEEF;
#[cfg(feature = "network")]
{
let till = picky_asn1::date::GeneralizedTime::new(2038, 1, 1, 0, 0, 0)
.ok_or_else(|| Error::Unsupported("till time out of range".into()))?;
let etypes: [i32; 3] = [18, 17, 23]; let cname_parts = [upn];
let realm_upper = self.realm.to_ascii_uppercase();
let sname_parts: [&str; 2] = ["krbtgt", &realm_upper];
let mut req_opts = network::AsReqOpts {
realm: &self.realm,
cname: &cname_parts,
sname: &sname_parts,
pa_pk_as_req_der: &[], nonce,
till: picky_asn1::wrapper::GeneralizedTimeAsn1::from(till),
etypes: &etypes,
};
let body_sha1 = network::compute_as_req_body_checksum(&req_opts)?;
let opts = pkinit::BuildOptions {
client_cert: &cert,
client_key: &key,
dh_group: dh::DhGroup::Modp2048,
as_req_body_checksum: Some(body_sha1.to_vec()),
ctime,
cusec: 0,
nonce,
};
let (pa_pk_as_req_der, dh) = pkinit::build_pa_pk_as_req(&opts)?;
req_opts.pa_pk_as_req_der = &pa_pk_as_req_der;
let req = network::build_as_req(&req_opts)?;
let reply = network::tcp_exchange(&self.kdc, &req, std::time::Duration::from_secs(15))?;
let key_bytes_for_etype = 32; let mut out = network::process_as_rep(&reply, &dh, &key, nonce, key_bytes_for_etype)?;
out.debug_as_req_der = pa_pk_as_req_der;
return Ok(out);
}
#[cfg(not(feature = "network"))]
{
let opts = pkinit::BuildOptions {
client_cert: &cert,
client_key: &key,
dh_group: dh::DhGroup::Modp2048,
as_req_body_checksum: None,
ctime,
cusec: 0,
nonce,
};
let (pa_pk_as_req_der, _dh) = pkinit::build_pa_pk_as_req(&opts)?;
let _ = upn;
return Ok(AsRepResult {
ticket: Vec::new(),
session_key: Vec::new(),
pac_credential_info: None,
debug_as_req_der: pa_pk_as_req_der,
});
}
}
pub fn request_tgt_with_pfx(&self, _pfx: &[u8], _password: &str) -> Result<AsRepResult> {
Err(Error::PfxUnsupported)
}
}
pub fn unpac_the_hash(decrypted_credential_data: &[u8]) -> Result<[u8; 16]> {
pac::extract_nt_hash_from_credential_data(decrypted_credential_data)
}
pub fn unpac_the_hash_from_asrep(rep: &AsRepResult) -> Result<[u8; 16]> {
let blob = rep
.pac_credential_info
.as_deref()
.ok_or_else(|| Error::PacParse("AsRepResult carries no PAC_CREDENTIAL_INFO".into()))?;
unpac_the_hash(blob)
}
fn load_rsa_key(pem: &[u8]) -> Result<RsaPrivateKey> {
let s = std::str::from_utf8(pem).map_err(|e| Error::Pem(e.to_string()))?;
if let Ok(k) = RsaPrivateKey::from_pkcs8_pem(s) {
return Ok(k);
}
RsaPrivateKey::from_pkcs1_pem(s).map_err(|e| Error::Pem(format!("RSA key: {e}")))
}