357 lines
10 KiB
Rust
357 lines
10 KiB
Rust
use std::{
|
|
collections::HashMap,
|
|
io::{Read, Write},
|
|
net::TcpStream,
|
|
sync::Mutex,
|
|
thread,
|
|
time::Duration,
|
|
};
|
|
|
|
use anyhow::{bail, Context, Error, Result};
|
|
|
|
use crate::{
|
|
command::{
|
|
Body, CommandHeartbeat, CommandQueryCustom, CommandQuerySubtype, CommandSubtypeResponse,
|
|
MessageType, RequestSerializer,
|
|
},
|
|
devices::{e1::E1, AttributeValue, DeviceBackend},
|
|
hex,
|
|
packet_builder::PacketBuilder,
|
|
security::{MsgType, Security},
|
|
DeviceInfo,
|
|
};
|
|
|
|
enum ParseMessage {
|
|
Success,
|
|
Padding,
|
|
}
|
|
|
|
pub struct Device {
|
|
info: DeviceInfo,
|
|
|
|
socket: Mutex<TcpStream>,
|
|
security: Security,
|
|
|
|
device_backend: Box<dyn DeviceBackend>,
|
|
|
|
buffer: Vec<u8>,
|
|
sub_type: u16,
|
|
device_protocol_version: u8,
|
|
|
|
updates: Vec<Box<dyn Fn(&HashMap<&'static str, AttributeValue>) -> Result<()> + Send + Sync>>,
|
|
|
|
token: [u8; 64],
|
|
key: [u8; 32],
|
|
}
|
|
|
|
impl Device {
|
|
pub async fn connect(info: DeviceInfo, token: &str, key: &str) -> Result<Self> {
|
|
let mut socket = Err(Error::msg(""));
|
|
|
|
for _ in 0..10 {
|
|
socket = TcpStream::connect(info.addr).context(info.addr);
|
|
|
|
if socket.is_ok() {
|
|
break;
|
|
}
|
|
|
|
thread::sleep(Duration::from_millis(500));
|
|
}
|
|
|
|
let socket = socket?;
|
|
socket.set_write_timeout(Some(Duration::from_secs(10)))?;
|
|
socket.set_read_timeout(Some(Duration::from_secs(10)))?;
|
|
|
|
let mut me = Self {
|
|
device_backend: Box::new(match info.device_type {
|
|
0xE1 => E1::new()?,
|
|
|
|
_ => bail!("unsupported device type: {:02X}", info.device_type),
|
|
}),
|
|
|
|
info,
|
|
socket: Mutex::new(socket),
|
|
security: Security::default(),
|
|
|
|
buffer: Vec::new(),
|
|
sub_type: 0,
|
|
device_protocol_version: 0,
|
|
|
|
updates: Vec::new(),
|
|
|
|
token: hex(token)?.try_into().unwrap(),
|
|
key: hex(key)?.try_into().unwrap(),
|
|
};
|
|
|
|
if me.info.protocol == 3 {
|
|
me.authenticate()?;
|
|
}
|
|
|
|
me.refresh_status().await?;
|
|
|
|
Ok(me)
|
|
}
|
|
|
|
fn authenticate(&mut self) -> Result<()> {
|
|
let request = self
|
|
.security
|
|
.encode_8370(&self.token, MsgType::HANDSHAKE_REQUEST)?;
|
|
|
|
let mut socket = self.socket.lock().unwrap();
|
|
|
|
socket.write(&request)?;
|
|
|
|
let mut buffer = [0; 512];
|
|
let bytes_read = socket.read(&mut buffer)?;
|
|
|
|
if bytes_read < 20 {
|
|
bail!(
|
|
"Authentication failed! (answer too short) {:?}",
|
|
&buffer[..bytes_read]
|
|
);
|
|
}
|
|
|
|
self.security.tcp_key(&buffer[8..72], &self.key)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn refresh_status(&mut self) -> Result<()> {
|
|
let mut cmds = vec![self.device_backend.build_query()];
|
|
|
|
if self.sub_type == 0 {
|
|
cmds.insert(0, CommandQuerySubtype::new(self.info.device_type).request());
|
|
}
|
|
|
|
for cmd in cmds {
|
|
self.build_send(cmd)?;
|
|
|
|
loop {
|
|
let mut buf = [0; 512];
|
|
let bytes_read = match self.socket.lock().unwrap().read(&mut buf) {
|
|
Ok(b) => b,
|
|
Err(_) => continue,
|
|
};
|
|
|
|
if bytes_read == 0 {
|
|
bail!("socket error");
|
|
}
|
|
|
|
match self.parse_message(&buf[..bytes_read])? {
|
|
ParseMessage::Success => break,
|
|
ParseMessage::Padding => continue,
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn set_attribute(&self, attribute: &str, value: AttributeValue) -> Result<()> {
|
|
self.build_send(self.device_backend.set_attribute(attribute, value))
|
|
}
|
|
|
|
pub async fn send_command(&self, message_type: MessageType, body: &[u8]) -> Result<()> {
|
|
self.build_send(CommandQueryCustom::new(
|
|
self.info.device_type,
|
|
message_type,
|
|
Body::from(body),
|
|
))
|
|
}
|
|
|
|
pub fn register_update<F>(mut self, f: F) -> Self
|
|
where
|
|
F: Fn(&HashMap<&'static str, AttributeValue>) -> Result<()> + Send + Sync + 'static,
|
|
{
|
|
self.updates.push(Box::new(f));
|
|
|
|
self
|
|
}
|
|
|
|
fn parse_message(&mut self, msg: &[u8]) -> Result<ParseMessage> {
|
|
let (messages, buffer) = self.security.decode_8370([&self.buffer, msg].concat())?;
|
|
self.buffer = buffer;
|
|
|
|
if messages.is_empty() {
|
|
return Ok(ParseMessage::Padding);
|
|
}
|
|
|
|
for mut message in messages {
|
|
if message == b"ERROR" {
|
|
bail!("parse message error");
|
|
}
|
|
|
|
let payload_len = message[4] as u16 + ((message[5] as u16) << 8) - 56;
|
|
let payload_type = message[2] as u16 + ((message[3] as u16) << 8);
|
|
|
|
// heartbeat
|
|
if payload_type == 0x1001 || payload_type == 0x0001 {
|
|
continue;
|
|
}
|
|
|
|
if message.len() > 56 && payload_len % 16 == 0 {
|
|
let len = message.len();
|
|
let crypt = &mut message[40..len - 16];
|
|
|
|
Security::aes_decrypt(crypt);
|
|
|
|
if self.pre_process_message(crypt) {
|
|
self.device_backend.process_message(crypt);
|
|
|
|
for update in self.updates.iter() {
|
|
update(self.device_backend.attributes())?;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(ParseMessage::Success)
|
|
}
|
|
|
|
fn pre_process_message(&mut self, msg: &[u8]) -> bool {
|
|
if msg[9] == MessageType::QuerySubtype as u8 {
|
|
let message = CommandSubtypeResponse::new(msg);
|
|
|
|
self.sub_type = message.sub_type;
|
|
self.device_protocol_version = message.header().device_protocol_version();
|
|
|
|
false
|
|
} else {
|
|
true
|
|
}
|
|
}
|
|
|
|
fn send_message(&self, msg: &[u8]) -> Result<()> {
|
|
let data = self.security.encode_8370(msg, MsgType::ENCRYPTED_REQUEST)?;
|
|
|
|
self.socket.lock().unwrap().write(&data)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn send_heartbeat(&self) -> Result<()> {
|
|
let msg = PacketBuilder::builder(self.info.id, CommandHeartbeat).finalize(0);
|
|
self.send_message(&msg)
|
|
}
|
|
|
|
fn build_send(&self, cmd: impl RequestSerializer) -> Result<()> {
|
|
let data = PacketBuilder::builder(self.info.id, cmd).finalize(1);
|
|
|
|
self.send_message(&data)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use std::net::{Ipv4Addr, SocketAddr};
|
|
|
|
use anyhow::{Context, Result};
|
|
use futures::future::try_join;
|
|
use serial_test::serial;
|
|
|
|
use crate::{device::Device, devices::AttributeValue, Cloud, Startup};
|
|
|
|
#[tokio::test]
|
|
async fn verify_hex() -> Result<()> {
|
|
let devices = Startup::discover().await?;
|
|
|
|
const PY_TOKEN: &str = "06df24fc4e8e950c6d9783051b8e38d971e5fbc617da259459d30d5e7d7fc05b4ccb708fe3a085f6f0af0f8cc961fa39dabfd0746f7bbcfbf7404d9cc5c2b077";
|
|
const PY_KEY: &str = "2a5b5200c2c04d4c811d0550e1dc5b31435436b95b774d2a88d7e46d61fd9669";
|
|
|
|
let token_hex = b"\x06\xdf$\xfcN\x8e\x95\x0cm\x97\x83\x05\x1b\x8e8\xd9q\xe5\xfb\xc6\x17\xda%\x94Y\xd3\r^}\x7f\xc0[L\xcbp\x8f\xe3\xa0\x85\xf6\xf0\xaf\x0f\x8c\xc9a\xfa9\xda\xbf\xd0to{\xbc\xfb\xf7@M\x9c\xc5\xc2\xb0w";
|
|
let key_hex = b"*[R\x00\xc2\xc0ML\x81\x1d\x05P\xe1\xdc[1CT6\xb9[wM*\x88\xd7\xe4ma\xfd\x96i";
|
|
|
|
for device_info in devices {
|
|
let device = Device::connect(device_info, PY_TOKEN, PY_KEY).await?;
|
|
|
|
assert_eq!(&device.token, token_hex);
|
|
assert_eq!(&device.key, key_hex);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn connect_py_token() -> Result<()> {
|
|
let devices = Startup::discover().await?;
|
|
|
|
const PY_TOKEN: &str = "18a821cb88293c6552dc576f0672d8b9445205f74b636764929de5e8badfa48a24caa9d741f632a18e1a9fee67c40b0b40edc21ac7c4c40b6352181cd4000203";
|
|
const PY_KEY: &str = "0fc0c56ea8124414a362e6449ee45ba92558a54f159d4937af697e405f2326b9";
|
|
|
|
for device_info in devices {
|
|
Device::connect(device_info, PY_TOKEN, PY_KEY).await?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
#[serial]
|
|
async fn full_flow() -> Result<()> {
|
|
let mut cloud = Cloud::new("michaelh.95@t-online.de", "Hoda.semi1")?;
|
|
|
|
let (_, devices) = try_join(cloud.login(), Startup::discover()).await?;
|
|
|
|
for device_info in devices {
|
|
let (token, key) = cloud.keys(device_info.id).await?;
|
|
|
|
Device::connect(device_info, &token, &key)
|
|
.await
|
|
.context(format!("\ntoken: {token}\nkey: {key}"))?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
#[serial]
|
|
async fn communication() -> Result<()> {
|
|
let token = "dead840607856a4b84c1a9d94ce8f553b50c037b65fa1ca22126de339c367eb765b231b4525d5b8336c48fe5dae38439bbb5e31282ed3790ff98a48049401dca";
|
|
let key = "50e77947dc63426db3883c7616613410044b02567f5240a5baf789391b2e5a79";
|
|
|
|
let device_info = crate::DeviceInfo {
|
|
id: 152832116426242,
|
|
model: "760EY015".to_string(),
|
|
sn: "0000E1541760EY01534091D002581H2R".to_string(),
|
|
protocol: 3,
|
|
device_type: 225,
|
|
addr: SocketAddr::new(std::net::IpAddr::V4(Ipv4Addr::new(192, 168, 178, 94)), 6444),
|
|
};
|
|
|
|
Device::connect(device_info, token, key).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
#[serial]
|
|
async fn write() -> Result<()> {
|
|
let token = "dead840607856a4b84c1a9d94ce8f553b50c037b65fa1ca22126de339c367eb765b231b4525d5b8336c48fe5dae38439bbb5e31282ed3790ff98a48049401dca";
|
|
let key = "50e77947dc63426db3883c7616613410044b02567f5240a5baf789391b2e5a79";
|
|
|
|
let device_info = crate::DeviceInfo {
|
|
id: 152832116426242,
|
|
model: "760EY015".to_string(),
|
|
sn: "0000E1541760EY01534091D002581H2R".to_string(),
|
|
protocol: 3,
|
|
device_type: 225,
|
|
addr: SocketAddr::new(std::net::IpAddr::V4(Ipv4Addr::new(192, 168, 178, 94)), 6444),
|
|
};
|
|
|
|
let mut device = Device::connect(device_info, token, key)
|
|
.await?
|
|
.register_update(|attributes| {
|
|
println!("{attributes:?}");
|
|
|
|
Ok(())
|
|
});
|
|
|
|
device
|
|
.set_attribute("attribute", AttributeValue::Bool(false))
|
|
.await?;
|
|
|
|
device.refresh_status().await?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|