Restore stock attach renderer handshake

Author: DoubleStyx

crates/renderide-shared/src/ipc/connection.rs

@@ -2,7 +2,7 @@
 //!
 //! Matches the managed host's argument convention (see `RenderingManager.GetConnectionParameters`).
 
-use std::env::{self, VarError};
+use std::env;
 use std::mem::size_of;
 use std::net::UdpSocket;
 use std::num::TryFromIntError;
@@ -15,14 +15,6 @@ use thiserror::Error;
 const ATTACH_RENDERER_PORT: u16 = 42_512;
 /// Maximum accepted attach handshake payload size.
 const ATTACH_RENDERER_PACKET_MAX_BYTES: usize = 4096;
-/// Environment variable carrying the debug-attach v2 nonce.
-pub const ATTACH_RENDERER_NONCE_ENV: &str = "RENDERIDE_ATTACH_NONCE";
-/// Magic prefix for authenticated debug-attach v2 packets.
-const ATTACH_RENDERER_V2_MAGIC: &[u8] = b"RenderideAttachV2\0";
-/// Minimum nonce length accepted for debug attach.
-const ATTACH_RENDERER_MIN_NONCE_BYTES: usize = 16;
-/// Maximum nonce length accepted for debug attach.
-const ATTACH_RENDERER_MAX_NONCE_BYTES: usize = 128;
 /// Maximum number of bytes in a .NET 7-bit encoded i32.
 const MAX_7BIT_ENCODED_I32_BYTES: usize = 5;
 /// High bit marking another 7-bit length byte.
