Strategy & Governance

Managed Security

Cyber Defense

Governance, Risk & Compliance

Operations & People

Talk to us

Cyber Defense

Mobile app security testing, on the attacker's device.

Mobile app security testing services that stop at the login screen miss the point. The attacker owns the device your app runs on. They can unpack the binary, read what you stored, hook what you call, and rewrite what you send, and none of that touches your server until it is already trusted.

We test iOS and Android builds the way that adversary does: static analysis of the shipped package, dynamic analysis on a rooted or jailbroken device, traffic interception through your pinning, and reverse engineering of the parts you assumed nobody would read. Then we test the backend the app talks to, because that is where the data actually lives.

Most mobile findings resolve into one of three sentences: it was stored in the clear, it was sent without protection, or the server trusted the client. If your API is the larger asset, pair this with an API security assessment; if you can share the source, source code security review reaches further into the same code.

Why you need it

01 / 06

Why mobile is a different discipline.

01

The client is in hostile hands.

Every secret compiled into your app is readable. Every check performed on the device can be bypassed. Root and jailbreak detection, certificate pinning and obfuscation raise the cost of an attack; they do not prevent one, and designing as if they do is the most common structural flaw we find.

02

Data outlives the session.

Tokens in shared preferences, personal data in an unencrypted SQLite database, credentials in the iOS keychain with the wrong accessibility class, sensitive values in logs and screenshots. All of it survives on a device that gets lost, sold or backed up to a laptop.

03

The mobile API is usually wider than the web one.

Mobile clients get endpoints that were built for convenience: bulk sync, offline reconciliation, device registration. They are frequently less well guarded than anything the website touches, and they are documented only in the binary.

04

App stores and regulators both check.

Store review, banking and payment requirements, and privacy law all impose obligations on what a mobile app may store and transmit. Failing them stops a release; finding it in testing costs a sprint.

Instrument

02 / 06

Peeling one finding apart.

How a scanner's output compares with what a tester confirms once the binary is open and the traffic is intercepted.

What we deliver

03 / 06

iOS and Android, statically and at runtime.

01

Static analysis of the shipped build

The IPA or APK as your users receive it: hardcoded API keys and credentials, exported components and intent handling on Android, URL schemes and universal links on iOS, debuggable and backup flags, weak or home-made cryptography, and third-party SDKs with known issues.

02

Data-at-rest review

Everything the app writes to the device: shared preferences, UserDefaults, keychain and keystore entries and their protection classes, SQLite and Realm databases, caches, logs, crash reports and screenshots taken when the app backgrounds.

03

Dynamic analysis and runtime instrumentation

The app running on a rooted or jailbroken device, hooked with Frida and objection: bypassing root detection and certificate pinning to see the traffic underneath, tampering with client-side checks, and observing what the app does when it is lied to.

04

Network and API testing

TLS configuration and pinning implementation, what is transmitted and whether it needed to be, and then the API itself: authentication, authorisation between accounts, and the endpoints only the binary knows about.

05

Authentication, session and biometrics

Token storage and lifetime, refresh handling, logout and remote revocation, session behaviour across device restarts, and whether the biometric check actually gates anything or merely animates before an already-valid token is used.

06

Reverse engineering and tamper resistance

Decompiling the application to read its logic, assessing obfuscation for whether it is meaningful or decorative, repackaging and re-signing to test integrity checks, and reporting exactly what a determined analyst learns from your binary.

How we run it

04 / 06

Six phases per platform.

  1. 01

    Information gathering

    Platform targets, build variants, backend environments, the roles and account types in scope, and any device or region gating. We ask for a debuggable build where one exists, and test the production build regardless.

    Day 1
  2. 02

    Static analysis

    Package inspection and decompilation with MobSF, jadx and apktool: manifest and entitlements, exported surfaces, embedded secrets, cryptographic use and bundled dependencies.

    Days 2-3
  3. 03

    Dynamic analysis

    The app on instrumented hardware, traffic intercepted through Burp Suite after pinning is bypassed, runtime hooking with Frida, and abuse of every client-side control that guards something on the server.

    Days 3-6
  4. 04

    Storage and platform controls

    A file-by-file review of what the app leaves on disk, keychain and keystore protection classes, backup inclusion, and what shows in logs, screenshots and crash telemetry.

    Days 5-6
  5. 05

    Reporting

    Findings with device, OS version, build and exact reproduction steps, ranked by what they reach. Platform-specific fixes, not generic advice. The Android and iOS answers are rarely the same.

    Days 7-8
  6. 06

    Re-test

    The corrected build is tested again on the same devices, and we confirm the fix holds under the same instrumentation rather than only in a code diff.

    After your fixes

