371 lines
14 KiB
Rust
371 lines
14 KiB
Rust
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::{
|
|
client_async_tls_with_config, connect_async_with_config,
|
|
tungstenite::{client::IntoClientRequest, http::HeaderValue, Message},
|
|
MaybeTlsStream, WebSocketStream,
|
|
};
|
|
use url::Url;
|
|
pub mod transport;
|
|
|
|
pub type Ws = WebSocketStream<MaybeTlsStream<TcpStream>>;
|
|
pub const CONNECT_TIMEOUT: Duration = Duration::from_secs(10);
|
|
pub const IO_TIMEOUT: Duration = Duration::from_secs(30);
|
|
pub const DEFAULT_RELAY: &str = "wss://ttstd.com/ads";
|
|
|
|
#[derive(Args, Clone, Debug)]
|
|
pub struct NetworkArgs {
|
|
/// Relay base URL; an optional reverse-proxy path prefix is supported
|
|
#[arg(long, default_value = DEFAULT_RELAY)]
|
|
pub server: String,
|
|
/// Optional origin host:port override; TLS still verifies the relay URL hostname
|
|
#[arg(long, env = "ADS_CONNECT_ADDRESS")]
|
|
pub connect_address: Option<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");
|
|
}
|
|
let endpoint = format!(
|
|
"{}/{}",
|
|
url.path().trim_end_matches('/'),
|
|
path.trim_start_matches('/')
|
|
);
|
|
url.set_path(&endpoint);
|
|
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, connect_address: Option<&str>) -> Result<Ws> {
|
|
// WSS needs an explicit provider; relying on transitive feature defaults
|
|
// leaves pure WebSocket builds without one and panics at the first TLS dial.
|
|
static TLS_PROVIDER: std::sync::Once = std::sync::Once::new();
|
|
TLS_PROVIDER.call_once(|| {
|
|
let _ = rustls::crypto::ring::default_provider().install_default();
|
|
});
|
|
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 handshake = async {
|
|
if let Some(address) = connect_address {
|
|
let tcp = TcpStream::connect(address).await?;
|
|
tcp.set_nodelay(true)?;
|
|
client_async_tls_with_config(request, tcp, Some(config), None).await
|
|
} else {
|
|
connect_async_with_config(request, Some(config), true).await
|
|
}
|
|
};
|
|
let result = timeout(CONNECT_TIMEOUT, handshake)
|
|
.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(Clone, 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>,
|
|
#[serde(default)]
|
|
pub protocol: u8,
|
|
#[serde(default)]
|
|
pub signal_key: Option<String>,
|
|
#[serde(default)]
|
|
pub ice_servers: Vec<String>,
|
|
#[serde(default)]
|
|
pub p2p_timeout_ms: u64,
|
|
#[serde(default)]
|
|
pub public_only: bool,
|
|
#[serde(default)]
|
|
pub routes: Vec<transport::Route>,
|
|
#[serde(default)]
|
|
pub sdp: Option<String>,
|
|
#[serde(default)]
|
|
pub node: 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() > 128 * 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")??)
|
|
}
|
|
|
|
pub async fn adb_devices(server: &str) -> Result<String> {
|
|
timeout(Duration::from_secs(5), async {
|
|
let mut stream = TcpStream::connect(server)
|
|
.await
|
|
.context("cannot connect to Agent host ADB server")?;
|
|
adb_request(&mut stream, "host:devices-l").await?;
|
|
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 data = vec![0; size];
|
|
stream.read_exact(&mut data).await?;
|
|
Ok::<_, anyhow::Error>(String::from_utf8(data)?)
|
|
})
|
|
.await
|
|
.context("ADB discovery 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(),
|
|
connect_address: None,
|
|
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"));
|
|
}
|
|
|
|
#[test]
|
|
fn relay_prefix_and_query_parameters_are_preserved() {
|
|
for base in ["wss://ttstd.com/ads", "wss://ttstd.com/ads/"] {
|
|
let network = NetworkArgs {
|
|
server: base.into(),
|
|
connect_address: None,
|
|
allow_insecure: false,
|
|
};
|
|
let url = network
|
|
.url(
|
|
"/v1/connect",
|
|
&[("device", "home-phone"), ("lease", "secret-ticket")],
|
|
)
|
|
.unwrap();
|
|
assert_eq!(url.path(), "/ads/v1/connect");
|
|
assert_eq!(url.query(), Some("device=home-phone&lease=secret-ticket"));
|
|
}
|
|
assert_eq!(DEFAULT_RELAY, "wss://ttstd.com/ads");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn discovers_adb_devices_with_length_framing() {
|
|
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
|
let address = listener.local_addr().unwrap().to_string();
|
|
let peer = tokio::spawn(async move {
|
|
let (mut socket, _) = listener.accept().await.unwrap();
|
|
let mut size = [0; 4];
|
|
socket.read_exact(&mut size).await.unwrap();
|
|
let count = usize::from_str_radix(std::str::from_utf8(&size).unwrap(), 16).unwrap();
|
|
let mut service = vec![0; count];
|
|
socket.read_exact(&mut service).await.unwrap();
|
|
assert_eq!(service, b"host:devices-l");
|
|
let body = "192.168.1.2:5555\tdevice model:Phone\nUSB123\tunauthorized\n";
|
|
let reply = format!("OKAY{:04x}{}", body.len(), body);
|
|
for chunk in reply.as_bytes().chunks(3) {
|
|
socket.write_all(chunk).await.unwrap();
|
|
}
|
|
});
|
|
let list = adb_devices(&address).await.unwrap();
|
|
assert!(list.contains("model:Phone"));
|
|
assert!(list.contains("unauthorized"));
|
|
peer.await.unwrap();
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn tls_failure_is_reported_without_a_provider_panic() {
|
|
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
|
let address = listener.local_addr().unwrap().to_string();
|
|
let peer = tokio::spawn(async move {
|
|
let (mut sock, _) = listener.accept().await.unwrap();
|
|
sock.write_all(b"not a TLS record").await.unwrap();
|
|
});
|
|
let result = dial(
|
|
Url::parse("wss://relay.invalid/v1/agent").unwrap(),
|
|
"test-token-at-least-thirty-two-characters",
|
|
Some(&address),
|
|
)
|
|
.await;
|
|
assert!(result.is_err());
|
|
peer.await.unwrap();
|
|
}
|
|
|
|
#[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();
|
|
}
|
|
}
|