feat(rdpdr): DR_CORE_SERVER_CLIENTID_CONFIRM and `DR_CORE_DEVICELIS…

…T_ANNOUNCE` (#193)

Adds handling for `DR_CORE_SERVER_CLIENTID_CONFIRM` and `DR_CORE_DEVICELIST_ANNOUNCE`/`DR_CORE_DEVICELIST_ANNOUNCE_REQ`.
The next steps in the rdpdr initialization sequence.

Cargo.toml

@@ -50,7 +50,7 @@ expect-test = "1"
 proptest = "1.1.0"
 rstest = "0.17.0"
 sspi = "0.10.1"
-tracing = "0.1.37"
+tracing = { version = "0.1.37", features = ["log"] }
 thiserror = "1.0.40"
 
 [profile.dev]

crates/ironrdp-client/Cargo.toml

@@ -31,6 +31,8 @@ native-tls = ["ironrdp-tls/native-tls"]
 ironrdp = { workspace = true, features = ["input", "graphics", "dvc", "rdpdr", "rdpsnd", "cliprdr"] }
 ironrdp-tls.workspace = true
 ironrdp-tokio.workspace = true
+ironrdp-rdpsnd.workspace = true
+ironrdp-rdpdr.workspace = true
 sspi = { workspace = true, features = ["network_client", "dns_resolver"] } # enable additional features
 
 # Windowing and rendering

crates/ironrdp-client/src/config.rs

@@ -12,7 +12,7 @@ use tap::prelude::*;
 const DEFAULT_WIDTH: u16 = 1920;
 const DEFAULT_HEIGHT: u16 = 1080;
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct Config {
     pub log_file: String,
     pub destination: Destination,

crates/ironrdp-client/src/rdp.rs

@@ -102,7 +102,7 @@ async fn connect(config: &Config) -> ConnectorResult<(ConnectionResult, Upgraded
         .with_credssp_network_client(RequestClientFactory)
         // .with_static_channel(ironrdp::dvc::Drdynvc::new()) // FIXME: drdynvc is not working
         .with_static_channel(ironrdp::rdpsnd::Rdpsnd::new())
-        .with_static_channel(ironrdp::rdpdr::Rdpdr::default())
+        .with_static_channel(ironrdp_rdpdr::Rdpdr::new("IronRDP".to_string()).with_smartcard(0))
         .with_static_channel(ironrdp::cliprdr::Cliprdr::default());
 
     let should_upgrade = ironrdp_tokio::connect_begin(&mut framed, &mut connector).await?;
@@ -122,6 +122,8 @@ async fn connect(config: &Config) -> ConnectorResult<(ConnectionResult, Upgraded
 
     let connection_result = ironrdp_tokio::connect_finalize(upgraded, &mut upgraded_framed, connector).await?;
 
+    debug!(?connection_result);
+
     Ok((connection_result, upgraded_framed))
 }
 

crates/ironrdp-cliprdr/src/lib.rs

@@ -65,14 +65,14 @@ impl Cliprdr {
         self.state = CliprdrState::Failed;
         error!("CLIPRDR(clipboard) failed: {err}");
 
-        Ok(vec![])
+        Ok(Vec::new())
     }
 
     fn handle_server_capabilities(&mut self, server_capabilities: Capabilities) -> PduResult<Vec<SvcMessage>> {
         self.capabilities.downgrade(&server_capabilities);
 
         // Do not send anything, wait for monitor ready pdu
-        Ok(vec![])
+        Ok(Vec::new())
     }
 
     fn handle_monitor_ready(&mut self) -> PduResult<Vec<SvcMessage>> {
@@ -99,7 +99,7 @@ impl Cliprdr {
             }
         }
 
-        Ok(vec![])
+        Ok(Vec::new())
     }
 }
 
@@ -126,7 +126,7 @@ impl StaticVirtualChannel for Cliprdr {
 
         if self.state == CliprdrState::Failed {
             error!("Attempted to process clipboard static virtual channel in failed state");
-            return Ok(vec![]);
+            return Ok(Vec::new());
         }
 
         match pdu {

crates/ironrdp-fuzzing/Cargo.toml

@@ -13,4 +13,5 @@ test = false
 arbitrary = { version = "1", features = ["derive"] }
 ironrdp-graphics.workspace = true
 ironrdp-pdu.workspace = true
-ironrdp-cliprdr.workspace = true
+ironrdp-cliprdr.workspace = true
+ironrdp-rdpdr.workspace = true

crates/ironrdp-fuzzing/src/oracles/mod.rs

@@ -75,6 +75,8 @@ pub fn pdu_decode(data: &[u8]) {
     let _ = decode::<bitmap::rdp6::BitmapStream>(data);
 
     let _ = decode::<ironrdp_cliprdr::pdu::ClipboardPdu>(data);
+
+    let _ = decode::<ironrdp_rdpdr::pdu::RdpdrPdu>(data);
 }
 
 pub fn rle_decompress_bitmap(input: BitmapInput) {

crates/ironrdp-graphics/src/pointer.rs

@@ -126,7 +126,7 @@ impl DecodedPointer {
             });
         }
 
-        let mut bitmap_data = vec![];
+        let mut bitmap_data = Vec::new();
 
         for row_idx in 0..data.height {
             // For non-monochrome cursors we read strides from bottom to top

crates/ironrdp-graphics/src/rectangle_processing.rs

@@ -1477,7 +1477,7 @@ mod tests {
                 right: 0,
                 bottom: 0,
             },
-            rectangles: vec![],
+            rectangles: Vec::new(),
         };
         let input_rectangle = InclusiveRectangle {
             left: 5,
@@ -1499,7 +1499,7 @@ mod tests {
                 right: 0,
                 bottom: 0,
             },
-            rectangles: vec![],
+            rectangles: Vec::new(),
         };
         let input_rectangle = InclusiveRectangle {
             left: 5,

crates/ironrdp-rdpdr/src/lib.rs

@@ -3,16 +3,17 @@
 //!
 //! [\[MS-RDPEFS\]: Remote Desktop Protocol: File System Virtual Channel Extension]: https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpefs/34d9de58-b2b5-40b6-b970-f82d4603bdb5
 
-mod pdu;
+pub mod pdu;
 use crate::pdu::{
     efs::{
-        CapabilityMessage, ClientNameRequest, ClientNameRequestUnicodeFlag, CoreCapability, CoreCapabilityKind,
-        VersionAndIdPdu, VersionAndIdPduKind,
+        ClientNameRequest, ClientNameRequestUnicodeFlag, CoreCapability, CoreCapabilityKind, VersionAndIdPdu,
+        VersionAndIdPduKind,
     },
     RdpdrPdu,
 };
 use ironrdp_pdu::{decode, gcc::ChannelName, other_err, PduResult};
 use ironrdp_svc::{impl_as_any, CompressionCondition, StaticVirtualChannel, SvcMessage};
+use pdu::efs::{Capabilities, ClientDeviceListAnnounce, Devices};
 use tracing::{trace, warn};
 
 /// The RDPDR channel as specified in [\[MS-RDPEFS\]].
@@ -27,25 +28,31 @@ use tracing::{trace, warn};
 pub struct Rdpdr {
     /// TODO: explain what this is
     computer_name: String,
-    capabilities: Vec<CapabilityMessage>,
-}
-
-impl Default for Rdpdr {
-    fn default() -> Self {
-        Self::new("IronRDP".to_string(), vec![CapabilityMessage::new_general(0)])
-    }
+    capabilities: Capabilities,
+    /// Pre-configured list of devices to announce to the server.
+    ///
+    /// All devices not of the type [`DeviceType::Filesystem`] must be declared here.
+    device_list: Devices,
 }
 
 impl Rdpdr {
     pub const NAME: ChannelName = ChannelName::from_static(b"rdpdr\0\0\0");
 
-    pub fn new(computer_name: String, capabilities: Vec<CapabilityMessage>) -> Self {
+    /// Creates a new [`Rdpdr`].
+    pub fn new(computer_name: String) -> Self {
         Self {
             computer_name,
-            capabilities,
+            capabilities: Capabilities::new(),
+            device_list: Devices::new(),
         }
     }
 
+    pub fn with_smartcard(mut self, device_id: u32) -> Self {
+        self.device_list.add_smartcard(device_id);
+        self.capabilities.add_smartcard();
+        self
+    }
+
     fn handle_server_announce(&mut self, req: VersionAndIdPdu) -> PduResult<Vec<SvcMessage>> {
         let client_announce_reply = RdpdrPdu::VersionAndIdPdu(VersionAndIdPdu::new_client_announce_reply(req)?);
         trace!("sending {:?}", client_announce_reply);
@@ -63,10 +70,16 @@ impl Rdpdr {
     }
 
     fn handle_server_capability(&mut self, _req: CoreCapability) -> PduResult<Vec<SvcMessage>> {
-        let res = RdpdrPdu::CoreCapability(CoreCapability::new_response(self.capabilities.clone()));
+        let res = RdpdrPdu::CoreCapability(CoreCapability::new_response(self.capabilities.clone_inner()));
         trace!("sending {:?}", res);
+        Ok(vec![SvcMessage::from(res)])
+    }
 
-        // TODO: Make CoreCapability PduEncode
+    fn handle_client_id_confirm(&mut self) -> PduResult<Vec<SvcMessage>> {
+        let res = RdpdrPdu::ClientDeviceListAnnounce(ClientDeviceListAnnounce {
+            device_list: self.device_list.clone_inner(),
+        });
+        trace!("sending {:?}", res);
         Ok(vec![SvcMessage::from(res)])
     }
 }
@@ -93,9 +106,12 @@ impl StaticVirtualChannel for Rdpdr {
             RdpdrPdu::CoreCapability(pdu) if pdu.kind == CoreCapabilityKind::ServerCoreCapabilityRequest => {
                 self.handle_server_capability(pdu)
             }
+            RdpdrPdu::VersionAndIdPdu(pdu) if pdu.kind == VersionAndIdPduKind::ServerClientIdConfirm => {
+                self.handle_client_id_confirm()
+            }
             RdpdrPdu::Unimplemented => {
                 warn!("received unimplemented packet: {:?}", pdu);
-                Ok(vec![])
+                Ok(Vec::new())
             }
             _ => Err(other_err!("rdpdr", "internal error")),
         }