Add IDA8.1 support (#42)

* wip: print dumps for new protocol version

* only allow 'guest' to connect for now (ida 8.1+)

* bump version to v0.2.0

Cargo.lock

···
 
 [[package]]
 name = "clap"
-version = "4.0.12"
+version = "4.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "385007cbbed899260395a4107435fead4cad80684461b3cc78238bdcb0bad58f"
+checksum = "69d64e88428747154bd8bc378d178377ef4dace7a5735ca1f3855be72f2c2cb5"
 dependencies = [
  "atty",
  "bitflags",
···
 
 [[package]]
 name = "common"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "binascii",
  "futures-util",
···
 
 [[package]]
 name = "lumen"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "clap",
  "common",
···
 
 [[package]]
 name = "tokio-stream"
-version = "0.1.10"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6edf2d6bc038a43d31353570e27270603f4648d18f5ed10c0e179abe43255af"
+checksum = "d660770404473ccd7bc9f8b28494a811bc18542b915c0855c51e8f419d5223ce"
 dependencies = [
  "futures-core",
  "pin-project-lite",

common/Cargo.toml

···
 [package]
 name = "common"
 description = "common utilities for lumen"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["Naim A. <[e-mail]>"]
 edition = "2018"
 publish = false

common/src/rpc/messages.rs

···
     pub msg: &'a str,
 }
 
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Creds<'a> {
+    pub username: &'a str,
+    pub password: &'a str,
+}
+
 #[derive(Serialize, Deserialize)]
 pub struct RpcHello<'a> {
-    pub unk0: u32,
+    pub protocol_version: u32,
     pub license_data: &'a [u8],
     pub lic_number: [u8; 6],
     pub unk2: u32,

common/src/rpc/mod.rs

···
     Ok(()),
     Fail(RpcFail<'a>),
     Notify(RpcNotify<'a>),
-    Hello(RpcHello<'a>),
+    Hello(RpcHello<'a>, Option<Creds<'a>>),
     PullMetadata(PullMetadata<'a>),
     PullMetadataResult(PullMetadataResult<'a>),
     PushMetadata(PushMetadata<'a>),
···
             RpcMessage::Ok(msg) => tuple.serialize_element(msg)?,
             RpcMessage::Fail(msg) => tuple.serialize_element(msg)?,
             RpcMessage::Notify(msg) => tuple.serialize_element(msg)?,
-            RpcMessage::Hello(msg) => tuple.serialize_element(msg)?,
+            RpcMessage::Hello(msg, _) => tuple.serialize_element(msg)?,
             RpcMessage::PullMetadata(msg) => tuple.serialize_element(msg)?,
             RpcMessage::PullMetadataResult(msg) => tuple.serialize_element(msg)?,
             RpcMessage::PushMetadata(msg) => tuple.serialize_element(msg)?,
···
     fn deserialize_check<T: serde::Deserialize<'a>>(payload: &'a [u8]) -> Result<T, Error> {
         let v = de::from_slice(payload)?;
         if v.1 != payload.len() {
-            trace!("{} remaining bytes after deserializing {}", payload.len() - v.1, std::any::type_name::<T>());
+            let bytes_remaining = crate::make_pretty_hex(&payload[v.1..]);
+            trace!("{} remaining bytes after deserializing {}\n{bytes_remaining}", payload.len() - v.1, std::any::type_name::<T>());
         }
         Ok(v.0)
     }
···
         let res = match msg_type {
             0x0a => {
                 if !payload.is_empty() {
-                    trace!("Ok message with additional data: {} bytes", payload.len());
+                    trace!("Ok message with additional data: {} bytes: {payload:02x?}", payload.len());
                 }
                 RpcMessage::Ok(())
             },
             0x0b => RpcMessage::Fail(Self::deserialize_check(payload)?),
             0x0c => RpcMessage::Notify(Self::deserialize_check(payload)?),
-            0x0d => RpcMessage::Hello(Self::deserialize_check(payload)?),
+            0x0d => {
+                let (hello, consumed) = de::from_slice::<messages::RpcHello>(payload)?;
+                let creds = if payload.len() > consumed && hello.protocol_version > 2 {
+                    let payload = &payload[consumed..];
+                    let (creds, consumed) = de::from_slice::<Creds>(payload)?;
+                    if payload.len() != consumed {
+                        trace!("bytes remaining after HelloV2: {payload:02x?}");
+                    }
+                    Some(creds)
+                } else {
+                    if hello.protocol_version > 2 || payload.len() != consumed {
+                        trace!("Unexpected Hello msg: {payload:02x?}");
+                    }
+                    None
+                };
+                RpcMessage::Hello(hello, creds)
+            },
             0x0e => RpcMessage::PullMetadata(Self::deserialize_check(payload)?),
             0x0f => RpcMessage::PullMetadataResult(Self::deserialize_check(payload)?),
             0x10 => RpcMessage::PushMetadata(Self::deserialize_check(payload)?),
···
             Ok(_) => 0x0a,
             Fail(_) => 0x0b,
             Notify(_) => 0x0c,
-            Hello(_) => 0x0d,
+            Hello(..) => 0x0d,
             PullMetadata(_) => 0x0e,
             PullMetadataResult(_) => 0x0f,
             PushMetadata(_) => 0x10,

lumen/Cargo.toml

···
 [package]
 name = "lumen"
 description = "lumen server"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["Naim A. <[e-mail]>"]
 edition = "2018"
 publish = false

lumen/src/main.rs

···
         },
     };
 
-    let hello = match RpcMessage::deserialize(&hello) {
-        Ok(RpcMessage::Hello(v)) => v,
+    let (hello, creds) = match RpcMessage::deserialize(&hello) {
+        Ok(RpcMessage::Hello(v, creds)) => {
+            debug!("hello protocol={}, login creds: {creds:?}", v.protocol_version);
+            (v, creds)
+        },
         _ => {
             // send error
             error!("got bad hello message");
···
             return Ok(());
         }
     };
+
+    if let Some(ref creds) = creds {
+        if creds.username != "guest" {
+            // Only allow "guest" to connect for now.
+            rpc::RpcMessage::Fail(rpc::RpcFail {
+                code: 1,
+                message: &format!("{server_name}: invalid username or password. Try logging in with `guest` instead."),
+            }).async_write(&mut stream).await?;
+            return Ok(());
+        }
+    }
 
     let resp = rpc::RpcMessage::Ok(());
     resp.async_write(&mut stream).await?;