apple-crates

@@ -232,6 +232,7 @@ dependencies = [

  "libc",

  "ouroboros",

  "rand 0.9.4",

+ "tempfile",

 ]

 [[package]]

@@ -4074,6 +4075,9 @@ version = "0.1.0"

 dependencies = [

  "adi",

  "dlopen2",

+ "md-5",

+ "tempfile",

+ "windows-sys 0.61.2",

 ]

 [[package]]

@@ -7089,6 +7093,7 @@ dependencies = [

  "chrono",

  "core-foundation 0.10.0",

  "crc32fast",

+ "der",

  "directories",

  "dlopen2",

  "env_logger",

@@ -7110,14 +7115,18 @@ dependencies = [

  "plist",

  "rand 0.10.2",

  "reqwest",

+ "rsa",

  "serde",

  "sha1 0.11.0",

+ "sha2 0.10.9",

  "tempfile",

  "thiserror 2.0.18",

  "tokio",

  "toml 0.8.23",

  "uuid",

  "walkdir",

+ "windows-sys 0.61.2",

+ "x509-cert",

  "xcode",

 ]

@@ -9,3 +9,6 @@ elf-loader.workspace = true

 ouroboros = "0.18.5"

 libc = "0.2.176"

 rand = "0.9"

+

+[dev-dependencies]

+tempfile = "3"

@@ -16,12 +16,12 @@ pub struct stat {

     pub st_size: libc::c_longlong,

     pub st_blksize: blksize_t,

     pub st_blocks: libc::c_ulonglong,

-    pub st_atime: libc::c_long,

-    pub st_atime_nsec: libc::c_long,

-    pub st_mtime: libc::c_long,

-    pub st_mtime_nsec: libc::c_long,

-    pub st_ctime: libc::c_long,

-    pub st_ctime_nsec: libc::c_long,

+    pub st_atime: isize,

+    pub st_atime_nsec: isize,

+    pub st_mtime: isize,

+    pub st_mtime_nsec: isize,

+    pub st_ctime: isize,

+    pub st_ctime_nsec: isize,

     pub st_ino: libc::c_ulonglong,

 }

@@ -35,17 +35,17 @@ pub struct stat {

     pub st_uid: uid_t,

     pub st_gid: gid_t,

     pub st_rdev: dev_t,

-    pub __pad1: libc::c_ulong,

+    pub __pad1: usize,

     pub st_size: off64_t,

     pub st_blksize: libc::c_int,

     pub __pad2: libc::c_int,

-    pub st_blocks: libc::c_long,

+    pub st_blocks: isize,

     pub st_atime: time_t,

-    pub st_atime_nsec: libc::c_long,

+    pub st_atime_nsec: isize,

     pub st_mtime: time_t,

-    pub st_mtime_nsec: libc::c_long,

+    pub st_mtime_nsec: isize,

     pub st_ctime: time_t,

-    pub st_ctime_nsec: libc::c_long,

+    pub st_ctime_nsec: isize,

     pub __unused4: libc::c_uint,

     pub __unused5: libc::c_uint,

 }

@@ -55,21 +55,21 @@ pub struct stat {

 pub struct stat {

     pub st_dev: dev_t,

     pub st_ino: ino_t,

-    pub st_nlink: libc::c_ulong,

+    pub st_nlink: usize,

     pub st_mode: libc::c_uint,

     pub st_uid: uid_t,

     pub st_gid: gid_t,

     pub st_rdev: dev_t,

     pub st_size: off64_t,

-    pub st_blksize: libc::c_long,

-    pub st_blocks: libc::c_long,

-    pub st_atime: libc::c_long,

-    pub st_atime_nsec: libc::c_long,

-    pub st_mtime: libc::c_long,

-    pub st_mtime_nsec: libc::c_long,

-    pub st_ctime: libc::c_long,

-    pub st_ctime_nsec: libc::c_long,

-    pub __unused: [libc::c_long; 3],

+    pub st_blksize: isize,

+    pub st_blocks: isize,

+    pub st_atime: isize,

+    pub st_atime_nsec: isize,

+    pub st_mtime: isize,

+    pub st_mtime_nsec: isize,

+    pub st_ctime: isize,

+    pub st_ctime_nsec: isize,

+    pub __unused: [isize; 3],

 }

 pub const O_RDONLY: libc::c_int = 0;

@@ -83,8 +83,8 @@ pub const O_NOFOLLOW: libc::c_int = 0x20000;

 #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]

 pub const O_NOFOLLOW: libc::c_int = 0x8000;

-pub type dev_t = libc::c_ulong;

-pub type ino_t = libc::c_ulong;

+pub type dev_t = usize;

+pub type ino_t = usize;

 pub type nlink_t = u32;

 pub type uid_t = u32;

 pub type gid_t = u32;

@@ -99,7 +99,7 @@ pub type mode_t = u32;

 #[cfg(target_pointer_width = "32")]

 pub type mode_t = u16;

-pub type time_t = libc::c_long;

+pub type time_t = isize;

 pub type suseconds_t = i64;

@@ -108,3 +108,16 @@ pub struct timeval {

     pub tv_sec: time_t,

     pub tv_usec: suseconds_t,

 }

+

+#[cfg(all(test, target_arch = "x86_64"))]

+mod tests {

+    use super::*;

+    #[test]

+    fn linux_abi_layout_is_independent_of_windows_long_width() {

+        assert_eq!(std::mem::size_of::<stat>(), 144);

+        assert_eq!(std::mem::offset_of!(stat, st_size), 48);

+        assert_eq!(std::mem::offset_of!(stat, st_atime), 72);

+        assert_eq!(std::mem::size_of::<timeval>(), 16);

+        assert_eq!(std::mem::offset_of!(timeval, tv_usec), 8);

+    }

+}

@@ -31,12 +31,12 @@ unsafe extern "C" {

     fn _errno() -> *mut libc::c_int;

     fn _timespec64_get(__ts: *mut _timespec64, __base: libc::c_int) -> libc::c_int;

     fn _timespec32_get(__ts: *mut _timespec32, __base: libc::c_int) -> libc::c_int;

-    fn _chsize(handle: i64, length: u64) -> usize;

+    fn _chsize_s(handle: libc::c_int, length: i64) -> libc::c_int;

 }

 #[linux_cc]

 pub unsafe fn chmod(path: *const libc::c_char, mode: mode_t) -> libc::c_int {

-    libc::chmod(linux_path_to_windows(path).as_ptr(), mem::transmute(mode))

+    libc::chmod(linux_path_to_windows(path).as_ptr(), mode as libc::c_int)

 }

 #[linux_cc]

@@ -56,12 +56,18 @@ pub unsafe fn free(p: *mut libc::c_void) {

 }

 #[linux_cc]

-pub unsafe fn ftruncate(handle: i64, length: u64) -> usize {

-    _chsize(handle, length)

+pub unsafe fn ftruncate(handle: libc::c_int, length: i64) -> libc::c_int {

+    let result = _chsize_s(handle, length);

+    if result == 0 {

+        0

+    } else {

+        *_errno() = result;

+        -1

+    }

 }

 #[linux_cc]

-pub unsafe fn gettimeofday(tp: *mut timeval, tz: *mut libc::c_void) -> libc::c_int {

+pub unsafe fn gettimeofday(tp: *mut timeval, _tz: *mut libc::c_void) -> libc::c_int {

     let mut time = MaybeUninit::uninit();

     #[cfg(target_pointer_width = "32")]

@@ -69,6 +75,9 @@ pub unsafe fn gettimeofday(tp: *mut timeval, tz: *mut libc::c_void) -> libc::c_i

     #[cfg(target_pointer_width = "64")]

     let result = _timespec64_get(time.as_mut_ptr(), 1);

+    if result != 1 {

+        return -1;

+    }

     let time = time.assume_init();

     *tp = timeval {

         tv_sec: time.tv_sec as _,

@@ -84,7 +93,7 @@ pub unsafe fn malloc(size: libc::size_t) -> *mut libc::c_void {

 }

 #[linux_cc]

-pub unsafe fn mkdir(path: *const libc::c_char, mode: mode_t) -> libc::c_int {

+pub unsafe fn mkdir(path: *const libc::c_char, _mode: mode_t) -> libc::c_int {

     libc::mkdir(linux_path_to_windows(path).as_ptr())

 }

@@ -119,16 +128,16 @@ unsafe fn local_stat_to_linux(buf: libc::stat) -> stat {

         st_dev: buf.st_dev as _,

         st_ino: buf.st_ino as _,

         st_nlink: buf.st_nlink as _,

-        st_mode: 0o777 as _,

+        st_mode: buf.st_mode as _,

         st_uid: buf.st_uid as _,

         st_gid: buf.st_gid as _,

         st_rdev: buf.st_rdev as _,

         st_size: buf.st_size as _,

-        st_atime: (buf.st_atime / 10000000) as _,

+        st_atime: buf.st_atime as _,

         // st_atime_nsec: buf.st_atime_nsec as _,

-        st_mtime: (buf.st_mtime / 10000000) as _,

+        st_mtime: buf.st_mtime as _,

         // st_mtime_nsec: buf.st_mtime_nsec as _,

-        st_ctime: (buf.st_ctime / 10000000) as _,

+        st_ctime: buf.st_ctime as _,

         // st_ctime_nsec: buf.st_ctime_nsec as _,

         ..mem::zeroed()

     }

@@ -170,24 +179,64 @@ pub unsafe fn fstat(fildes: libc::c_int, buf: *mut stat) -> libc::c_int {

 #[linux_cc]

 pub unsafe fn open(path: *const libc::c_char, oflag: libc::c_int) -> libc::c_int {

-    let mut local_flag = 0x8000;

-

-    if oflag & 0b11 == O_WRONLY {

-        local_flag = libc::O_RDWR;

-    }

-    if oflag & 0b11 == O_RDWR {

-        local_flag = libc::O_RDWR;

-    }

-    if oflag & 0b11 == O_RDONLY {

-        local_flag = libc::O_RDWR;

-    }

-

-    if oflag & O_CREAT != 0 {

-        local_flag |= libc::O_CREAT;

+    let access = match oflag & 3 {

+        O_WRONLY => libc::O_WRONLY,

+        O_RDWR => libc::O_RDWR,

+        _ => libc::O_RDONLY,

+    };

+    let mut local_flag = access | libc::O_BINARY;

+    for (linux, windows) in [

+        (O_CREAT, libc::O_CREAT),

+        (0o200, libc::O_EXCL),

+        (0o1000, libc::O_TRUNC),

+        (0o2000, libc::O_APPEND),

+    ] {

+        if oflag & linux != 0 {

+            local_flag |= windows;

+        }

+    }

+    // The CRT requires a mode argument when creating a file. ADI uses private

+    // provisioning files; Windows ACLs determine access beyond these mode bits.

+    libc::open(

+        linux_path_to_windows(path).as_ptr(),

+        local_flag,

+        libc::S_IREAD | libc::S_IWRITE,

+    )

+}

+

+#[cfg(test)]

+mod tests {

+    use super::*;

+    #[test]

+    fn provisioning_files_round_trip_binary_data_and_report_linux_stat() {

+        let directory = tempfile::tempdir().unwrap();

+        let path = directory.path().join("provisioning");

+        let path_c = CString::new(path.to_str().unwrap()).unwrap();

+        let data = [0, 10, 13, 10, 26, 255];

+        unsafe {

+            let fd = open(path_c.as_ptr(), O_WRONLY | O_CREAT);

+            assert!(fd >= 0);

+            assert_eq!(

+                write(fd, data.as_ptr().cast(), data.len() as _),

+                data.len() as _

+            );

+            assert_eq!(close(fd), 0);

+            assert_eq!(std::fs::read(&path).unwrap(), data);

+            let fd = open(path_c.as_ptr(), O_RDONLY);

+            assert!(fd >= 0);

+            let mut actual = [0; 6];

+            assert_eq!(read(fd, actual.as_mut_ptr().cast(), actual.len() as _), 6);

+            assert_eq!(actual, data);

+            let mut stat = std::mem::zeroed();

+            assert_eq!(fstat(fd, &mut stat), 0);

+            assert_eq!(stat.st_size, 6);

+            assert_eq!(stat.st_mode & 0o170000, 0o100000);

+            assert!(stat.st_mtime > 1_500_000_000);

+            assert_eq!(close(fd), 0);

+            let fd = open(path_c.as_ptr(), O_RDWR);

+            assert_eq!(ftruncate(fd, 2), 0);

+            assert_eq!(close(fd), 0);

+            assert_eq!(std::fs::metadata(&path).unwrap().len(), 2);

         }

-    if oflag & O_NOFOLLOW != 0 {

-        // local_flag |= libc::O_NOFOLLOW;

     }

-

-    libc::open(linux_path_to_windows(path).as_ptr(), local_flag)

 }

@@ -13,6 +13,13 @@ pub const AUTH_KIT_BUNDLE_INFORMATION: BundleInformation = BundleInformation {

     bundle_version: "1",

 };

+/// akd

+pub const AKD_BUNDLE_INFORMATION: BundleInformation = BundleInformation {

+    bundle_name: "akd",

+    bundle_identifier: "com.apple.akd",

+    bundle_version: "1.0",

+};

+

 /// Apple TV 1.5.6 (macOS Sequoia 15.7.3)

 pub const APPLE_TV_BUNDLE_INFORMATION: BundleInformation = BundleInformation {

     bundle_name: "TV",

@@ -17,9 +17,9 @@ impl Device {

             "<{}> <{}> <{}/{} ({}/{})>",

             self.device_model,

             self.operating_system_information,

-            authentication_framework.bundle_name,

+            authentication_framework.bundle_identifier,

             authentication_framework.bundle_version,

-            application_information.bundle_name,

+            application_information.bundle_identifier,

             application_information.bundle_version,

         )

     }

@@ -271,6 +271,7 @@ pub async fn login(

     let response = http_session

         .anisette_request_builder(Method::POST, gs_service_url)?

+        .header("Content-Type", "text/x-xml-plist")

         .body(dict_to_body(request_plist))

         .send()

         .await?

@@ -365,6 +366,7 @@ pub async fn login(

         // to be interrupted here. It is important because on some networks, the apptokens

         // request fails if the TLS session is kept alive.

         .header("Connection", "close")

+        .header("Content-Type", "text/x-xml-plist")

         .body(dict_to_body(request_plist))

         .send()

         .await?

@@ -254,6 +254,7 @@ impl<'a, 'b> AuthenticatedHTTPSession<'a, 'b> {

         let response = http_session

             .anisette_request_builder(Method::POST, gs_service_url)

             .map_err(AppTokenRequestError::Anisette)?

+            .header("Content-Type", "text/x-xml-plist")

             .body(request_body)

             .send()

             .await

@@ -59,6 +59,7 @@ impl AuthenticatedHTTPSession<'_, '_> {

         let response = self

             .authenticated_request_builder(Method::POST, post_data_url)?

+            .header("Content-Type", "text/x-xml-plist")

             .body(plist_to_body(request.into()))

             .send()

             .await?

@@ -6,3 +6,10 @@ edition = "2024"

 [dependencies]

 adi.workspace = true

 dlopen2 = "0.8.2"

+

+[target.'cfg(target_os = "windows")'.dependencies]

+md-5 = "0.10"

+windows-sys = { version = "0.61", features = ["Win32_Foundation", "Win32_NetworkManagement_IpHelper", "Win32_NetworkManagement_Ndis", "Win32_Networking_WinSock", "Win32_Storage_FileSystem", "Win32_System_LibraryLoader", "Win32_System_Registry", "Win32_System_WindowsProgramming"] }

+

+[dev-dependencies]

+tempfile = "3"

@@ -1,3 +1,6 @@

+#[cfg(target_os = "windows")]

+pub mod windows;

+

 use adi::core_adi::{CoreADIADIProxy, CoreADIParameters, CoreADIProxy};

 use dlopen2::symbor::{Library, Symbol};

@@ -0,0 +1,441 @@

+// TODO move this to another crate

+

+use adi::core_adi::{CoreADIADIProxy, CoreADIParameters, CoreADIProxy};

+use md5::{Digest, Md5};

+use std::ffi::{CStr, OsStr};

+use std::io;

+use std::os::windows::ffi::OsStrExt;

+use std::path::{Path, PathBuf};

+use std::ptr::{null, null_mut};

+use windows_sys::Win32::Foundation::{

+    ERROR_BUFFER_OVERFLOW, ERROR_MORE_DATA, FreeLibrary, HMODULE,

+};

+use windows_sys::Win32::NetworkManagement::IpHelper::{

+    GAA_FLAG_INCLUDE_ALL_INTERFACES, GetAdaptersAddresses, IP_ADAPTER_ADDRESSES_LH,

+};

+use windows_sys::Win32::Storage::FileSystem::GetVolumeInformationW;

+use windows_sys::Win32::System::LibraryLoader::{

+    GetProcAddress, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS, LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR,

+    LoadLibraryExW,

+};

+use windows_sys::Win32::System::Registry::*;

+use windows_sys::Win32::System::WindowsProgramming::{

+    GetComputerNameW, GetCurrentHwProfileW, HW_PROFILE_INFOW,

+};

+

+fn wide(value: &OsStr) -> Vec<u16> {

+    value.encode_wide().chain(Some(0)).collect()

+}

+

+struct Key(HKEY);

+impl Drop for Key {

+    fn drop(&mut self) {

+        unsafe {

+            RegCloseKey(self.0);

+        }

+    }

+}

+

+fn open_key(root: HKEY, path: &CStr, view: u32) -> Option<Key> {

+    let mut key = null_mut();

+    (unsafe { RegOpenKeyExA(root, path.as_ptr().cast(), 0, KEY_READ | view, &mut key) } == 0)

+        .then_some(Key(key))

+}

+

+fn value_bytes(key: HKEY, name: &CStr) -> Option<Vec<u8>> {

+    let mut size = 0;

+    if unsafe {

+        RegQueryValueExA(

+            key,

+            name.as_ptr().cast(),

+            null(),

+            null_mut(),

+            null_mut(),

+            &mut size,

+        )

+    } != 0

+    {

+        return None;

+    }

+    loop {

+        let mut bytes = vec![0; size as usize];

+        let result = unsafe {

+            RegQueryValueExA(

+                key,

+                name.as_ptr().cast(),

+                null(),

+                null_mut(),

+                bytes.as_mut_ptr(),

+                &mut size,

+            )

+        };

+        if result == ERROR_MORE_DATA {

+            continue;

+        }

+        if result != 0 {

+            return None;

+        }

+        bytes.truncate(size as usize);

+        return Some(bytes);

+    }

+}

+

+fn registry_bytes(path: &CStr, name: &CStr) -> Option<Vec<u8>> {

+    let key = open_key(HKEY_LOCAL_MACHINE, path, 0)?;

+    value_bytes(key.0, name)

+}

+

+fn registry_path(key: HKEY, name: &CStr) -> Option<PathBuf> {

+    // Paths must use the Unicode API; identity values deliberately use ANSI.

+    let name: Vec<u16> = name

+        .to_bytes()

+        .iter()

+        .map(|b| *b as u16)

+        .chain(Some(0))

+        .collect();

+    let mut size = 0;

+    if unsafe {

+        RegQueryValueExW(

+            key,

+            name.as_ptr(),

+            null(),

+            null_mut(),

+            null_mut(),

+            &mut size,

+        )

+    } != 0

+    {

+        return None;

+    }

+    let mut data = vec![0u16; size as usize / 2 + 1];

+    if unsafe {

+        RegQueryValueExW(

+            key,

+            name.as_ptr(),

+            null(),

+            null_mut(),

+            data.as_mut_ptr().cast(),

+            &mut size,

+        )

+    } != 0

+    {

+        return None;

+    }

+    let len = data.iter().position(|c| *c == 0).unwrap_or(data.len());

+    use std::os::windows::ffi::OsStringExt;

+    Some(std::ffi::OsString::from_wide(&data[..len]).into())

+}

+

+fn first_mac() -> Option<Vec<u8>> {

+    let mut size = 0;

+    // iTunes takes the first adapter, including interfaces which are down.

+    // u64 storage guarantees the alignment required by IP_ADAPTER_ADDRESSES.

+    loop {

+        let mut storage = vec![0u64; (size as usize).div_ceil(8).max(1)];

+        let adapter = storage.as_mut_ptr().cast::<IP_ADAPTER_ADDRESSES_LH>();

+        let result = unsafe {

+            GetAdaptersAddresses(

+                0,

+                GAA_FLAG_INCLUDE_ALL_INTERFACES,

+                null(),

+                adapter,

+                &mut size,

+            )

+        };

+        if result == ERROR_BUFFER_OVERFLOW {

+            continue;

+        }

+        if result != 0 {

+            return None;

+        }

+        let adapter = unsafe { &*adapter };

+        let mut mac = vec![0; 6];

+        let length = (adapter.PhysicalAddressLength as usize).min(6);

+        mac[..length].copy_from_slice(&adapter.PhysicalAddress[..length]);

+        return Some(mac);

+    }

+}

+

+fn volume_serial() -> Option<Vec<u8>> {

+    let mut serial = 0u32;

+    let root = wide(OsStr::new("C:\\"));

+    (unsafe {

+        GetVolumeInformationW(

+            root.as_ptr(),

+            null_mut(),

+            0,

+            &mut serial,

+            null_mut(),

+            null_mut(),

+            null_mut(),

+            0,

+        )

+    } != 0)

+        .then(|| serial.to_le_bytes().to_vec())

+}

+

+fn computer_name_bytes() -> Option<Vec<u8>> {

+    let mut name = [0u16; 16];

+    let mut length = name.len() as u32;

+    if unsafe { GetComputerNameW(name.as_mut_ptr(), &mut length) } == 0 {

+        return None;

+    }

+    // Compatibility quirk: iTunes passes the WCHAR count as a BYTE count.

+    let mut bytes: Vec<_> = name.iter().flat_map(|c| c.to_le_bytes()).collect();

+    bytes.truncate(length as usize);

+    Some(bytes)

+}

+

+fn hardware_profile_bytes() -> Option<Vec<u8>> {

+    let mut profile: HW_PROFILE_INFOW = unsafe { std::mem::zeroed() };

+    if unsafe { GetCurrentHwProfileW(&mut profile) } == 0 {

+        return None;

+    }

+    Some(

+        profile

+            .szHwProfileGuid

+            .iter()

+            .take_while(|c| **c != 0)

+            .flat_map(|c| c.to_le_bytes())

+            .collect(),

+    )

+}

+

+fn format_identifier(parts: &[Option<Vec<u8>>; 7]) -> String {

+    parts

+        .iter()

+        .map(|part| match part {

+            Some(bytes) => Md5::digest(bytes)[..4]

+                .iter()

+                .map(|b| format!("{b:02X}"))

+                .collect(),

+            None => "00000000".to_string(),

+        })

+        .collect::<Vec<String>>()

+        .join(".")

+}

+

+/// Compute the same device identifier used by iTunes on Windows 8+.

+/// Unavailable hardware components have zero segments, as in iTunes.

+pub fn device_identifier() -> String {

+    format_identifier(&[

+        first_mac(),

+        volume_serial(),

+        registry_bytes(

+            c"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",

+            c"ProductId",

+        ),

+        registry_bytes(

+            c"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0",

+            c"ProcessorNameString",

+        ),

+        registry_bytes(c"HARDWARE\\DESCRIPTION\\System", c"SystemBiosVersion"),

+        computer_name_bytes(),

+        hardware_profile_bytes(),

+    ])

+}

+

+fn add_directory(candidates: &mut Vec<PathBuf>, directory: &Path) {

+    let names: &[&str] = if cfg!(target_arch = "x86_64") {

+        &["CoreADI64.dll", "CoreADI.dll"]

+    } else {

+        &["CoreADI.dll"]

+    };

+    for name in names {

+        let path = directory.join(name);

+        if !candidates.contains(&path) {

+            candidates.push(path);

+        }

+    }

+}

+

+/// Candidate paths from registered desktop/Store installations and standard folders.

+pub fn library_candidates() -> Vec<PathBuf> {

+    let mut candidates = Vec::new();

+    for root in [HKEY_LOCAL_MACHINE, HKEY_CURRENT_USER] {

+        for view in [KEY_WOW64_64KEY, KEY_WOW64_32KEY] {

+            if let Some(key) = open_key(

+                root,

+                c"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\iTunes.exe",

+                view,

+            ) {

+                if let Some(path) = registry_path(key.0, c"") {

+                    if let Some(parent) = path.parent() {

+                        add_directory(&mut candidates, parent);

+                    }

+                }

+            }

+        }

+    }

+    for variable in ["ProgramW6432", "ProgramFiles", "ProgramFiles(x86)"] {

+        if let Some(root) = std::env::var_os(variable) {

+            let root = PathBuf::from(root);

+            for suffix in [

+                "iTunes",

+                "Common Files/Apple/Apple Application Support",

+                "Common Files/Apple/Internet Services",

+                "Apple/Apple Application Support",

+            ] {

+                add_directory(&mut candidates, &root.join(suffix));

+            }

+        }

+    }

+    for variable in [

+        "CommonProgramW6432",

+        "CommonProgramFiles",

+        "CommonProgramFiles(x86)",

+    ] {

+        if let Some(root) = std::env::var_os(variable) {

+            for suffix in ["Apple/Apple Application Support", "Apple/Internet Services"] {

+                add_directory(&mut candidates, &PathBuf::from(&root).join(suffix));

+            }

+        }

+    }

+    if let Some(key) = open_key(HKEY_CURRENT_USER, c"Software\\Classes\\Local Settings\\Software\\Microsoft\\Windows\\CurrentVersion\\AppModel\\Repository\\Packages", KEY_WOW64_64KEY) {

+        for index in 0.. {

+            let mut name = vec![0u8; 512];

+            let mut len = name.len() as u32;

+            if unsafe { RegEnumKeyExA(key.0, index, name.as_mut_ptr(), &mut len, null(), null_mut(), null_mut(), null_mut()) } != 0 { break; }

+            name.truncate(len as usize);

+            if ![b"AppleInc.iTunes_".as_slice(), b"AppleInc.iCloud_".as_slice()].iter().any(|prefix| name.starts_with(prefix)) { continue; }

+            name.push(0);

+            if let Some(package) = open_key(key.0, CStr::from_bytes_with_nul(&name).unwrap(), 0) {

+                if let Some(root) = registry_path(package.0, c"PackageRootFolder") {

+                    for suffix in ["", "VFS/ProgramFilesX64/iTunes", "VFS/ProgramFilesCommonX64/Apple/Internet Services", "VFS/ProgramFilesCommonX64/Apple/Apple Application Support"] {

+                        add_directory(&mut candidates, &root.join(suffix));

+                    }

+                }

+            }

+        }

+    }

+    candidates

+}

+

+fn compatible_library(path: &Path) -> bool {

+    use std::io::{Read, Seek, SeekFrom};

+    let Ok(mut file) = std::fs::File::open(path) else {

+        return false;

+    };

+    let mut dos = [0; 64];

+    if file.read_exact(&mut dos).is_err() || &dos[..2] != b"MZ" {

+        return false;

+    }

+    let offset = u32::from_le_bytes(dos[60..64].try_into().unwrap());

+    if file.seek(SeekFrom::Start(offset as u64)).is_err() {

+        return false;

+    }

+    let mut pe = [0; 6];

+    file.read_exact(&mut pe).is_ok()

+        && &pe[..4] == b"PE\0\0"

+        && u16::from_le_bytes([pe[4], pe[5]])

+            == if cfg!(target_arch = "x86_64") {

+                0x8664

+            } else if cfg!(target_arch = "aarch64") {

+                0xaa64

+            } else {

+                0x14c

+            }

+}

+

+pub fn find_library() -> Option<PathBuf> {

+    library_candidates()

+        .into_iter()

+        .find(|path| compatible_library(path))

+}

+

+/// Owns the DLL and uses its directory for dependency resolution, without changing PATH.

+pub struct WindowsCoreADIProxy {

+    module: HMODULE,

+    dispatcher: unsafe extern "C" fn(u32, *const CoreADIParameters) -> i32,

+}

+

+impl WindowsCoreADIProxy {

+    pub fn open(path: &Path) -> Result<Self, Box<dyn std::error::Error>> {

+        let path = std::fs::canonicalize(path)?;

+        let module = unsafe {

+            LoadLibraryExW(

+                wide(path.as_os_str()).as_ptr(),

+                null_mut(),

+                LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR | LOAD_LIBRARY_SEARCH_DEFAULT_DIRS,

+            )

+        };

+        if module.is_null() {

+            return Err(io::Error::last_os_error().into());

+        }

+        let symbol = unsafe { GetProcAddress(module, c"vdfut768ig".as_ptr().cast()) };

+        let Some(symbol) = symbol else {

+            let error = io::Error::last_os_error();

+            unsafe {

+                FreeLibrary(module);

+            }

+            return Err(error.into());

+        };

+        let proxy = Self {

+            module,

+            dispatcher: unsafe { std::mem::transmute(symbol) },

+        };

+        proxy.initialize()?;

+        Ok(proxy)

+    }

+}

+

+impl CoreADIProxy for WindowsCoreADIProxy {

+    unsafe fn dispatch(&self, code: u32, parameters: *const CoreADIParameters) -> i32 {

+        unsafe { (self.dispatcher)(code, parameters) }

+    }

+}

+

+impl Drop for WindowsCoreADIProxy {

+    fn drop(&mut self) {

+        let _ = self.finalize();

+        unsafe {

+            FreeLibrary(self.module);

+        }

+    }

+}

+

+#[cfg(test)]

+mod tests {

+    use super::*;

+    #[test]

+    fn discovery_rejects_wrong_architecture_and_malformed_files() {

+        let temp = tempfile::tempdir().unwrap();

+        let path = temp.path().join("CoreADI.dll");

+        assert!(!compatible_library(&path));

+        std::fs::write(&path, b"not a DLL").unwrap();

+        assert!(!compatible_library(&path));

+        let mut bytes = vec![0u8; 70];

+        bytes[..2].copy_from_slice(b"MZ");

+        bytes[60..64].copy_from_slice(&64u32.to_le_bytes());

+        bytes[64..68].copy_from_slice(b"PE\0\0");

+        let native: u16 = if cfg!(target_arch = "x86_64") {

+            0x8664

+        } else if cfg!(target_arch = "aarch64") {

+            0xaa64

+        } else {

+            0x14c

+        };

+        bytes[68..70].copy_from_slice(&native.to_le_bytes());

+        std::fs::write(&path, &bytes).unwrap();

+        assert!(compatible_library(&path));

+        bytes[68..70].copy_from_slice(&0xffffu16.to_le_bytes());

+        std::fs::write(&path, &bytes).unwrap();

+        assert!(!compatible_library(&path));

+    }

+

+    #[test]

+    fn identifier_preserves_order_null_bytes_and_missing_components() {

+        assert_eq!(

+            format_identifier(&[

+                Some(b"abc".to_vec()),

+                None,

+                Some(vec![]),

+                Some(b"abc\0".to_vec()),

+                None,

+                None,

+                None

+            ]),

+            "90015098.00000000.D41D8CD9.147A664A.00000000.00000000.00000000"

+        );

+    }

+}

@@ -29,6 +29,11 @@ rand = "0.10.2"

 reqwest.workspace = true

 serde = { version = "1.0.228", features = ["derive"] }

 sha1.workspace = true

+# Match the RustCrypto versions used by apple-codesign.

+der = { version = "0.7.10", features = ["alloc", "std"] }

+rsa = { version = "0.9.9", features = ["sha2", "getrandom"] }

+sha2_010 = { package = "sha2", version = "0.10" }

+x509-cert = { version = "0.2.5", features = ["builder"] }

 thiserror.workspace = true

 tempfile = "3.27"

 toml = "0.8.23"

@@ -43,6 +48,7 @@ core-foundation = "0.10.0"

 libc = "0.2.176"

 [target.'cfg(target_os = "windows")'.dependencies]

+windows-sys = { version = "0.61", features = ["Win32_System_SystemInformation"] }

 dlopen2 = "0.8.2"

 library-coreadi.workspace = true

 ouroboros = "0.18.5"

@@ -5,16 +5,12 @@ use crate::domain::{

     AdiRepairAction, MachineIdentity,

 };

 use adi::core_adi::CoreADIADIProxy;

-#[cfg(target_os = "windows")]

-use adi::core_adi::{CoreADIParameters, CoreADIProxy};

 use adi::ADIProxy;

 use async_zip::tokio::read::fs::ZipFileReader;

 use futures_lite::io::AsyncReadExt;

-use grandslam::bundle_information::BundleInformation;

+use grandslam::bundle_information::{BundleInformation, AKD_BUNDLE_INFORMATION};

 use grandslam::device::Device;

 use grandslam::http_session::AnisetteHTTPSession;

-#[cfg(target_os = "windows")]

-use ouroboros::self_referencing;

 use std::ffi::CString;

 use std::fs;

 use std::path::{Path, PathBuf};

@@ -109,8 +105,8 @@ async fn provision_adi_async(

 ) -> BackendResult<()> {

     let proxy = selected_adi_proxy(kind, &android_adi_identifier)?;

     let http_session = grandslam::http_session(

-        grandslam_device(&machine_identity),

-        XCODE_BUNDLE_INFORMATION,

+        grandslam_device(&machine_identity, kind),

+        AKD_BUNDLE_INFORMATION,

     )

     .await

     .map_err(|error| {

@@ -125,7 +121,18 @@ async fn provision_adi_async(

         .map_err(|error| BackendError::Adi(format!("Failed to provision ADI: {error}")))

 }

-pub(crate) fn grandslam_device(machine_identity: &MachineIdentity) -> Device {

+pub(crate) fn grandslam_device(machine_identity: &MachineIdentity, kind: AdiBackendKind) -> Device {

+    #[cfg(target_os = "windows")]

+    if kind == AdiBackendKind::WindowsCoreAdi {

+        let identity = crate::backend::system_identity::windows_machine_identity();

+        return Device {

+            device_model: identity.machine_name,

+            operating_system_information: format!("{}; {}", identity.os_name, identity.os_version),

+            device_uuid: identity.machine_id,

+        };

+    }

+    #[cfg(not(target_os = "windows"))]

+    let _ = kind;

     Device {

         device_model: machine_identity.machine_name.to_string(),

         operating_system_information: format!(

@@ -162,56 +169,22 @@ fn system_adi_proxy() -> BackendResult<Box<dyn ADIProxy>> {

     ))

 }

-#[cfg(target_os = "windows")]

-#[self_referencing]

-struct WindowsCoreADIProxy {

-    library: dlopen2::symbor::Library,

-

-    #[borrows(library)]

-    #[covariant]

-    proxy: library_coreadi::LibraryCoreADIProxy<'this>,

-}

-

-#[cfg(target_os = "windows")]

-impl WindowsCoreADIProxy {

-    fn open(path: PathBuf) -> BackendResult<Self> {

-        let library = dlopen2::symbor::Library::open(path.as_os_str())

-            .map_err(|error| BackendError::Adi(format!("Failed to load CoreADI.dll: {error}")))?;

-        let proxy = WindowsCoreADIProxyTryBuilder {

-            library,

-            proxy_builder: |library| {

-                library_coreadi::LibraryCoreADIProxy::new(library).map_err(|error| {

-                    BackendError::Adi(format!("CoreADI entry point could not be loaded: {error}"))

-                })

-            },

-        }

-        .try_build()?;

-

-        proxy

-            .with_proxy(|proxy| {

-                CoreADIADIProxy::initialize(proxy).map_err(|error| {

-                    BackendError::Adi(format!("CoreADI initialization failed: {error}"))

-                })

-            })

-            .map(|()| proxy)

-    }

-}

-

-#[cfg(target_os = "windows")]

-impl CoreADIProxy for WindowsCoreADIProxy {

-    unsafe fn dispatch(&self, function_code: u32, parameters: *const CoreADIParameters) -> i32 {

-        self.with_proxy(|proxy| unsafe { proxy.dispatch(function_code, parameters) })

-    }

-}

-

 #[cfg(target_os = "windows")]

 fn windows_coreadi_proxy() -> BackendResult<Box<dyn ADIProxy>> {

     let library_path = find_windows_coreadi_library().ok_or_else(|| {

         BackendError::Adi(

-            "CoreADI.dll was not found in the usual iTunes or iCloud folders.".to_string(),

+            "A compatible CoreADI library was not found in the installed iTunes or iCloud folders."

+                .into(),

         )

     })?;

-    Ok(Box::new(WindowsCoreADIProxy::open(library_path)?))

+    let proxy =

+        library_coreadi::windows::WindowsCoreADIProxy::open(&library_path).map_err(|error| {

+            BackendError::Adi(format!(

+                "Failed to load {}: {error}",

+                library_path.display()

+            ))

+        })?;

+    Ok(Box::new(proxy))

 }

 #[cfg(not(target_os = "windows"))]

@@ -322,6 +295,11 @@ fn windows_coreadi_backend() -> AdiBackend {

                 label: "Identity storage".into(),

                 value: "Apple managed".into(),

             },

+            #[cfg(target_os = "windows")]

+            AdiBackendDetail {

+                label: "Device identifier".into(),

+                value: library_coreadi::windows::device_identifier(),

+            },

         ],

         provisioning_state: AdiProvisioningState::Unknown,

         editable_identity: false,

@@ -539,23 +517,22 @@ async fn publish_partial_file(

 pub(crate) async fn download_and_install_android_coreadi(

     mut progress: impl FnMut(AndroidCoreAdiInstallEvent) + Send + 'static,

 ) -> BackendResult<PathBuf> {

-    backend_runtime::run_send("CoreADI install", async move {

-        let apk_path = download_android_coreadi_apk(|download| {

+    backend_runtime::run_send_with("CoreADI install", move || async move {

+        let apk_path = Box::pin(download_android_coreadi_apk(|download| {

             progress(AndroidCoreAdiInstallEvent::Downloading(download));

-        })

+        }))

         .await?;

         progress(AndroidCoreAdiInstallEvent::Installing);

-        install_android_coreadi_from_apk_async(apk_path).await

+        Box::pin(install_android_coreadi_from_apk_async(apk_path)).await

     })

     .await?

 }

 #[allow(dead_code)]

 pub(crate) async fn install_android_coreadi_from_apk(apk_path: PathBuf) -> BackendResult<PathBuf> {

-    backend_runtime::run_send(

-        "CoreADI APK reader",

-        install_android_coreadi_from_apk_async(apk_path),

-    )

+    backend_runtime::run_send_with("CoreADI APK reader", move || {

+        Box::pin(install_android_coreadi_from_apk_async(apk_path))

+    })

     .await?

 }

@@ -611,7 +588,8 @@ async fn install_android_coreadi_from_apk_async(apk_path: PathBuf) -> BackendRes

                 source: error,

             })?;

     let mut written_bytes = 0u64;

-    let mut buffer = [0u8; 64 * 1024];

+    // Keep the extraction buffer out of the async state machine on the caller stack.

+    let mut buffer = vec![0u8; 64 * 1024];

     loop {

         let read = entry_reader.read(&mut buffer).await.map_err(|error| {

             BackendError::Zip(format!("Failed to extract CoreADI from APK: {error}"))

@@ -693,48 +671,26 @@ fn c_string_from_path(path: &Path) -> BackendResult<CString> {

 }

 fn find_windows_coreadi_library() -> Option<PathBuf> {

-    if !cfg!(target_os = "windows") {

-        return None;

-    }

-