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

Implement software TCP stack

Browse Source
This commit is contained in:
Jackson Coxson
2025-03-21 23:29:16 -06:00
parent c3395b032a
commit e1bfcd39ff
20 changed files with 1768 additions and 818 deletions
Download Patch File Download Diff File Expand all files Collapse all files

97
tools/src/core_device_proxy_tun.rs
View File

@@ -3,7 +3,6 @@
use clap::{Arg, Command};
use idevice::{
core_device_proxy::{self},
xpc::XPCDevice,
IdeviceService,
};
use tun_rs::AbstractDevice;
@@ -63,57 +62,51 @@ async fn main() {
let mut tun_proxy = core_device_proxy::CoreDeviceProxy::connect(&*provider)
.await
.expect("Unable to connect");
let rsd_port = tun_proxy.handshake.server_rsd_port;
let mut tunnel = tun_proxy.create_software_tunnel().unwrap();
let channel = tunnel.connect_tcp(rsd_port).unwrap();
let client = XPCDevice::new(Box::new(channel)).await.expect("no xpc??");
todo!();
let dev = tun_rs::create(&tun_rs::Configuration::default()).unwrap();
dev.add_address_v6(
tun_proxy
.handshake
.client_parameters
.address
.parse()
.unwrap(),
32,
)
.unwrap();
dev.set_mtu(tun_proxy.handshake.client_parameters.mtu)
.unwrap();
dev.set_network_address(
tun_proxy.handshake.client_parameters.address.clone(),
tun_proxy
.handshake
.client_parameters
.netmask
.parse()
.unwrap(),
Some(tun_proxy.handshake.server_address.parse().unwrap()),
)
.unwrap();
// let dev = tun_rs::create(&tun_rs::Configuration::default()).unwrap();
// dev.add_address_v6(
// tun_proxy
// .handshake
// .client_parameters
// .address
// .parse()
// .unwrap(),
// 32,
// )
// .unwrap();
// dev.set_mtu(tun_proxy.handshake.client_parameters.mtu)
// .unwrap();
// dev.set_network_address(
// tun_proxy.handshake.client_parameters.address.clone(),
// tun_proxy
// .handshake
// .client_parameters
// .netmask
// .parse()
// .unwrap(),
// Some(tun_proxy.handshake.server_address.parse().unwrap()),
// )
// .unwrap();
//
// let async_dev = tun_rs::AsyncDevice::new(dev).unwrap();
// async_dev.enabled(true).unwrap();
// println!("-----------------------------");
// println!("tun device created: {:?}", async_dev.name());
// println!("server address: {}", tun_proxy.handshake.server_address);
// println!("rsd port: {}", tun_proxy.handshake.server_rsd_port);
// println!("-----------------------------");
//
// let mut buf = vec![0; 1500];
// loop {
// tokio::select! {
// Ok(len) = async_dev.recv(&mut buf) => {
// println!("tun pkt: {:?}", &buf[..len]);
// tun_proxy.send(&buf[..len]).await.unwrap();
// }
// Ok(res) = tun_proxy.recv() => {
// println!("dev pkt: {:?}", &res);
// async_dev.send(&res).await.unwrap();
// }
// }
// }
let async_dev = tun_rs::AsyncDevice::new(dev).unwrap();
async_dev.enabled(true).unwrap();
println!("-----------------------------");
println!("tun device created: {:?}", async_dev.name());
println!("server address: {}", tun_proxy.handshake.server_address);
println!("rsd port: {}", tun_proxy.handshake.server_rsd_port);
println!("-----------------------------");
let mut buf = vec![0; 1500];
loop {
tokio::select! {
Ok(len) = async_dev.recv(&mut buf) => {
println!("tun pkt: {:?}", &buf[..len]);
tun_proxy.send(&buf[..len]).await.unwrap();
}
Ok(res) = tun_proxy.recv() => {
println!("dev pkt: {:?}", &res);
async_dev.send(&res).await.unwrap();
}
}
}
}

75
tools/src/debug_proxy.rs
View File

