VirtualApp

VirtualApp is an Android application virtualization engine and user-space sandbox that enables the execution of applications within an isolated environment. It allows for the running of multiple independent instances of the same application on a single device and supports private application installation without requiring system-level root access.

The project features a comprehensive hooking framework for intercepting Java and native layer functions to modify application behavior. It includes tools for hardware simulation to spoof device models and system information, as well as a non-root process debugger capable of memory manipulation and process injection.

The platform provides a broad suite of capabilities covering application lifecycle management, file system I/O redirection for data isolation, and environment fingerprint masking to bypass detection. It further supports cross-architecture runtime switching to execute both 32-bit and 64-bit applications via a plugin-based extension framework.

Features

Sandboxed Runtimes - Provides an isolated execution space that redirects file IO and system calls to decouple guest applications from the host.
Android App Virtualization - Runs multiple independent instances of the same Android application on a single device to support multiple account logins.
Application Instance Virtualization - Implements a virtualization engine allowing multiple independent instances of the same Android application to run simultaneously.
Installation-Free Execution - Enables applications to run in an isolated environment by proxying system requests to mimic a formal installation.
Multi-Instance Managers - Enables running multiple independent copies of the same application to support multi-account usage.
Virtual User Profile Management - Supports unlimited independent application instances via a multi-user virtual environment for identity and data isolation.
System Service Mocks - Mocks local Android system services, such as battery and contacts, to provide controlled environment data.
System Hooking Frameworks - Provides a toolkit for intercepting Java and native functions to spoof hardware and modify system behavior.
System Service Proxies - Provides a proxy layer to intercept and modify Android system service calls to bypass installation checks.
Android Runtimes - Launches and runs Android applications in isolated containerized environments without formal system installation.
Android Device Emulators - Emulates specific Android device models and hardware information at the native level to mimic physical hardware.
Virtualization Frameworks - Serves as a runtime environment that executes Android applications within an isolated sandbox without requiring root access.
Android Hooking Frameworks - Provides a toolkit for intercepting Java and native layer functions to modify application behavior without source changes.
Android App Virtualization Engines - Provides a runtime environment that executes Android applications within an isolated sandbox without root access.
Native Runtime Hooking - Intercepts and modifies native function calls and system calls to spoof hardware and bypass environment detection.
Rootless Android Hooking - Modifies application behavior and intercepts system APIs at runtime without requiring root access.
Application Sandboxing Clones - Copies existing host applications into a private sandbox to enable multiple independent instances.
File System Path Redirections - Deno Virtualizer reroutes absolute path requests from uninstalled applications to internal sandbox paths for correct access.
Inter-Process Request Routing - Routes application requests to a specialized server process to handle operations the native system cannot perform.
Process Lifecycle Managers - Manages the execution state and lifecycle of virtual applications through dedicated host and server processes.
Native Hooking Frameworks - Hooks JNI functions at the native level to modify application behavior and system interactions.
Non-Root Application Sandboxing - Provides a user-space sandbox that manages application lifecycles and process memory without needing system-level root access.
User-Space Application Sandboxes - Executes application packages in isolated environments with private memory and storage to bypass system-level installation.
User-Space Containers - Provides an isolated user-space execution environment that redirects file IO and system calls.
Virtual File System Redirections - Intercepts file system I/O requests to map absolute paths to virtual internal directories for data isolation.
Virtual Application Runtimes - Builds a lightweight, customizable environment that isolates applications from the host system for secure execution.
32/64-bit Architecture Support - Selects between 32-bit and 64-bit runtime packages to match the target binary architecture of the application.
Android Device Spoofing - Spoofs device models and system information at the native layer to bypass environment detection.
Runtime and Process Isolation - Enforces strict boundaries between the virtualized execution context and the host system to isolate files and communication.
Application Data Isolation - Creates a sandboxed environment with separate files and process communication to keep application data independent.
Storage Redirection - Controls file read and write operations via a redirection layer to implement data encryption and isolation.
Virtual Environment Isolation - Separates application data and system requests using a virtual layer to protect sensitive user information.
Runtime Logic Injection - Injects custom loading and control logic into virtual application process entry points at runtime.
Method Hooking Frameworks - Hooks Java layer methods to redirect system service requests and manipulate application behavior at runtime.
Method Hooking - Intercepts and modifies Java and native method calls at runtime using a built-in hooking framework.
Sandbox Application Installations - Enables installing and running application packages within a private sandbox without requiring formal system-level installation.
Silent Installers - Implements background installation, upgrading, and uninstallation of virtual applications without user confirmation.
Emulated Process Debugging - Allows for the analysis of signals and crashes within the virtualized execution environment through injection and tracing.
Path Masking Utilities - Replaces internal sandbox paths with simulated system paths to deceive apps checking for official installation.
Android Hardware Simulation Tools - Mocks device models and simulates hardware events to change how applications detect the underlying platform.
Google Play Services Integration - Maintains a compatible environment for applications that rely on Google Play Services.
Hardware Identity Emulation - Emulates hardware events and identity changes to influence how applications react to signals.
Kernel-Level Hooking - Uses seccomp-bpf and inline hooks to filter and modify low-level kernel calls and control application behavior.
Plugin-Based Application Execution - Loads and executes applications as plugins to enable hot updates and modular development without installation.
Process Memory Access - Allows reading and writing to the memory space of internal application processes without root privileges.
Rootless Process Debuggers - Performs process injection and debugging via ptrace on internal applications without needing root access.
Rootless Process Debugging - Performs memory manipulation and process injection on virtualized Android applications without requiring root access.
Sandbox-to-Server Request Routing - Proxies complex system operations from the guest sandbox to a specialized background process for execution.
System Modification Frameworks - Simulates system-level responses and modifies the Android framework to emulate hardware peripherals.
Hardware Event Simulation - Mocks device models and simulates hardware events to control how applications detect the underlying platform.
Virtualization Artifact Masking - Hides the virtualized nature of the environment by masking process and file system characteristics.
System API Permission Control - Monitors and restricts access to sensitive system APIs and device information to protect privacy.
Runtime Memory Manipulation - Performs live memory patching and reading of internal application processes without root access.
Environment Fingerprint Masking - Intercepts system calls and modifies file system reads to hide the sandbox environment from detection.
User Privacy Protection - Controls access to sensitive user information such as contacts and call logs to protect real user data.
Extensible Plugin Architectures - Supports the integration of additional packages to run applications with different architectures via a plugin system.
Application API Auditing - Monitors API access and sensitive data usage to implement geographic fences and privacy controls.
Process Debuggers - Provides a utility to inspect and manipulate the memory of virtualized application processes without root access.

