From 9c5d872cf42f6ea88cdd08e7c9cf953e84b9ec96 Mon Sep 17 00:00:00 2001 From: Jackson Coxson Date: Fri, 23 May 2025 01:36:43 -0600 Subject: [PATCH] Update tools to use new TCP stack --- tools/src/debug_proxy.rs | 109 +++++++---------------- tools/src/location_simulation.rs | 25 ++++-- tools/src/process_control.rs | 145 ++++++++----------------------- 3 files changed, 87 insertions(+), 192 deletions(-) diff --git a/tools/src/debug_proxy.rs b/tools/src/debug_proxy.rs index e5206c5..809b24d 100644 --- a/tools/src/debug_proxy.rs +++ b/tools/src/debug_proxy.rs @@ -1,17 +1,12 @@ // Jackson Coxson -use std::{ - io::Write, - net::{IpAddr, SocketAddr}, - str::FromStr, -}; +use std::io::Write; use clap::{Arg, Command}; use idevice::{ - core_device_proxy::CoreDeviceProxy, debug_proxy::DebugProxyClient, - tunneld::get_tunneld_devices, xpc::XPCDevice, IdeviceService, ReadWrite, + core_device_proxy::CoreDeviceProxy, debug_proxy::DebugProxyClient, rsd::RsdClient, + tcp::stream::AdapterStream, IdeviceService, }; -use tokio::net::TcpStream; mod common; @@ -63,79 +58,41 @@ async fn main() { let pairing_file = matches.get_one::("pairing_file"); let host = matches.get_one::("host"); - let mut dp: DebugProxyClient> = if matches.get_flag("tunneld") { - let socket = SocketAddr::new( - IpAddr::from_str("127.0.0.1").unwrap(), - idevice::tunneld::DEFAULT_PORT, - ); - let mut devices = get_tunneld_devices(socket) - .await - .expect("Failed to get tunneld devices"); - - let (_udid, device) = match udid { - Some(u) => ( - u.to_owned(), - devices.remove(u).expect("Device not in tunneld"), - ), - None => devices.into_iter().next().expect("No devices"), + let provider = + match common::get_provider(udid, host, pairing_file, "debug-proxy-jkcoxson").await { + Ok(p) => p, + Err(e) => { + eprintln!("{e}"); + return; + } }; + let proxy = CoreDeviceProxy::connect(&*provider) + .await + .expect("no core proxy"); + let rsd_port = proxy.handshake.server_rsd_port; - // Make the connection to RemoteXPC - let client = XPCDevice::new(Box::new( - TcpStream::connect((device.tunnel_address.as_str(), device.tunnel_port)) - .await - .unwrap(), - )) + let mut adapter = proxy.create_software_tunnel().expect("no software tunnel"); + let stream = AdapterStream::connect(&mut adapter, rsd_port) + .await + .expect("no RSD connect"); + + // Make the connection to RemoteXPC + let mut client = RsdClient::new(stream).await.unwrap(); + + // Get the debug proxy + let service = client + .get_services() + .await + .unwrap() + .get(idevice::debug_proxy::SERVICE_NAME) + .expect("Client did not contain debug proxy service") + .to_owned(); + + let stream = AdapterStream::connect(&mut adapter, service.port) .await .unwrap(); - // Get the debug proxy - let service = client - .services - .get(idevice::debug_proxy::SERVICE_NAME) - .expect("Client did not contain debug proxy service"); - - let stream = TcpStream::connect(SocketAddr::new( - IpAddr::from_str(&device.tunnel_address).unwrap(), - service.port, - )) - .await - .expect("Failed to connect"); - - DebugProxyClient::new(Box::new(stream)) - } else { - let provider = - match common::get_provider(udid, host, pairing_file, "debug-proxy-jkcoxson").await { - Ok(p) => p, - Err(e) => { - eprintln!("{e}"); - return; - } - }; - let proxy = CoreDeviceProxy::connect(&*provider) - .await - .expect("no core proxy"); - let rsd_port = proxy.handshake.server_rsd_port; - - let mut adapter = proxy.create_software_tunnel().expect("no software tunnel"); - adapter.connect(rsd_port).await.expect("no RSD connect"); - - // Make the connection to RemoteXPC - let client = XPCDevice::new(Box::new(adapter)).await.unwrap(); - - // Get the debug proxy - let service = client - .services - .get(idevice::debug_proxy::SERVICE_NAME) - .expect("Client did not contain debug proxy service") - .to_owned(); - - let mut adapter = client.into_inner(); - adapter.close().await.unwrap(); - adapter.connect(service.port).await.unwrap(); - - DebugProxyClient::new(Box::new(adapter)) - }; + let mut dp = DebugProxyClient::new(stream); println!("Shell connected!"); loop { diff --git a/tools/src/location_simulation.rs b/tools/src/location_simulation.rs index 26d7284..471a239 100644 --- a/tools/src/location_simulation.rs +++ b/tools/src/location_simulation.rs @@ -2,7 +2,9 @@ // Just lists apps for now use clap::{Arg, Command}; -use idevice::{core_device_proxy::CoreDeviceProxy, xpc::XPCDevice, IdeviceService}; +use idevice::{ + core_device_proxy::CoreDeviceProxy, rsd::RsdClient, tcp::stream::AdapterStream, IdeviceService, +}; mod common; @@ -69,26 +71,31 @@ async fn main() { let rsd_port = proxy.handshake.server_rsd_port; let mut adapter = proxy.create_software_tunnel().expect("no software tunnel"); - adapter.connect(rsd_port).await.expect("no RSD connect"); + let stream = AdapterStream::connect(&mut adapter, rsd_port) + .await + .expect("no RSD connect"); // Make the connection to RemoteXPC - let client = XPCDevice::new(Box::new(adapter)).await.unwrap(); + let mut client = RsdClient::new(stream).await.unwrap(); // Get the debug proxy let service = client - .services + .get_services() + .await + .unwrap() .get(idevice::dvt::SERVICE_NAME) .expect("Client did not contain DVT service") .to_owned(); - let mut adapter = client.into_inner(); - adapter.connect(service.port).await.unwrap(); + let stream = AdapterStream::connect(&mut adapter, service.port) + .await + .unwrap(); - let mut rs_client = idevice::dvt::remote_server::RemoteServerClient::new(Box::new(adapter)); - rs_client.read_message(0).await.expect("no read??"); + let mut ls_client = idevice::dvt::remote_server::RemoteServerClient::new(stream); + ls_client.read_message(0).await.expect("no read??"); let mut ls_client = - idevice::dvt::location_simulation::LocationSimulationClient::new(&mut rs_client) + idevice::dvt::location_simulation::LocationSimulationClient::new(&mut ls_client) .await .expect("Unable to get channel for location simulation"); diff --git a/tools/src/process_control.rs b/tools/src/process_control.rs index 412ccb4..0f7f84d 100644 --- a/tools/src/process_control.rs +++ b/tools/src/process_control.rs @@ -1,16 +1,9 @@ // Jackson Coxson -use std::{ - net::{IpAddr, SocketAddr}, - str::FromStr, -}; - use clap::{Arg, Command}; use idevice::{ - core_device_proxy::CoreDeviceProxy, tunneld::get_tunneld_devices, xpc::XPCDevice, - IdeviceService, + core_device_proxy::CoreDeviceProxy, rsd::RsdClient, tcp::stream::AdapterStream, IdeviceService, }; -use tokio::net::TcpStream; mod common; @@ -71,70 +64,8 @@ async fn main() { .get_one::("bundle_id") .expect("No bundle ID specified"); - if matches.get_flag("tunneld") { - let socket = SocketAddr::new( - IpAddr::from_str("127.0.0.1").unwrap(), - idevice::tunneld::DEFAULT_PORT, - ); - let mut devices = get_tunneld_devices(socket) - .await - .expect("Failed to get tunneld devices"); - - let (_udid, device) = match udid { - Some(u) => ( - u.to_owned(), - devices.remove(u).expect("Device not in tunneld"), - ), - None => devices.into_iter().next().expect("No devices"), - }; - - // Make the connection to RemoteXPC - let client = XPCDevice::new(Box::new( - TcpStream::connect((device.tunnel_address.as_str(), device.tunnel_port)) - .await - .unwrap(), - )) - .await - .unwrap(); - - // Get the debug proxy - let service = client - .services - .get(idevice::dvt::SERVICE_NAME) - .expect("Client did not contain DVT service"); - - let stream = TcpStream::connect(SocketAddr::new( - IpAddr::from_str(&device.tunnel_address).unwrap(), - service.port, - )) - .await - .expect("Failed to connect"); - - let mut rs_client = idevice::dvt::remote_server::RemoteServerClient::new(Box::new(stream)); - rs_client.read_message(0).await.expect("no read??"); - let mut pc_client = - idevice::dvt::process_control::ProcessControlClient::new(&mut rs_client) - .await - .unwrap(); - - let pid = pc_client - .launch_app(bundle_id, None, None, true, false) - .await - .expect("no launch??"); - pc_client - .disable_memory_limit(pid) - .await - .expect("no disable??"); - println!("PID: {pid}"); - } else { - let provider = match common::get_provider( - udid, - host, - pairing_file, - "process_control-jkcoxson", - ) - .await - { + let provider = + match common::get_provider(udid, host, pairing_file, "process_control-jkcoxson").await { Ok(p) => p, Err(e) => { eprintln!("{e}"); @@ -142,45 +73,45 @@ async fn main() { } }; - let proxy = CoreDeviceProxy::connect(&*provider) - .await - .expect("no core proxy"); - let rsd_port = proxy.handshake.server_rsd_port; + let proxy = CoreDeviceProxy::connect(&*provider) + .await + .expect("no core proxy"); + let rsd_port = proxy.handshake.server_rsd_port; - let mut adapter = proxy.create_software_tunnel().expect("no software tunnel"); - adapter.connect(rsd_port).await.expect("no RSD connect"); + let mut adapter = proxy.create_software_tunnel().expect("no software tunnel"); + let stream = AdapterStream::connect(&mut adapter, rsd_port) + .await + .expect("no RSD connect"); - // Make the connection to RemoteXPC - let client = XPCDevice::new(Box::new(adapter)).await.unwrap(); + // Make the connection to RemoteXPC + let mut client = RsdClient::new(stream).await.unwrap(); - // Get the debug proxy - let service = client - .services - .get(idevice::dvt::SERVICE_NAME) - .expect("Client did not contain DVT service") - .to_owned(); + // Get the debug proxy + let service = client + .get_services() + .await + .unwrap() + .get(idevice::dvt::SERVICE_NAME) + .expect("Client did not contain DVT service") + .to_owned(); - let mut adapter = client.into_inner(); - adapter.connect(service.port).await.unwrap(); + let stream = AdapterStream::connect(&mut adapter, service.port) + .await + .unwrap(); - let mut rs_client = idevice::dvt::remote_server::RemoteServerClient::new(Box::new(adapter)); - rs_client.read_message(0).await.expect("no read??"); - let mut pc_client = - idevice::dvt::process_control::ProcessControlClient::new(&mut rs_client) - .await - .unwrap(); + let mut rs_client = idevice::dvt::remote_server::RemoteServerClient::new(stream); + rs_client.read_message(0).await.expect("no read??"); + let mut pc_client = idevice::dvt::process_control::ProcessControlClient::new(&mut rs_client) + .await + .unwrap(); - let pid = pc_client - .launch_app(bundle_id, None, None, true, false) - .await - .expect("no launch??"); - pc_client - .disable_memory_limit(pid) - .await - .expect("no disable??"); - println!("PID: {pid}"); - - // let mut adapter = rs_client.into_inner(); - // adapter.close().await.expect("no close??"); - } + let pid = pc_client + .launch_app(bundle_id, None, None, true, false) + .await + .expect("no launch??"); + pc_client + .disable_memory_limit(pid) + .await + .expect("no disable??"); + println!("PID: {pid}"); }