[enhance] modified examples

Author: YinMo19

README.cn.md

@@ -45,6 +45,8 @@ insert-dylib [options] <dylib_path> <binary_path> [new_binary_path]
 - `--strip-codesig` 在可行时强制移除 `LC_CODE_SIGNATURE`
 - `--no-strip-codesig` 不移除 `LC_CODE_SIGNATURE`
 - `--all-yes` 对所有交互提示自动回答 `yes`
+- `--ios` 将 dylib 的 Mach-O 平台字段从 `macOS` 改为 `iOS`（必须配合 `--dylib-path`）
+- `--dylib-path <path>` 配合 `--ios` 使用的本地 dylib 文件路径，用于平台字段改写
 
 ## 示例
 
@@ -68,6 +70,12 @@ insert-dylib --weak --inplace @rpath/libHook.dylib MyApp
 insert-dylib --strip-codesig --overwrite @loader_path/libHook.dylib MyApp MyApp.patched
 ```
 
+写入 iOS install name，并对本地 dylib 文件执行平台改写：
+
+```bash
+insert-dylib --ios --dylib-path libarcaea_function.dylib @executable_path/Frameworks/libarcaea_function.dylib Arc-mobile
+```
+
 ## 代码签名说明
 
 若移除了 `LC_CODE_SIGNATURE`，原签名会失效。需要的话请对补丁后的文件重新签名：

README.md

@@ -45,6 +45,8 @@ If `new_binary_path` is omitted (and `--inplace` is not used), output defaults t
 - `--strip-codesig` force removing `LC_CODE_SIGNATURE` when possible
 - `--no-strip-codesig` never remove `LC_CODE_SIGNATURE`
 - `--all-yes` auto-answer `yes` to all interactive prompts
+- `--ios` rewrite dylib Mach-O platform markers from `macOS` to `iOS` (requires `--dylib-path`)
+- `--dylib-path <path>` local dylib file path used by `--ios` for Mach-O platform rewrite
 
 ## Examples
 
@@ -68,6 +70,12 @@ Force code-signature stripping and overwrite output:
 insert-dylib --strip-codesig --overwrite @loader_path/libHook.dylib MyApp MyApp.patched
 ```
 
+Inject iOS install name while rewriting a local dylib file to iOS platform metadata:
+
+```bash
+insert-dylib --ios --dylib-path libarcaea_function.dylib @executable_path/Frameworks/libarcaea_function.dylib Arc-mobile
+```
+
 ## Code Signing Note
 
 If `LC_CODE_SIGNATURE` is removed, the binary's signature is invalidated. Re-sign the patched binary if needed:

examples/classic-tight-headerpad-case/hook/src/lib.rs

