use crate::der::{
application_tag, context_tag, encode_integer, encode_sequence, explicit, one_or, tlv, Der,
DerError, TAG_BIT_STRING, TAG_SEQUENCE,
};
use crate::messages::{KdcReq, KdcReqBody, Ticket};
use crate::types::{encode_realm, Checksum, EncryptedData, KerberosTime, PaData, PrincipalName};
pub const KU_AS_REQ_PA_ENC_TS: u32 = 1;
pub const KU_AS_REP_ENC_PART: u32 = 3;
pub const PA_ENC_TIMESTAMP: i32 = 2;
pub const PA_ETYPE_INFO2: i32 = 19;
pub const NT_PRINCIPAL: i32 = 1;
pub const NT_SRV_INST: i32 = 2;
pub fn unix_to_kerberos_time(secs: u64) -> String {
let days = (secs / 86400) as i64;
let rem = secs % 86400;
let (h, mi, s) = (rem / 3600, (rem % 3600) / 60, rem % 60);
let z = days + 719_468;
let era = if z >= 0 { z } else { z - 146_096 } / 146_097;
let doe = z - era * 146_097; let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365; let y = yoe + era * 400;
let doy = doe - (365 * yoe + yoe / 4 - yoe / 100); let mp = (5 * doy + 2) / 153; let d = doy - (153 * mp + 2) / 5 + 1; let m = if mp < 10 { mp + 3 } else { mp - 9 }; let year = if m <= 2 { y + 1 } else { y };
format!("{year:04}{m:02}{d:02}{h:02}{mi:02}{s:02}Z")
}
pub fn krbtgt_sname(realm: &str) -> PrincipalName {
PrincipalName {
name_type: NT_SRV_INST,
name_string: vec!["krbtgt".to_string(), realm.to_string()],
}
}
pub fn client_cname(user: &str) -> PrincipalName {
PrincipalName {
name_type: NT_PRINCIPAL,
name_string: vec![user.to_string()],
}
}
pub fn encode_pa_enc_ts_enc(kerberos_time: &str, usec: i32) -> Vec<u8> {
let body = [
explicit(0, &KerberosTime(kerberos_time.to_string()).encode()),
explicit(1, &crate::der::encode_integer(usec as i64)),
]
.concat();
encode_sequence(&body)
}
pub fn build_as_req(
realm: &str,
cname: &PrincipalName,
nonce: u32,
till: &str,
etypes: &[i32],
padata: Vec<PaData>,
) -> Vec<u8> {
let body = KdcReqBody {
kdc_options: 0x4081_0010, cname: Some(cname.clone()),
realm: realm.to_string(),
sname: Some(krbtgt_sname(realm)),
from: None,
till: KerberosTime(till.to_string()),
rtime: None,
nonce,
etypes: etypes.to_vec(),
addresses: None,
enc_authorization_data: None,
additional_tickets: None,
};
KdcReq {
msg_type: 10,
padata,
req_body: body,
}
.encode()
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct EtypeInfo2Entry {
pub etype: i32,
pub salt: Option<String>,
pub s2kparams: Option<Vec<u8>>,
}
impl EtypeInfo2Entry {
pub fn s2k_iterations(&self) -> Option<u32> {
match self.s2kparams.as_deref() {
Some([a, b, c, d]) => {
let n = u32::from_be_bytes([*a, *b, *c, *d]);
Some(if n == 0 { u32::MAX } else { n })
}
_ => None,
}
}
}
pub fn parse_etype_info2(padata_value: &[u8]) -> Result<Vec<EtypeInfo2Entry>, DerError> {
let seq = one_or(padata_value, TAG_SEQUENCE)?;
let mut r = Der::new(seq);
let mut out = Vec::new();
while !r.is_empty() {
let (_, entry) = r.read_tlv()?;
let mut er = Der::new(entry);
let etype = {
let mut ir = Der::new(er.expect(context_tag(0))?);
i32::try_from(ir.read_integer()?).map_err(|_| DerError::IntTooLarge)?
};
let salt = if er.peek_tag() == Some(context_tag(1)) {
let c = er.expect(context_tag(1))?;
let inner = one_or(c, crate::der::TAG_GENERAL_STRING)?;
Some(String::from_utf8_lossy(inner).into_owned())
} else {
None
};
let s2kparams = if er.peek_tag() == Some(context_tag(2)) {
let c = er.expect(context_tag(2))?;
Some(one_or(c, crate::der::TAG_OCTET_STRING)?.to_vec())
} else {
None
};
out.push(EtypeInfo2Entry {
etype,
salt,
s2kparams,
});
}
Ok(out)
}
pub fn enc_kdc_rep_part_session_key(
plaintext: &[u8],
) -> Result<crate::types::EncryptionKey, DerError> {
let mut r = Der::new(plaintext);
let (tag, inner) = r.read_tlv()?;
if tag != crate::der::application_tag(25) && tag != crate::der::application_tag(26) {
return Err(DerError::TagMismatch {
expected: crate::der::application_tag(25),
found: tag,
});
}
let seq = one_or(inner, TAG_SEQUENCE)?;
let mut sr = Der::new(seq);
let key_der = sr.expect(context_tag(0))?;
crate::types::EncryptionKey::decode(key_der)
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct EncKdcRepPart {
pub key: crate::types::EncryptionKey,
pub nonce: u32,
pub endtime: String,
pub srealm: String,
pub sname: PrincipalName,
}
fn skip_opt(r: &mut Der<'_>, n: u8) -> Result<(), DerError> {
if r.peek_tag() == Some(context_tag(n)) {
r.expect(context_tag(n))?;
}
Ok(())
}
pub fn parse_enc_kdc_rep_part(plaintext: &[u8]) -> Result<EncKdcRepPart, DerError> {
let mut r = Der::new(plaintext);
let (tag, inner) = r.read_tlv()?;
if tag != application_tag(25) && tag != application_tag(26) {
return Err(DerError::TagMismatch {
expected: application_tag(25),
found: tag,
});
}
let seq = one_or(inner, TAG_SEQUENCE)?;
let mut sr = Der::new(seq);
let key = crate::types::EncryptionKey::decode(sr.expect(context_tag(0))?)?;
let _last_req = sr.expect(context_tag(1))?; let nonce = crate::der::read_u32(sr.expect(context_tag(2))?)?;
skip_opt(&mut sr, 3)?; let _flags = sr.expect(context_tag(4))?; let _authtime = sr.expect(context_tag(5))?; skip_opt(&mut sr, 6)?; let endtime = KerberosTime::decode(sr.expect(context_tag(7))?)?.0;
skip_opt(&mut sr, 8)?; let srealm = crate::types::decode_realm(sr.expect(context_tag(9))?)?;
let sname = PrincipalName::decode(sr.expect(context_tag(10))?)?;
Ok(EncKdcRepPart {
key,
nonce,
endtime,
srealm,
sname,
})
}
pub fn verify_kdc_rep(plaintext: &[u8], expected_nonce: u32) -> Result<EncKdcRepPart, DerError> {
let part = parse_enc_kdc_rep_part(plaintext)?;
if part.nonce != expected_nonce {
return Err(DerError::MsgTypeMismatch);
}
Ok(part)
}
pub fn pa_enc_timestamp(enc: &EncryptedData) -> PaData {
PaData {
padata_type: PA_ENC_TIMESTAMP,
padata_value: enc.encode(),
}
}
pub const KU_TGS_REQ_AUTH_CKSUM: u32 = 6;
pub const KU_TGS_REQ_AUTH: u32 = 7;
pub const KU_TGS_REP_ENC_PART: u32 = 8;
pub const PA_TGS_REQ: i32 = 1;
pub const CKSUM_HMAC_SHA1_96_AES256: i32 = 16;
fn encode_authenticator(
crealm: &str,
cname: &PrincipalName,
cusec: i32,
ctime: &str,
cksum: Option<&Checksum>,
subkey: Option<&crate::types::EncryptionKey>,
seq_number: Option<u32>,
) -> Vec<u8> {
let mut body = explicit(0, &encode_integer(5)); body.extend_from_slice(&explicit(1, &encode_realm(crealm)));
body.extend_from_slice(&explicit(2, &cname.encode()));
if let Some(c) = cksum {
body.extend_from_slice(&explicit(3, &c.encode()));
}
body.extend_from_slice(&explicit(4, &encode_integer(cusec as i64)));
body.extend_from_slice(&explicit(5, &KerberosTime(ctime.to_string()).encode()));
if let Some(sk) = subkey {
body.extend_from_slice(&explicit(6, &sk.encode()));
}
if let Some(n) = seq_number {
body.extend_from_slice(&explicit(7, &encode_integer(n as i64)));
}
tlv(application_tag(2), &encode_sequence(&body))
}
fn encode_ap_req(ticket_der: &[u8], enc_auth: &EncryptedData, ap_options: u32) -> Vec<u8> {
let mut opt = vec![0u8];
opt.extend_from_slice(&ap_options.to_be_bytes());
let ap_options = tlv(TAG_BIT_STRING, &opt);
let body = [
explicit(0, &encode_integer(5)),
explicit(1, &encode_integer(14)),
explicit(2, &ap_options),
explicit(3, ticket_der),
explicit(4, &enc_auth.encode()),
]
.concat();
tlv(application_tag(14), &encode_sequence(&body))
}
#[allow(clippy::too_many_arguments)]
pub fn build_tgs_req(
realm: &str,
sname: &PrincipalName,
tgt: &Ticket,
tgt_session_key: &crate::keys::KerberosKey,
crealm: &str,
cname: &PrincipalName,
nonce: u32,
till: &str,
etypes: &[i32],
ctime: &str,
cusec: i32,
) -> Result<Vec<u8>, crate::keys::KeyError> {
let mut conf = vec![0u8; tgt_session_key.enctype().confounder_len()];
getrandom::getrandom(&mut conf).expect("OS CSPRNG available for Kerberos confounder");
build_tgs_req_with_confounder(
realm,
sname,
tgt,
tgt_session_key,
crealm,
cname,
nonce,
till,
etypes,
ctime,
cusec,
&conf,
)
}
const DEFAULT_TGS_KDC_OPTIONS: u32 = 0x4081_0000;
pub const KDC_OPT_CANONICALIZE: u32 = 0x0001_0000;
pub const KDC_OPT_RENEWABLE_OK: u32 = 0x0000_0010;
pub const KDC_OPT_RENEW: u32 = 0x0000_0002;
pub const KDC_OPT_VALIDATE: u32 = 0x0000_0001;
#[allow(clippy::too_many_arguments)]
pub fn build_tgs_req_with_confounder(
realm: &str,
sname: &PrincipalName,
tgt: &Ticket,
tgt_session_key: &crate::keys::KerberosKey,
crealm: &str,
cname: &PrincipalName,
nonce: u32,
till: &str,
etypes: &[i32],
ctime: &str,
cusec: i32,
confounder: &[u8],
) -> Result<Vec<u8>, crate::keys::KeyError> {
build_tgs_req_with_options(
realm,
sname,
tgt,
tgt_session_key,
crealm,
cname,
nonce,
till,
etypes,
ctime,
cusec,
DEFAULT_TGS_KDC_OPTIONS,
confounder,
)
}
#[allow(clippy::too_many_arguments)]
pub fn build_tgs_req_with_options(
realm: &str,
sname: &PrincipalName,
tgt: &Ticket,
tgt_session_key: &crate::keys::KerberosKey,
crealm: &str,
cname: &PrincipalName,
nonce: u32,
till: &str,
etypes: &[i32],
ctime: &str,
cusec: i32,
kdc_options: u32,
confounder: &[u8],
) -> Result<Vec<u8>, crate::keys::KeyError> {
let enctype = tgt_session_key.enctype();
let cksumtype = enctype
.authenticator_cksumtype()
.ok_or(crate::keys::KeyError::UnsupportedEnctype(enctype.to_i32()))?;
let body = KdcReqBody {
kdc_options,
cname: None,
realm: realm.to_string(),
sname: Some(sname.clone()),
from: None,
till: KerberosTime(till.to_string()),
rtime: None,
nonce,
etypes: etypes.to_vec(),
addresses: None,
enc_authorization_data: None,
additional_tickets: None,
};
let body_der = body.encode();
let cksum = Checksum {
cksumtype,
checksum: tgt_session_key.checksum(KU_TGS_REQ_AUTH_CKSUM, &body_der),
};
let auth = encode_authenticator(crealm, cname, cusec, ctime, Some(&cksum), None, None);
let enc_auth = EncryptedData {
etype: enctype.to_i32(),
kvno: None,
cipher: tgt_session_key.encrypt_with_confounder(KU_TGS_REQ_AUTH, confounder, &auth),
};
let ap_req = encode_ap_req(&tgt.encode(), &enc_auth, 0);
let padata = vec![PaData {
padata_type: PA_TGS_REQ,
padata_value: ap_req,
}];
Ok(KdcReq {
msg_type: 12,
padata,
req_body: body,
}
.encode())
}
pub fn referral_realm(
rep_sname: &PrincipalName,
requested_sname: &PrincipalName,
) -> Option<String> {
let next = match rep_sname.name_string.as_slice() {
[svc, realm] if svc.eq_ignore_ascii_case("krbtgt") => realm.clone(),
_ => return None,
};
if let [svc, realm] = requested_sname.name_string.as_slice() {
if svc.eq_ignore_ascii_case("krbtgt") && realm.eq_ignore_ascii_case(&next) {
return None;
}
}
Some(next)
}
#[allow(clippy::too_many_arguments)]
pub fn build_tgs_renew(
realm: &str,
renewable_tgt: &Ticket,
tgt_session_key: &crate::keys::KerberosKey,
crealm: &str,
cname: &PrincipalName,
nonce: u32,
till: &str,
etypes: &[i32],
ctime: &str,
cusec: i32,
) -> Result<Vec<u8>, crate::keys::KeyError> {
let mut conf = vec![0u8; tgt_session_key.enctype().confounder_len()];
getrandom::getrandom(&mut conf).expect("OS CSPRNG available for Kerberos confounder");
build_tgs_req_with_options(
realm,
&krbtgt_sname(realm),
renewable_tgt,
tgt_session_key,
crealm,
cname,
nonce,
till,
etypes,
ctime,
cusec,
KDC_OPT_RENEW | KDC_OPT_RENEWABLE_OK,
&conf,
)
}
pub const KU_AP_REQ_AUTH_CKSUM: u32 = 10;
pub const KU_AP_REQ_AUTH: u32 = 11;
pub const KU_AP_REP_ENC_PART: u32 = 12;
pub const AP_OPTS_MUTUAL_REQUIRED: u32 = 0x2000_0000;
pub const AP_OPTS_USE_SESSION_KEY: u32 = 0x4000_0000;
#[allow(clippy::too_many_arguments)]
pub fn build_ap_req_with_confounder(
ticket: &Ticket,
session_key: &crate::keys::KerberosKey,
crealm: &str,
cname: &PrincipalName,
ctime: &str,
cusec: i32,
ap_options: u32,
cksum: Option<&Checksum>,
subkey: Option<&crate::types::EncryptionKey>,
seq_number: Option<u32>,
confounder: &[u8],
) -> Vec<u8> {
let enctype = session_key.enctype();
let auth = encode_authenticator(crealm, cname, cusec, ctime, cksum, subkey, seq_number);
let enc_auth = EncryptedData {
etype: enctype.to_i32(),
kvno: None,
cipher: session_key.encrypt_with_confounder(KU_AP_REQ_AUTH, confounder, &auth),
};
encode_ap_req(&ticket.encode(), &enc_auth, ap_options)
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct EncApRepPart {
pub ctime: String,
pub cusec: i32,
pub subkey: Option<crate::types::EncryptionKey>,
pub seq_number: Option<u32>,
}
pub fn parse_ap_rep(der: &[u8]) -> Result<EncryptedData, DerError> {
let mut r = Der::new(der);
let (tag, inner) = r.read_tlv()?;
if tag != application_tag(15) {
return Err(DerError::TagMismatch {
expected: application_tag(15),
found: tag,
});
}
let seq = one_or(inner, TAG_SEQUENCE)?;
let mut sr = Der::new(seq);
let pvno = crate::der::read_u32(sr.expect(context_tag(0))?)?;
let msg_type = crate::der::read_u32(sr.expect(context_tag(1))?)?;
if pvno != 5 || msg_type != 15 {
return Err(DerError::MsgTypeMismatch);
}
EncryptedData::decode(sr.expect(context_tag(2))?)
}
pub fn parse_enc_ap_rep_part(plaintext: &[u8]) -> Result<EncApRepPart, DerError> {
let mut r = Der::new(plaintext);
let (tag, inner) = r.read_tlv()?;
if tag != application_tag(27) {
return Err(DerError::TagMismatch {
expected: application_tag(27),
found: tag,
});
}
let seq = one_or(inner, TAG_SEQUENCE)?;
let mut sr = Der::new(seq);
let ctime = KerberosTime::decode(sr.expect(context_tag(0))?)?.0;
let cusec = {
let mut ir = Der::new(sr.expect(context_tag(1))?);
i32::try_from(ir.read_integer()?).map_err(|_| DerError::IntTooLarge)?
};
let subkey = if sr.peek_tag() == Some(context_tag(2)) {
Some(crate::types::EncryptionKey::decode(
sr.expect(context_tag(2))?,
)?)
} else {
None
};
let seq_number = if sr.peek_tag() == Some(context_tag(3)) {
Some(crate::der::read_u32(sr.expect(context_tag(3))?)?)
} else {
None
};
Ok(EncApRepPart {
ctime,
cusec,
subkey,
seq_number,
})
}
pub fn verify_ap_rep(
plaintext: &[u8],
expected_ctime: &str,
expected_cusec: i32,
) -> Result<EncApRepPart, DerError> {
let part = parse_enc_ap_rep_part(plaintext)?;
if part.ctime != expected_ctime || part.cusec != expected_cusec {
return Err(DerError::MsgTypeMismatch);
}
Ok(part)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn kerberos_time_epoch_and_known() {
assert_eq!(unix_to_kerberos_time(0), "19700101000000Z");
assert_eq!(unix_to_kerberos_time(1_704_164_645), "20240102030405Z");
}
#[test]
fn pa_enc_ts_enc_roundtrips_through_crypto() {
let plain = encode_pa_enc_ts_enc("20240102030405Z", 123456);
let key = [0x11u8; 32];
let enc = crate::crypto::encrypt_message(&key, KU_AS_REQ_PA_ENC_TS, &[0x22u8; 16], &plain);
let dec = crate::crypto::decrypt_message(&key, KU_AS_REQ_PA_ENC_TS, &enc).unwrap();
assert_eq!(dec, plain);
}
#[test]
fn as_req_has_krbtgt_sname() {
let der = build_as_req(
"EXAMPLE.COM",
&client_cname("alice"),
42,
"20370913024805Z",
&[18, 17],
vec![],
);
let req = KdcReq::decode(&der).unwrap();
assert_eq!(req.req_body.sname.unwrap(), krbtgt_sname("EXAMPLE.COM"));
assert_eq!(req.req_body.etypes, vec![18, 17]);
}
fn sample_tgt() -> Ticket {
Ticket {
tkt_vno: 5,
realm: "EXAMPLE.COM".into(),
sname: krbtgt_sname("EXAMPLE.COM"),
enc_part: crate::types::EncryptedData {
etype: 18,
kvno: Some(2),
cipher: vec![0u8; 32],
},
}
}
fn svc_sname() -> PrincipalName {
PrincipalName {
name_type: NT_SRV_INST,
name_string: vec!["host".into(), "dc.example.com".into()],
}
}
fn sample_sk() -> crate::keys::KerberosKey {
crate::keys::KerberosKey::new(crate::keys::Enctype::Aes256CtsHmacSha1_96, vec![0x11u8; 32])
.unwrap()
}
#[test]
fn tgs_req_uses_fresh_random_confounder() {
let (tgt, sk, sname, cname) = (
sample_tgt(),
sample_sk(),
svc_sname(),
client_cname("alice"),
);
let a = build_tgs_req(
"EXAMPLE.COM",
&sname,
&tgt,
&sk,
"EXAMPLE.COM",
&cname,
1,
"20370913024805Z",
&[18],
"20240102030405Z",
0,
)
.unwrap();
let b = build_tgs_req(
"EXAMPLE.COM",
&sname,
&tgt,
&sk,
"EXAMPLE.COM",
&cname,
1,
"20370913024805Z",
&[18],
"20240102030405Z",
0,
)
.unwrap();
assert_ne!(a, b, "TGS-REQ must use a fresh random confounder each call");
}
#[test]
fn tgs_req_with_confounder_is_deterministic_and_etype_correct() {
let (tgt, sk, sname, cname) = (
sample_tgt(),
sample_sk(),
svc_sname(),
client_cname("alice"),
);
let conf = [0x24u8; 16];
let mk = || {
build_tgs_req_with_confounder(
"EXAMPLE.COM",
&sname,
&tgt,
&sk,
"EXAMPLE.COM",
&cname,
1,
"20370913024805Z",
&[18],
"20240102030405Z",
0,
&conf,
)
.unwrap()
};
let a = mk();
assert_eq!(a, mk(), "same confounder + inputs must be byte-identical");
assert_eq!(KdcReq::decode(&a).unwrap().msg_type, 12);
}
#[test]
fn tgs_req_rejects_rfc8009_session_key() {
let sk = crate::keys::KerberosKey::new(
crate::keys::Enctype::Aes256CtsHmacSha384_192,
vec![0u8; 32],
)
.unwrap();
let err = build_tgs_req(
"EXAMPLE.COM",
&svc_sname(),
&sample_tgt(),
&sk,
"EXAMPLE.COM",
&client_cname("alice"),
1,
"20370913024805Z",
&[20],
"20240102030405Z",
0,
)
.unwrap_err();
assert!(matches!(err, crate::keys::KeyError::UnsupportedEnctype(20)));
}
fn sample_enc_as_rep_part(nonce: u32) -> Vec<u8> {
let key = crate::types::EncryptionKey {
keytype: 18,
keyvalue: vec![0x41u8; 32],
}
.encode();
let sname = PrincipalName {
name_type: 2,
name_string: vec!["krbtgt".into(), "EXAMPLE.COM".into()],
}
.encode();
let body = [
explicit(0, &key),
explicit(1, &encode_sequence(&[])), explicit(2, &encode_integer(nonce as i64)),
explicit(4, &encode_integer(0)), explicit(5, &KerberosTime("20260908000000Z".into()).encode()), explicit(7, &KerberosTime("20260908100000Z".into()).encode()), explicit(9, &encode_realm("EXAMPLE.COM")),
explicit(10, &sname),
]
.concat();
tlv(application_tag(25), &encode_sequence(&body))
}
#[test]
fn enc_kdc_rep_part_extracts_nonce_and_sname() {
let der = sample_enc_as_rep_part(0xDEAD_BEEF);
let part = parse_enc_kdc_rep_part(&der).unwrap();
assert_eq!(part.nonce, 0xDEAD_BEEF);
assert_eq!(part.key.keytype, 18);
assert_eq!(part.endtime, "20260908100000Z");
assert_eq!(part.srealm, "EXAMPLE.COM");
assert_eq!(part.sname.name_string, vec!["krbtgt", "EXAMPLE.COM"]);
}
#[test]
fn verify_kdc_rep_matches_and_rejects_nonce() {
let der = sample_enc_as_rep_part(4242);
assert_eq!(verify_kdc_rep(&der, 4242).unwrap().nonce, 4242);
assert!(matches!(
verify_kdc_rep(&der, 9999),
Err(DerError::MsgTypeMismatch)
));
}
#[test]
fn etype_info2_parses_salt_and_s2k_iterations() {
use crate::der::{encode_general_string, encode_octet_string};
let entry = |etype: i64, salt: &str, s2k: Option<&[u8]>| {
let mut b = explicit(0, &encode_integer(etype));
b.extend_from_slice(&explicit(1, &encode_general_string(salt)));
if let Some(p) = s2k {
b.extend_from_slice(&explicit(2, &encode_octet_string(p)));
}
encode_sequence(&b)
};
let seq = [
entry(18, "EXAMPLE.COMalice", Some(&[0x00, 0x00, 0xC0, 0x00])),
entry(17, "EXAMPLE.COMalice", None),
entry(18, "s", Some(&[0x00, 0x00, 0x00, 0x00])),
]
.concat();
let padata = encode_sequence(&seq);
let entries = parse_etype_info2(&padata).unwrap();
assert_eq!(entries.len(), 3);
assert_eq!(entries[0].etype, 18);
assert_eq!(entries[0].salt.as_deref(), Some("EXAMPLE.COMalice"));
assert_eq!(entries[0].s2k_iterations(), Some(49152));
assert_eq!(entries[1].s2kparams, None);
assert_eq!(entries[1].s2k_iterations(), None);
assert_eq!(entries[2].s2k_iterations(), Some(u32::MAX));
}
#[test]
fn referral_realm_detection() {
let krbtgt = |realm: &str| PrincipalName {
name_type: 2,
name_string: vec!["krbtgt".into(), realm.into()],
};
let svc = PrincipalName {
name_type: 2,
name_string: vec!["cifs".into(), "fs.b.example.com".into()],
};
assert_eq!(
referral_realm(&krbtgt("B.EXAMPLE.COM"), &svc).as_deref(),
Some("B.EXAMPLE.COM")
);
assert_eq!(referral_realm(&svc, &svc), None);
assert_eq!(
referral_realm(&krbtgt("B.EXAMPLE.COM"), &krbtgt("B.EXAMPLE.COM")),
None
);
assert_eq!(
referral_realm(&krbtgt("b.example.com"), &krbtgt("B.EXAMPLE.COM")),
None
);
}
#[test]
fn default_tgs_req_sets_canonicalize_and_options_can_clear_it() {
assert_eq!(
DEFAULT_TGS_KDC_OPTIONS & KDC_OPT_CANONICALIZE,
KDC_OPT_CANONICALIZE
);
let conf = [0u8; 16];
let default = build_tgs_req_with_confounder(
"EXAMPLE.COM",
&svc_sname(),
&sample_tgt(),
&sample_sk(),
"EXAMPLE.COM",
&client_cname("alice"),
1,
"20370913024805Z",
&[18],
"20240102030405Z",
0,
&conf,
)
.unwrap();
let no_canon = build_tgs_req_with_options(
"EXAMPLE.COM",
&svc_sname(),
&sample_tgt(),
&sample_sk(),
"EXAMPLE.COM",
&client_cname("alice"),
1,
"20370913024805Z",
&[18],
"20240102030405Z",
0,
DEFAULT_TGS_KDC_OPTIONS & !KDC_OPT_CANONICALIZE,
&conf,
)
.unwrap();
assert_ne!(default, no_canon);
}
#[test]
fn tgs_renew_sets_renew_option_and_targets_krbtgt() {
assert_eq!(KDC_OPT_RENEW, 0x0000_0002);
let renew = build_tgs_renew(
"EXAMPLE.COM",
&sample_tgt(),
&sample_sk(),
"EXAMPLE.COM",
&client_cname("alice"),
5,
"20370913024805Z",
&[18],
"20240102030405Z",
0,
)
.unwrap();
let needle = [0x00u8, 0x00, 0x00, 0x00, 0x12];
assert!(
renew.windows(5).any(|w| w == needle),
"renew TGS-REQ should carry RENEW|RENEWABLE-OK flags"
);
}
#[test]
fn ap_req_build_then_ap_rep_mutual_auth_round_trip() {
let sk = sample_sk(); let ctime = "20260908120000Z";
let cusec = 424242;
let ap_req = build_ap_req_with_confounder(
&sample_tgt(),
&sk,
"EXAMPLE.COM",
&client_cname("alice"),
ctime,
cusec,
AP_OPTS_MUTUAL_REQUIRED,
None,
None,
Some(1),
&[0x55u8; 16],
);
assert!(!ap_req.is_empty());
let enc_part = tlv(
application_tag(27),
&encode_sequence(
&[
explicit(0, &KerberosTime(ctime.into()).encode()),
explicit(1, &encode_integer(cusec as i64)),
]
.concat(),
),
);
let ed = EncryptedData {
etype: sk.enctype().to_i32(),
kvno: None,
cipher: sk.encrypt(KU_AP_REP_ENC_PART, &enc_part),
};
let ap_rep = tlv(
application_tag(15),
&encode_sequence(
&[
explicit(0, &encode_integer(5)),
explicit(1, &encode_integer(15)),
explicit(2, &ed.encode()),
]
.concat(),
),
);
let got = parse_ap_rep(&ap_rep).unwrap();
let plain = sk.decrypt(KU_AP_REP_ENC_PART, &got.cipher).unwrap();
let part = verify_ap_rep(&plain, ctime, cusec).unwrap();
assert_eq!(part.ctime, ctime);
assert_eq!(part.cusec, cusec);
assert!(matches!(
verify_ap_rep(&plain, "20000101000000Z", cusec),
Err(DerError::MsgTypeMismatch)
));
}
#[test]
fn enc_kdc_rep_part_rejects_wrong_app_tag() {
let inner = {
let der = sample_enc_as_rep_part(1);
let mut r = Der::new(&der);
let (_t, body) = r.read_tlv().unwrap();
tlv(application_tag(30), body)
};
assert!(parse_enc_kdc_rep_part(&inner).is_err());
}
}