use crate::der::{
application_tag, context_tag, encode_general_string, encode_integer, encode_octet_string,
encode_sequence, explicit, tlv, Der, DerError, TAG_BIT_STRING, TAG_GENERAL_STRING,
TAG_OCTET_STRING, TAG_SEQUENCE,
};
use crate::types::{
decode_realm, encode_realm, EncryptedData, KerberosTime, PaData, PrincipalName,
};
fn one(der: &[u8], tag: u8) -> Result<&[u8], DerError> {
let mut r = Der::new(der);
let c = r.expect(tag)?;
r.finish()?;
Ok(c)
}
fn read_i32(der: &[u8]) -> Result<i32, DerError> {
let mut r = Der::new(der);
let v = r.read_integer()?;
r.finish()?;
i32::try_from(v).map_err(|_| DerError::IntTooLarge)
}
fn encode_flags(flags: u32) -> Vec<u8> {
let mut content = Vec::with_capacity(5);
content.push(0x00); content.extend_from_slice(&flags.to_be_bytes());
tlv(TAG_BIT_STRING, &content)
}
fn decode_flags(der: &[u8]) -> Result<u32, DerError> {
let c = one(der, TAG_BIT_STRING)?;
if c.len() != 5 || c[0] != 0 {
return Err(DerError::BadBitString);
}
let mut v = 0u32;
for &b in &c[1..5] {
v = (v << 8) | b as u32;
}
Ok(v)
}
fn encode_int_seq(vals: &[i32]) -> Vec<u8> {
let body: Vec<u8> = vals
.iter()
.flat_map(|v| encode_integer(*v as i64))
.collect();
encode_sequence(&body)
}
fn decode_int_seq(der: &[u8]) -> Result<Vec<i32>, DerError> {
let seq = one(der, TAG_SEQUENCE)?;
let mut r = Der::new(seq);
let mut out = Vec::new();
while !r.is_empty() {
out.push(i32::try_from(r.read_integer()?).map_err(|_| DerError::IntTooLarge)?);
}
Ok(out)
}
fn encode_padata_seq(padata: &[PaData]) -> Vec<u8> {
let body: Vec<u8> = padata.iter().flat_map(|p| p.encode()).collect();
encode_sequence(&body)
}
fn decode_padata_seq(der: &[u8]) -> Result<Vec<PaData>, DerError> {
let seq = one(der, TAG_SEQUENCE)?;
let mut r = Der::new(seq);
let mut out = Vec::new();
while !r.is_empty() {
let (_, item) = r.read_tlv()?;
out.push(PaData::decode(&tlv(TAG_SEQUENCE, item))?);
}
Ok(out)
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Ticket {
pub tkt_vno: i32,
pub realm: String,
pub sname: PrincipalName,
pub enc_part: EncryptedData,
}
impl Ticket {
pub fn encode(&self) -> Vec<u8> {
let body = [
explicit(0, &encode_integer(self.tkt_vno as i64)),
explicit(1, &encode_realm(&self.realm)),
explicit(2, &self.sname.encode()),
explicit(3, &self.enc_part.encode()),
]
.concat();
tlv(application_tag(1), &encode_sequence(&body))
}
pub fn decode(der: &[u8]) -> Result<Self, DerError> {
let seq = one(one(der, application_tag(1))?, TAG_SEQUENCE)?;
let mut r = Der::new(seq);
let tkt_vno = read_i32(r.expect(context_tag(0))?)?;
if tkt_vno != 5 {
return Err(DerError::BadProtocolVersion);
}
let realm = decode_realm(r.expect(context_tag(1))?)?;
let sname = PrincipalName::decode(r.expect(context_tag(2))?)?;
let enc_part = EncryptedData::decode(r.expect(context_tag(3))?)?;
r.finish()?;
Ok(Ticket {
tkt_vno,
realm,
sname,
enc_part,
})
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct KdcReqBody {
pub kdc_options: u32,
pub cname: Option<PrincipalName>,
pub realm: String,
pub sname: Option<PrincipalName>,
pub from: Option<KerberosTime>,
pub till: KerberosTime,
pub rtime: Option<KerberosTime>,
pub nonce: u32,
pub etypes: Vec<i32>,
pub addresses: Option<Vec<u8>>,
pub enc_authorization_data: Option<Vec<u8>>,
pub additional_tickets: Option<Vec<u8>>,
}
impl KdcReqBody {
pub fn encode(&self) -> Vec<u8> {
let mut body = explicit(0, &encode_flags(self.kdc_options));
if let Some(c) = &self.cname {
body.extend_from_slice(&explicit(1, &c.encode()));
}
body.extend_from_slice(&explicit(2, &encode_realm(&self.realm)));
if let Some(s) = &self.sname {
body.extend_from_slice(&explicit(3, &s.encode()));
}
if let Some(t) = &self.from {
body.extend_from_slice(&explicit(4, &t.encode()));
}
body.extend_from_slice(&explicit(5, &self.till.encode()));
if let Some(t) = &self.rtime {
body.extend_from_slice(&explicit(6, &t.encode()));
}
body.extend_from_slice(&explicit(7, &encode_integer(self.nonce as i64)));
body.extend_from_slice(&explicit(8, &encode_int_seq(&self.etypes)));
if let Some(v) = &self.addresses {
body.extend_from_slice(&explicit(9, v));
}
if let Some(v) = &self.enc_authorization_data {
body.extend_from_slice(&explicit(10, v));
}
if let Some(v) = &self.additional_tickets {
body.extend_from_slice(&explicit(11, v));
}
encode_sequence(&body)
}
pub fn decode(der: &[u8]) -> Result<Self, DerError> {
let body = one(der, TAG_SEQUENCE)?;
let mut r = Der::new(body);
let kdc_options = decode_flags(r.expect(context_tag(0))?)?;
let cname = opt(&mut r, 1, PrincipalName::decode)?;
let realm = decode_realm(r.expect(context_tag(2))?)?;
let sname = opt(&mut r, 3, PrincipalName::decode)?;
let from = opt(&mut r, 4, KerberosTime::decode)?;
let till = KerberosTime::decode(r.expect(context_tag(5))?)?;
let rtime = opt(&mut r, 6, KerberosTime::decode)?;
let nonce = crate::der::read_u32(r.expect(context_tag(7))?)?;
let etypes = decode_int_seq(r.expect(context_tag(8))?)?;
let addresses = opt_raw(&mut r, 9)?;
let enc_authorization_data = opt_raw(&mut r, 10)?;
let additional_tickets = opt_raw(&mut r, 11)?;
r.finish()?;
Ok(KdcReqBody {
kdc_options,
cname,
realm,
sname,
from,
till,
rtime,
nonce,
etypes,
addresses,
enc_authorization_data,
additional_tickets,
})
}
}
fn opt<T>(
r: &mut Der<'_>,
n: u8,
f: impl Fn(&[u8]) -> Result<T, DerError>,
) -> Result<Option<T>, DerError> {
if r.peek_tag() == Some(context_tag(n)) {
Ok(Some(f(r.expect(context_tag(n))?)?))
} else {
Ok(None)
}
}
fn opt_raw(r: &mut Der<'_>, n: u8) -> Result<Option<Vec<u8>>, DerError> {
if r.peek_tag() == Some(context_tag(n)) {
Ok(Some(r.expect(context_tag(n))?.to_vec()))
} else {
Ok(None)
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct KdcReq {
pub msg_type: i32,
pub padata: Vec<PaData>,
pub req_body: KdcReqBody,
}
impl KdcReq {
pub fn encode(&self) -> Vec<u8> {
let mut body = explicit(1, &encode_integer(5)); body.extend_from_slice(&explicit(2, &encode_integer(self.msg_type as i64)));
if !self.padata.is_empty() {
body.extend_from_slice(&explicit(3, &encode_padata_seq(&self.padata)));
}
body.extend_from_slice(&explicit(4, &self.req_body.encode()));
tlv(
application_tag(self.msg_type as u8),
&encode_sequence(&body),
)
}
pub fn decode(der: &[u8]) -> Result<Self, DerError> {
let (app, inner) = Der::new(der).read_tlv().and_then(|(t, c)| {
if t == application_tag(10) || t == application_tag(12) {
Ok((t, c))
} else {
Err(DerError::TagMismatch {
expected: application_tag(10),
found: t,
})
}
})?;
let seq = one(inner, TAG_SEQUENCE)?;
let mut r = Der::new(seq);
let pvno = read_i32(r.expect(context_tag(1))?)?;
if pvno != 5 {
return Err(DerError::BadProtocolVersion);
}
let msg_type = read_i32(r.expect(context_tag(2))?)?;
let expected = if app == application_tag(10) { 10 } else { 12 };
if msg_type != expected {
return Err(DerError::MsgTypeMismatch);
}
let padata = match opt(&mut r, 3, |b| Ok::<_, DerError>(b.to_vec()))? {
Some(raw) => decode_padata_seq(&raw)?,
None => Vec::new(),
};
let req_body = KdcReqBody::decode(r.expect(context_tag(4))?)?;
r.finish()?;
Ok(KdcReq {
msg_type,
padata,
req_body,
})
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct KdcRep {
pub msg_type: i32,
pub padata: Vec<PaData>,
pub crealm: String,
pub cname: PrincipalName,
pub ticket: Ticket,
pub enc_part: EncryptedData,
}
impl KdcRep {
pub fn encode(&self) -> Vec<u8> {
let mut body = explicit(0, &encode_integer(5)); body.extend_from_slice(&explicit(1, &encode_integer(self.msg_type as i64)));
if !self.padata.is_empty() {
body.extend_from_slice(&explicit(2, &encode_padata_seq(&self.padata)));
}
body.extend_from_slice(&explicit(3, &encode_realm(&self.crealm)));
body.extend_from_slice(&explicit(4, &self.cname.encode()));
body.extend_from_slice(&explicit(5, &self.ticket.encode()));
body.extend_from_slice(&explicit(6, &self.enc_part.encode()));
tlv(
application_tag(self.msg_type as u8),
&encode_sequence(&body),
)
}
pub fn decode(der: &[u8]) -> Result<Self, DerError> {
let (app, inner) = Der::new(der).read_tlv().and_then(|(t, c)| {
if t == application_tag(11) || t == application_tag(13) {
Ok((t, c))
} else {
Err(DerError::TagMismatch {
expected: application_tag(11),
found: t,
})
}
})?;
let seq = one(inner, TAG_SEQUENCE)?;
let mut r = Der::new(seq);
let pvno = read_i32(r.expect(context_tag(0))?)?;
if pvno != 5 {
return Err(DerError::BadProtocolVersion);
}
let msg_type = read_i32(r.expect(context_tag(1))?)?;
let expected = if app == application_tag(11) { 11 } else { 13 };
if msg_type != expected {
return Err(DerError::MsgTypeMismatch);
}
let padata = match opt(&mut r, 2, |b| Ok::<_, DerError>(b.to_vec()))? {
Some(raw) => decode_padata_seq(&raw)?,
None => Vec::new(),
};
let crealm = decode_realm(r.expect(context_tag(3))?)?;
let cname = PrincipalName::decode(r.expect(context_tag(4))?)?;
let ticket = Ticket::decode(r.expect(context_tag(5))?)?;
let enc_part = EncryptedData::decode(r.expect(context_tag(6))?)?;
r.finish()?;
Ok(KdcRep {
msg_type,
padata,
crealm,
cname,
ticket,
enc_part,
})
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct KrbError {
pub stime: KerberosTime,
pub susec: i32,
pub error_code: i32,
pub realm: String,
pub sname: PrincipalName,
pub e_text: Option<String>,
pub e_data: Option<Vec<u8>>,
}
impl KrbError {
pub fn encode(&self) -> Vec<u8> {
let mut body = explicit(0, &encode_integer(5)); body.extend_from_slice(&explicit(1, &encode_integer(30))); body.extend_from_slice(&explicit(4, &self.stime.encode()));
body.extend_from_slice(&explicit(5, &encode_integer(self.susec as i64)));
body.extend_from_slice(&explicit(6, &encode_integer(self.error_code as i64)));
body.extend_from_slice(&explicit(9, &encode_realm(&self.realm)));
body.extend_from_slice(&explicit(10, &self.sname.encode()));
if let Some(t) = &self.e_text {
body.extend_from_slice(&explicit(11, &encode_general_string(t)));
}
if let Some(d) = &self.e_data {
body.extend_from_slice(&explicit(12, &encode_octet_string(d)));
}
tlv(application_tag(30), &encode_sequence(&body))
}
pub fn decode(der: &[u8]) -> Result<Self, DerError> {
let seq = one(one(der, application_tag(30))?, TAG_SEQUENCE)?;
let mut r = Der::new(seq);
let pvno = read_i32(r.expect(context_tag(0))?)?;
if pvno != 5 {
return Err(DerError::BadProtocolVersion);
}
let msg_type = read_i32(r.expect(context_tag(1))?)?;
if msg_type != 30 {
return Err(DerError::MsgTypeMismatch);
}
let _ = opt(&mut r, 2, |b| Ok::<_, DerError>(b.to_vec()))?;
let _ = opt(&mut r, 3, |b| Ok::<_, DerError>(b.to_vec()))?;
let stime = KerberosTime::decode(r.expect(context_tag(4))?)?;
let susec = read_i32(r.expect(context_tag(5))?)?;
let error_code = read_i32(r.expect(context_tag(6))?)?;
let _ = opt(&mut r, 7, |b| Ok::<_, DerError>(b.to_vec()))?;
let _ = opt(&mut r, 8, |b| Ok::<_, DerError>(b.to_vec()))?;
let realm = decode_realm(r.expect(context_tag(9))?)?;
let sname = PrincipalName::decode(r.expect(context_tag(10))?)?;
let e_text = opt(&mut r, 11, |b| {
let c = one(b, TAG_GENERAL_STRING)?;
Ok::<_, DerError>(String::from_utf8_lossy(c).into_owned())
})?;
let e_data = opt(&mut r, 12, |b| {
Ok::<_, DerError>(one(b, TAG_OCTET_STRING)?.to_vec())
})?;
r.finish()?;
Ok(KrbError {
stime,
susec,
error_code,
realm,
sname,
e_text,
e_data,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
fn sample_princ() -> PrincipalName {
PrincipalName {
name_type: 1,
name_string: vec!["alice".into()],
}
}
fn sample_svc() -> PrincipalName {
PrincipalName {
name_type: 2,
name_string: vec!["host".into(), "dc.example.com".into()],
}
}
fn sample_ticket() -> Ticket {
Ticket {
tkt_vno: 5,
realm: "EXAMPLE.COM".into(),
sname: sample_svc(),
enc_part: EncryptedData {
etype: 18,
kvno: Some(2),
cipher: vec![0xde, 0xad, 0xbe, 0xef],
},
}
}
#[test]
fn ticket_roundtrip_and_app_tag() {
let t = sample_ticket();
let der = t.encode();
assert_eq!(der[0], application_tag(1)); assert_eq!(Ticket::decode(&der).unwrap(), t);
}
#[test]
fn as_req_roundtrip_and_app_tag() {
let body = KdcReqBody {
kdc_options: 0x40810010,
cname: Some(sample_princ()),
realm: "EXAMPLE.COM".into(),
sname: Some(sample_svc()),
from: None,
till: KerberosTime("20370913024805Z".into()),
rtime: None,
nonce: 0x1234_5678,
etypes: vec![18, 17, 23],
addresses: None,
enc_authorization_data: None,
additional_tickets: None,
};
let req = KdcReq {
msg_type: 10,
padata: vec![PaData {
padata_type: 128,
padata_value: vec![0x30, 0x00],
}],
req_body: body,
};
let der = req.encode();
assert_eq!(der[0], application_tag(10)); assert_eq!(KdcReq::decode(&der).unwrap(), req);
}
#[test]
fn as_rep_roundtrip_and_app_tag() {
let rep = KdcRep {
msg_type: 11,
padata: vec![],
crealm: "EXAMPLE.COM".into(),
cname: sample_princ(),
ticket: sample_ticket(),
enc_part: EncryptedData {
etype: 18,
kvno: None,
cipher: vec![1, 2, 3],
},
};
let der = rep.encode();
assert_eq!(der[0], application_tag(11)); assert_eq!(KdcRep::decode(&der).unwrap(), rep);
}
#[test]
fn krb_error_roundtrip_and_app_tag() {
let err = KrbError {
stime: KerberosTime("20240102030405Z".into()),
susec: 123456,
error_code: 25, realm: "EXAMPLE.COM".into(),
sname: sample_svc(),
e_text: Some("NEEDED_PREAUTH".into()),
e_data: Some(vec![0x30, 0x05, 0x02, 0x01, 0x01]),
};
let der = err.encode();
assert_eq!(der[0], application_tag(30)); assert_eq!(KrbError::decode(&der).unwrap(), err);
}
#[test]
fn kdc_req_body_optional_fields_roundtrip() {
let body = KdcReqBody {
kdc_options: 0,
cname: None, realm: "R".into(),
sname: Some(sample_svc()),
from: Some(KerberosTime("20240101000000Z".into())),
till: KerberosTime("20240102000000Z".into()),
rtime: Some(KerberosTime("20240103000000Z".into())),
nonce: 1,
etypes: vec![18],
addresses: Some(vec![0x30, 0x00]),
enc_authorization_data: None,
additional_tickets: Some(vec![0x30, 0x00]),
};
assert_eq!(KdcReqBody::decode(&body.encode()).unwrap(), body);
}
#[test]
fn ticket_der_matches_picky_krb() {
let der = sample_ticket().encode();
let pk: picky_krb::data_types::Ticket =
picky_asn1_der::from_bytes(&der).expect("picky-krb parses kerbcore Ticket DER");
let reencoded = picky_asn1_der::to_vec(&pk).expect("picky-krb re-encodes");
assert_eq!(reencoded, der, "Ticket DER diverges from picky-krb");
}
#[test]
fn krb_error_der_matches_picky_krb() {
let err = KrbError {
stime: KerberosTime("20240102030405Z".into()),
susec: 123456,
error_code: 25,
realm: "EXAMPLE.COM".into(),
sname: sample_svc(),
e_text: Some("NEEDED_PREAUTH".into()),
e_data: Some(vec![0x30, 0x05, 0x02, 0x01, 0x01]),
};
let der = err.encode();
let pk: picky_krb::messages::KrbError =
picky_asn1_der::from_bytes(&der).expect("picky-krb parses kerbcore KRB-ERROR DER");
let reencoded = picky_asn1_der::to_vec(&pk).expect("picky-krb re-encodes");
assert_eq!(reencoded, der, "KRB-ERROR DER diverges from picky-krb");
}
#[test]
fn as_rep_der_matches_picky_krb() {
let rep = KdcRep {
msg_type: 11,
padata: vec![],
crealm: "EXAMPLE.COM".into(),
cname: sample_princ(),
ticket: sample_ticket(),
enc_part: EncryptedData {
etype: 18,
kvno: None,
cipher: vec![1, 2, 3],
},
};
let der = rep.encode();
let pk: picky_krb::messages::AsRep =
picky_asn1_der::from_bytes(&der).expect("picky-krb parses kerbcore AS-REP DER");
let reencoded = picky_asn1_der::to_vec(&pk).expect("picky-krb re-encodes");
assert_eq!(reencoded, der, "AS-REP DER diverges from picky-krb");
}
#[test]
fn messages_reject_garbage_without_panic() {
for bad in [&[][..], &[0x6a, 0x02, 0x30, 0x00][..], &[0xff][..]] {
assert!(Ticket::decode(bad).is_err());
assert!(KdcReq::decode(bad).is_err());
assert!(KdcRep::decode(bad).is_err());
assert!(KrbError::decode(bad).is_err());
}
}
fn sample_req_body() -> KdcReqBody {
KdcReqBody {
kdc_options: 0x40810010,
cname: Some(sample_princ()),
realm: "EXAMPLE.COM".into(),
sname: Some(sample_svc()),
from: None,
till: KerberosTime("20370913024805Z".into()),
rtime: None,
nonce: 1,
etypes: vec![18],
addresses: None,
enc_authorization_data: None,
additional_tickets: None,
}
}
#[test]
fn kdc_req_rejects_app_tag_msg_type_mismatch() {
let inner = encode_sequence(
&[
explicit(1, &encode_integer(5)), explicit(2, &encode_integer(12)), explicit(4, &sample_req_body().encode()),
]
.concat(),
);
let der = tlv(application_tag(10), &inner);
assert_eq!(KdcReq::decode(&der), Err(DerError::MsgTypeMismatch));
}
#[test]
fn kdc_req_rejects_bad_pvno() {
let inner = encode_sequence(
&[
explicit(1, &encode_integer(6)), explicit(2, &encode_integer(10)),
explicit(4, &sample_req_body().encode()),
]
.concat(),
);
let der = tlv(application_tag(10), &inner);
assert_eq!(KdcReq::decode(&der), Err(DerError::BadProtocolVersion));
}
#[test]
fn ticket_rejects_bad_tkt_vno() {
let mut t = sample_ticket();
t.tkt_vno = 4;
assert_eq!(
Ticket::decode(&t.encode()),
Err(DerError::BadProtocolVersion)
);
}
#[test]
fn kdc_req_body_rejects_noncanonical_flags() {
let bad = encode_sequence(&explicit(0, &tlv(TAG_BIT_STRING, &[0x00, 0, 0, 0])));
assert_eq!(KdcReqBody::decode(&bad), Err(DerError::BadBitString));
}
#[test]
fn kdc_req_body_rejects_truncated_trailing_optional() {
let good = sample_req_body().encode();
let inner = one(&good, TAG_SEQUENCE).unwrap();
let mut corrupt = inner.to_vec();
corrupt.push(context_tag(9)); assert!(KdcReqBody::decode(&encode_sequence(&corrupt)).is_err());
}
}