Implement authenticated public relay and Rust device daemons

This commit is contained in:
tongtong committed 2026-11-12 12:33:39 +08:00
1 parent f96c1aa109
commit e1c152a657
29 files changed
+3244 -39

No files matched your search

+16
View File
@@ -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
+256
View File
@@ -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();
}
}