Otukan combines iOS code protection and runtime checks by applying both to the same distribution build in one protection step. At build time, it obfuscates Swift and Objective-C names and strings and embeds integrity data for the executable, resources and signing identity. On the device, runtime checks watch for jailbreaks, debuggers and injected libraries, and feed a response policy your backend enforces. The scope names the main executable, your own frameworks and each app extension you choose. The result is an iOS app that is slower and costlier to analyse and patch, and a backend that knows when someone tries.
For the cross-platform view, see mobile app shielding.
Binary and bundle coverage
An iOS app is a bundle of several signed binaries, not one file. Otukan protects each part according to what it holds.
| Component | What it contains | What an analyst reads without protection | What Otukan does |
|---|---|---|---|
| Main executable | Your Swift and Objective-C code as a Mach-O binary | Class and method names, Swift type metadata, string literals | Obfuscates names and strings; embeds integrity data |
| Your frameworks | Dynamic frameworks you build | The same metadata, for every framework | Protects them like the main executable, keeping their public interface |
| Vendor XCFrameworks | Third-party binaries signed by their vendor | Vendor code | Leaves them as shipped, so vendor signatures stay valid |
| App extensions | Widgets, notification, share and other extensions | Logic that handles shared data | Protects the extensions you choose, with light runtime checks |
| Resources | Info.plist, asset catalogues, bundled JSON and models | Configuration and endpoints in plain files | Covers them with integrity data |
| Framework bundles | Flutter’s compiled Dart code or a React Native JavaScript or Hermes bundle | Most of the app’s logic, outside the Swift layer | Protects the framework layer, not only the native shell |
App Store encryption does not change this picture. iOS decrypts the executable to run it, and on a jailbroken device the decrypted binary can be written out and read. Obfuscation detail is covered on iOS code obfuscation.
Runtime protection policy
Runtime checks produce signals. Your policy decides what each signal means in each part of the app.
Signals
- Jailbreak. Independent checks for filesystem traces, sandbox integrity and code the app did not ship. Rootless jailbreaks keep the system volume intact and place files elsewhere, and Otukan covers both layouts.
- Debugger. A debugger attached to the release build outside development.
- Injected libraries. Dynamic libraries loaded into the app that are not part of your bundle, as used by instrumentation frameworks and tweak loaders.
- Integrity. A team identifier, bundle identifier or bundle content that differs from your distributed build. A copy re-signed by another team also loses access to Keychain items stored under your access groups.
Responses
Set a response per user flow: observe, warn, restrict or end the session. Otukan sends signals with login and transaction requests so your server decides, and your server can pair them with App Attest on devices that support it. Policy design is covered on threat response, and runtime mechanics are covered on mobile RASP.
Signing, performance and release acceptance
Signing and distribution
You sign with your distribution certificate, and Apple re-signs App Store builds for delivery. TestFlight, ad hoc, custom app and enterprise builds each carry different signing details, and Otukan’s integrity expectations list the legitimate identity for each channel you use. Otukan fits your existing build and release pipeline, and your distribution certificate and its private key stay with your team.
Performance
iOS terminates apps that take too long to launch, so Otukan keeps launch-time checks light and applies heavier transforms only to the code you choose. We measure launch time and app size with your team on the oldest iPhone and iOS version you support, comparing protected and unprotected builds.
Release acceptance
Otukan accepts each release with your engineers:
- Build and sign the protected app exactly as for release.
- On physical devices, reproduce each signal in an authorised lab and confirm the expected response.
- Repeat the same journeys on a supported, non-jailbroken device and confirm nothing fires.
- Run install, update from the previous release, sign-in and your most sensitive flow.
- Confirm a test crash symbolicates with the build’s dSYM files.
- Record iOS versions, device models, results and the reviewer.
The simulator runs a different build for a different environment, so acceptance always happens on devices.
For the platform view, return to iOS app security. If your iOS app is already on the App Store, you can request a free App Exposure Check of the public release.