@@ -1,14 +1,12 @@
// Jackson Coxson
use std::{
io::Write,
net::{IpAddr, SocketAddr},
str::FromStr,
};
use std::io::Write;
use clap::{Arg, Command};
use idevice::{debug_proxy::DebugProxyClient, tunneld::get_tunneld_devices, xpc::XPCDevice};
use tokio::net::TcpStream;
use idevice::{
core_device_proxy::CoreDeviceProxy, debug_proxy::DebugProxyClient, xpc::XPCDevice,
IdeviceService,
};
mod common;
@@ -18,6 +16,18 @@ async fn main() {
let matches = Command::new("remotexpc")
.about("Get services from RemoteXPC")
.arg(
Arg::new("host")
.long("host")
.value_name("HOST")
.help("IP address of the device"),
)
.arg(
Arg::new("pairing_file")
.long("pairing-file")
.value_name("PATH")
.help("Path to the pairing file"),
)
.arg(
Arg::new("udid")
.value_name("UDID")
@@ -39,46 +49,41 @@ async fn main() {
}
let udid = matches.get_one::<String>("udid");
let pairing_file = matches.get_one::<String>("pairing_file");
let host = matches.get_one::<String>("host");
let socket = SocketAddr::new(
IpAddr::from_str("127.0.0.1").unwrap(),
idevice::tunneld::DEFAULT_PORT,
);
let mut devices = get_tunneld_devices(socket)
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("Failed to get tunneld devices");
.expect("no core proxy");
let rsd_port = proxy.handshake.server_rsd_port;
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 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(
TcpStream::connect((device.tunnel_address.as_str(), device.tunnel_port))
.await
.unwrap(),
))
.await
.unwrap();
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");
.expect("Client did not contain debug proxy service")
.to_owned();
let stream = TcpStream::connect(SocketAddr::new(
IpAddr::from_str(&device.tunnel_address).unwrap(),
service.port,
))
.await
.expect("Failed to connect");
let mut adapter = client.into_inner();
adapter.close().await.unwrap();
adapter.connect(service.port).await.unwrap();
let mut dp = DebugProxyClient::new(Box::new(stream));
let mut dp = DebugProxyClient::new(Box::new(adapter));
println!("Shell connected!");
loop {

9
tools/src/misagent.rs
View File

@@ -1,12 +1,7 @@
// Jackson Coxson
use std::path::PathBuf;
use clap::{arg, value_parser, Arg, Command};
use idevice::{
lockdownd::LockdowndClient, misagent::MisagentClient, mounter::ImageMounter,
pretty_print_plist, IdeviceService,
};
use clap::{Arg, Command};
use idevice::{misagent::MisagentClient, pretty_print_plist, IdeviceService};
mod common;

70
tools/src/process_control.rs
View File

@@ -1,13 +1,7 @@
// Jackson Coxson
use std::{
net::{IpAddr, SocketAddr},
str::FromStr,
};
use clap::{Arg, Command};
use idevice::{tunneld::get_tunneld_devices, xpc::XPCDevice};
use tokio::net::TcpStream;
use idevice::{core_device_proxy::CoreDeviceProxy, xpc::XPCDevice, IdeviceService};
mod common;
@@ -17,6 +11,18 @@ async fn main() {
let matches = Command::new("process_control")
.about("Query process control")
.arg(
Arg::new("host")
.long("host")
.value_name("HOST")
.help("IP address of the device"),
)
.arg(
Arg::new("pairing_file")
.long("pairing-file")
.value_name("PATH")
.help("Path to the pairing file"),
)
.arg(
Arg::new("udid")
.value_name("UDID")
@@ -44,50 +50,44 @@ async fn main() {
}
let udid = matches.get_one::<String>("udid");
let pairing_file = matches.get_one::<String>("pairing_file");
let host = matches.get_one::<String>("host");
let provider =
match common::get_provider(udid, host, pairing_file, "heartbeat_client-jkcoxson").await {
Ok(p) => p,
Err(e) => {
eprintln!("{e}");
return;
}
};
let bundle_id = matches
.get_one::<String>("bundle_id")
.expect("No bundle ID specified");
let socket = SocketAddr::new(
IpAddr::from_str("127.0.0.1").unwrap(),
idevice::tunneld::DEFAULT_PORT,
);
let mut devices = get_tunneld_devices(socket)
let proxy = CoreDeviceProxy::connect(&*provider)
.await
.expect("Failed to get tunneld devices");
.expect("no core proxy");
let rsd_port = proxy.handshake.server_rsd_port;
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 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(
TcpStream::connect((device.tunnel_address.as_str(), device.tunnel_port))
.await
.unwrap(),
))
.await
.unwrap();
let client = XPCDevice::new(Box::new(adapter)).await.unwrap();
// Get the debug proxy
let service = client
.services
.get(idevice::dvt::SERVICE_NAME)
.expect("Client did not contain DVT service");
.expect("Client did not contain DVT service")
.to_owned();
let stream = TcpStream::connect(SocketAddr::new(
IpAddr::from_str(&device.tunnel_address).unwrap(),
service.port,
))
.await
.expect("Failed to connect");
let mut adapter = client.into_inner();
adapter.connect(service.port).await.unwrap();
let mut rs_client =
idevice::dvt::remote_server::RemoteServerClient::new(Box::new(stream)).unwrap();
idevice::dvt::remote_server::RemoteServerClient::new(Box::new(adapter)).unwrap();
rs_client.read_message(0).await.expect("no read??");
let mut pc_client = idevice::dvt::process_control::ProcessControlClient::new(&mut rs_client)
.await

59
tools/src/remotexpc.rs
View File

@@ -1,14 +1,8 @@
// Jackson Coxson
// Print out all the RemoteXPC services
use std::{
net::{IpAddr, SocketAddr},
str::FromStr,
};
use clap::{Arg, Command};
use idevice::{tunneld::get_tunneld_devices, xpc::XPCDevice};
use tokio::net::TcpStream;
use idevice::{core_device_proxy::CoreDeviceProxy, xpc::XPCDevice, IdeviceService};
mod common;
@@ -18,6 +12,18 @@ async fn main() {
let matches = Command::new("remotexpc")
.about("Get services from RemoteXPC")
.arg(
Arg::new("host")
.long("host")
.value_name("HOST")
.help("IP address of the device"),
)
.arg(
Arg::new("pairing_file")
.long("pairing-file")
.value_name("PATH")
.help("Path to the pairing file"),
)
.arg(
Arg::new("udid")
.value_name("UDID")
@@ -39,31 +45,28 @@ async fn main() {
}
let udid = matches.get_one::<String>("udid");
let pairing_file = matches.get_one::<String>("pairing_file");
let host = matches.get_one::<String>("host");
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, "remotexpc-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(
TcpStream::connect((device.tunnel_address.as_str(), device.tunnel_port))
.await
.unwrap(),
))
.await
.unwrap();
let client = XPCDevice::new(Box::new(adapter)).await.unwrap();
println!("{:#?}", client.services);
}