#[path = "common/adb_key_auth.rs"]
mod adb_key_auth;
use libadb::channel::SelectResult;
use libadb::{Connection, ConnectionConfig, Error, HostBanner, TokioTcp};
use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
#[tokio::main(flavor = "current_thread")]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut args = std::env::args().skip(1);
let (Some(addr), Some(device_spec), Some(local_port)) = (args.next(), args.next(), args.next())
else {
eprintln!("usage: reverse ADDR DEVICE_SPEC LOCAL_PORT");
eprintln!(" reverse 127.0.0.1:5555 tcp:6100 8899");
std::process::exit(2);
};
let local_port: u16 = local_port.parse()?;
let tcp = tokio::net::TcpStream::connect(&addr).await?;
tcp.set_nodelay(true)?;
let auth = adb_key_auth::load_or_generate()?;
let mut conn = Connection::connect(
TokioTcp::new(tcp),
auth,
HostBanner::Features(&[]),
ConnectionConfig::new(),
)
.await?;
let host_spec = format!("tcp:{local_port}");
let assigned = libadb::reverse::establish(&mut conn, &device_spec, &host_spec).await?;
match assigned {
Some(port) => {
println!("[*] rule established: device port {port} -> 127.0.0.1:{local_port}")
}
None => println!("[*] rule established: {device_spec} -> 127.0.0.1:{local_port}"),
}
let mut expected_dest = host_spec.into_bytes();
expected_dest.push(0);
loop {
let incoming = conn.accept_incoming().await?;
let dest = incoming.destination().to_vec();
println!("[*] incoming: {:?}", String::from_utf8_lossy(&dest));
if dest != expected_dest {
eprintln!("[!] unexpected destination, rejecting");
incoming.reject().await?;
continue;
}
let ch = incoming.accept().await?;
let local = match tokio::net::TcpStream::connect(("127.0.0.1", local_port)).await {
Ok(s) => {
s.set_nodelay(true)?;
s
}
Err(e) => {
eprintln!("[!] 127.0.0.1:{local_port}: {e}");
conn.close_channel(ch).await?;
continue;
}
};
let (mut local_r, mut local_w) = local.into_split();
let mut chan_buf = vec![0u8; 16 * 1024];
let mut sock_buf = vec![0u8; 16 * 1024];
loop {
let done = match conn
.select_channel(ch, &mut chan_buf, local_r.read(&mut sock_buf))
.await
{
Ok(SelectResult::Data(n)) => match local_w.write_all(&chan_buf[..n]).await {
Ok(()) => false,
Err(e) => {
eprintln!("[!] local write: {e}");
true
}
},
Ok(SelectResult::Interrupted(Ok(0))) => true,
Ok(SelectResult::Interrupted(Ok(n))) => {
match conn.write_channel(ch, &sock_buf[..n]).await {
Ok(()) => false,
Err(Error::ChannelClosed) => true,
Err(e) => return Err(e.into()),
}
}
Ok(SelectResult::Interrupted(Err(e))) => {
eprintln!("[!] local read: {e}");
true
}
Err(Error::ChannelClosed) => true,
Err(e) => return Err(e.into()),
};
if done {
conn.close_channel(ch).await?;
break;
}
}
println!("[*] bridge closed");
}
}