StephenDev0/idevice
1
0
Fork 0
mirror of https://github.com/jkcoxson/idevice.git synced 2026-03-02 06:26:15 +01:00
Code Issues Packages Projects Releases Wiki Activity

Update tools to use new TCP stack

Browse Source
This commit is contained in:
Jackson Coxson
2025-05-23 01:36:43 -06:00
parent de4a4e2722
commit 9c5d872cf4
3 changed files with 87 additions and 192 deletions
Download Patch File Download Diff File Expand all files Collapse all files

109
tools/src/debug_proxy.rs
View File

@@ -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::<String>("pairing_file");
let host = matches.get_one::<String>("host");
let mut dp: DebugProxyClient<Box<dyn ReadWrite>> = 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 {

25
tools/src/location_simulation.rs
View File

@@ -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");

145
tools/src/process_control.rs
View File

@@ -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::<String>("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}");
}