const SYS_DESCR_OID: &[u8] = &[0x2b, 0x06, 0x01, 0x02, 0x01, 0x01, 0x01, 0x00];
mod tag {
pub const SEQUENCE: u8 = 0x30;
pub const OID: u8 = 0x06;
pub const OCTET_STRING: u8 = 0x04;
pub const GET_RESPONSE: u8 = 0xa2;
}
const MAX_SYS_DESCR: usize = 255;
struct Reader<'a> {
bytes: &'a [u8],
}
impl<'a> Reader<'a> {
fn new(bytes: &'a [u8]) -> Self {
Self { bytes }
}
fn read(&mut self) -> Option<(u8, &'a [u8])> {
let (&tag, rest) = self.bytes.split_first()?;
let (&first, rest) = rest.split_first()?;
let (length, rest) = if first < 0x80 {
(usize::from(first), rest)
} else {
let count = usize::from(first & 0x7f);
if count == 0 || count > 4 {
return None;
}
let (digits, rest) = rest.split_at_checked(count)?;
let length = digits
.iter()
.fold(0usize, |acc, &b| (acc << 8) | usize::from(b));
(length, rest)
};
let (value, remainder) = rest.split_at_checked(length)?;
self.bytes = remainder;
Some((tag, value))
}
fn expect(&mut self, expected: u8) -> Option<&'a [u8]> {
let (tag, value) = self.read()?;
(tag == expected).then_some(value)
}
fn skip(&mut self) -> Option<()> {
self.read().map(|_| ())
}
}
pub(crate) fn sys_descr(datagram: &[u8]) -> Option<&str> {
let mut message = Reader::new(Reader::new(datagram).expect(tag::SEQUENCE)?);
message.skip()?; message.skip()?;
let mut response = Reader::new(message.expect(tag::GET_RESPONSE)?);
response.skip()?; response.skip()?; response.skip()?;
let mut bindings = Reader::new(response.expect(tag::SEQUENCE)?);
let mut binding = Reader::new(bindings.expect(tag::SEQUENCE)?);
if binding.expect(tag::OID)? != SYS_DESCR_OID {
return None;
}
let value = binding.expect(tag::OCTET_STRING)?;
(value.len() <= MAX_SYS_DESCR)
.then(|| std::str::from_utf8(value).ok())
.flatten()
}
#[cfg(test)]
mod tests {
use super::*;
fn tlv(tag: u8, value: &[u8]) -> Vec<u8> {
let mut out = vec![tag, value.len() as u8];
out.extend_from_slice(value);
out
}
fn get_response(oid: &[u8], value_tag: u8, value: &[u8]) -> Vec<u8> {
let mut binding = tlv(tag::OID, oid);
binding.extend(tlv(value_tag, value));
let bindings = tlv(tag::SEQUENCE, &tlv(tag::SEQUENCE, &binding));
let mut pdu = tlv(0x02, b"zond"); pdu.extend(tlv(0x02, &[0])); pdu.extend(tlv(0x02, &[0])); pdu.extend(bindings);
let mut message = tlv(0x02, &[0]); message.extend(tlv(tag::OCTET_STRING, b"public"));
message.extend(tlv(tag::GET_RESPONSE, &pdu));
tlv(tag::SEQUENCE, &message)
}
fn sys_descr_reply(description: &str) -> Vec<u8> {
get_response(SYS_DESCR_OID, tag::OCTET_STRING, description.as_bytes())
}
#[test]
fn a_unix_agent_yields_the_kernel_it_is_running() {
let uname = "Linux pi 6.1.0-rpi7-rpi-v8 #1 SMP PREEMPT Debian 1:6.1.63-1+rpt1 aarch64";
assert_eq!(sys_descr(&sys_descr_reply(uname)), Some(uname));
}
#[test]
fn a_binding_for_another_object_is_refused() {
let other = &[0x2b, 0x06, 0x01, 0x02, 0x01, 0x01, 0x03, 0x00];
let reply = get_response(other, tag::OCTET_STRING, b"Linux something");
assert_eq!(sys_descr(&reply), None);
}
#[test]
fn a_value_that_is_not_a_string_is_refused() {
let reply = get_response(SYS_DESCR_OID, 0x02, &[0x01, 0x02]);
assert_eq!(sys_descr(&reply), None);
}
#[test]
fn nothing_a_peer_can_send_makes_this_panic() {
let whole = sys_descr_reply("Linux test 6.1.0 aarch64");
for cut in 0..whole.len() {
let _ = sys_descr(&whole[..cut]);
}
for offset in 0..whole.len() {
for byte in [0x00u8, 0x01, 0x30, 0x7f, 0x80, 0x84, 0xa2, 0xff] {
let mut mutated = whole.clone();
mutated[offset] = byte;
let _ = sys_descr(&mutated);
}
}
for junk in [
&b""[..],
&[0x30][..],
&[0x30, 0xff][..],
&[0x30, 0x84, 0xff, 0xff, 0xff, 0xff][..],
b"SSH-2.0-OpenSSH_9.2p1",
] {
let _ = sys_descr(junk);
}
}
#[test]
fn a_length_running_past_the_datagram_yields_nothing() {
let mut reply = sys_descr_reply("Linux test");
reply[1] = 0x7f; assert_eq!(sys_descr(&reply), None);
}
#[test]
fn a_description_past_the_defined_bound_is_refused() {
let value = vec![b'A'; 300];
let mut binding = tlv(tag::OID, SYS_DESCR_OID);
binding.push(tag::OCTET_STRING);
binding.extend_from_slice(&[0x82, 0x01, 0x2c]); binding.extend_from_slice(&value);
let bindings = tlv(tag::SEQUENCE, &tlv(tag::SEQUENCE, &binding));
let mut pdu = tlv(0x02, b"zond");
pdu.extend(tlv(0x02, &[0]));
pdu.extend(tlv(0x02, &[0]));
pdu.extend(bindings);
let mut message = tlv(0x02, &[0]);
message.extend(tlv(tag::OCTET_STRING, b"public"));
message.extend(tlv(tag::GET_RESPONSE, &pdu));
let mut reply = vec![tag::SEQUENCE, 0x82];
reply.extend_from_slice(&(message.len() as u16).to_be_bytes());
reply.extend_from_slice(&message);
assert_eq!(sys_descr(&reply), None);
}
#[test]
fn a_request_is_not_an_answer() {
let mut reply = sys_descr_reply("Linux test");
let pdu = reply
.iter()
.position(|&b| b == tag::GET_RESPONSE)
.expect("the fixture carries a response PDU");
reply[pdu] = 0xa0; assert_eq!(sys_descr(&reply), None);
}
}