Key benefits

05 / 06

What changes after.

You know what your binary gives away

A concrete list of the secrets, endpoints and logic recoverable from your shipped app, and which of them actually matter once the server stops trusting the client.

The device stops holding what it should not

Tokens, personal data and cached records either move behind proper platform protection or stop being written at all.

Release reviews get easier

A dated report per platform, mapped to OWASP MASVS, answers store review questions and enterprise security questionnaires without a fresh scramble each time.

Tools we use

06 / 06

Named, and used on your engagement.

No “latest tech tools”. These are the ones your report will cite, alongside the manual work that a tool cannot do for you.

Static analysis and reversing

  • MobSF
  • jadx
  • apktool
  • Ghidra
  • class-dump

Runtime instrumentation

  • Frida
  • objection
  • Magisk
  • Corellium

Traffic

  • Burp Suite Professional
  • mitmproxy
  • Wireshark

Code and dependencies

  • Semgrep
  • Trivy
  • OWASP Dependency-Check

Methodology

  • OWASP MASVS
  • OWASP MASTG

Why Aphelion

Shared

Four things you can check.

01

The work is done by people with names.

Darshap Nayak, formerly of KPMG, holds a master’s degree in cybersecurity and more than seven years in security operations. Jaimin Somani brings fifteen-plus years of academic and hands-on VAPT. Hemang Desai is an ICT network specialist from Australia. You will meet them, not a logo.

Meet the team
02

Evidence, not adjectives.

Every finding arrives with the reproduction steps, the affected asset and the fix, ranked by what it actually reaches in your environment, not by a CVSS number copied from a scanner. You get the report and the raw output, not a summary of a summary.

See how we test
03

Two offices, one practice.

Ahmedabad and Sharjah, working the same methodology on the same tooling. Indian data-residency requirements and UAE delivery are both ordinary here, and the AphelioNYX AD Pen-Test module runs entirely inside your perimeter when regulation says it must.

The platform
04

What we will not do.

Invent a statistic to make a slide land. Publish your name as a client without written permission. Print an award badge nobody awarded. Founded in 2024. We say so, and we attribute experience to the people who have it.

Ask us anything

100+ organizations secured

Across the globe, and across eight industries. We name a client only with their written permission.

  • Finance & Banking
  • Healthcare
  • Retail & E-commerce
  • Technology
  • SaaS
  • Hospitality
  • Manufacturing
  • Pharmaceuticals

AphelioNYX is SOC 2, ISO and GDPR compliant; attestations are available on request under NDA. We would rather hand you the report than print a badge.

Questions

FAQ

What clients ask before a mobile test.

Do you need our source code?
No. We test the shipped IPA and APK exactly as an attacker gets them, which is the honest simulation. Source access makes the test faster and deeper: we can confirm a suspected flaw in minutes rather than inferring it from decompiled output, so we take it when offered, but a black-box mobile test is a complete engagement on its own.
We use certificate pinning. Does that not stop this?
It stops casual interception and it is worth keeping. It does not stop a tester or an attacker with a rooted device and Frida, which takes minutes to bypass. Pinning is a speed bump, and any control that assumes it holds, including "the client already validated this", is the finding we are looking for.
Do you test iOS and Android separately?
Yes, and they should be priced that way. The platforms differ in storage model, permission model, inter-process communication and cryptographic APIs, and the same product routinely has a serious flaw on one platform and not the other. Sharing a backend does not make them one test.
Will you test on a real device or an emulator?
Both. Emulators are convenient for static work and quick iteration, but several classes of finding (keychain accessibility, biometric flows, hardware-backed key storage, real network conditions) only behave correctly on physical hardware. We name the device and OS version alongside every finding.
How does this differ from testing our API?
This engagement covers the client: the binary, the device, the runtime and the traffic it generates. An API security assessment covers the server contract in full, including endpoints and parameters your app never calls. Mobile testing exercises the API through the app; it does not enumerate it exhaustively. Products where the backend is the real asset should scope both.

Forty-five minutes. Your environment, not a slide deck.

A personalised walkthrough and a free readiness assessment against the frameworks you are actually being asked for. Pick a time that suits you, or write to us. We reply within one business day.