use super::ServiceError;
pub const AARQ_TAG: u8 = 0x60;
pub const AARE_TAG: u8 = 0x61;
pub const RLRQ_TAG: u8 = 0x62;
pub const RLRE_TAG: u8 = 0x63;
pub mod release_reason {
pub const NORMAL: u8 = 0;
pub const URGENT: u8 = 1;
pub const NOT_FINISHED: u8 = 1;
pub const USER_DEFINED: u8 = 30;
}
pub mod result {
pub const ACCEPTED: u8 = 0;
pub const REJECTED_PERMANENT: u8 = 1;
pub const REJECTED_TRANSIENT: u8 = 2;
}
pub mod application_context {
pub const LN: u8 = 1;
pub const SN: u8 = 2;
pub const LN_CIPHERING: u8 = 3;
pub const SN_CIPHERING: u8 = 4;
}
pub mod mechanism {
pub const LOWEST: u8 = 0;
pub const LLS: u8 = 1;
pub const HLS_MD5: u8 = 3;
pub const HLS_SHA1: u8 = 4;
pub const HLS_GMAC: u8 = 5;
pub const HLS_SHA256: u8 = 6;
pub const HLS_ECDSA: u8 = 7;
pub const HLS_GOST_CMAC: u8 = 8;
pub const HLS_GOST_STREEBOG: u8 = 9;
pub const HLS_GOST_SIGNATURE: u8 = 10;
}
pub mod acse_diagnostic {
pub const NULL: u8 = 0;
pub const APPLICATION_CONTEXT_NAME_NOT_SUPPORTED: u8 = 2;
pub const CALLING_AP_TITLE_NOT_RECOGNIZED: u8 = 3;
pub const AUTHENTICATION_MECHANISM_NAME_NOT_RECOGNISED: u8 = 11;
pub const AUTHENTICATION_FAILURE: u8 = 13;
pub const AUTHENTICATION_REQUIRED: u8 = 14;
}
pub mod acse_provider_diagnostic {
pub const NO_COMMON_ACSE_VERSION: u8 = 2;
}
pub const PROTOCOL_VERSION_1: [u8; 2] = [0x02, 0x84];
const OID_PREFIX_APP_CONTEXT: [u8; 6] = [0x60, 0x85, 0x74, 0x05, 0x08, 0x01];
const OID_PREFIX_MECHANISM: [u8; 6] = [0x60, 0x85, 0x74, 0x05, 0x08, 0x02];
#[derive(Debug, Clone, PartialEq, Default)]
pub struct AssociationRequest {
pub protocol_version: Option<[u8; 2]>,
pub application_context: u8,
pub calling_ap_title: Option<Vec<u8>>,
pub sender_acse_requirements: Option<u8>,
pub mechanism_name: Option<u8>,
pub calling_authentication_value: Option<Vec<u8>>,
pub user_information: Vec<u8>,
}
impl AssociationRequest {
pub fn encode(&self) -> Vec<u8> {
let mut content = Vec::new();
if let Some(pv) = self.protocol_version {
content.extend_from_slice(&[0x80, 0x02, pv[0], pv[1]]);
}
ber_tlv(0xA1, &object_identifier(OID_PREFIX_APP_CONTEXT, self.application_context), &mut content);
if let Some(title) = &self.calling_ap_title {
ber_tlv(0xA6, &octet_string(title), &mut content);
}
if let Some(mech) = self.mechanism_name {
let acse_req = self.sender_acse_requirements.unwrap_or(0x80);
content.extend_from_slice(&[0x8A, 0x02, 0x07, acse_req]);
content.push(0x8B);
let oid = raw_oid(OID_PREFIX_MECHANISM, mech);
push_length(oid.len(), &mut content);
content.extend_from_slice(&oid);
if let Some(auth) = &self.calling_authentication_value {
let mut inner = vec![0x80];
push_length(auth.len(), &mut inner);
inner.extend_from_slice(auth);
ber_tlv(0xAC, &inner, &mut content);
}
} else if let Some(acse_req) = self.sender_acse_requirements {
content.extend_from_slice(&[0x8A, 0x02, 0x07, acse_req]);
if let Some(auth) = &self.calling_authentication_value {
let mut inner = vec![0x80];
push_length(auth.len(), &mut inner);
inner.extend_from_slice(auth);
ber_tlv(0xAC, &inner, &mut content);
}
} else if let Some(auth) = &self.calling_authentication_value {
let mut inner = vec![0x80];
push_length(auth.len(), &mut inner);
inner.extend_from_slice(auth);
ber_tlv(0xAC, &inner, &mut content);
}
ber_tlv(0xBE, &octet_string(&self.user_information), &mut content);
let mut apdu = vec![AARQ_TAG];
push_length(content.len(), &mut apdu);
apdu.extend_from_slice(&content);
apdu
}
pub fn decode(bytes: &[u8]) -> Result<AssociationRequest, ServiceError> {
let content = outer_content(bytes, AARQ_TAG)?;
let mut req = AssociationRequest::default();
for (tag, value) in TlvIter::new(content) {
match tag {
0x80 if value.len() >= 2 => req.protocol_version = Some([value[0], value[1]]),
0xA1 => req.application_context = parse_oid_last_arc(value)?,
0xA6 => req.calling_ap_title = Some(parse_octet_string(value)?),
0x8A if value.len() >= 2 => req.sender_acse_requirements = Some(value[1]),
0x8B => req.mechanism_name = Some(*value.last().ok_or(ServiceError::Truncated)?),
0xAC => req.calling_authentication_value = Some(parse_auth_value(value)?),
0xBE => req.user_information = parse_octet_string(value)?,
_ => {} }
}
Ok(req)
}
}
#[derive(Debug, Clone, PartialEq, Default)]
pub struct AssociationResponse {
pub protocol_version: Option<[u8; 2]>,
pub application_context: u8,
pub result: u8,
pub diagnostic: u8,
pub diagnostic_is_provider: bool,
pub responding_ap_title: Option<Vec<u8>>,
pub mechanism_name: Option<u8>,
pub responding_authentication_value: Option<Vec<u8>>,
pub user_information: Vec<u8>,
}
impl AssociationResponse {
pub fn encode(&self) -> Vec<u8> {
let mut content = Vec::new();
if let Some(pv) = self.protocol_version {
content.extend_from_slice(&[0x80, 0x02, pv[0], pv[1]]);
}
ber_tlv(0xA1, &object_identifier(OID_PREFIX_APP_CONTEXT, self.application_context), &mut content);
ber_tlv(0xA2, &[0x02, 0x01, self.result], &mut content);
let diag_choice = if self.diagnostic_is_provider { 0xA2 } else { 0xA1 };
ber_tlv(0xA3, &[diag_choice, 0x03, 0x02, 0x01, self.diagnostic], &mut content);
if let Some(title) = &self.responding_ap_title {
ber_tlv(0xA4, &octet_string(title), &mut content);
}
if self.responding_authentication_value.is_some() {
content.extend_from_slice(&[0x88, 0x02, 0x07, 0x80]);
if let Some(mech) = self.mechanism_name {
content.push(0x89);
let oid = raw_oid(OID_PREFIX_MECHANISM, mech);
push_length(oid.len(), &mut content);
content.extend_from_slice(&oid);
}
if let Some(auth) = &self.responding_authentication_value {
let mut inner = vec![0x80];
push_length(auth.len(), &mut inner);
inner.extend_from_slice(auth);
ber_tlv(0xAA, &inner, &mut content);
}
}
ber_tlv(0xBE, &octet_string(&self.user_information), &mut content);
let mut apdu = vec![AARE_TAG];
push_length(content.len(), &mut apdu);
apdu.extend_from_slice(&content);
apdu
}
pub fn decode(bytes: &[u8]) -> Result<AssociationResponse, ServiceError> {
let content = outer_content(bytes, AARE_TAG)?;
let mut resp = AssociationResponse { result: result::REJECTED_PERMANENT, ..AssociationResponse::default() };
for (tag, value) in TlvIter::new(content) {
match tag {
0x80 if value.len() >= 2 => resp.protocol_version = Some([value[0], value[1]]),
0xA1 => resp.application_context = parse_oid_last_arc(value)?,
0xA2 => resp.result = *value.last().ok_or(ServiceError::Truncated)?,
0xA3 => {
resp.diagnostic_is_provider = value.first() == Some(&0xA2);
resp.diagnostic = *value.last().ok_or(ServiceError::Truncated)?;
}
0xA4 => resp.responding_ap_title = Some(parse_octet_string(value)?),
0x89 => resp.mechanism_name = Some(*value.last().ok_or(ServiceError::Truncated)?),
0xAA => resp.responding_authentication_value = Some(parse_auth_value(value)?),
0xBE => resp.user_information = parse_octet_string(value)?,
_ => {}
}
}
Ok(resp)
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct ReleaseRequest {
pub reason: Option<u8>,
pub user_information: Option<Vec<u8>>,
}
pub type ReleaseResponse = ReleaseRequest;
impl ReleaseRequest {
pub fn encode_rlrq(&self) -> Vec<u8> {
self.encode(RLRQ_TAG)
}
pub fn encode_rlre(&self) -> Vec<u8> {
self.encode(RLRE_TAG)
}
fn encode(&self, apdu_tag: u8) -> Vec<u8> {
let mut content = Vec::new();
if let Some(reason) = self.reason {
content.extend_from_slice(&[0x80, 0x01, reason]);
}
if let Some(info) = &self.user_information {
ber_tlv(0xBE, &octet_string(info), &mut content);
}
let mut apdu = vec![apdu_tag];
push_length(content.len(), &mut apdu);
apdu.extend_from_slice(&content);
apdu
}
pub fn decode_rlrq(bytes: &[u8]) -> Result<ReleaseRequest, ServiceError> {
Self::decode(bytes, RLRQ_TAG)
}
pub fn decode_rlre(bytes: &[u8]) -> Result<ReleaseResponse, ServiceError> {
Self::decode(bytes, RLRE_TAG)
}
fn decode(bytes: &[u8], apdu_tag: u8) -> Result<ReleaseRequest, ServiceError> {
let content = outer_content(bytes, apdu_tag)?;
let mut req = ReleaseRequest { reason: None, user_information: None };
for (tag, value) in TlvIter::new(content) {
match tag {
0x80 => req.reason = Some(*value.last().ok_or(ServiceError::Truncated)?),
0xBE => req.user_information = Some(parse_octet_string(value)?),
_ => {}
}
}
Ok(req)
}
}
fn object_identifier(prefix: [u8; 6], last_arc: u8) -> Vec<u8> {
let mut v = vec![0x06, 0x07];
v.extend_from_slice(&prefix);
v.push(last_arc);
v
}
fn raw_oid(prefix: [u8; 6], last_arc: u8) -> Vec<u8> {
let mut v = prefix.to_vec();
v.push(last_arc);
v
}
fn octet_string(bytes: &[u8]) -> Vec<u8> {
let mut v = vec![0x04];
push_length(bytes.len(), &mut v);
v.extend_from_slice(bytes);
v
}
fn ber_tlv(tag: u8, value: &[u8], out: &mut Vec<u8>) {
out.push(tag);
push_length(value.len(), out);
out.extend_from_slice(value);
}
#[allow(clippy::cast_possible_truncation)] fn push_length(length: usize, out: &mut Vec<u8>) {
if length < 128 {
out.push(length as u8);
} else {
let bytes = (length as u64).to_be_bytes();
let first = bytes.iter().position(|&b| b != 0).unwrap_or(7);
let n = 8 - first;
out.push(0x80 | n as u8);
out.extend_from_slice(&bytes[first..]);
}
}
fn read_length(bytes: &[u8]) -> Result<(usize, usize), ServiceError> {
let first = *bytes.first().ok_or(ServiceError::Truncated)?;
if first < 128 {
Ok((first as usize, 1))
} else {
let n = (first & 0x7F) as usize;
let slice = bytes.get(1..1 + n).ok_or(ServiceError::Truncated)?;
let mut len = 0usize;
for &b in slice {
len = (len << 8) | b as usize;
}
Ok((len, 1 + n))
}
}
fn outer_content(bytes: &[u8], expected_tag: u8) -> Result<&[u8], ServiceError> {
let tag = *bytes.first().ok_or(ServiceError::Truncated)?;
if tag != expected_tag {
return Err(ServiceError::UnexpectedTag(tag));
}
let (len, header) = read_length(&bytes[1..])?;
let start = 1 + header;
bytes.get(start..start + len).ok_or(ServiceError::Truncated)
}
fn parse_oid_last_arc(value: &[u8]) -> Result<u8, ServiceError> {
value.last().copied().ok_or(ServiceError::Truncated)
}
fn parse_octet_string(value: &[u8]) -> Result<Vec<u8>, ServiceError> {
if value.first() != Some(&0x04) {
return Err(ServiceError::InvalidData);
}
let (len, header) = read_length(&value[1..])?;
let start = 1 + header;
value.get(start..start + len).map(|s| s.to_vec()).ok_or(ServiceError::Truncated)
}
fn parse_auth_value(value: &[u8]) -> Result<Vec<u8>, ServiceError> {
if value.first() != Some(&0x80) {
return Err(ServiceError::InvalidData);
}
let (len, header) = read_length(&value[1..])?;
let start = 1 + header;
value.get(start..start + len).map(|s| s.to_vec()).ok_or(ServiceError::Truncated)
}
struct TlvIter<'a> {
rest: &'a [u8],
}
impl<'a> TlvIter<'a> {
fn new(rest: &'a [u8]) -> Self {
TlvIter { rest }
}
}
impl<'a> Iterator for TlvIter<'a> {
type Item = (u8, &'a [u8]);
fn next(&mut self) -> Option<Self::Item> {
if self.rest.is_empty() {
return None;
}
let tag = self.rest[0];
let (len, header) = read_length(&self.rest[1..]).ok()?;
let start = 1 + header;
let value = self.rest.get(start..start + len)?;
self.rest = &self.rest[start + len..];
Some((tag, value))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn aarq_lls_matches_reference_bytes() {
let initiate_request = vec![0x01, 0x00, 0x00, 0x00, 0x06, 0x5F, 0x1F, 0x04, 0x00, 0x00, 0x7E, 0x1F, 0x04, 0xB0];
let aarq = AssociationRequest {
protocol_version: None,
application_context: application_context::LN,
calling_ap_title: None,
sender_acse_requirements: Some(0x80),
mechanism_name: Some(mechanism::LLS),
calling_authentication_value: Some(b"12345678".to_vec()),
user_information: initiate_request,
};
let encoded = aarq.encode();
let expected = vec![
0x60, 0x36, 0xA1, 0x09, 0x06, 0x07, 0x60, 0x85, 0x74, 0x05, 0x08, 0x01, 0x01, 0x8A, 0x02, 0x07, 0x80, 0x8B, 0x07, 0x60, 0x85, 0x74, 0x05, 0x08, 0x02, 0x01, 0xAC, 0x0A, 0x80, 0x08, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0xBE, 0x10, 0x04, 0x0E, 0x01, 0x00, 0x00, 0x00, 0x06, 0x5F, 0x1F, 0x04, 0x00, 0x00, 0x7E, 0x1F, 0x04, 0xB0,
];
assert_eq!(encoded, expected);
assert_eq!(AssociationRequest::decode(&encoded).unwrap(), aarq);
}
#[test]
fn aarq_no_security_round_trips() {
let aarq = AssociationRequest {
application_context: application_context::LN,
calling_ap_title: None,
mechanism_name: None,
calling_authentication_value: None,
user_information: vec![0x01, 0x00, 0x00, 0x00, 0x06, 0x5F, 0x1F, 0x04, 0x00, 0x00, 0x7E, 0x1F, 0x04, 0xB0],
..Default::default()
};
assert_eq!(AssociationRequest::decode(&aarq.encode()).unwrap(), aarq);
}
#[test]
fn aare_accepted_round_trips() {
let aare = AssociationResponse {
application_context: application_context::LN,
result: result::ACCEPTED,
diagnostic: 0,
responding_ap_title: None,
responding_authentication_value: None,
user_information: vec![0x08, 0x00, 0x06, 0x5F, 0x1F, 0x04, 0x00, 0x00, 0x7E, 0x1F, 0x04, 0xB0],
..Default::default()
};
let encoded = aare.encode();
assert_eq!(encoded[0], AARE_TAG);
assert_eq!(AssociationResponse::decode(&encoded).unwrap(), aare);
}
#[test]
fn rlrq_normal_round_trips() {
let rlrq = ReleaseRequest { reason: Some(release_reason::NORMAL), user_information: None };
assert_eq!(rlrq.encode_rlrq(), vec![0x62, 0x03, 0x80, 0x01, 0x00]);
assert_eq!(ReleaseRequest::decode_rlrq(&rlrq.encode_rlrq()).unwrap(), rlrq);
}
#[test]
fn rlre_with_user_information_round_trips() {
let rlre = ReleaseResponse {
reason: Some(release_reason::NORMAL),
user_information: Some(vec![0x08, 0x00, 0x06, 0x5F, 0x1F, 0x04, 0x00, 0x00, 0x7E, 0x1F, 0x04, 0xB0]),
};
let bytes = rlre.encode_rlre();
assert_eq!(bytes[0], RLRE_TAG);
assert_eq!(ReleaseResponse::decode_rlre(&bytes).unwrap(), rlre);
}
#[test]
fn aare_hls_carries_stoc_and_server_title() {
let aare = AssociationResponse {
application_context: application_context::LN_CIPHERING,
result: result::ACCEPTED,
diagnostic: 0,
responding_ap_title: Some(vec![0x4D, 0x4D, 0x4D, 0x00, 0x00, 0xBC, 0x61, 0x4E]),
responding_authentication_value: Some(b"P6wRJ21F".to_vec()),
user_information: vec![0x08, 0x00],
..Default::default()
};
let decoded = AssociationResponse::decode(&aare.encode()).unwrap();
assert_eq!(decoded, aare);
assert_eq!(decoded.responding_authentication_value.unwrap(), b"P6wRJ21F");
}
}