ShizuStore

Shevery

HmnDev-Tech

14.6.5 · GitHub

Download APK
Shizuku implementations Android 7.0+ 2 days ago Apache-2.0 Dhizuku Recommended
5.1k ShizuStore
177.1k GitHub
1.7k Stars
10 MB Size

More about this app

Material 3 fork with autostart, TCP mode, Dhizuku, module support and a built-in terminal with AI integration

Shevery

Stars Forks Downloads Build Android APK Telegram

English | Русский | Қазақша | Qazaqşa (Latın) | Português | Español | العربية | 简体中文 | 日本語

Fork status

Important

Side-by-Side Installation Supported: Thanks to its independent package ID (com.hamondev.shevery) and isolated permission namespace, you can now install Shevery directly alongside other Shizuku implementations without uninstalling them first. For legacy apps that explicitly check for moe.shizuku.privileged.api, you can optionally enable Compatibility Stubs in Settings once original Shizuku is removed. Upstream project reference: https://github.com/RikkaApps/Shizuku

Fork additions

  • Jetpack Compose manager UI with Material 3 Expressive components, motion, switches, and rounded icon treatment.
  • Device Owner Management & Integration: Full Device Owner management (app delegation scopes, ownership transfer, DPM-assisted ADB) inspired by and compatible with Dhizuku.
  • Biometric Security & Protection: Master switch to require biometric or device PIN/pattern/password authentication with configurable timeouts and granular action protection.
  • Better shell/adb based "Comput" feature with Gemini Explaination, Macros and Commandium AI Command create.
  • Android 16/17 target work with current SDK/build tooling in this fork.
  • ADB Modules screen for installing and managing ZIP modules.
  • Module features: module.prop, banner, enable/disable switch, action.sh, policy-gated service.sh, local WebUI, delete, path checks, size limits, output limits, and last-run logs.
  • Module policy settings: Safe mode, Full access, and background action control.
  • Module Catalog with direct install.

Documentation

Background

When developing apps that requires root, the most common method is to run some commands in the su shell. For example, there is an app that uses the pm enable/disable command to enable/disable components.

This method has very big disadvantages:

  1. Extremely slow (Multiple process creation)
  2. Needs to process texts (Super unreliable)
  3. The possibility is limited to available commands
  4. Even if ADB has sufficient permissions, the app requires root privileges to run

Shizuku uses a completely different way. See detailed description below.

User guide & Download

https://shizuku.rikka.app/

Screenshots

Click to open Screenshots

Main Screen

Comput Console

ADB Modules

Settings

How does Shevery works?

First, we need to talk about how app use system APIs. For example, if the app wants to get installed apps, we all know we should use PackageManager#getInstalledPackages(). This is actually an interprocess communication (IPC) process of the app process and system server process, just the Android framework did the inner works for us.

Android uses binder to do this type of IPC. Binder allows the server-side to learn the uid and pid of the client-side, so that the system server can check if the app has the permission to do the operation.

Usually, if there is a "manager" (e.g., PackageManager) for apps to use, there should be a "service" (e.g., PackageManagerService) in the system server process. We can simply think if the app holds the binder of the "service", it can communicate with the "service". The app process will receive binders of system services on start.

Shizuku guides users to run a process, Shizuku server, with root or ADB first. When the app starts, the binder to Shizuku server will also be sent to the app.

The most important feature Shevery provides is something like be a middle man to receive requests from the app, sent them to the system server, and send back the results. You can see the transactRemote method in rikka.shizuku.server.ShizukuService class, and moe.shizuku.api.ShizukuBinderWrapper class for the detail.

So, we reached our goal, to use system APIs with higher permission. And to the app, it is almost identical to the use of system APIs directly.

Developer guide

API & sample

https://github.com/RikkaApps/Shizuku-API

Migrating from pre-v11

Existing applications still works, of course.

https://github.com/RikkaApps/Shizuku-API#migration-guide-for-existing-applications-use-shizuku-pre-v11

