use crate::client::KU_AP_REQ_AUTH;
use crate::der::{
application_tag, context_tag, one_or, read_u32, Der, DerError, TAG_BIT_STRING, TAG_SEQUENCE,
};
use crate::keys::{KerberosKey, KeyError};
use crate::messages::Ticket;
use crate::types::{Checksum, EncryptedData, EncryptionKey, KerberosTime, PrincipalName};
use std::collections::HashMap;
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ApReq {
pub pvno: i32,
pub msg_type: i32,
pub ap_options: u32,
pub ticket: Ticket,
pub enc_auth: EncryptedData,
}
pub fn parse_ap_req(der: &[u8]) -> Result<ApReq, DerError> {
let mut r = Der::new(der);
let (tag, inner) = r.read_tlv()?;
if tag != application_tag(14) {
return Err(DerError::TagMismatch {
expected: application_tag(14),
found: tag,
});
}
let seq = one_or(inner, TAG_SEQUENCE)?;
let mut sr = Der::new(seq);
let pvno = read_i32(sr.expect(context_tag(0))?)?;
let msg_type = read_i32(sr.expect(context_tag(1))?)?;
if pvno != 5 || msg_type != 14 {
return Err(DerError::MsgTypeMismatch);
}
let opt_bytes = one_or(sr.expect(context_tag(2))?, TAG_BIT_STRING)?;
if opt_bytes.len() < 5 {
return Err(DerError::Truncated);
}
let ap_options = u32::from_be_bytes([opt_bytes[1], opt_bytes[2], opt_bytes[3], opt_bytes[4]]);
let ticket = Ticket::decode(sr.expect(context_tag(3))?)?;
let enc_auth = EncryptedData::decode(sr.expect(context_tag(4))?)?;
Ok(ApReq {
pvno,
msg_type,
ap_options,
ticket,
enc_auth,
})
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Authenticator {
pub authenticator_vno: i32,
pub crealm: String,
pub cname: PrincipalName,
pub cksum: Option<Checksum>,
pub cusec: i32,
pub ctime: String,
pub subkey: Option<EncryptionKey>,
pub seq_number: Option<u32>,
}
pub fn parse_authenticator(plaintext: &[u8]) -> Result<Authenticator, DerError> {
let mut r = Der::new(plaintext);
let (tag, inner) = r.read_tlv()?;
if tag != application_tag(2) {
return Err(DerError::TagMismatch {
expected: application_tag(2),
found: tag,
});
}
let seq = one_or(inner, TAG_SEQUENCE)?;
let mut sr = Der::new(seq);
let authenticator_vno = read_i32(sr.expect(context_tag(0))?)?;
if authenticator_vno != 5 {
return Err(DerError::BadProtocolVersion);
}
let crealm = crate::types::decode_realm(sr.expect(context_tag(1))?)?;
let cname = PrincipalName::decode(sr.expect(context_tag(2))?)?;
let cksum = if sr.peek_tag() == Some(context_tag(3)) {
Some(Checksum::decode(sr.expect(context_tag(3))?)?)
} else {
None
};
let cusec = read_i32(sr.expect(context_tag(4))?)?;
let ctime = KerberosTime::decode(sr.expect(context_tag(5))?)?.0;
let subkey = if sr.peek_tag() == Some(context_tag(6)) {
Some(EncryptionKey::decode(sr.expect(context_tag(6))?)?)
} else {
None
};
let seq_number = if sr.peek_tag() == Some(context_tag(7)) {
Some(read_u32(sr.expect(context_tag(7))?)?)
} else {
None
};
Ok(Authenticator {
authenticator_vno,
crealm,
cname,
cksum,
cusec,
ctime,
subkey,
seq_number,
})
}
pub trait ReplayCache {
fn remember(&mut self, id: [u8; 32], expires_at: u64) -> Result<(), Replay>;
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Replay;
#[derive(Debug, Default)]
pub struct HashSetReplayCache {
seen: HashMap<[u8; 32], u64>,
}
impl HashSetReplayCache {
#[must_use]
pub fn new() -> Self {
Self::default()
}
pub fn expire(&mut self, now_secs: u64) {
self.seen.retain(|_, exp| *exp > now_secs);
}
#[must_use]
pub fn len(&self) -> usize {
self.seen.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.seen.is_empty()
}
}
impl ReplayCache for HashSetReplayCache {
fn remember(&mut self, id: [u8; 32], expires_at: u64) -> Result<(), Replay> {
if self.seen.contains_key(&id) {
return Err(Replay);
}
self.seen.insert(id, expires_at);
Ok(())
}
}
#[derive(Debug, Default, Clone, Copy)]
pub struct NoopReplayCache;
impl ReplayCache for NoopReplayCache {
fn remember(&mut self, _id: [u8; 32], _expires_at: u64) -> Result<(), Replay> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AuthContext {
pub authenticator: Authenticator,
pub client_realm: String,
pub client_principal: PrincipalName,
pub subkey: Option<EncryptionKey>,
pub sequence_number: Option<u32>,
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AcceptorError {
Decrypt(&'static str),
TicketDecrypt(&'static str),
BadTicket(DerError),
TicketExpired {
endtime: String,
now_secs: u64,
},
PrincipalMismatch,
BadAuthenticator(DerError),
ClockSkewExceeded {
ctime: String,
now_secs: u64,
allowed_skew_seconds: u64,
},
BadClientTime(String),
Replay,
}
impl std::fmt::Display for AcceptorError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
AcceptorError::Decrypt(s) => write!(f, "authenticator decrypt failed: {s}"),
AcceptorError::TicketDecrypt(s) => write!(f, "ticket decrypt failed: {s}"),
AcceptorError::BadTicket(e) => write!(f, "ticket parse: {e:?}"),
AcceptorError::TicketExpired { endtime, now_secs } => {
write!(f, "ticket endtime {endtime} <= now={now_secs}")
}
AcceptorError::PrincipalMismatch => {
write!(f, "authenticator principal does not match ticket principal")
}
AcceptorError::BadAuthenticator(e) => write!(f, "authenticator parse: {e:?}"),
AcceptorError::ClockSkewExceeded {
ctime,
now_secs,
allowed_skew_seconds,
} => write!(
f,
"authenticator ctime {ctime} outside {allowed_skew_seconds}s of now={now_secs}"
),
AcceptorError::BadClientTime(s) => write!(f, "malformed ctime: {s}"),
AcceptorError::Replay => write!(f, "AP-REQ replay rejected"),
}
}
}
impl std::error::Error for AcceptorError {}
impl From<KeyError> for AcceptorError {
fn from(_: KeyError) -> Self {
AcceptorError::Decrypt("KeyError from KerberosKey::decrypt")
}
}
pub fn verify_ap_req<C: ReplayCache>(
ap_req: &ApReq,
session_key: &KerberosKey,
clock_skew_seconds: u64,
now_secs: u64,
replay_cache: &mut C,
) -> Result<AuthContext, AcceptorError> {
let plaintext = session_key
.decrypt(KU_AP_REQ_AUTH, &ap_req.enc_auth.cipher)
.map_err(AcceptorError::from)?;
let authenticator =
parse_authenticator(&plaintext).map_err(AcceptorError::BadAuthenticator)?;
let ctime_secs = parse_kerberos_time(&authenticator.ctime)
.ok_or_else(|| AcceptorError::BadClientTime(authenticator.ctime.clone()))?;
let skew = clock_skew_seconds as i64;
let delta = ctime_secs as i64 - now_secs as i64;
if delta.abs() > skew {
return Err(AcceptorError::ClockSkewExceeded {
ctime: authenticator.ctime.clone(),
now_secs,
allowed_skew_seconds: clock_skew_seconds,
});
}
let id = replay_id(&authenticator);
replay_cache
.remember(id, now_secs.saturating_add(clock_skew_seconds))
.map_err(|_| AcceptorError::Replay)?;
Ok(AuthContext {
subkey: authenticator.subkey.clone(),
sequence_number: authenticator.seq_number,
client_realm: authenticator.crealm.clone(),
client_principal: authenticator.cname.clone(),
authenticator,
})
}
fn replay_id(a: &Authenticator) -> [u8; 32] {
use sha2::{Digest, Sha256};
let mut h = Sha256::new();
for comp in &a.cname.name_string {
h.update(comp.as_bytes());
h.update([0x1f]);
}
h.update(a.crealm.as_bytes());
h.update([0x1e]); h.update(a.ctime.as_bytes());
h.update([0x1e]);
h.update((a.cusec as i64).to_be_bytes());
h.finalize().into()
}
fn parse_kerberos_time(s: &str) -> Option<u64> {
if s.len() != 15 || !s.ends_with('Z') {
return None;
}
let n = |a: usize, b: usize| s[a..b].parse::<u32>().ok();
let y = n(0, 4)? as i64;
let mo = n(4, 6)? as i64;
let d = n(6, 8)? as i64;
let h = n(8, 10)? as i64;
let mi = n(10, 12)? as i64;
let se = n(12, 14)? as i64;
if !(1..=12).contains(&mo) || !(1..=31).contains(&d) || h > 23 || mi > 59 || se > 60 {
return None;
}
let y2 = y - i64::from(mo <= 2);
let era = if y2 >= 0 { y2 } else { y2 - 399 } / 400;
let yoe = y2 - era * 400;
let doy = (153 * (mo + if mo > 2 { -3 } else { 9 }) + 2) / 5 + d - 1;
let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
let days = era * 146_097 + doe - 719_468;
let secs = days * 86_400 + h * 3600 + mi * 60 + se;
if secs < 0 {
None
} else {
Some(secs as u64)
}
}
fn read_i32(der: &[u8]) -> Result<i32, DerError> {
let mut r = Der::new(der);
let n = r.read_integer()?;
r.finish()?;
i32::try_from(n).map_err(|_| DerError::IntTooLarge)
}
pub const KU_TICKET: u32 = 2;
#[non_exhaustive]
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct EncTicketPart {
pub flags: u32,
pub key: EncryptionKey,
pub crealm: String,
pub cname: PrincipalName,
pub authtime: String,
pub starttime: Option<String>,
pub endtime: String,
pub renew_till: Option<String>,
pub authorization_data: Vec<u8>,
}
pub fn parse_enc_ticket_part(plaintext: &[u8]) -> Result<EncTicketPart, DerError> {
let mut r = Der::new(plaintext);
let (tag, inner) = r.read_tlv()?;
if tag != application_tag(3) {
return Err(DerError::TagMismatch {
expected: application_tag(3),
found: tag,
});
}
let seq = one_or(inner, TAG_SEQUENCE)?;
let mut sr = Der::new(seq);
let flags_bytes = one_or(sr.expect(context_tag(0))?, TAG_BIT_STRING)?;
if flags_bytes.len() < 5 {
return Err(DerError::Truncated);
}
let flags = u32::from_be_bytes([
flags_bytes[1],
flags_bytes[2],
flags_bytes[3],
flags_bytes[4],
]);
let key = EncryptionKey::decode(sr.expect(context_tag(1))?)?;
let crealm = crate::types::decode_realm(sr.expect(context_tag(2))?)?;
let cname = PrincipalName::decode(sr.expect(context_tag(3))?)?;
let _transited = sr.expect(context_tag(4))?;
let authtime = KerberosTime::decode(sr.expect(context_tag(5))?)?.0;
let starttime = if sr.peek_tag() == Some(context_tag(6)) {
Some(KerberosTime::decode(sr.expect(context_tag(6))?)?.0)
} else {
None
};
let endtime = KerberosTime::decode(sr.expect(context_tag(7))?)?.0;
let renew_till = if sr.peek_tag() == Some(context_tag(8)) {
Some(KerberosTime::decode(sr.expect(context_tag(8))?)?.0)
} else {
None
};
if sr.peek_tag() == Some(context_tag(9)) {
let _ = sr.expect(context_tag(9))?;
}
let authorization_data = if sr.peek_tag() == Some(context_tag(10)) {
sr.expect(context_tag(10))?.to_vec()
} else {
Vec::new()
};
Ok(EncTicketPart {
flags,
key,
crealm,
cname,
authtime,
starttime,
endtime,
renew_till,
authorization_data,
})
}
pub fn decrypt_ticket(
ap_req: &ApReq,
service_key: &KerberosKey,
) -> Result<EncTicketPart, AcceptorError> {
let plaintext = service_key
.decrypt(KU_TICKET, &ap_req.ticket.enc_part.cipher)
.map_err(|_| AcceptorError::TicketDecrypt("service key rejected ticket ciphertext"))?;
parse_enc_ticket_part(&plaintext).map_err(AcceptorError::BadTicket)
}
pub fn verify_ap_req_full<C: ReplayCache>(
ap_req: &ApReq,
service_key: &KerberosKey,
clock_skew_seconds: u64,
now_secs: u64,
replay_cache: &mut C,
) -> Result<(AuthContext, EncTicketPart), AcceptorError> {
let enc_ticket = decrypt_ticket(ap_req, service_key)?;
let endtime_secs = parse_kerberos_time(&enc_ticket.endtime)
.ok_or_else(|| AcceptorError::BadClientTime(enc_ticket.endtime.clone()))?;
if endtime_secs <= now_secs {
return Err(AcceptorError::TicketExpired {
endtime: enc_ticket.endtime.clone(),
now_secs,
});
}
let session = KerberosKey::from_i32(enc_ticket.key.keytype, enc_ticket.key.keyvalue.clone())
.map_err(AcceptorError::from)?;
let ctx = verify_ap_req(ap_req, &session, clock_skew_seconds, now_secs, replay_cache)?;
if ctx.client_realm != enc_ticket.crealm || ctx.client_principal != enc_ticket.cname {
return Err(AcceptorError::PrincipalMismatch);
}
Ok((ctx, enc_ticket))
}
pub fn build_ap_rep_with_confounder(
session_key: &KerberosKey,
client_authenticator: &Authenticator,
subkey: Option<&EncryptionKey>,
seq_number: Option<u32>,
confounder: &[u8],
) -> Vec<u8> {
use crate::client::KU_AP_REP_ENC_PART;
use crate::der::{encode_integer, encode_sequence, explicit, tlv};
let mut inner = explicit(0, &KerberosTime(client_authenticator.ctime.clone()).encode());
inner.extend_from_slice(&explicit(
1,
&encode_integer(client_authenticator.cusec as i64),
));
if let Some(sk) = subkey {
inner.extend_from_slice(&explicit(2, &sk.encode()));
}
if let Some(n) = seq_number {
inner.extend_from_slice(&explicit(3, &encode_integer(n as i64)));
}
let enc_ap_rep_part = tlv(application_tag(27), &encode_sequence(&inner));
let cipher = session_key.encrypt_with_confounder(
KU_AP_REP_ENC_PART,
confounder,
&enc_ap_rep_part,
);
let enc_part = EncryptedData {
etype: session_key.enctype().to_i32(),
kvno: None,
cipher,
};
let body = [
explicit(0, &encode_integer(5)),
explicit(1, &encode_integer(15)),
explicit(2, &enc_part.encode()),
]
.concat();
tlv(application_tag(15), &encode_sequence(&body))
}
pub fn build_ap_rep(
session_key: &KerberosKey,
client_authenticator: &Authenticator,
subkey: Option<&EncryptionKey>,
seq_number: Option<u32>,
) -> Vec<u8> {
let mut conf = vec![0u8; session_key.enctype().confounder_len()];
getrandom::getrandom(&mut conf)
.expect("OS CSPRNG available for AP-REP confounder");
build_ap_rep_with_confounder(session_key, client_authenticator, subkey, seq_number, &conf)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::client::{build_ap_req_with_confounder, AP_OPTS_MUTUAL_REQUIRED};
use crate::keys::Enctype;
use crate::messages::Ticket;
fn ticket_stub() -> Ticket {
Ticket {
tkt_vno: 5,
realm: "CORP.LOCAL".into(),
sname: PrincipalName {
name_type: 2,
name_string: vec!["HTTP".into(), "web.corp.local".into()],
},
enc_part: EncryptedData {
etype: 18,
kvno: None,
cipher: vec![0u8; 32], },
}
}
fn make_ap_req(session_key: &KerberosKey, ctime: &str, cusec: i32) -> Vec<u8> {
build_ap_req_with_confounder(
&ticket_stub(),
session_key,
"CORP.LOCAL",
&PrincipalName {
name_type: 1,
name_string: vec!["alice".into()],
},
ctime,
cusec,
AP_OPTS_MUTUAL_REQUIRED,
None,
None,
None,
&[0u8; 16], )
}
fn key() -> KerberosKey {
KerberosKey::new(Enctype::Aes256CtsHmacSha1_96, vec![0x42u8; 32]).unwrap()
}
#[test]
fn ap_req_round_trips_through_parse() {
let k = key();
let der = make_ap_req(&k, "20260101120000Z", 0);
let parsed = parse_ap_req(&der).unwrap();
assert_eq!(parsed.pvno, 5);
assert_eq!(parsed.msg_type, 14);
assert_eq!(parsed.ap_options, AP_OPTS_MUTUAL_REQUIRED);
assert_eq!(parsed.ticket.sname.name_string[0], "HTTP");
}
#[test]
fn verify_ap_req_happy_path() {
let k = key();
let now: u64 = 1_767_268_800;
let der = make_ap_req(&k, "20260101120000Z", 0);
let ap = parse_ap_req(&der).unwrap();
let mut cache = HashSetReplayCache::new();
let ctx = verify_ap_req(&ap, &k, 300, now, &mut cache).unwrap();
assert_eq!(ctx.client_realm, "CORP.LOCAL");
assert_eq!(ctx.client_principal.name_string[0], "alice");
assert_eq!(cache.len(), 1);
}
#[test]
fn verify_ap_req_rejects_wrong_key() {
let k = key();
let now: u64 = 1_767_268_800;
let der = make_ap_req(&k, "20260101120000Z", 0);
let ap = parse_ap_req(&der).unwrap();
let wrong = KerberosKey::new(Enctype::Aes256CtsHmacSha1_96, vec![0xffu8; 32]).unwrap();
let mut cache = HashSetReplayCache::new();
let err = verify_ap_req(&ap, &wrong, 300, now, &mut cache).unwrap_err();
assert!(matches!(err, AcceptorError::Decrypt(_)));
}
#[test]
fn verify_ap_req_rejects_replay() {
let k = key();
let now: u64 = 1_767_268_800;
let der = make_ap_req(&k, "20260101120000Z", 0);
let ap = parse_ap_req(&der).unwrap();
let mut cache = HashSetReplayCache::new();
verify_ap_req(&ap, &k, 300, now, &mut cache).unwrap();
let err = verify_ap_req(&ap, &k, 300, now, &mut cache).unwrap_err();
assert_eq!(err, AcceptorError::Replay);
}
#[test]
fn verify_ap_req_rejects_stale_ctime() {
let k = key();
let now: u64 = 1_767_268_800 + 3600;
let der = make_ap_req(&k, "20260101120000Z", 0);
let ap = parse_ap_req(&der).unwrap();
let mut cache = HashSetReplayCache::new();
let err = verify_ap_req(&ap, &k, 60, now, &mut cache).unwrap_err();
assert!(matches!(err, AcceptorError::ClockSkewExceeded { .. }));
}
#[test]
fn noop_replay_cache_accepts_everything() {
let mut c = NoopReplayCache;
assert!(c.remember([0u8; 32], 0).is_ok());
assert!(c.remember([0u8; 32], 0).is_ok());
assert!(c.remember([0u8; 32], 0).is_ok());
}
#[test]
fn hash_set_replay_cache_expires() {
let mut c = HashSetReplayCache::new();
c.remember([1u8; 32], 100).unwrap();
c.remember([2u8; 32], 200).unwrap();
assert_eq!(c.len(), 2);
c.expire(150);
assert_eq!(c.len(), 1);
c.expire(999);
assert!(c.is_empty());
}
#[test]
fn parse_kerberos_time_epoch_and_2026() {
assert_eq!(parse_kerberos_time("19700101000000Z"), Some(0));
assert_eq!(parse_kerberos_time("20260101120000Z"), Some(1_767_268_800));
}
#[test]
fn parse_kerberos_time_rejects_bogus() {
assert!(parse_kerberos_time("20260132120000Z").is_none()); assert!(parse_kerberos_time("20260101120000").is_none()); assert!(parse_kerberos_time("XXXX0101120000Z").is_none()); }
fn synth_enc_ticket_part(
session_key: &EncryptionKey,
crealm: &str,
cname: &PrincipalName,
authtime: &str,
endtime: &str,
) -> Vec<u8> {
use crate::der::{encode_integer, encode_sequence, explicit, tlv};
use crate::types::encode_realm;
let _ = encode_integer;
let mut flags_bytes = vec![0u8]; flags_bytes.extend_from_slice(&0x4000_0000u32.to_be_bytes());
let flags = explicit(0, &tlv(TAG_BIT_STRING, &flags_bytes));
let key = explicit(1, &session_key.encode());
let crealm = explicit(2, &encode_realm(crealm));
let cname_der = explicit(3, &cname.encode());
let tr_body = [
explicit(0, &crate::der::encode_integer(0)),
explicit(1, &crate::der::encode_octet_string(&[])),
]
.concat();
let transited = explicit(4, &encode_sequence(&tr_body));
let authtime = explicit(5, &KerberosTime(authtime.to_string()).encode());
let endtime = explicit(7, &KerberosTime(endtime.to_string()).encode());
let inner: Vec<u8> = [flags, key, crealm, cname_der, transited, authtime, endtime]
.concat();
tlv(application_tag(3), &encode_sequence(&inner))
}
#[allow(clippy::too_many_arguments)]
fn make_ap_req_full(
service_key: &KerberosKey,
session_key: &KerberosKey,
crealm: &str,
cname: &PrincipalName,
ctime: &str,
cusec: i32,
authtime: &str,
endtime: &str,
) -> Vec<u8> {
let session_wire = EncryptionKey {
keytype: session_key.enctype().to_i32(),
keyvalue: session_key.key().to_vec(),
};
let etp_plain = synth_enc_ticket_part(&session_wire, crealm, cname, authtime, endtime);
let ticket_cipher =
service_key.encrypt_with_confounder(KU_TICKET, &[0u8; 16], &etp_plain);
let ticket = Ticket {
tkt_vno: 5,
realm: crealm.into(),
sname: PrincipalName {
name_type: 2,
name_string: vec!["HTTP".into(), "web.corp.local".into()],
},
enc_part: EncryptedData {
etype: service_key.enctype().to_i32(),
kvno: None,
cipher: ticket_cipher,
},
};
build_ap_req_with_confounder(
&ticket,
session_key,
crealm,
cname,
ctime,
cusec,
AP_OPTS_MUTUAL_REQUIRED,
None,
None,
None,
&[0u8; 16],
)
}
#[test]
fn full_acceptor_end_to_end_happy_path() {
let service_key =
KerberosKey::new(Enctype::Aes256CtsHmacSha1_96, vec![0x11u8; 32]).unwrap();
let session_key =
KerberosKey::new(Enctype::Aes256CtsHmacSha1_96, vec![0x22u8; 32]).unwrap();
let cname = PrincipalName {
name_type: 1,
name_string: vec!["alice".into()],
};
let now: u64 = 1_767_268_800;
let der = make_ap_req_full(
&service_key,
&session_key,
"CORP.LOCAL",
&cname,
"20260101120000Z",
0,
"20260101120000Z",
"20260101220000Z",
);
let ap = parse_ap_req(&der).unwrap();
let mut cache = HashSetReplayCache::new();
let (ctx, etp) = verify_ap_req_full(&ap, &service_key, 300, now, &mut cache).unwrap();
assert_eq!(ctx.client_principal.name_string, vec!["alice".to_string()]);
assert_eq!(etp.crealm, "CORP.LOCAL");
assert_eq!(etp.flags & 0x4000_0000, 0x4000_0000, "FORWARDABLE bit set");
assert!(cache.len() == 1);
}
#[test]
fn full_acceptor_rejects_expired_ticket() {
let service_key =
KerberosKey::new(Enctype::Aes256CtsHmacSha1_96, vec![0x11u8; 32]).unwrap();
let session_key =
KerberosKey::new(Enctype::Aes256CtsHmacSha1_96, vec![0x22u8; 32]).unwrap();
let cname = PrincipalName {
name_type: 1,
name_string: vec!["alice".into()],
};
let now: u64 = 1_767_268_800;
let der = make_ap_req_full(
&service_key,
&session_key,
"CORP.LOCAL",
&cname,
"20260101110000Z", 0,
"20260101100000Z",
"20260101110000Z", );
let ap = parse_ap_req(&der).unwrap();
let mut cache = HashSetReplayCache::new();
let err = verify_ap_req_full(&ap, &service_key, 7200, now, &mut cache).unwrap_err();
assert!(matches!(err, AcceptorError::TicketExpired { .. }));
}
#[test]
fn full_acceptor_rejects_wrong_service_key() {
let service_key =
KerberosKey::new(Enctype::Aes256CtsHmacSha1_96, vec![0x11u8; 32]).unwrap();
let wrong_service_key =
KerberosKey::new(Enctype::Aes256CtsHmacSha1_96, vec![0xffu8; 32]).unwrap();
let session_key =
KerberosKey::new(Enctype::Aes256CtsHmacSha1_96, vec![0x22u8; 32]).unwrap();
let cname = PrincipalName {
name_type: 1,
name_string: vec!["alice".into()],
};
let now: u64 = 1_767_268_800;
let der = make_ap_req_full(
&service_key,
&session_key,
"CORP.LOCAL",
&cname,
"20260101120000Z",
0,
"20260101120000Z",
"20260101220000Z",
);
let ap = parse_ap_req(&der).unwrap();
let mut cache = HashSetReplayCache::new();
let err =
verify_ap_req_full(&ap, &wrong_service_key, 300, now, &mut cache).unwrap_err();
assert!(matches!(err, AcceptorError::TicketDecrypt(_)));
}
#[test]
fn ap_rep_round_trips_ctime_cusec() {
use crate::client::{parse_ap_rep, parse_enc_ap_rep_part, KU_AP_REP_ENC_PART};
let session_key =
KerberosKey::new(Enctype::Aes256CtsHmacSha1_96, vec![0x33u8; 32]).unwrap();
let auth = Authenticator {
authenticator_vno: 5,
crealm: "CORP.LOCAL".into(),
cname: PrincipalName {
name_type: 1,
name_string: vec!["alice".into()],
},
cksum: None,
cusec: 12345,
ctime: "20260101120000Z".into(),
subkey: None,
seq_number: None,
};
let der =
build_ap_rep_with_confounder(&session_key, &auth, None, Some(42), &[0u8; 16]);
let enc = parse_ap_rep(&der).unwrap();
let plaintext = session_key
.decrypt(KU_AP_REP_ENC_PART, &enc.cipher)
.expect("AP-REP decrypt");
let part = parse_enc_ap_rep_part(&plaintext).unwrap();
assert_eq!(part.ctime, "20260101120000Z");
assert_eq!(part.cusec, 12345);
assert_eq!(part.seq_number, Some(42));
assert!(part.subkey.is_none());
}
}