Implement authenticated public relay and Rust device daemons
This commit is contained in:
1 parent
f96c1aa109
commit
e1c152a657
29 files changed
+3244
-39
No files matched your search
@@ -0,0 +1,16 @@
|
||||
[package]
|
||||
name = "ads-core"
|
||||
version.workspace = true
|
||||
edition.workspace = true
|
||||
license.workspace = true
|
||||
|
||||
[dependencies]
|
||||
anyhow.workspace = true
|
||||
clap.workspace = true
|
||||
futures-util.workspace = true
|
||||
serde.workspace = true
|
||||
serde_json.workspace = true
|
||||
tokio.workspace = true
|
||||
tokio-tungstenite.workspace = true
|
||||
tracing-subscriber.workspace = true
|
||||
url.workspace = true
|
||||
@@ -0,0 +1,256 @@
|
||||
use anyhow::{bail, Context, Result};
|
||||
use clap::Args;
|
||||
use futures_util::{SinkExt, StreamExt};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::time::Duration;
|
||||
use tokio::{
|
||||
io::{AsyncReadExt, AsyncWriteExt},
|
||||
net::TcpStream,
|
||||
time::timeout,
|
||||
};
|
||||
use tokio_tungstenite::{
|
||||
connect_async_with_config,
|
||||
tungstenite::{client::IntoClientRequest, http::HeaderValue, Message},
|
||||
MaybeTlsStream, WebSocketStream,
|
||||
};
|
||||
use url::Url;
|
||||
|
||||
pub type Ws = WebSocketStream<MaybeTlsStream<TcpStream>>;
|
||||
pub const CONNECT_TIMEOUT: Duration = Duration::from_secs(10);
|
||||
pub const IO_TIMEOUT: Duration = Duration::from_secs(30);
|
||||
|
||||
#[derive(Args, Clone, Debug)]
|
||||
pub struct NetworkArgs {
|
||||
/// Relay URL, e.g. wss://devices.example.com
|
||||
#[arg(long)]
|
||||
pub server: String,
|
||||
/// Allow unencrypted ws:// for isolated development only
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub allow_insecure: bool,
|
||||
}
|
||||
|
||||
impl NetworkArgs {
|
||||
pub fn url(&self, path: &str, params: &[(&str, &str)]) -> Result<Url> {
|
||||
let mut url = Url::parse(&self.server).context("invalid relay URL")?;
|
||||
match url.scheme() {
|
||||
"wss" => {}
|
||||
"ws" if self.allow_insecure => {}
|
||||
_ => bail!("use wss://; ws:// requires --allow-insecure for development"),
|
||||
}
|
||||
if !url.username().is_empty()
|
||||
|| url.password().is_some()
|
||||
|| url.query().is_some()
|
||||
|| url.fragment().is_some()
|
||||
{
|
||||
bail!("relay URL must not contain credentials, query, or fragment");
|
||||
}
|
||||
if url.path() != "/" && !url.path().is_empty() {
|
||||
bail!("relay URL must use the root path (no URL prefix)");
|
||||
}
|
||||
url.set_path(path);
|
||||
url.query_pairs_mut().extend_pairs(params.iter().copied());
|
||||
Ok(url)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn valid_device_id(id: &str) -> bool {
|
||||
!id.is_empty()
|
||||
&& id.len() <= 128
|
||||
&& id
|
||||
.bytes()
|
||||
.all(|c| c.is_ascii_alphanumeric() || b"-_.".contains(&c))
|
||||
}
|
||||
|
||||
pub fn validate_token(token: &str) -> Result<()> {
|
||||
if token.len() < 32 {
|
||||
bail!("token must be at least 32 characters");
|
||||
}
|
||||
HeaderValue::from_str(&format!("Bearer {token}")).context("invalid token characters")?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn dial(url: Url, token: &str) -> Result<Ws> {
|
||||
let mut request = url.as_str().into_client_request()?;
|
||||
request.headers_mut().insert(
|
||||
"Authorization",
|
||||
HeaderValue::from_str(&format!("Bearer {token}"))?,
|
||||
);
|
||||
// Do not include the URL in errors: session and lease tickets are secrets.
|
||||
let config = tokio_tungstenite::tungstenite::protocol::WebSocketConfig::default()
|
||||
.max_message_size(Some(128 * 1024))
|
||||
.max_frame_size(Some(128 * 1024));
|
||||
let result = timeout(
|
||||
CONNECT_TIMEOUT,
|
||||
connect_async_with_config(request, Some(config), true),
|
||||
)
|
||||
.await
|
||||
.context("relay handshake timed out")?;
|
||||
match result {
|
||||
Ok((socket, _)) => Ok(socket),
|
||||
Err(tokio_tungstenite::tungstenite::Error::Http(response)) => {
|
||||
bail!("relay rejected request: HTTP {}", response.status())
|
||||
}
|
||||
Err(_) => bail!("relay connection failed (check address, TLS certificate and network)"),
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
pub struct Control {
|
||||
#[serde(rename = "type")]
|
||||
pub kind: String,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub device: Option<String>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub lease: Option<String>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub session: Option<String>,
|
||||
}
|
||||
|
||||
pub async fn next_control(ws: &mut Ws) -> Result<Control> {
|
||||
loop {
|
||||
match ws.next().await.context("control connection closed")?? {
|
||||
Message::Text(text) => {
|
||||
if text.len() > 16 * 1024 {
|
||||
bail!("control message too large");
|
||||
}
|
||||
return Ok(serde_json::from_str(&text)?);
|
||||
}
|
||||
Message::Ping(data) => ws.send(Message::Pong(data)).await?,
|
||||
Message::Pong(_) => {}
|
||||
Message::Close(_) => bail!("control connection closed"),
|
||||
_ => bail!("unexpected control message"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Binary-only relay. Bounded chunks and awaited writes provide backpressure.
|
||||
/// A websocket close terminates both directions; TCP half-close is not preserved.
|
||||
pub async fn relay(tcp: TcpStream, ws: Ws) -> Result<()> {
|
||||
tcp.set_nodelay(true)?;
|
||||
let (mut reader, mut writer) = tcp.into_split();
|
||||
let (mut sink, mut stream) = ws.split();
|
||||
let to_ws = async {
|
||||
let mut buffer = vec![0; 64 * 1024];
|
||||
loop {
|
||||
let size = reader.read(&mut buffer).await?;
|
||||
if size == 0 {
|
||||
return Ok::<(), anyhow::Error>(());
|
||||
}
|
||||
timeout(
|
||||
IO_TIMEOUT,
|
||||
sink.send(Message::Binary(buffer[..size].to_vec().into())),
|
||||
)
|
||||
.await??;
|
||||
}
|
||||
};
|
||||
let to_tcp = async {
|
||||
while let Some(message) = stream.next().await {
|
||||
match message? {
|
||||
Message::Binary(data) => {
|
||||
if data.len() > 128 * 1024 {
|
||||
bail!("data message too large");
|
||||
}
|
||||
timeout(IO_TIMEOUT, writer.write_all(&data)).await??;
|
||||
}
|
||||
Message::Close(_) => return Ok::<(), anyhow::Error>(()),
|
||||
Message::Ping(_) | Message::Pong(_) => {}
|
||||
_ => bail!("unexpected text on binary tunnel"),
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
};
|
||||
// Closing either side tears down this ADB transport; reconnect creates a new one.
|
||||
tokio::select! { result = to_ws => result, result = to_tcp => result }
|
||||
}
|
||||
|
||||
pub async fn tcp_connect(address: &str) -> Result<TcpStream> {
|
||||
Ok(timeout(CONNECT_TIMEOUT, TcpStream::connect(address))
|
||||
.await
|
||||
.context("TCP connect timed out")??)
|
||||
}
|
||||
|
||||
async fn adb_request(stream: &mut TcpStream, service: &str) -> Result<()> {
|
||||
if service.len() > 65535 {
|
||||
bail!("ADB service name too long");
|
||||
}
|
||||
stream
|
||||
.write_all(format!("{:04x}{service}", service.len()).as_bytes())
|
||||
.await?;
|
||||
let mut status = [0; 4];
|
||||
stream.read_exact(&mut status).await?;
|
||||
match &status {
|
||||
b"OKAY" => Ok(()),
|
||||
b"FAIL" => {
|
||||
let mut size = [0; 4];
|
||||
stream.read_exact(&mut size).await?;
|
||||
let size = usize::from_str_radix(std::str::from_utf8(&size)?, 16)?;
|
||||
let mut error = vec![0; size];
|
||||
stream.read_exact(&mut error).await?;
|
||||
bail!("remote ADB: {}", String::from_utf8_lossy(&error))
|
||||
}
|
||||
_ => bail!("invalid ADB smart socket reply"),
|
||||
}
|
||||
}
|
||||
|
||||
/// Requires TCP adbd on the phone, even when selecting a USB transport.
|
||||
pub async fn adb_tcp_connect(server: &str, serial: &str, port: u16) -> Result<TcpStream> {
|
||||
let mut stream = tcp_connect(server).await?;
|
||||
timeout(CONNECT_TIMEOUT, async {
|
||||
adb_request(&mut stream, &format!("host:transport:{serial}")).await?;
|
||||
adb_request(&mut stream, &format!("tcp:{port}")).await
|
||||
})
|
||||
.await
|
||||
.context("ADB service handshake timed out")??;
|
||||
Ok(stream)
|
||||
}
|
||||
|
||||
pub fn init_logging() {
|
||||
tracing_subscriber::fmt()
|
||||
.with_env_filter(
|
||||
tracing_subscriber::EnvFilter::try_from_default_env().unwrap_or_else(|_| "info".into()),
|
||||
)
|
||||
.with_target(false)
|
||||
.init();
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn rejects_unsafe_configuration() {
|
||||
let network = NetworkArgs {
|
||||
server: "ws://example.com".into(),
|
||||
allow_insecure: false,
|
||||
};
|
||||
assert!(network.url("/v1/agent", &[]).is_err());
|
||||
assert!(validate_token("short").is_err());
|
||||
assert!(!valid_device_id("bad/device"));
|
||||
assert!(valid_device_id("home-phone_1"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn adb_handshake_selects_transport_and_phone_port() {
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let address = listener.local_addr().unwrap().to_string();
|
||||
let task = tokio::spawn(async move {
|
||||
let (mut sock, _) = listener.accept().await.unwrap();
|
||||
for expected in ["host:transport:test", "tcp:5555"] {
|
||||
let mut size = [0; 4];
|
||||
sock.read_exact(&mut size).await.unwrap();
|
||||
let size = usize::from_str_radix(std::str::from_utf8(&size).unwrap(), 16).unwrap();
|
||||
let mut payload = vec![0; size];
|
||||
sock.read_exact(&mut payload).await.unwrap();
|
||||
assert_eq!(payload, expected.as_bytes());
|
||||
sock.write_all(b"OK").await.unwrap();
|
||||
sock.write_all(b"AY").await.unwrap();
|
||||
}
|
||||
sock.write_all(b"raw-adbd").await.unwrap();
|
||||
});
|
||||
let mut stream = adb_tcp_connect(&address, "test", 5555).await.unwrap();
|
||||
let mut data = [0; 8];
|
||||
stream.read_exact(&mut data).await.unwrap();
|
||||
assert_eq!(&data, b"raw-adbd");
|
||||
task.await.unwrap();
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user