Sense
Sign inBook a demo
Code Obfuscation · Build-time app hardening

Your app ships as a readable manual for attacking it.

A published APK or IPA decompiles in minutes — keys, endpoints and fraud thresholds all legible. Sense app shielding rewrites the binary at build time, so the code obfuscation is done before release and what an attacker downloads carries no usable map.

No sourceupload the compiled build
7 layersapplied in one build step
Android + iOSnative, Flutter, React Native
jadx · yourbank-v8.2.apk4,182 classes
UNPROTECTED BUILDdecompiling…
class PaymentAuthService {
  String API_KEY ="sk_live_9f2a7c…"
  booleanisDeviceRooted()
  void approveTransfer(Txn t) {
    if (t.amount <TXN_LIMIT) send(t);
  }
}
live API keyroot check foundtxn limit exposed
SAME BUILD, SENSE-PROTECTED0 SYMBOLS RECOVERED
class a.b.c.ᐧ {
  byte[] ᒿ = ᐩ(0x3e,0x91,0x0c,…)
  boolean ǃ() { → vm.exec(0x4c) }
  void ᐨ(ᐧ ᒡ) { ᐩ(ᒡ, ᐩ(0x11)) }
}
HARDENING APPLIED7 of 7
WHAT THE ATTACKER GETS
No names, no strings, no readable control flowand a VM they must reverse before they start
Attack cost ↑
TECHNIQUES

Seven transformations, one build step.

Renaming alone is a speed bump — a competent analyst reads through it in an afternoon. Sense layers transformations so each one destroys a different tool an attacker relies on. Pick a layer to see what it does to the same method.

DEFEATSReading the app like source. Grepping for “payment”, “root” or “token”.

Identifier renaming and symbol stripping

Class, method and field names are replaced with meaningless, non-reversible symbols across the whole package — including native exports and cross-platform bundles that R8 never touches.

WHAT THE ATTACKER SEES TODAY
class PaymentAuthService {
  boolean isDeviceRooted()
  void approveTransfer(Txn t)
}
AFTER SENSE
class a.b.c.ᐧ {
  boolean ǃ()
  void ᐨ(ᐡ ᑡ)
}
ANALYSIS COSTHours → days
RUNTIME IMPACTNone
APPLIES TOWhole package
PRESET

Protection is a trade you get to make.

Virtualising every method would be slow and pointless. Choose a preset — or turn individual layers on for the twenty classes that actually matter: payment, auth, key handling.

LAYERSTATESIZE COSTSCOPE
Identifier renamingONWhole package
String & asset encryptionON+0.1 MBWhole package
Control-flow flatteningON+0.4 MBSelected classes
Code virtualisationPARTIAL+0.9 MB10–30 methods
Native code protectionON+0.3 MBNative + bundles
Anti-debug & anti-dumpON+0.1 MBWhole package
Integrity & anti-repackagingON+0.1 MBWhole package
Estimated build impact:+1.2 MB, ~4 min added to the buildPer-class overrides available in the dashboard
COVERAGE

Every layer of the package, on both platforms.

ANDROID
DEX & Kotlin bytecodenative .so librariesmanifest & resourcesassets & raw filessigning-block integrityPlay App Signing
iOS
Mach-O binarySwift & Obj-C symbolsembedded frameworksplist & asset cataloguesre-sign preserved
CROSS-PLATFORM
Flutter (Dart AOT)React Native & HermesCordova / IonicUnity IL2CPPXamarin assemblies
TOOLS DEFEATED
jadxapktoolGhidraIDA ProHopperFrida traceObjectionclass-dumpblutter
PIPELINE

Inside your CI, after the compiler, before the store.

01
Hand over the compiled build
APK, AAB or IPA from your existing pipeline. Source code, build scripts and Gradle config stay untouched.
02
Transform and verify
Layers apply per the preset; the protected build is smoke-tested and diffed so a broken reflection call surfaces before release, not in production.
03
Re-sign and ship
Signed with your key, mapping file retained for crash symbolication in Crashlytics or Sentry.
04
Watch the wild
Store and side-load monitoring reports clones and re-signed copies of your package name back to your team.
sense protect --preset recommended
unpacked app-release.aab4,182 classes
renamed identifiersdone
encrypted strings & assetsdone
flattened control flowdone
virtualised 21 methodsdone
injected integrity & anti-debugdone
stripped debug symbols & logsdone
hardened native libraries3 .so
smoke tested 148 screenspass
diffed against previous buildno regressions
retained mapping for symbolicationuploaded
re-signed with release keyok
0m 00sadded to the CI job
+0.0 MBpackage size delta
JenkinsGitHub ActionsGitLab CIBitriseAzure DevOpsCLI & REST API
WITH RASP

Obfuscation buys time. Runtime protection uses it.

A determined attacker with enough weeks will get through any static protection — that is the honest position. Hardening makes the analysis expensive; RASP makes the resulting attack useless, because the app detects it while it runs. Both ship in the same build step.

THE ATTACKOBFUSCATION ALONEHARDENING + RASP
Static decompile to find the logic
OBFUSCATION ALONEWeeks of work instead of an afternoon — the intended effect.
HARDENING + RASPSame, plus the attempt is visible in your telemetry.
Attach a debugger to the live app
OBFUSCATION ALONEAnti-debug traps slow it; a patient analyst strips them.
HARDENING + RASPSession terminated, verdict signed to your backend.
Hook a method at runtime with Frida
OBFUSCATION ALONENothing stops it once the target method is found.
HARDENING + RASPDetected in-thread and refused before the call completes.
Repackage and distribute a clone
OBFUSCATION ALONEIntegrity checks fail the clone — if they survive the patch.
HARDENING + RASPClone refuses to run, and the sighting is reported to you.
Hardening and RASP are configured together, from the same dashboard.Explore Sense RASP →
QUESTIONS ENGINEERING TEAMS ASK
We already run R8 / ProGuard. Is this different?R8 renames and shrinks — useful, and trivially reversed with a mapping heuristic. It does not flatten flow, encrypt strings, virtualise methods or defend the running process.
Will it break reflection or crash reporting?Reflection targets and dynamic class loads are declared in a keep list; the mapping file uploads to your crash tool so stack traces stay readable to you and nobody else.
What does it cost at runtime?Renaming and string encryption are effectively free. Virtualisation is the expensive one, which is why it is scoped to the handful of methods that hold real secrets.
Do you keep our binary?Builds are processed in-region and discarded after delivery; regulated customers run the protection engine on-premise inside their own CI network.

Find out what your current build gives away.

Send us your live APK and we will return the decompile — the keys, the endpoints and the logic an attacker reads today.