Skip to content

Run a virtual iPhone on an Apple Silicon Mac.

Swift

Fix RootHide loader links before chained spawns

Lakr5f9f8712bdb3
diff --git a/Research/0_binary_patch_comparison.md b/Research/0_binary_patch_comparison.md
index dddb2f29..7719134a 100644
--- a/Research/0_binary_patch_comparison.md
+++ b/Research/0_binary_patch_comparison.md
@@ -76,6 +76,14 @@
> `_MSSafeMode=1` each reported no `DYLD_INSERT_LIBRARIES` and
> `systemhook_loaded=0` after reboot. This diagnostic library proves the
> loading path, not real ElleKit or a tweak package.
+> On 2026-09-25, the launchd and SystemHook spawn bridges gained a shared
+> RootHide loader-link helper. Before a bootstrap executable is spawned, it
+> creates or validates the `.jbroot` link beside that executable, accepting
+> `/var` and `/private/var` spellings of the same root. On an isolated clone
+> of `vphone-27.0-cloudos-26.4`, Xrash and Irisin App launches each created a
+> missing link and reached the foreground. A dynamically loaded LaunchDaemon
+> did not traverse the observed interposers; it still needed its link before
+> service load. vphoned's initial fixed-directory link seeding remains in place.
> A bootstrap CLI probe then spawned itself with explicit stripped
> environments. Its `posix_spawn`, `posix_spawnp` (absolute program path), and
> `execve` children all reported `systemhook_loaded=1`,
diff --git a/Research/roothide_loader_links.md b/Research/roothide_loader_links.md
new file mode 100644
index 00000000..3561e737
--- /dev/null
+++ b/Research/roothide_loader_links.md
@@ -0,0 +1,90 @@
+# RootHide loader links for later-installed applications
+
+## Observation and boundary
+
+The 2026-09-24 TrollSpeed crash reports an unresolved
+`@loader_path/.jbroot/usr/lib/libroothide.dylib`. dyld tried the physical
+`<jbroot>/Applications/TrollSpeed.app/.jbroot/usr/lib/libroothide.dylib`
+and stopped before the application began executing. This identifies a loader
+path failure, but the report alone does not prove whether the `.jbroot` link,
+the target `usr/lib/libroothide.dylib`, or both are missing. Inspect both on
+the guest before changing anything.
+
+RootHide's [developer documentation](https://github.com/roothide/Developer/blob/main/roothide.md)
+specifies a `.jbroot` link in every directory containing a Mach-O image and
+says package installation or the jailbreak's loader normally creates it.
+Apple's [dynamic library documentation](https://developer.apple.com/library/archive/documentation/DeveloperTools/Conceptual/DynamicLibraries/100-Articles/DynamicLibraryDesignGuidelines.html)
+defines `@loader_path` relative to the referencing image. A link beside the
+main executable alone will not cover a dependent image in an embedded
+framework or extension directory.
+
+## Present vphone behavior
+
+- `GuestIrisinInstaller.ensureRootHideLinks` seeds the bootstrap root and
+ `bin`, `sbin`, `usr/bin`, `usr/sbin`, `usr/lib`, and `usr/libexec` at initial
+ bootstrap installation and on `vphoned` startup. It does not cover
+ `Applications/*.app` installed later.
+- The launchd hook sees physical bootstrap executable paths and app paths
+ before `posix_spawn`. It passes `VPHONE_JB_ROOT` and SystemHook injection to
+ `xpcproxy` and direct app spawns.
+- SystemHook's constructor loads `TweakLoader.dylib` with `dlopen`, but a
+ required `LC_LOAD_DYLIB` is resolved by dyld before that constructor. An
+ in-process repair there cannot recover this launch failure. SystemHook in
+ the parent of a chained spawn could repair links before spawning instead.
+- vphone's `apps.install` calls IcliKit, which installs into an application
+ container without creating RootHide loader links. The Irisin bootstrap
+ installer and Irisin's own package installer are separate installation
+ paths. Neither existing vphone link seeding nor a hook on `dpkg` alone
+ covers every one of these paths.
+
+## Implemented boundary
+
+The shared `RootHideLoaderLinks` helper runs before the final spawn in both
+`launchdhook-vphone` and `SystemHook-vphone`. It accepts executable paths
+inside the selected RootHide bootstrap, including `/var` and `/private/var`
+spellings, and creates a relative `.jbroot` link in the executable's own
+directory. It resolves and validates an existing link, refuses a non-link or
+a link to another root, and never writes into an unrelated app container.
+The spawn result is preserved if link creation fails; the hooks log the
+failure. A single directory operation is bounded work in PID 1. Embedded
+frameworks with their own `@loader_path/.jbroot` dependency will still need
+their own link before dyld loads them; that needs a separate package-side
+pass or a carefully bounded Mach-O directory walk.
+
+The fixed bootstrap link seeding in `vphoned` remains necessary. A test
+LaunchDaemon loaded after boot spawned without passing through either observed
+interposer: a copied RootHide `true` executable under an unlinked app directory
+exited with `OS_REASON_DYLD` (status 6), then exited successfully (status 0)
+after its `.jbroot` link was created. Removing vphoned's `usr/libexec` seed
+could therefore regress the first Irisin daemon launch. An installer-side link
+pass is useful for such jobs and for normal uninstall cleanup, but cannot
+cover third-party installers by itself. A dyld path remap could
+remove the filesystem links entirely, but would require an early, versioned
+patch to the loader, a reliable current-root lookup in every affected process,
+and tests for every RootHide load-command form. Its boot-wide reach makes it
+the highest-risk option for this specific gap.
+
+## Further verification
+
+1. Check `lstat`/`readlink` of the exact app directory's `.jbroot`, confirm
+ `<jbroot>/usr/lib/libroothide.dylib` exists, and inspect the executable's
+ `LC_LOAD_DYLIB` entries. Keep the original crash report.
+2. Reproduce the missing-link launch on a clone. Confirm launchd logs the
+ final physical executable and that the failure happens before SystemHook
+ logs its constructor for that PID.
+3. With the link in place before spawn, confirm dyld opens the target library,
+ TrollSpeed starts, and any later failure is diagnosed separately.
+4. Exercise a bundle with a framework or extension referencing the same
+ install name, a package upgrade, uninstall, safe mode, and a RootHide root
+ rerandomization. Confirm existing non-link `.jbroot` entries are preserved.
+
+On 2026-09-25, a copy of `vphone-27.0-cloudos-26.4` booted with both updated
+hooks. Its RootHide `usr/lib/libroothide.dylib` existed. The unlinked
+`Applications/Xrash.app` launched and became frontmost; launchd logged
+`loader-link ... status=0`, and the new `.jbroot` resolved to the selected
+root. The same before/after result was observed for `Applications/irisin.app`.
+The test LaunchDaemon described above was unloaded and removed. TrollSpeed
+was not installed on this VM, so its exact package remains untested here.
+The original named VM then booted with the two updated hooks. Xrash and
+Irisin each launched frontmost, and each missing app-directory `.jbroot`
+was created and resolved to the selected RootHide root.
diff --git a/Research/vphoned_http_api.md b/Research/vphoned_http_api.md
index 1fe087ef..c909e6c4 100644
--- a/Research/vphoned_http_api.md
+++ b/Research/vphoned_http_api.md
@@ -55,6 +55,10 @@ library directories. On startup it repairs missing links for an existing
completed installation without replacing links that point elsewhere. These
links let `@loader_path/.jbroot/usr/lib/...` dependencies resolve when a
package manager later installs tools such as `dash`.
+The launchd and SystemHook spawn bridges also create a missing `.jbroot`
+beside a bootstrap executable just before it starts, covering applications
+installed after the initial bootstrap. The fixed links remain necessary for
+jobs whose launch path does not pass through either observed spawn bridge.
`POST /v1/bootstrap/firmware` (RPC `bootstrap.firmware`)
repairs the record for a bootstrap already identified by the completion marker
without running another install. The reply includes the tag,
diff --git a/VPhoneExecutable/VPhoneVirtualization/Resources/Info.plist b/VPhoneExecutable/VPhoneVirtualization/Resources/Info.plist
index d5f9bbe8..30226dff 100644
--- a/VPhoneExecutable/VPhoneVirtualization/Resources/Info.plist
+++ b/VPhoneExecutable/VPhoneVirtualization/Resources/Info.plist
@@ -9,9 +9,9 @@
<key>CFBundlePackageType</key>
<string>BNDL</string>
<key>CFBundleVersion</key>
- <string>2</string>
+ <string>3</string>
<key>CFBundleShortVersionString</key>
- <string>2.0.0</string>
+ <string>2.0.1</string>
<key>NSLocationUsageDescription</key>
<string>Shares your location with the virtual iPhone so apps running inside it see the same location.</string>
<key>NSLocationWhenInUseUsageDescription</key>
diff --git a/VPhoneGuestComponents/LaunchHook/launchdhook-vphone.c b/VPhoneGuestComponents/LaunchHook/launchdhook-vphone.c
index 1b2a003b..56d5c216 100644
--- a/VPhoneGuestComponents/LaunchHook/launchdhook-vphone.c
+++ b/VPhoneGuestComponents/LaunchHook/launchdhook-vphone.c
@@ -1,4 +1,5 @@
#include "../Shared/InjectionEnvironment.h"
+#include "../Shared/RootHideLoaderLinks.h"
#include <ctype.h>
#include <dirent.h>
#include <dlfcn.h>
@@ -14,6 +15,7 @@
#include <xpc/xpc.h>
static char vpBootRoot[PATH_MAX];
+static int vpFindJBRoot(char root[PATH_MAX]);
static void vpLogInjection(const char *event, const char *path, int status) {
int fd = open("/var/mobile/Library/Caches/vphone-launchdhook-injection.log",
@@ -44,14 +46,31 @@ static int vpIsAppProgram(const char *path) {
sizeof("/private/var/containers/Bundle/Application/") - 1) == 0;
}
+static int vpIsBootstrapProgram(const char *path) {
+ if (!path)
+ return 0;
+ if (strncmp(path, "/var/jb/", 8) == 0)
+ return 1;
+ const char *root = vpBootRoot;
+ if (strncmp(root, "/private/var/", 13) == 0 && strncmp(path, "/var/", 5) == 0) {
+ root += 8; // /private/var/... and /var/... name the same directory.
+ }
+ size_t length = strlen(root);
+ return length && strncmp(path, root, length) == 0 && path[length] == '/';
+}
+
static int vpSpawn(pid_t *restrict pid, const char *restrict path, const posix_spawn_file_actions_t *restrict actions,
const posix_spawnattr_t *restrict attributes, char *const argv[restrict],
char *const envp[restrict]) {
- size_t rootLength = strlen(vpBootRoot);
- int bootstrapProgram =
- path && ((rootLength && strncmp(path, vpBootRoot, rootLength) == 0 && path[rootLength] == '/') ||
- strncmp(path, "/var/jb/", 8) == 0);
+ if (!vpBootRoot[0] && path && (vpIsAppProgram(path) || strstr(path, "/.jbroot-")))
+ vpFindJBRoot(vpBootRoot);
+ int bootstrapProgram = vpIsBootstrapProgram(path);
int appProgram = vpIsAppProgram(path);
+ if (bootstrapProgram || appProgram) {
+ int linkStatus = vpEnsureRootHideLoaderLink(path, vpBootRoot);
+ if (linkStatus || (path && strstr(path, "/.jbroot-")))
+ vpLogInjection("loader-link", path, linkStatus);
+ }
if (!path || (strcmp(path, "/usr/libexec/xpcproxy") != 0 && !bootstrapProgram && !appProgram) ||
vpInjectionDisabled(envp)) {
int status = posix_spawn(pid, path, actions, attributes, argv, envp);
diff --git a/VPhoneGuestComponents/Makefile b/VPhoneGuestComponents/Makefile
index 007ed2c8..2d3cd158 100644
--- a/VPhoneGuestComponents/Makefile
+++ b/VPhoneGuestComponents/Makefile
@@ -15,10 +15,10 @@ VCAMCAPTURED := $(STAGE)/vcamcaptured/libvcamcaptured.dylib
VCAMCAPTURED_SOURCES := $(wildcard VCamCaptured/*.m)
VCAMCAPTURED_INCLUDES := $(wildcard VCamCaptured/*.h VCamCaptured/*.inc)
LAUNCHHOOK := $(STAGE)/launchhook/launchdhook-vphone.dylib
-LAUNCHHOOK_SOURCES := $(wildcard LaunchHook/*.c)
+LAUNCHHOOK_SOURCES := $(wildcard LaunchHook/*.c) Shared/RootHideLoaderLinks.c
LAUNCHHOOK_INCLUDES := $(wildcard LaunchHook/*.h LaunchHook/*.inc Shared/*.h)
SYSTEMHOOK := $(STAGE)/systemhook/SystemHook-vphone.dylib
-SYSTEMHOOK_SOURCES := $(wildcard SystemHook/*.c)
+SYSTEMHOOK_SOURCES := $(wildcard SystemHook/*.c) Shared/RootHideLoaderLinks.c
SYSTEMHOOK_INCLUDES := $(wildcard SystemHook/*.h SystemHook/*.inc Shared/*.h)
GPU_PLUGIN := $(STAGE)/gpu/libAppleParavirtCompilerPluginIOGPUFamily.dylib
GPU_PLUGIN_SOURCES := $(wildcard GraphicLoader/*.mm)
@@ -29,7 +29,7 @@ GPU_PROVENANCE := $(STAGE)/gpu/README.md
# Directory timestamps also catch files removed from the wildcard inputs.
-.PHONY: all gpu package clean
+.PHONY: all gpu package test-loader-links clean
all: $(ARTIFACTS) $(PLISTS) $(GPU_PROVENANCE)
@@ -40,6 +40,12 @@ package: all
@/usr/bin/tar -cf $(ARCHIVE) -C $(STAGE) camfix vcamcaptured launchhook systemhook gpu
@echo "Packaged $(ARCHIVE)"
+test-loader-links:
+ @mkdir -p $(OUT)
+ /usr/bin/clang -Wall -Wextra -Werror -o $(OUT)/RootHideLoaderLinksTests \
+ Tests/RootHideLoaderLinksTests.c Shared/RootHideLoaderLinks.c
+ @$(OUT)/RootHideLoaderLinksTests
+
$(STAGE)/camfix $(STAGE)/vcamcaptured $(STAGE)/launchhook $(STAGE)/systemhook $(STAGE)/gpu:
@mkdir -p $@
diff --git a/VPhoneGuestComponents/Shared/RootHideLoaderLinks.c b/VPhoneGuestComponents/Shared/RootHideLoaderLinks.c
new file mode 100644
index 00000000..ba2234ba
--- /dev/null
+++ b/VPhoneGuestComponents/Shared/RootHideLoaderLinks.c
@@ -0,0 +1,82 @@
+#include "RootHideLoaderLinks.h"
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+static int vpWithin(const char *path, const char *directory) {
+ size_t length = strlen(directory);
+ return strncmp(path, directory, length) == 0 &&
+ (path[length] == '/' || path[length] == '\0');
+}
+
+static int vpLinkTarget(const char *directory, const char *root, char target[PATH_MAX]) {
+ const char *relative = directory + strlen(root);
+ if (!*relative) {
+ strcpy(target, ".");
+ return 0;
+ }
+ size_t depth = 0;
+ for (const char *cursor = relative; *cursor; cursor++) {
+ if (*cursor == '/')
+ depth++;
+ }
+ if (depth * 3 >= PATH_MAX)
+ return ENAMETOOLONG;
+ target[0] = '\0';
+ for (size_t index = 0; index < depth; index++)
+ strcat(target, index ? "/.." : "..");
+ return 0;
+}
+
+int vpEnsureRootHideLoaderLink(const char *executable, const char *root) {
+ if (!executable || !root || !strstr(root, "/.jbroot-"))
+ return 0;
+ const char *namedRoot = root;
+ if (strncmp(root, "/private/var/", 13) == 0 && strncmp(executable, "/var/", 5) == 0)
+ namedRoot += 8;
+ if (!vpWithin(executable, namedRoot))
+ return 0;
+
+ char canonicalRoot[PATH_MAX];
+ char canonicalExecutable[PATH_MAX];
+ if (!realpath(root, canonicalRoot) || !realpath(executable, canonicalExecutable))
+ return errno;
+ char *leaf = strrchr(canonicalExecutable, '/');
+ if (!leaf || leaf == canonicalExecutable)
+ return EINVAL;
+ *leaf = '\0';
+ if (!vpWithin(canonicalExecutable, canonicalRoot))
+ return 0;
+
+ char target[PATH_MAX];
+ int status = vpLinkTarget(canonicalExecutable, canonicalRoot, target);
+ if (status)
+ return status;
+ int directory = open(canonicalExecutable, O_RDONLY | O_DIRECTORY | O_NOFOLLOW | O_CLOEXEC);
+ if (directory < 0)
+ return errno;
+ struct stat info;
+ if (fstatat(directory, ".jbroot", &info, AT_SYMLINK_NOFOLLOW) == 0) {
+ if (!S_ISLNK(info.st_mode)) {
+ close(directory);
+ return EEXIST;
+ }
+ char linkPath[PATH_MAX];
+ char resolved[PATH_MAX];
+ int used = snprintf(linkPath, sizeof(linkPath), "%s/.jbroot", canonicalExecutable);
+ status = used <= 0 || (size_t)used >= sizeof(linkPath) ? ENAMETOOLONG :
+ !realpath(linkPath, resolved) ? errno :
+ strcmp(resolved, canonicalRoot) == 0 ? 0 : EEXIST;
+ } else if (errno == ENOENT) {
+ status = symlinkat(target, directory, ".jbroot") == 0 ? 0 : errno;
+ } else {
+ status = errno;
+ }
+ close(directory);
+ return status;
+}
diff --git a/VPhoneGuestComponents/Shared/RootHideLoaderLinks.h b/VPhoneGuestComponents/Shared/RootHideLoaderLinks.h
new file mode 100644
index 00000000..51b0e6e6
--- /dev/null
+++ b/VPhoneGuestComponents/Shared/RootHideLoaderLinks.h
@@ -0,0 +1,8 @@
+#ifndef VPHONE_ROOT_HIDE_LOADER_LINKS_H
+#define VPHONE_ROOT_HIDE_LOADER_LINKS_H
+
+// Ensure @loader_path/.jbroot can resolve before dyld starts the child.
+// Returns zero on success or when no change is needed, otherwise an errno.
+int vpEnsureRootHideLoaderLink(const char *executable, const char *root);
+
+#endif
diff --git a/VPhoneGuestComponents/SystemHook/SystemHook-vphone.c b/VPhoneGuestComponents/SystemHook/SystemHook-vphone.c
index e610f292..3529fd13 100644
--- a/VPhoneGuestComponents/SystemHook/SystemHook-vphone.c
+++ b/VPhoneGuestComponents/SystemHook/SystemHook-vphone.c
@@ -1,4 +1,5 @@
#include "../Shared/InjectionEnvironment.h"
+#include "../Shared/RootHideLoaderLinks.h"
#include <crt_externs.h>
#include <dlfcn.h>
#include <errno.h>
@@ -17,6 +18,9 @@ static int vpInBootstrap;
static int vpIsBootstrapPath(const char *path, const char *root) {
if (path && strncmp(path, "/var/jb/", 8) == 0)
return 1;
+ if (path && root && strncmp(root, "/private/var/", 13) == 0 &&
+ strncmp(path, "/var/", 5) == 0)
+ root += 8;
size_t length = root ? strlen(root) : 0;
return path && length && strncmp(path, root, length) == 0 && path[length] == '/';
}
@@ -60,11 +64,24 @@ static void vpLogSpawn(const char *path, const char *decision) {
close(fd);
}
+static void vpPrepareLoaderLink(const char *path) {
+ const char *root = getenv("VPHONE_JB_ROOT");
+ int status = vpEnsureRootHideLoaderLink(path, root);
+ if (!status && (!path || !strstr(path, "/.jbroot-")))
+ return;
+ int fd = vpOpenLog("vphone-systemhook-spawn.log");
+ if (fd >= 0) {
+ dprintf(fd, "pid=%d path=%s loader_link_errno=%d\n", getpid(), path ? path : "<null>", status);
+ close(fd);
+ }
+}
+
static int vpSpawnP(pid_t *restrict pid, const char *restrict path, const posix_spawn_file_actions_t *restrict actions,
const posix_spawnattr_t *restrict attributes, char *const argv[restrict],
char *const envp[restrict]) {
if (!vpIsInjectionTarget(path))
return posix_spawnp(pid, path, actions, attributes, argv, envp);
+ vpPrepareLoaderLink(path);
if (vpInjectionDisabled(envp)) {
vpLogSpawn(path, "disabled");
return posix_spawnp(pid, path, actions, attributes, argv, envp);
@@ -81,6 +98,7 @@ static int vpSpawn(pid_t *restrict pid, const char *restrict path, const posix_s
char *const envp[restrict]) {
if (!vpIsInjectionTarget(path))
return posix_spawn(pid, path, actions, attributes, argv, envp);
+ vpPrepareLoaderLink(path);
if (vpInjectionDisabled(envp)) {
vpLogSpawn(path, "disabled");
return posix_spawn(pid, path, actions, attributes, argv, envp);
@@ -95,6 +113,7 @@ static int vpSpawn(pid_t *restrict pid, const char *restrict path, const posix_s
static int vpExecve(const char *path, char *const argv[], char *const envp[]) {
if (!vpIsInjectionTarget(path))
return execve(path, argv, envp);
+ vpPrepareLoaderLink(path);
if (vpInjectionDisabled(envp)) {
vpLogSpawn(path, "exec-disabled");
return execve(path, argv, envp);
diff --git a/VPhoneGuestComponents/Tests/RootHideLoaderLinksTests.c b/VPhoneGuestComponents/Tests/RootHideLoaderLinksTests.c
new file mode 100644
index 00000000..9a985f90
--- /dev/null
+++ b/VPhoneGuestComponents/Tests/RootHideLoaderLinksTests.c
@@ -0,0 +1,61 @@
+#include "../Shared/RootHideLoaderLinks.h"
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+static void directory(const char *path) { assert(mkdir(path, 0700) == 0); }
+static void file(const char *path) {
+ FILE *stream = fopen(path, "w");
+ assert(stream);
+ assert(fclose(stream) == 0);
+}
+
+int main(void) {
+ char scratch[] = "/tmp/vphone-loader-links.XXXXXX";
+ assert(mkdtemp(scratch));
+ char root[PATH_MAX], apps[PATH_MAX], bundle[PATH_MAX], executable[PATH_MAX], link[PATH_MAX];
+ assert((size_t)snprintf(root, sizeof(root), "%s/.jbroot-000114514191980C", scratch) < sizeof(root));
+ assert((size_t)snprintf(apps, sizeof(apps), "%s/Applications", root) < sizeof(apps));
+ assert((size_t)snprintf(bundle, sizeof(bundle), "%s/TrollSpeed.app", apps) < sizeof(bundle));
+ assert((size_t)snprintf(executable, sizeof(executable), "%s/TrollSpeed", bundle) < sizeof(executable));
+ assert((size_t)snprintf(link, sizeof(link), "%s/.jbroot", bundle) < sizeof(link));
+ directory(root);
+ directory(apps);
+ directory(bundle);
+ file(executable);
+
+ assert(vpEnsureRootHideLoaderLink(executable, root) == 0);
+ char resolved[PATH_MAX], canonicalRoot[PATH_MAX], canonicalScratch[PATH_MAX];
+ assert(realpath(root, canonicalRoot));
+ assert(realpath(scratch, canonicalScratch));
+ assert(realpath(link, resolved) && strcmp(resolved, canonicalRoot) == 0);
+ assert(vpEnsureRootHideLoaderLink(executable, root) == 0);
+
+ assert(unlink(link) == 0);
+ assert(symlink(scratch, link) == 0);
+ assert(vpEnsureRootHideLoaderLink(executable, root) == EEXIST);
+ assert(realpath(link, resolved) && strcmp(resolved, canonicalScratch) == 0);
+
+ assert(unlink(link) == 0);
+ file(link);
+ assert(vpEnsureRootHideLoaderLink(executable, root) == EEXIST);
+ assert(unlink(link) == 0);
+
+ char unrelated[PATH_MAX];
+ assert((size_t)snprintf(unrelated, sizeof(unrelated), "%s/unrelated", scratch) < sizeof(unrelated));
+ file(unrelated);
+ assert(vpEnsureRootHideLoaderLink(unrelated, root) == 0);
+ assert(unlink(unrelated) == 0);
+
+ assert(unlink(executable) == 0);
+ assert(rmdir(bundle) == 0);
+ assert(rmdir(apps) == 0);
+ assert(rmdir(root) == 0);
+ assert(rmdir(scratch) == 0);
+ puts("RootHide loader link tests passed");
+}
diff --git a/VPhoneKit/VPhoneCoreKit/VirtualMachine/VPhoneVirtualMachineManifest.swift b/VPhoneKit/VPhoneCoreKit/VirtualMachine/VPhoneVirtualMachineManifest.swift
index 3300c54c..403f74d5 100644
--- a/VPhoneKit/VPhoneCoreKit/VirtualMachine/VPhoneVirtualMachineManifest.swift
+++ b/VPhoneKit/VPhoneCoreKit/VirtualMachine/VPhoneVirtualMachineManifest.swift
@@ -35,7 +35,7 @@ extension VPhoneManifestError: CustomStringConvertible, LocalizedError {
enum VPhoneRuntimeVersion {
/// A plain `swift build` executable has no app bundle Info.plist.
- private static let unbundledVersion = "2.0.0"
+ private static let unbundledVersion = "2.0.1"
static var current: String {
let contents = VPhoneResources.runningExecutable().deletingLastPathComponent().deletingLastPathComponent()