use crate::der::{
context_tag, encode_len, encode_octet_string, encode_sequence, explicit, one_or, tlv, Der,
DerError, TAG_OCTET_STRING, TAG_SEQUENCE,
};
pub const SPNEGO_OID_DER: &[u8] = &[0x06, 0x06, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x02];
pub const MS_KRB5_OID_DER: &[u8] = &[
0x06, 0x09, 0x2A, 0x86, 0x48, 0x82, 0xF7, 0x12, 0x01, 0x02, 0x02,
];
const TAG_OID: u8 = 0x06;
const TAG_ENUMERATED: u8 = 0x0A;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SpnegoError {
BadToken,
NotSpnego,
}
impl From<DerError> for SpnegoError {
fn from(_: DerError) -> Self {
SpnegoError::BadToken
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum NegState {
AcceptCompleted,
AcceptIncomplete,
Reject,
RequestMic,
}
impl NegState {
fn from_u8(v: u8) -> Option<Self> {
match v {
0 => Some(NegState::AcceptCompleted),
1 => Some(NegState::AcceptIncomplete),
2 => Some(NegState::Reject),
3 => Some(NegState::RequestMic),
_ => None,
}
}
fn to_u8(self) -> u8 {
match self {
NegState::AcceptCompleted => 0,
NegState::AcceptIncomplete => 1,
NegState::Reject => 2,
NegState::RequestMic => 3,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct NegTokenInit {
pub mech_types: Vec<Vec<u8>>,
pub mech_token: Option<Vec<u8>>,
pub mech_list_mic: Option<Vec<u8>>,
}
impl NegTokenInit {
pub fn encode(&self) -> Vec<u8> {
let mech_list: Vec<u8> = self.mech_types.concat();
let mut fields = explicit(0, &encode_sequence(&mech_list)); if let Some(t) = &self.mech_token {
fields.extend_from_slice(&explicit(2, &encode_octet_string(t)));
}
if let Some(m) = &self.mech_list_mic {
fields.extend_from_slice(&explicit(3, &encode_octet_string(m)));
}
let neg = encode_sequence(&fields);
let choice = explicit(0, &neg); let mut content = Vec::with_capacity(SPNEGO_OID_DER.len() + choice.len());
content.extend_from_slice(SPNEGO_OID_DER);
content.extend_from_slice(&choice);
let mut out = vec![0x60];
out.extend_from_slice(&encode_len(content.len()));
out.extend_from_slice(&content);
out
}
pub fn parse(token: &[u8]) -> Result<Self, SpnegoError> {
let mut r = Der::new(token);
let (tag, inner) = r.read_tlv()?;
if tag != 0x60 {
return Err(SpnegoError::BadToken);
}
if inner.len() < SPNEGO_OID_DER.len() || &inner[..SPNEGO_OID_DER.len()] != SPNEGO_OID_DER {
return Err(SpnegoError::NotSpnego);
}
let rest = &inner[SPNEGO_OID_DER.len()..];
let mut cr = Der::new(rest);
let neg = one_or(cr.expect(context_tag(0))?, TAG_SEQUENCE)?; let mut nr = Der::new(neg);
let mech_list = one_or(nr.expect(context_tag(0))?, TAG_SEQUENCE)?;
let mut ml = Der::new(mech_list);
let mut mech_types = Vec::new();
while !ml.is_empty() {
let (t, c) = ml.read_tlv()?;
if t != TAG_OID {
return Err(SpnegoError::BadToken);
}
mech_types.push(tlv(TAG_OID, c));
}
let mut mech_token = None;
let mut mech_list_mic = None;
if nr.peek_tag() == Some(context_tag(1)) {
let _ = nr.expect(context_tag(1))?;
}
if nr.peek_tag() == Some(context_tag(2)) {
mech_token = Some(one_or(nr.expect(context_tag(2))?, TAG_OCTET_STRING)?.to_vec());
}
if nr.peek_tag() == Some(context_tag(3)) {
mech_list_mic = Some(one_or(nr.expect(context_tag(3))?, TAG_OCTET_STRING)?.to_vec());
}
Ok(NegTokenInit {
mech_types,
mech_token,
mech_list_mic,
})
}
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct NegTokenResp {
pub neg_state: Option<NegState>,
pub supported_mech: Option<Vec<u8>>,
pub response_token: Option<Vec<u8>>,
pub mech_list_mic: Option<Vec<u8>>,
}
impl NegTokenResp {
pub fn encode(&self) -> Vec<u8> {
let mut fields = Vec::new();
if let Some(s) = self.neg_state {
fields.extend_from_slice(&explicit(0, &tlv(TAG_ENUMERATED, &[s.to_u8()])));
}
if let Some(m) = &self.supported_mech {
fields.extend_from_slice(&explicit(1, m));
}
if let Some(t) = &self.response_token {
fields.extend_from_slice(&explicit(2, &encode_octet_string(t)));
}
if let Some(m) = &self.mech_list_mic {
fields.extend_from_slice(&explicit(3, &encode_octet_string(m)));
}
explicit(1, &encode_sequence(&fields)) }
pub fn parse(token: &[u8]) -> Result<Self, SpnegoError> {
let mut r = Der::new(token);
let (tag, inner) = r.read_tlv()?;
if tag != context_tag(1) {
return Err(SpnegoError::BadToken);
}
let seq = one_or(inner, TAG_SEQUENCE)?;
let mut nr = Der::new(seq);
let mut out = NegTokenResp::default();
if nr.peek_tag() == Some(context_tag(0)) {
let en = one_or(nr.expect(context_tag(0))?, TAG_ENUMERATED)?;
let v = en.first().copied().ok_or(SpnegoError::BadToken)?;
out.neg_state = Some(NegState::from_u8(v).ok_or(SpnegoError::BadToken)?);
}
if nr.peek_tag() == Some(context_tag(1)) {
let oid = nr.expect(context_tag(1))?;
let mut o = Der::new(oid);
let (t, c) = o.read_tlv()?;
if t != TAG_OID {
return Err(SpnegoError::BadToken);
}
out.supported_mech = Some(tlv(TAG_OID, c));
}
if nr.peek_tag() == Some(context_tag(2)) {
out.response_token =
Some(one_or(nr.expect(context_tag(2))?, TAG_OCTET_STRING)?.to_vec());
}
if nr.peek_tag() == Some(context_tag(3)) {
out.mech_list_mic =
Some(one_or(nr.expect(context_tag(3))?, TAG_OCTET_STRING)?.to_vec());
}
Ok(out)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::gss::KRB5_MECH_OID_DER;
#[test]
fn neg_token_init_round_trip() {
let init = NegTokenInit {
mech_types: vec![KRB5_MECH_OID_DER.to_vec(), MS_KRB5_OID_DER.to_vec()],
mech_token: Some(b"\x60\x03krb5-ap-req".to_vec()),
mech_list_mic: None,
};
let enc = init.encode();
assert_eq!(enc[0], 0x60);
let got = NegTokenInit::parse(&enc).unwrap();
assert_eq!(got, init);
assert_eq!(got.mech_types.len(), 2);
assert_eq!(got.mech_types[0], KRB5_MECH_OID_DER);
}
#[test]
fn neg_token_init_rejects_non_spnego() {
let mut content = KRB5_MECH_OID_DER.to_vec();
content.extend_from_slice(&[0x01, 0x00]);
let mut tok = vec![0x60];
tok.extend_from_slice(&encode_len(content.len()));
tok.extend_from_slice(&content);
assert_eq!(NegTokenInit::parse(&tok), Err(SpnegoError::NotSpnego));
}
#[test]
fn neg_token_resp_round_trip() {
let resp = NegTokenResp {
neg_state: Some(NegState::AcceptCompleted),
supported_mech: Some(KRB5_MECH_OID_DER.to_vec()),
response_token: Some(b"ap-rep-bytes".to_vec()),
mech_list_mic: Some(vec![0xAA; 12]),
};
let enc = resp.encode();
assert_eq!(enc[0], context_tag(1));
let got = NegTokenResp::parse(&enc).unwrap();
assert_eq!(got, resp);
}
#[test]
fn neg_token_resp_all_states() {
for st in [
NegState::AcceptCompleted,
NegState::AcceptIncomplete,
NegState::Reject,
NegState::RequestMic,
] {
let resp = NegTokenResp {
neg_state: Some(st),
..Default::default()
};
assert_eq!(
NegTokenResp::parse(&resp.encode()).unwrap().neg_state,
Some(st)
);
}
}
#[test]
fn garbage_does_not_panic() {
for b in [
&b""[..],
&[0x60],
&[0x60, 0x01, 0x00],
&[0xA1, 0x02, 0x30, 0x00],
&[0xFF; 8],
] {
let _ = NegTokenInit::parse(b);
let _ = NegTokenResp::parse(b);
}
}
}