Attention

  1. ADB permissions are limited

    ADB has limited permissions and different on various system versions. You can see permissions granted to ADB here.

    Before calling the API, you can use ShizukuService#getUid to check if Shizuku is running user ADB, or use ShizukuService#checkPermission to check if the server has sufficient permissions.

  2. Hidden API limitation from Android 9

    As of Android 9, the usage of the hidden APIs is limited for normal apps. Please use other methods (such as https://github.com/LSPosed/AndroidHiddenApiBypass).

  3. Android 8.0 & ADB

    At present, the way Shizuku service gets the app process is to combine IActivityManager#registerProcessObserver and IActivityManager#registerUidObserver (26+) to ensure that the app process will be sent when the app starts. However, on API 26, ADB lacks permissions to use registerUidObserver, so if you need to use Shizuku in a process that might not be started by an Activity, it is recommended to trigger the send binder by starting a transparent activity.

  4. Direct use of transactRemote requires attention

    • The API may be different under different Android versions, please be sure to check it carefully. Also, the android.app.IActivityManager has the aidl form in API 26 and later, and android.app.IActivityManager$Stub exists only on API 26.

    • SystemServiceHelper.getTransactionCode may not get the correct transaction code, such as android.content.pm.IPackageManager$Stub.TRANSACTION_getInstalledPackages does not exist on API 25 and there is android.content.pm.IPackageManager$Stub.TRANSACTION_getInstalledPackages_47 (this situation has been dealt with, but it is not excluded that there may be other circumstances). This problem is not encountered with the ShizukuBinderWrapper method.

Developing Shizuku itself

Build

  • Clone with git clone --recurse-submodules
  • Run gradle task :manager:assembleDebug or :manager:assembleRelease

The :manager:assembleDebug task generates a debuggable server. You can attach a debugger to shizuku_server to debug the server. Be aware that, in Android Studio, "Run/Debug configurations" - "Always install with package manager" should be checked, so that the server will use the latest code.

CI builds

Every push to main, dev and nightly, and every pull request, runs the Build Android APK workflow. Each run always uploads both artifacts — there is no debug-or-release choice:

Artifact Gradle task Description
shevery-debug :manager:assembleDebug Debuggable APK for testing; the server can be debugged with an attached debugger
shevery-release :manager:assembleRelease Release APK, signed with the release keystore when the secrets are configured, otherwise it falls back to debug signing

The release artifact is signature-verified with apksigner in every run. Fork pull requests build both variants with a generated keystore, so untrusted code never touches the release signing key.

License

All code files in this project are licensed under Apache 2.0

Credits

And...

Now, you can publish your ADB module! Follow this steps:

  • Create your module.
  • Create GH Repository for this module.
  • Add topic "shevery-modules"
  • Add sources and Release with module.

Caution

Free App Notice

Shevery is a completely free app. Do not pay any third-party file managers or cloud services to download this application.

For fresh builds/CI of Shevery, go to Actions — every run attaches both a shevery-debug and a shevery-release APK artifact. But this APKs are unstable and can contain some bugs. If you found bugs on latest CI, you can report about it in Issues.

Close

How Shizuku is used

Can run typed shell commands, module scripts, helper installs, owner setup and network blocks via `sh -c` through Shizuku.

This is an AI-assisted analysis of Shizuku-related usages in the app's public source code. It is best effort, so it may not catch every single usage.

How this app uses Shizuku

Shevery uses Shizuku to run privileged shell commands and system lookups for its console, modules, helper install and access management.

  • Run shell commands: Type any command in the built in console and run saved macros, executed as a privileged shell with sh -c through Shizuku and shown with output and exit status.
  • Run module scripts: Install modules from ZIP files and run their action and background service scripts with sh -c through Shizuku, including commands sent from a module Web UI.
  • Install helper package: Install and uninstall the companion stub package using pm install and pm uninstall through Shizuku, piping the APK content into the privileged shell.
  • Keep wireless debugging on: Reapply the wireless debugging flag with the settings put global adb_wifi_enabled shell command through Shizuku.
  • Set device owner: Activate device owner or profile owner with dpm set-device-owner and dpm set-profile-owner shell commands through Shizuku.
  • Control app networking: Block or unblock an app's network access and check its state with the cmd connectivity shell commands through Shizuku.
  • Manage app access: View installed apps and users and grant or revoke Shizuku access for other apps using the system package, permission and user services through Shizuku.

Android APIs or commands used

  • sh -c
  • pm install
  • pm uninstall
  • dpm set-profile-owner
  • dpm set-device-owner
  • settings put global adb_wifi_enabled
  • cmd connectivity get-chain3-enabled
  • cmd connectivity set-chain3-enabled
  • cmd connectivity set-package-networking-enabled
  • cmd connectivity get-package-networking-enabled
  • IPackageManager.getInstalledPackages
  • IPackageManager.getPackageInfo
  • IPackageManager.getApplicationInfo
  • IPermissionManager.grantRuntimePermission
  • IPermissionManager.revokeRuntimePermission
  • IPermissionManager.checkPermission
  • IUserManager.getUsers

Notable details

The built in console treats host side adb install, adb push and adb pull as unsupported inside the on device shell and suggests on device equivalents such as pm install and cp or mv. Helper install can also complete without Shizuku via the system package installer when device owner rights are available.

Close

Changelog

What's new for version 14.6.5

Overview

Shevery 14.6.5 (versionCode 1068) brings a full Rust rewrite of the native layer, stronger IPC and binder security enforcement, expanded Dhizuku UserService support, new manager usability and diagnostics features, and dynamic commit-count versioning.


Highlights

Native Rust Architecture

  • Rewrote the legacy C/C++ native layer (starter, rish, adb_pairing) in Rust, removing BoringSSL and libc++ native build dependencies:
    • starter: SELinux context transition, cgroup v1/v2 setup, process enumeration, and app_process launch.
    • rish: PTY management, raw termios, SIGWINCH self-pipe handling, and JNI bridges.
    • adb_pairing & ADB crypto: pure-Rust SPAKE2 (curve25519-dalek), HKDF-SHA256, AES-128-GCM, packet framing/checksums, and RSA-2048 Montgomery public key encoding.
    • Stealth & module helpers: Rust Stealth APK binary swapper, AXML manifest patcher, DEX header fixer, APK v2 Merkle digest, SHA-256 tree fingerprinter, and FD tail reader.
  • Integrated cargo-ndk across all four ABIs (arm64-v8a, armeabi-v7a, x86, x86_64).

Security Hardening

  • Enforced callingUid validation across SheveryProvider and privileged IPC endpoints, plus package ownership validation in ClientManager.
  • Extended android.app.Service in DhizukuService with caller authentication on all binder calls.
  • Enforced custom module access permissions, blocked cwd/environment injection, and hardened the adb shim.
  • Zeroized SPAKE2 secret material, added nonce overflow guards, and closed leaked file descriptors across rish/starter.

Manager, Diagnostics & Compatibility

  • Smart Logs Diagnostics: added Shevery smart logs viewer with copy and download support.
  • Appearance & Settings: added experimental Autoscale option, custom TCP port support (#385), optional home diagnostics card (#389), firewall search and auto-block, and app search in Hide Developer options.
  • Dhizuku & Device Owner: added isolated :dhizuku_user_service process with UserService lifecycle, remoteProcess, lock-task listeners, real versions, scope auth, and API-level-guarded DevicePolicyManager delegation scopes.
  • Localization: completed zh-rTW and zh-rCN translations and aligned Chinese READMEs with side-by-side install guidance.

Tooling, Refactoring & Tests

  • Updated build.gradle so gitCommitCount (versionCode) dynamically computes the total repository commit count via git rev-list --count HEAD (1068 in this release), and bumped Shevery-API to 14.6.5.
  • Upgraded Gradle, AGP, Kotlin, AndroidX, Material3 (1.5.0-rc01), and Rust dependencies.
  • Migrated non-critical manager, server, common, and stub utilities from Java to Kotlin.
  • Expanded unit test coverage across API, manager, server, errorprotect, tasker, and Rust crates.

Bug Fixes

  • Fixed UTF-8 byte overflow when patching AXML manifest labels in Stealth builds.
  • Removed unconditional || true fallback in AdbMdns.isLocalAddress.
  • Fixed diagnostics state retention inside LazyListScope items on Home.
  • Fixed Kotlin and Material3 1.5.0-rc01 compilation regressions (ShizukuSettings, Logger, ToggleButtonDefaults.colors, ExposedDropdownMenu).

Verification & Assets

Artifact Size SHA-256
shevery-release.apk 10,528,551 bytes b793b2ecbdbed943c1df6819057d472c461b67ff94011c092b9c9c67b3626bb9
Close

Permissions

22 permissions requested

  • android.permission.RECEIVE_BOOT_COMPLETED
  • android.permission.FOREGROUND_SERVICE
  • android.permission.FOREGROUND_SERVICE_SPECIAL_USE
  • android.permission.INTERNET
  • android.permission.NEARBY_WIFI_DEVICES
  • android.permission.ACCESS_LOCAL_NETWORK
  • android.permission.USE_LOOPBACK_INTERFACE
  • android.permission.POST_NOTIFICATIONS
  • android.permission.WRITE_SECURE_SETTINGS
  • android.permission.PACKAGE_USAGE_STATS
  • android.permission.CHANGE_WIFI_MULTICAST_STATE
  • android.permission.ACCESS_NETWORK_STATE
  • android.permission.REQUEST_INSTALL_PACKAGES
  • android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS
  • android.permission.QUERY_ALL_PACKAGES
  • com.hamondev.shevery.permission.MANAGER
  • com.hamondev.shevery.permission.PRIVILEGED_API
  • com.hamondev.shevery.DYNAMIC_RECEIVER_NOT_EXPORTED_PERMISSION
  • android.permission.USE_BIOMETRIC
  • android.permission.USE_FINGERPRINT
  • android.permission.WAKE_LOCK
  • com.rosan.dhizuku.permission.API
Close