android-hacker/VirtualXposed

15,955View on GitHub

VirtualXposed is an Android virtualization framework that provides a containerized environment for running applications and system-level hooks. It functions as an isolated execution space, allowing users to manage and extend installed software independently from the host operating system. The platform enables the execution of specialized software extensions and framework modules that modify application behavior without requiring device rooting, bootloader unlocking, or modifications to the core system image. By creating a secondary, containerized Android system, it allows for the application

JingMatrix/LSPosed

11,494View on GitHub

LSPosed is an Android runtime hooking framework and system modification tool. It enables the modification of application and system behavior in memory without altering original installation files, serving as a platform for distributing and managing community-created extension modules. The project provides a comprehensive suite for device and identity spoofing, including the ability to mask hardware identifiers, simulate geographic locations, and conceal root access or hooking frameworks to bypass security and integrity checks. It also functions as an application modder to unlock premium featu

steipete/Aspects

8,436View on GitHub

Aspects is an aspect-oriented programming library and method hooking framework designed for intercepting and modifying JavaScript function behavior without altering the original source code. It serves as a runtime logic injector that allows for the addition and removal of executable code wrappers from active functions. The library enables the injection of custom logic before or after methods to change application behavior at runtime. It further provides the ability to intercept method calls to capture or override return values before they reach the caller. The framework manages these interce

alibaba/dexposed

4,508View on GitHub

Dexposed is a set of runtime tools and engines designed for dynamic patching, framework interception, and code instrumentation on Android devices. It functions as a hooking framework and instrumentation tool used to load custom code into running processes to alter logic without modifying the original bytecode. The project enables the interception and modification of method behavior within both Android applications and the system framework. It specifically provides capabilities for bypassing operating system limitations by overriding framework calls and applying hot patches to live processes w

asLodyVirtualApp

Features