RASP Instrumentation Engine
Runtime Application Self Protection (RASP) detects and responds to interference with executing code. It is built into Cipherstep’s Attestation SDK to make reverse engineering harder. We will create a build and compiler toolchain custom-fit to your app to distribute RASP checkpoints through its execution code.
What RASP is in practice
Runtime Application Self Protection (RASP) adds checks inside executing code to detect interference and respond to it. In mobile apps, that can mean identifying a debugger, detecting hooks that redirect a function, or finding signs that protected code has been modified.
Tools such as LLDB and Frida let researchers inspect execution, intercept calls, and replace values. An attacker can use those same techniques to study security checks or substitute data during identity capture, login, or checkout. RASP makes that work harder by protecting both the code being examined and the mechanisms that detect interference.
The response depends on the finding and the protection policy. An enforcing check can terminate the protected process; other findings can inform an assessment without causing a crash. A rooted or jailbroken environment is different from direct evidence of tampering. Runtime protection adds resistance to supported attacks while the app executes, alongside the authorization and validation your backend performs.
RASP inside the Attestation SDK
RASP is built into Cipherstep’s Attestation SDKs for iOS/Android to protect the SDK’s own execution and runtime environment. Collecting and sealing device evidence would be less useful if an attacker could easily intercept the collection, alter its results, or disable its checks.
Our protections address supported debugging, instrumentation, hooking, and tampering attempts. Obfuscated detection logic and hardened response paths make the repeated tracing and patching used to reverse engineer the SDK more difficult. Our security researchers maintain these protections as operating systems and attack techniques change.
This internal RASP protects the attestation process; integrating the SDK does not automatically instrument all of your surrounding application code. The SDK produces sealed evidence for server-side analysis, and your backend uses the completed Decision API result to decide whether a protected request should proceed.
A build toolchain custom-fit to your app
The RASP Instrumentation Engine brings runtime protection into your own application code. We will create a dedicated build and compiler toolchain for your iOS or Android app, tailored to its code, sensitive operations, and release workflow.
During compilation, the toolchain will insert and distribute RASP checkpoints through selected execution paths in your app. Those checkpoints become part of the compiled application and run as it executes, checking for supported interference around operations such as credential submission, identity capture, or payment initiation.
Distributing checkpoints through the application makes protection harder to isolate and disable. Hardened detection and response paths add resistance to tracing and patching, while build-time instrumentation reduces the need for your developers to place each check manually.
We will work with your engineers to map the execution paths that need protection, agree on checkpoint placement and response behavior, and fit the toolchain into your build process. Integration includes compatibility checks, device testing, and release validation for your app. The resulting coverage is specific to your application and the platforms it supports.
The engine extends protection to your application’s execution code. The RASP already built into the Attestation SDK protects evidence collection and sealing; your backend uses the server-verified attestation result to decide whether a sensitive request should proceed.