@@ -52,24 +44,6 @@ enum AttachConnectionError {
     /// The attach listener failed while waiting for the host datagram.
     #[error("failed to receive attach renderer parameters: {0}")]
     Receive(#[source] std::io::Error),
-    /// An authenticated v2 attach packet was received without a configured nonce.
-    #[error("attach renderer v2 packet requires {ATTACH_RENDERER_NONCE_ENV}")]
-    MissingNonce,
-    /// Attach nonce was outside the accepted size range.
-    #[error("attach renderer nonce length {len} is outside the accepted range")]
-    InvalidNonceLength {
-        /// Nonce byte length.
-        len: usize,
-    },
-    /// Attach nonce could not be read as a Unicode environment value.
-    #[error("attach renderer nonce is not valid Unicode")]
-    InvalidNonceEncoding,
-    /// The packet was not an authenticated v2 attach packet.
-    #[error("attach renderer packet is not an authenticated v2 packet")]
-    MissingV2Magic,
-    /// The packet nonce does not match the expected launch nonce.
-    #[error("attach renderer nonce mismatch")]
-    NonceMismatch,
     /// The payload ended before the queue name length prefix completed.
     #[error("attach renderer payload ended before the queue name length prefix completed")]
     TruncatedStringLength,
@@ -179,19 +153,7 @@ fn arg_has_ascii_suffix(arg: &str, suffix: &str) -> bool {
 
 /// Waits for connection parameters from the debug attach UDP handshake.
 fn get_connection_parameters_from_attach_renderer() -> Option<ConnectionParams> {
-    let nonce = match attach_renderer_nonce_from_env() {
-        Ok(nonce) => nonce,
-        Err(error) => {
-            logger::warn!("Attach renderer handshake failed: {error}");
-            return None;
-        }
-    };
-    if nonce.is_none() {
-        logger::warn!(
-            "Attach renderer nonce not configured; accepting unauthenticated legacy attach payloads"
-        );
-    }
-    match receive_attach_renderer_parameters(nonce.as_deref()) {
+    match receive_attach_renderer_parameters() {
         Ok(params) => Some(params),
         Err(error) => {
             logger::warn!("Attach renderer handshake failed: {error}");
@@ -200,29 +162,8 @@ fn get_connection_parameters_from_attach_renderer() -> Option<ConnectionParams>
     }
 }
 
-fn attach_renderer_nonce_from_env() -> Result<Option<Vec<u8>>, AttachConnectionError> {
-    let nonce = match env::var(ATTACH_RENDERER_NONCE_ENV) {
-        Ok(nonce) => nonce.into_bytes(),
-        Err(VarError::NotPresent) => return Ok(None),
-        Err(VarError::NotUnicode(_nonce)) => {
-            return Err(AttachConnectionError::InvalidNonceEncoding);
-        }
-    };
-    validate_attach_renderer_nonce(&nonce)?;
-    Ok(Some(nonce))
-}
-
-fn validate_attach_renderer_nonce(nonce: &[u8]) -> Result<(), AttachConnectionError> {
-    if !(ATTACH_RENDERER_MIN_NONCE_BYTES..=ATTACH_RENDERER_MAX_NONCE_BYTES).contains(&nonce.len()) {
-        return Err(AttachConnectionError::InvalidNonceLength { len: nonce.len() });
-    }
-    Ok(())
-}
-
 /// Receives and parses the debug attach UDP datagram.
-fn receive_attach_renderer_parameters(
-    expected_nonce: Option<&[u8]>,
-) -> Result<ConnectionParams, AttachConnectionError> {
+fn receive_attach_renderer_parameters() -> Result<ConnectionParams, AttachConnectionError> {
     let socket = UdpSocket::bind(("127.0.0.1", ATTACH_RENDERER_PORT))
         .map_err(AttachConnectionError::Bind)?;
     logger::info!(
@@ -233,48 +174,11 @@ fn receive_attach_renderer_parameters(
     let (len, _) = socket
         .recv_from(&mut buf)
         .map_err(AttachConnectionError::Receive)?;
-    parse_attach_renderer_packet(&buf[..len], expected_nonce)
+    parse_attach_renderer_packet(&buf[..len])
 }
 
-/// Parses the authenticated host attach datagram.
-fn parse_attach_renderer_packet(
-    packet: &[u8],
-    expected_nonce: Option<&[u8]>,
-) -> Result<ConnectionParams, AttachConnectionError> {
-    let Some(rest) = packet.strip_prefix(ATTACH_RENDERER_V2_MAGIC) else {
-        if expected_nonce.is_some() {
-            return Err(AttachConnectionError::MissingV2Magic);
-        }
-        logger::warn!("Attach renderer accepted unauthenticated legacy payload");
-        return parse_attach_renderer_legacy_payload(packet);
-    };
-    let Some(expected_nonce) = expected_nonce else {
-        return Err(AttachConnectionError::MissingNonce);
-    };
-    validate_attach_renderer_nonce(expected_nonce)?;
-    let (nonce_len, nonce_offset) = read_7bit_encoded_usize(rest)?;
-    let nonce_end = nonce_offset.checked_add(nonce_len).ok_or_else(|| {
-        AttachConnectionError::TruncatedQueueName {
-            expected: nonce_len,
-            remaining: rest.len().saturating_sub(nonce_offset),
-        }
-    })?;
-    if nonce_end > rest.len() {
-        return Err(AttachConnectionError::TruncatedQueueName {
-            expected: nonce_len,
-            remaining: rest.len().saturating_sub(nonce_offset),
-        });
-    }
-    if &rest[nonce_offset..nonce_end] != expected_nonce {
-        return Err(AttachConnectionError::NonceMismatch);
-    }
-    parse_attach_renderer_legacy_payload(&rest[nonce_end..])
-}
-
-/// Parses the queue portion of the host attach datagram encoded by `.NET BinaryWriter`.
-fn parse_attach_renderer_legacy_payload(
-    packet: &[u8],
-) -> Result<ConnectionParams, AttachConnectionError> {
+/// Parses the host attach datagram encoded by `.NET BinaryWriter`.
+fn parse_attach_renderer_packet(packet: &[u8]) -> Result<ConnectionParams, AttachConnectionError> {
     let (queue_name_len, queue_name_offset) = read_7bit_encoded_usize(packet)?;
     let Some(queue_name_end) = queue_name_offset.checked_add(queue_name_len) else {
         return Err(AttachConnectionError::TruncatedQueueName {
@@ -424,29 +328,14 @@ pub fn publisher_queue_name(base: &str, channel: &str) -> String {
 mod tests {
     use super::*;
 
-    const TEST_NONCE: &[u8] = b"0123456789abcdef";
-
     fn attach_packet(queue_name: &str, queue_capacity: i64) -> Vec<u8> {
-        v2_packet(&legacy_attach_packet(queue_name, queue_capacity))
-    }
-
-    fn legacy_attach_packet(queue_name: &str, queue_capacity: i64) -> Vec<u8> {
         let mut packet = Vec::new();
         write_7bit_encoded_usize(queue_name.len(), &mut packet);
         packet.extend_from_slice(queue_name.as_bytes());
         packet.extend_from_slice(&queue_capacity.to_le_bytes());
         packet
     }
 
-    fn v2_packet(legacy_payload: &[u8]) -> Vec<u8> {
-        let mut packet = Vec::new();
-        packet.extend_from_slice(ATTACH_RENDERER_V2_MAGIC);
-        write_7bit_encoded_usize(TEST_NONCE.len(), &mut packet);
-        packet.extend_from_slice(TEST_NONCE);
-        packet.extend_from_slice(legacy_payload);
-        packet
-    }
-
     fn write_7bit_encoded_usize(mut value: usize, packet: &mut Vec<u8>) {
         while value >= usize::from(SEVEN_BIT_CONTINUATION) {
             packet.push((value as u8 & SEVEN_BIT_VALUE_MASK) | SEVEN_BIT_CONTINUATION);
@@ -470,13 +359,10 @@ mod tests {
     }
 
     #[test]
-    fn parse_attach_renderer_packet_accepts_authenticated_binary_writer_payload() {
+    fn parse_attach_renderer_packet_accepts_binary_writer_payload() {
         assert_eq!(
-            parse_attach_renderer_packet(
-                &attach_packet("RenderideQueue", 8_388_608),
-                Some(TEST_NONCE),
-            )
-            .expect("attach packet should parse"),
+            parse_attach_renderer_packet(&attach_packet("RenderideQueue", 8_388_608))
+                .expect("attach packet should parse"),
             ConnectionParams {
                 queue_name: "RenderideQueue".into(),
                 queue_capacity: 8_388_608,
@@ -488,7 +374,7 @@ mod tests {
     fn parse_attach_renderer_packet_accepts_multibyte_string_length() {
         let queue_name = "q".repeat(130);
         assert_eq!(
-            parse_attach_renderer_packet(&attach_packet(&queue_name, 4096), Some(TEST_NONCE))
+            parse_attach_renderer_packet(&attach_packet(&queue_name, 4096))
                 .expect("attach packet should parse"),
             ConnectionParams {
                 queue_name,
@@ -497,53 +383,10 @@ mod tests {
         );
     }
 
-    #[test]
-    fn parse_attach_renderer_packet_rejects_legacy_payload_when_nonce_is_configured() {
-        let error = parse_attach_renderer_packet(
-            &legacy_attach_packet("RenderideQueue", 8_388_608),
-            Some(TEST_NONCE),
-        )
-        .expect_err("legacy attach packet should be rejected");
-        assert!(matches!(error, AttachConnectionError::MissingV2Magic));
-    }
-
-    #[test]
-    fn parse_attach_renderer_packet_accepts_legacy_payload_when_nonce_is_absent() {
-        assert_eq!(
-            parse_attach_renderer_packet(&legacy_attach_packet("RenderideQueue", 8_388_608), None,)
-                .expect("legacy attach packet should parse"),
-            ConnectionParams {
-                queue_name: "RenderideQueue".into(),
-                queue_capacity: 8_388_608,
-            }
-        );
-    }
-
-    #[test]
-    fn parse_attach_renderer_packet_rejects_v2_payload_when_nonce_is_absent() {
-        let error = parse_attach_renderer_packet(&attach_packet("RenderideQueue", 8_388_608), None)
-            .expect_err("v2 attach packet without expected nonce should be rejected");
-        assert!(matches!(error, AttachConnectionError::MissingNonce));
-    }
-
-    #[test]
-    fn parse_attach_renderer_packet_rejects_nonce_mismatch() {
-        let mut wrong_nonce = TEST_NONCE.to_vec();
-        wrong_nonce[0] ^= 0xff;
-
-        let error = parse_attach_renderer_packet(
-            &attach_packet("RenderideQueue", 8_388_608),
-            Some(&wrong_nonce),
-        )
-        .expect_err("wrong nonce should be rejected");
-        assert!(matches!(error, AttachConnectionError::NonceMismatch));
-    }
-
     #[test]
     fn parse_attach_renderer_packet_rejects_truncated_string_length() {
-        let error =
-            parse_attach_renderer_packet(&v2_packet(&[SEVEN_BIT_CONTINUATION]), Some(TEST_NONCE))
-                .expect_err("length prefix should be incomplete");
+        let error = parse_attach_renderer_packet(&[SEVEN_BIT_CONTINUATION])
+            .expect_err("length prefix should be incomplete");
         assert!(matches!(
             error,
             AttachConnectionError::TruncatedStringLength
@@ -552,11 +395,8 @@ mod tests {
 
     #[test]
     fn parse_attach_renderer_packet_rejects_malformed_string_length() {
-        let error = parse_attach_renderer_packet(
-            &v2_packet(&[0xff, 0xff, 0xff, 0xff, 0x08]),
-            Some(TEST_NONCE),
-        )
-        .expect_err("length prefix should be malformed");
+        let error = parse_attach_renderer_packet(&[0xff, 0xff, 0xff, 0xff, 0x08])
+            .expect_err("length prefix should be malformed");
         assert!(matches!(
             error,
             AttachConnectionError::MalformedStringLength
@@ -565,8 +405,8 @@ mod tests {
 
     #[test]
     fn parse_attach_renderer_packet_rejects_truncated_queue_name() {
-        let error = parse_attach_renderer_packet(&v2_packet(&[4, b'n']), Some(TEST_NONCE))
-            .expect_err("queue name should be incomplete");
+        let error =
+            parse_attach_renderer_packet(&[4, b'n']).expect_err("queue name should be incomplete");
         assert!(matches!(
             error,
             AttachConnectionError::TruncatedQueueName {
@@ -581,7 +421,7 @@ mod tests {
         let mut packet = vec![1, 0xff];
         packet.extend_from_slice(&4096_i64.to_le_bytes());
 
-        let error = parse_attach_renderer_packet(&v2_packet(&packet), Some(TEST_NONCE))
+        let error = parse_attach_renderer_packet(&packet)
             .expect_err("queue name should reject invalid UTF-8");
         assert!(matches!(
             error,
@@ -591,11 +431,8 @@ mod tests {
 
     #[test]
     fn parse_attach_renderer_packet_rejects_truncated_queue_capacity() {
-        let error = parse_attach_renderer_packet(
-            &v2_packet(&[4, b'n', b'a', b'm', b'e']),
-            Some(TEST_NONCE),
-        )
-        .expect_err("queue capacity should be incomplete");
+        let error = parse_attach_renderer_packet(&[4, b'n', b'a', b'm', b'e'])
+            .expect_err("queue capacity should be incomplete");
         assert!(matches!(
             error,
             AttachConnectionError::TruncatedQueueCapacity { remaining: 0 }
@@ -604,14 +441,14 @@ mod tests {
 
     #[test]
     fn parse_attach_renderer_packet_rejects_non_positive_queue_capacity() {
-        let zero = parse_attach_renderer_packet(&attach_packet("queue", 0), Some(TEST_NONCE))
+        let zero = parse_attach_renderer_packet(&attach_packet("queue", 0))
             .expect_err("zero capacity should be invalid");
         assert!(matches!(
             zero,
             AttachConnectionError::InvalidQueueCapacity { queue_capacity: 0 }
         ));
 
-        let negative = parse_attach_renderer_packet(&attach_packet("queue", -1), Some(TEST_NONCE))
+        let negative = parse_attach_renderer_packet(&attach_packet("queue", -1))
             .expect_err("negative capacity should be invalid");
         assert!(matches!(
             negative,
@@ -621,10 +458,10 @@ mod tests {
 
     #[test]
     fn parse_attach_renderer_packet_rejects_oversized_queue_capacity() {
-        let error = parse_attach_renderer_packet(
-            &attach_packet("queue", interprocess::QueueOptions::MAX_CAPACITY + 8),
-            Some(TEST_NONCE),
-        )
+        let error = parse_attach_renderer_packet(&attach_packet(
+            "queue",
+            interprocess::QueueOptions::MAX_CAPACITY + 8,
+        ))
         .expect_err("oversized capacity should be invalid");
         assert!(matches!(
             error,