From 2fde404f88e22a5f6d09964ef849eefef49a2151 Mon Sep 17 00:00:00 2001 From: Jackson Coxson Date: Fri, 28 Mar 2025 12:12:06 -0600 Subject: [PATCH] lockdownd bindings --- ffi/examples/lockdownd.c | 149 +++++++++++++++++++ ffi/src/lib.rs | 1 + ffi/src/lockdownd.rs | 310 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 460 insertions(+) create mode 100644 ffi/examples/lockdownd.c create mode 100644 ffi/src/lockdownd.rs diff --git a/ffi/examples/lockdownd.c b/ffi/examples/lockdownd.c new file mode 100644 index 0000000..73372d9 --- /dev/null +++ b/ffi/examples/lockdownd.c @@ -0,0 +1,149 @@ +// Jackson Coxson + +#include "idevice.h" +#include +#include +#include +#include + +int main() { + // Initialize logger + idevice_init_logger(Debug, Disabled, NULL); + + // Create the socket address (replace with your device's IP) + struct sockaddr_in addr; + memset(&addr, 0, sizeof(addr)); + addr.sin_family = AF_INET; + addr.sin_port = htons(LOCKDOWN_PORT); + inet_pton(AF_INET, "10.7.0.2", &addr.sin_addr); + + // Read pairing file (replace with your pairing file path) + IdevicePairingFile *pairing_file = NULL; + IdeviceErrorCode err = + idevice_pairing_file_read("pairing_file.plist", &pairing_file); + if (err != IdeviceSuccess) { + fprintf(stderr, "Failed to read pairing file: %d\n", err); + return 1; + } + + // Create TCP provider + TcpProviderHandle *provider = NULL; + err = idevice_tcp_provider_new((struct sockaddr *)&addr, pairing_file, + "LockdowndTest", &provider); + if (err != IdeviceSuccess) { + fprintf(stderr, "Failed to create TCP provider: %d\n", err); + idevice_pairing_file_free(pairing_file); + return 1; + } + + // Connect to lockdownd + LockdowndClientHandle *client = NULL; + err = lockdownd_connect_tcp(provider, &client); + if (err != IdeviceSuccess) { + fprintf(stderr, "Failed to connect to lockdownd: %d\n", err); + tcp_provider_free(provider); + return 1; + } + + // Read pairing file (replace with your pairing file path) + IdevicePairingFile *pairing_file_2 = NULL; + err = idevice_pairing_file_read("pairing_file.plist", &pairing_file_2); + if (err != IdeviceSuccess) { + fprintf(stderr, "Failed to read pairing file: %d\n", err); + return 1; + } + + // Start session + err = lockdownd_start_session(client, pairing_file_2); + if (err != IdeviceSuccess) { + fprintf(stderr, "Failed to start session: %d\n", err); + lockdownd_client_free(client); + tcp_provider_free(provider); + return 1; + } + + // Get device name + plist_t name_plist = NULL; + err = lockdownd_get_value(client, "DeviceName", &name_plist); + if (err != IdeviceSuccess) { + fprintf(stderr, "Failed to get device name: %d\n", err); + } else { + char *name = NULL; + plist_get_string_val(name_plist, &name); + printf("Device name: %s\n", name); + free(name); + plist_free(name_plist); + } + + // Get product version + plist_t version_plist = NULL; + err = lockdownd_get_value(client, "ProductVersion", &version_plist); + if (err != IdeviceSuccess) { + fprintf(stderr, "Failed to get product version: %d\n", err); + } else { + char *version = NULL; + plist_get_string_val(version_plist, &version); + printf("iOS version: %s\n", version); + free(version); + plist_free(version_plist); + } + + // Get all values + plist_t all_values = NULL; + err = lockdownd_get_all_values(client, &all_values); + if (err != IdeviceSuccess) { + fprintf(stderr, "Failed to get all values: %d\n", err); + } else { + printf("\nAll device values:\n"); + // Iterate through dictionary (simplified example) + plist_dict_iter it = NULL; + plist_dict_new_iter(all_values, &it); + if (it) { + char *key = NULL; + plist_t val = NULL; + do { + plist_dict_next_item(all_values, it, &key, &val); + if (key) { + printf("- %s: ", key); + // Print value based on type (simplified) + if (plist_get_node_type(val) == PLIST_STRING) { + char *str_val = NULL; + plist_get_string_val(val, &str_val); + printf("%s", str_val); + free(str_val); + } else if (plist_get_node_type(val) == PLIST_BOOLEAN) { + uint8_t bool_val = 0; + plist_get_bool_val(val, &bool_val); + printf("%s", bool_val ? "true" : "false"); + } else if (plist_get_node_type(val) == PLIST_UINT) { + uint64_t int_val = 0; + plist_get_uint_val(val, &int_val); + printf("%llu", int_val); + } + printf("\n"); + free(key); + } + } while (key); + free(it); + } + plist_free(all_values); + } + + // Test starting a service (heartbeat in this example) + uint16_t port = 0; + bool ssl = false; + err = lockdownd_start_service(client, "com.apple.mobile.heartbeat", &port, + &ssl); + if (err != IdeviceSuccess) { + fprintf(stderr, "Failed to start heartbeat service: %d\n", err); + } else { + printf("\nStarted heartbeat service on port %d (SSL: %s)\n", port, + ssl ? "true" : "false"); + } + + // Cleanup + lockdownd_client_free(client); + tcp_provider_free(provider); + + return 0; +} diff --git a/ffi/src/lib.rs b/ffi/src/lib.rs index 8031933..cd5b179 100644 --- a/ffi/src/lib.rs +++ b/ffi/src/lib.rs @@ -6,6 +6,7 @@ pub mod debug_proxy; mod errors; pub mod heartbeat; pub mod installation_proxy; +pub mod lockdownd; pub mod logging; pub mod mounter; mod pairing_file; diff --git a/ffi/src/lockdownd.rs b/ffi/src/lockdownd.rs new file mode 100644 index 0000000..bb67fba --- /dev/null +++ b/ffi/src/lockdownd.rs @@ -0,0 +1,310 @@ +// Jackson Coxson + +use std::ffi::c_void; + +use idevice::{IdeviceError, IdeviceService, lockdownd::LockdowndClient}; + +use crate::{ + IdeviceErrorCode, IdeviceHandle, IdevicePairingFile, RUNTIME, + provider::{TcpProviderHandle, UsbmuxdProviderHandle}, +}; + +pub struct LockdowndClientHandle(pub LockdowndClient); + +/// Connects to lockdownd service using TCP provider +/// +/// # Arguments +/// * [`provider`] - A TcpProvider +/// * [`client`] - On success, will be set to point to a newly allocated LockdowndClient handle +/// +/// # Returns +/// An error code indicating success or failure +/// +/// # Safety +/// `provider` must be a valid pointer to a handle allocated by this library +/// `client` must be a valid, non-null pointer to a location where the handle will be stored +#[unsafe(no_mangle)] +pub unsafe extern "C" fn lockdownd_connect_tcp( + provider: *mut TcpProviderHandle, + client: *mut *mut LockdowndClientHandle, +) -> IdeviceErrorCode { + if provider.is_null() || client.is_null() { + log::error!("Null pointer provided"); + return IdeviceErrorCode::InvalidArg; + } + + let res: Result = RUNTIME.block_on(async move { + let provider_box = unsafe { Box::from_raw(provider) }; + let provider_ref = &provider_box.0; + let result = LockdowndClient::connect(provider_ref).await; + std::mem::forget(provider_box); + result + }); + + match res { + Ok(r) => { + let boxed = Box::new(LockdowndClientHandle(r)); + unsafe { *client = Box::into_raw(boxed) }; + IdeviceErrorCode::IdeviceSuccess + } + Err(e) => { + let _ = unsafe { Box::from_raw(provider) }; + e.into() + } + } +} + +/// Connects to lockdownd service using Usbmuxd provider +/// +/// # Arguments +/// * [`provider`] - A UsbmuxdProvider +/// * [`client`] - On success, will be set to point to a newly allocated LockdowndClient handle +/// +/// # Returns +/// An error code indicating success or failure +/// +/// # Safety +/// `provider` must be a valid pointer to a handle allocated by this library +/// `client` must be a valid, non-null pointer to a location where the handle will be stored +#[unsafe(no_mangle)] +pub unsafe extern "C" fn lockdownd_connect_usbmuxd( + provider: *mut UsbmuxdProviderHandle, + client: *mut *mut LockdowndClientHandle, +) -> IdeviceErrorCode { + if provider.is_null() || client.is_null() { + log::error!("Null pointer provided"); + return IdeviceErrorCode::InvalidArg; + } + + let res: Result = RUNTIME.block_on(async move { + let provider_box = unsafe { Box::from_raw(provider) }; + let provider_ref = &provider_box.0; + let result = LockdowndClient::connect(provider_ref).await; + std::mem::forget(provider_box); + result + }); + + match res { + Ok(r) => { + let boxed = Box::new(LockdowndClientHandle(r)); + unsafe { *client = Box::into_raw(boxed) }; + IdeviceErrorCode::IdeviceSuccess + } + Err(e) => e.into(), + } +} + +/// Creates a new LockdowndClient from an existing Idevice connection +/// +/// # Arguments +/// * [`socket`] - An IdeviceSocket handle +/// * [`client`] - On success, will be set to point to a newly allocated LockdowndClient handle +/// +/// # Returns +/// An error code indicating success or failure +/// +/// # Safety +/// `socket` must be a valid pointer to a handle allocated by this library +/// `client` must be a valid, non-null pointer to a location where the handle will be stored +#[unsafe(no_mangle)] +pub unsafe extern "C" fn lockdownd_new( + socket: *mut IdeviceHandle, + client: *mut *mut LockdowndClientHandle, +) -> IdeviceErrorCode { + if socket.is_null() || client.is_null() { + return IdeviceErrorCode::InvalidArg; + } + let socket = unsafe { Box::from_raw(socket) }.0; + let r = LockdowndClient::new(socket); + let boxed = Box::new(LockdowndClientHandle(r)); + unsafe { *client = Box::into_raw(boxed) }; + IdeviceErrorCode::IdeviceSuccess +} + +/// Starts a session with lockdownd +/// +/// # Arguments +/// * `client` - A valid LockdowndClient handle +/// * `pairing_file` - An IdevicePairingFile alocated by this library +/// +/// # Returns +/// An error code indicating success or failure +/// +/// # Safety +/// `client` must be a valid pointer to a handle allocated by this library +/// `pairing_file` must be a valid plist_t containing a pairing file +#[unsafe(no_mangle)] +pub unsafe extern "C" fn lockdownd_start_session( + client: *mut LockdowndClientHandle, + pairing_file: *mut IdevicePairingFile, +) -> IdeviceErrorCode { + let res: Result<(), IdeviceError> = RUNTIME.block_on(async move { + let mut client_box = unsafe { Box::from_raw(client) }; + let pairing_file = unsafe { Box::from_raw(pairing_file) }; + + let client_ref = &mut client_box.0; + let res = client_ref.start_session(&pairing_file.0).await; + + std::mem::forget(client_box); + std::mem::forget(pairing_file); + res + }); + + match res { + Ok(_) => IdeviceErrorCode::IdeviceSuccess, + Err(e) => e.into(), + } +} + +/// Starts a service through lockdownd +/// +/// # Arguments +/// * `client` - A valid LockdowndClient handle +/// * `identifier` - The service identifier to start (null-terminated string) +/// * `port` - Pointer to store the returned port number +/// * `ssl` - Pointer to store whether SSL should be enabled +/// +/// # Returns +/// An error code indicating success or failure +/// +/// # Safety +/// `client` must be a valid pointer to a handle allocated by this library +/// `identifier` must be a valid null-terminated string +/// `port` and `ssl` must be valid pointers +#[unsafe(no_mangle)] +pub unsafe extern "C" fn lockdownd_start_service( + client: *mut LockdowndClientHandle, + identifier: *const libc::c_char, + port: *mut u16, + ssl: *mut bool, +) -> IdeviceErrorCode { + if identifier.is_null() || port.is_null() || ssl.is_null() { + return IdeviceErrorCode::InvalidArg; + } + + let identifier = unsafe { std::ffi::CStr::from_ptr(identifier) } + .to_string_lossy() + .into_owned(); + + let res: Result<(u16, bool), IdeviceError> = RUNTIME.block_on(async move { + let mut client_box = unsafe { Box::from_raw(client) }; + let client_ref = &mut client_box.0; + let res = client_ref.start_service(identifier).await; + std::mem::forget(client_box); + res + }); + + match res { + Ok((p, s)) => { + unsafe { + *port = p; + *ssl = s; + } + IdeviceErrorCode::IdeviceSuccess + } + Err(e) => e.into(), + } +} + +/// Gets a value from lockdownd +/// +/// # Arguments +/// * `client` - A valid LockdowndClient handle +/// * `value` - The value to get (null-terminated string) +/// * `out_plist` - Pointer to store the returned plist value +/// +/// # Returns +/// An error code indicating success or failure +/// +/// # Safety +/// `client` must be a valid pointer to a handle allocated by this library +/// `value` must be a valid null-terminated string +/// `out_plist` must be a valid pointer to store the plist +#[unsafe(no_mangle)] +pub unsafe extern "C" fn lockdownd_get_value( + client: *mut LockdowndClientHandle, + value: *const libc::c_char, + out_plist: *mut *mut c_void, +) -> IdeviceErrorCode { + if value.is_null() || out_plist.is_null() { + return IdeviceErrorCode::InvalidArg; + } + + let value = unsafe { std::ffi::CStr::from_ptr(value) } + .to_string_lossy() + .into_owned(); + + let res: Result = RUNTIME.block_on(async move { + let mut client_box = unsafe { Box::from_raw(client) }; + let client_ref = &mut client_box.0; + let res = client_ref.get_value(value).await; + std::mem::forget(client_box); + res + }); + + match res { + Ok(value) => { + unsafe { + *out_plist = crate::util::plist_to_libplist(&value); + } + IdeviceErrorCode::IdeviceSuccess + } + Err(e) => e.into(), + } +} + +/// Gets all values from lockdownd +/// +/// # Arguments +/// * `client` - A valid LockdowndClient handle +/// * `out_plist` - Pointer to store the returned plist dictionary +/// +/// # Returns +/// An error code indicating success or failure +/// +/// # Safety +/// `client` must be a valid pointer to a handle allocated by this library +/// `out_plist` must be a valid pointer to store the plist +#[unsafe(no_mangle)] +pub unsafe extern "C" fn lockdownd_get_all_values( + client: *mut LockdowndClientHandle, + out_plist: *mut *mut c_void, +) -> IdeviceErrorCode { + if out_plist.is_null() { + return IdeviceErrorCode::InvalidArg; + } + + let res: Result = RUNTIME.block_on(async move { + let mut client_box = unsafe { Box::from_raw(client) }; + let client_ref = &mut client_box.0; + let res = client_ref.get_all_values().await; + std::mem::forget(client_box); + res + }); + + match res { + Ok(dict) => { + unsafe { + *out_plist = crate::util::plist_to_libplist(&plist::Value::Dictionary(dict)); + } + IdeviceErrorCode::IdeviceSuccess + } + Err(e) => e.into(), + } +} + +/// Frees a LockdowndClient handle +/// +/// # Arguments +/// * [`handle`] - The handle to free +/// +/// # Safety +/// `handle` must be a valid pointer to the handle that was allocated by this library, +/// or NULL (in which case this function does nothing) +#[unsafe(no_mangle)] +pub unsafe extern "C" fn lockdownd_client_free(handle: *mut LockdowndClientHandle) { + if !handle.is_null() { + log::debug!("Freeing lockdownd_client"); + let _ = unsafe { Box::from_raw(handle) }; + } +}