Docs · Supported Formats
Docs
Supported Formats
Upload your app → harden → sign with your certificate → download / distribute. This reference shows what you can upload, what protection you get, and whether each installer can be repackaged. Honest status, no overstatement.
This reference pairs with the User Guide. Status marks: verified, needs a real device, partial, not supported.
1. Native binaries (upload and harden)
| Platform | Upload | Protection | Runs correctly after hardening? |
|---|---|---|---|
| Android | .apk .aab | DEX packing + anti-debug / anti-injection + integrity + obfuscation + Live Key + device management | Launches on emulator (pure-Java apps, and apps with bundled native libs: gomobile/C/Unity/Flutter — libraries load, native methods work, integrity doesn't false-positive) |
| Linux | .so .elf | Injected runtime protection library (anti-debug / anti-VM / integrity / string encryption) | Verified: module combinations run, only tampering is blocked |
| Windows | .exe .dll | Injected runtime protection (active at load: anti-debug / integrity / telemetry) | Passes on the compatibility layer |
| macOS | .app .dylib | Injected runtime protection module + re-signing + integrity self-check | Structure / signature verified; runtime behavior needs a macOS device |
| iOS | .ipa | Injected runtime protection module + re-signing (with your certificate) | Structure / signature verified; runtime behavior needs an iOS device |
Integrity doesn't false-positive: an untampered artifact runs normally; protection only fires on repackaging / tampering (exit / report / degrade — three configurable policies).
2. Installers / disk images
| Format | Repackage & harden? | Notes |
|---|---|---|
| macOS PKG | Supported | Extract Payload → harden the inner .app → reseal. Re-signing the whole package needs your certificate |
| Windows MSI | Supported (with fallback) | Extract the installed EXE → harden → replace in place. Complex custom actions / compression that can't be resealed are labeled honestly |
| macOS DMG | Supported (fragile, with fallback) | Extract the volume's .app → harden → reseal. Resealing on Linux is fragile; on failure the original is kept, no fake success |
| Windows NSIS / Inno Setup | Can't repackage | A compiled installer can't be rebuilt losslessly (needs the original script) → see “when a format isn't supported” |
| Self-extracting EXE | Depends | Recognized; most can't be resealed losslessly → use “harden before packaging” |
3. Cross-platform frameworks
| Framework | Handling |
|---|---|
| Flutter | Injects protection into libapp.so + snapshot-segment encryption (decrypted at runtime by the guard) |
| React Native / Cordova / Capacitor / uni-app / Weex / Taro / Electron | Native shell hardened per platform + web assets (JS/HTML/asar) obfuscated and encrypted, decryption key sunk into the native shell |
| Tauri (desktop / mobile) | Desktop uses the matching platform's native protection; mobile goes through the apk/ipa pipeline |
Transparent runtime-decryption boundary: asset encryption + key sinking are done; transparent decryption at runtime needs the app's own native cooperation (RN JSI / Cordova WebView interception) — labeled
NEEDS_APP_NATIVE, a consequence of framework architecture.4. Bundlers / language formats (23 recognized)
| Type | Protection |
|---|---|
| PyInstaller / py2exe (Python) | Outer bootloader hardened + embedded bytecode encrypted (AES-GCM, key sunk; unpacking yields ciphertext, decompilation fails). Fully transparent self-execution needs a bootloader patch (NEEDS_BOOTLOADER_PATCH) |
| Go / Rust / Nuitka / GraalVM native-image (natively compiled) | Already native binaries — harden on upload |
| .NET single-file/R2R, Java fat-jar, Node pkg/SEA, PHP phar, deno/bun compile | Recognized + native-shell hardening; interpreted code assets encrypted (same transparent-decryption boundary) |
5. When a format isn't supported
Core idea: harden the application itself before packaging, not the finished installer.
- NSIS / Inno / self-extracting installers: upload your
.exe/.dlland harden → download → repackage with your NSIS / Inno / WiX script. - DMG (if resealing fails): upload the
.app(dragged out of the DMG) and harden → rebuild the DMG on macOS withhdiutil create. - PKG (whole-package re-sign needs a certificate): harden the .app, then
productbuild+ your certificateproductsign. - PyInstaller full self-execution: the pure-encryption layer already works (static anti-extraction); self-decryption at runtime needs the shipped bootloader patch, or layer a third-party Python source-hardening tool.
Not sure about your format? The hardening report tells you exactly what was hardened, what didn't take effect, and what to do next. We never report false success on an artifact that wasn't actually hardened — if the contents didn't change, it's marked failed with the reason.
6. Honest limits
- macOS / iOS runtime behavior (force-exit, jailbreak detection, Gatekeeper) needs a real device; static injection + signing are verified, and Windows is tested on a compatibility layer.
- Apps with bundled native libs (gomobile/C/Unity/Flutter): the
.sobytes aren't modified (so integrity passes), and after hardening the library loads and native methods work (the shell loader's native-library path and integrity ordering are fixed, verified on emulator). Second-level hardening of that native logic itself (.so segment encryption) is a separate in-progress enhancement. - RN / Cordova / PyInstaller transparent code decryption needs the app's own native cooperation.
- Browser upload of source packages >100 MB currently uses a size-limited channel; the artifact side already supports large-file direct upload.
Questions? Contact platform support.