@@ -6,7 +6,7 @@ const LOG_MSG: &[u8] = b"[+] hooked: now x0 is 99.\n";
 extern "C" fn replace_logic(_address: u64, ctx: *mut HookContext) {
     unsafe {
         let _ = libc::write(
-            libc::STDERR_FILENO,
+            libc::STDOUT_FILENO,
             LOG_MSG.as_ptr() as *const libc::c_void,
             LOG_MSG.len(),
         );

src/main.rs

@@ -24,6 +24,12 @@ const LC_LOAD_DYLIB: u32 = 0xc;
 const LC_LOAD_WEAK_DYLIB: u32 = 0x80000018;
 const LC_SEGMENT_64: u32 = 0x19;
 const LC_CODE_SIGNATURE: u32 = 0x1d;
+const LC_VERSION_MIN_MACOSX: u32 = 0x24;
+const LC_VERSION_MIN_IPHONEOS: u32 = 0x25;
+const LC_BUILD_VERSION: u32 = 0x32;
+
+const PLATFORM_MACOS: u32 = 1;
+const PLATFORM_IOS: u32 = 2;
 
 const BUFSIZE: usize = 512;
 
@@ -128,6 +134,26 @@ struct LinkeditDataCommand {
     datasize: u32,
 }
 
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+struct VersionMinCommand {
+    cmd: u32,
+    cmdsize: u32,
+    version: u32,
+    sdk: u32,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+struct BuildVersionCommand {
+    cmd: u32,
+    cmdsize: u32,
+    platform: u32,
+    minos: u32,
+    sdk: u32,
+    ntools: u32,
+}
+
 #[repr(C)]
 #[derive(Clone, Copy, Debug)]
 struct FatHeader {
@@ -152,6 +178,14 @@ struct Options {
     overwrite: bool,
     codesig_flag: u8,
     all_yes: bool,
+    ios: bool,
+    ios_dylib_path: Option<String>,
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+struct PlatformRewriteStats {
+    platform_commands: usize,
+    rewritten_commands: usize,
 }
 
 fn is_64_bit(magic: u32) -> bool {
@@ -193,8 +227,9 @@ fn absdiff(lhs: u64, rhs: u64) -> u64 {
 fn usage() -> ! {
     println!("Usage: insert-dylib dylib_path binary_path [new_binary_path]");
     println!(
-        "Option flags: --inplace --weak --overwrite --strip-codesig --no-strip-codesig --all-yes"
+        "Option flags: --inplace --weak --overwrite --strip-codesig --no-strip-codesig --all-yes --ios --dylib-path <path>"
     );
+    println!("Note: --ios requires --dylib-path <local_dylib_file>.");
     process::exit(1);
 }
 
@@ -599,12 +634,133 @@ fn insert_dylib(
     Ok(true)
 }
 
+fn rewrite_macho_platform_to_ios_slice(
+    file: &mut File,
+    header_offset: u64,
+) -> io::Result<PlatformRewriteStats> {
+    file.seek(SeekFrom::Start(header_offset))?;
+
+    let mh: MachHeader = read_struct(file)?;
+    if mh.magic != MH_MAGIC_64
+        && mh.magic != MH_CIGAM_64
+        && mh.magic != MH_MAGIC
+        && mh.magic != MH_CIGAM
+    {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidData,
+            format!("Unknown Mach-O magic: 0x{:x}", mh.magic),
+        ));
+    }
+
+    let commands_offset = header_offset
+        + if is_64_bit(mh.magic) {
+            size_of::<MachHeader64>() as u64
+        } else {
+            size_of::<MachHeader>() as u64
+        };
+
+    file.seek(SeekFrom::Start(commands_offset))?;
+    let ncmds = swap32(mh.ncmds, mh.magic);
+    let mut stats = PlatformRewriteStats::default();
+
+    for _ in 0..ncmds {
+        let command_offset = file.stream_position()?;
+        let lc: LoadCommand = peek_struct(file)?;
+        let cmd = swap32(lc.cmd, mh.magic);
+        let cmdsize = swap32(lc.cmdsize, mh.magic);
+
+        if cmdsize < size_of::<LoadCommand>() as u32 {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                "load command size is smaller than load_command",
+            ));
+        }
+
+        match cmd {
+            LC_BUILD_VERSION => {
+                if cmdsize < size_of::<BuildVersionCommand>() as u32 {
+                    return Err(io::Error::new(
+                        io::ErrorKind::InvalidData,
+                        "LC_BUILD_VERSION command is truncated",
+                    ));
+                }
+
+                let mut cmd_data: BuildVersionCommand = read_struct(file)?;
+                let platform = swap32(cmd_data.platform, mh.magic);
+                stats.platform_commands += 1;
+
+                if platform == PLATFORM_MACOS {
+                    cmd_data.platform = swap32(PLATFORM_IOS, mh.magic);
+                    file.seek(SeekFrom::Start(command_offset))?;
+                    write_struct(file, &cmd_data)?;
+                    stats.rewritten_commands += 1;
+                }
+            }
+            LC_VERSION_MIN_MACOSX => {
+                if cmdsize < size_of::<VersionMinCommand>() as u32 {
+                    return Err(io::Error::new(
+                        io::ErrorKind::InvalidData,
+                        "LC_VERSION_MIN_MACOSX command is truncated",
+                    ));
+                }
+
+                let mut cmd_data: VersionMinCommand = read_struct(file)?;
+                cmd_data.cmd = swap32(LC_VERSION_MIN_IPHONEOS, mh.magic);
+                file.seek(SeekFrom::Start(command_offset))?;
+                write_struct(file, &cmd_data)?;
+                stats.platform_commands += 1;
+                stats.rewritten_commands += 1;
+            }
+            LC_VERSION_MIN_IPHONEOS => {
+                stats.platform_commands += 1;
+            }
+            _ => {}
+        }
+
+        file.seek(SeekFrom::Start(command_offset + cmdsize as u64))?;
+    }
+
+    Ok(stats)
+}
+
+fn rewrite_dylib_platform_to_ios(path: &str) -> io::Result<PlatformRewriteStats> {
+    let mut file = File::options().read(true).write(true).open(path)?;
+    let magic: u32 = read_struct(&mut file)?;
+
+    match magic {
+        FAT_MAGIC | FAT_CIGAM => {
+            file.seek(SeekFrom::Start(0))?;
+            let fat_header: FatHeader = read_struct(&mut file)?;
+            let nfat_arch = swap32(fat_header.nfat_arch, magic) as usize;
+            let archs = read_fat_arches(&mut file, nfat_arch)?;
+
+            let mut total = PlatformRewriteStats::default();
+            for arch in archs {
+                let offset = swap32(arch.offset, magic) as u64;
+                let stats = rewrite_macho_platform_to_ios_slice(&mut file, offset)?;
+                total.platform_commands += stats.platform_commands;
+                total.rewritten_commands += stats.rewritten_commands;
+            }
+            Ok(total)
+        }
+        MH_MAGIC_64 | MH_CIGAM_64 | MH_MAGIC | MH_CIGAM => {
+            file.seek(SeekFrom::Start(0))?;
+            rewrite_macho_platform_to_ios_slice(&mut file, 0)
+        }
+        _ => Err(io::Error::new(
+            io::ErrorKind::InvalidData,
+            format!("Unknown Mach-O magic: 0x{:x}", magic),
+        )),
+    }
+}
+
 fn parse_args() -> (Options, Vec<String>) {
     let mut options = Options::default();
     let mut positional = Vec::new();
 
+    let mut args = env::args().skip(1).peekable();
     let mut parsing_options = true;
-    for arg in env::args().skip(1) {
+    while let Some(arg) = args.next() {
         if parsing_options {
             if arg == "--" {
                 parsing_options = false;
@@ -619,7 +775,21 @@ fn parse_args() -> (Options, Vec<String>) {
                     "--strip-codesig" => options.codesig_flag = 1,
                     "--no-strip-codesig" => options.codesig_flag = 2,
                     "--all-yes" => options.all_yes = true,
-                    _ => usage(),
+                    "--ios" => options.ios = true,
+                    "--dylib-path" => {
+                        let path = args.next().unwrap_or_else(|| usage());
+                        options.ios_dylib_path = Some(path);
+                    }
+                    _ => {
+                        if let Some(path) = arg.strip_prefix("--dylib-path=") {
+                            if path.is_empty() {
+                                usage();
+                            }
+                            options.ios_dylib_path = Some(path.to_string());
+                        } else {
+                            usage();
+                        }
+                    }
                 }
                 continue;
             }
@@ -677,6 +847,35 @@ fn run() -> io::Result<i32> {
         return Ok(1);
     }
 
+    if options.ios_dylib_path.is_some() && !options.ios {
+        eprintln!("--dylib-path can only be used together with --ios.");
+        return Ok(1);
+    }
+
+    if options.ios {
+        let ios_dylib_path = options.ios_dylib_path.as_deref().unwrap_or_else(|| {
+            eprintln!("--ios requires --dylib-path <local_dylib_file>.");
+            usage();
+        });
+
+        if fs::metadata(ios_dylib_path).is_err() {
+            eprintln!("{ios_dylib_path}: not found (--dylib-path)");
+            return Ok(1);
+        }
+
+        let stats = rewrite_dylib_platform_to_ios(ios_dylib_path)?;
+        if stats.platform_commands == 0 {
+            println!("No platform load command found in {ios_dylib_path}; skipped --ios rewrite.");
+        } else if stats.rewritten_commands == 0 {
+            println!("{ios_dylib_path} already declares iOS platform; no rewrite needed.");
+        } else {
+            println!(
+                "Rewrote {} platform load command(s) from macOS to iOS in {ios_dylib_path}.",
+                stats.rewritten_commands
+            );
+        }
+    }
+
     if !options.inplace {
         let new_binary_path = if positional.len() == 3 {
             positional[2].clone()