Techbanq

Offensive security · mobile

The device belongs to the attacker

Every check the app performs on itself can be removed by someone holding the phone. What survives that is the backend, so a mobile test that stops at the binary has tested the part that does not matter.

Serving Saudi Arabia from our Riyadh office and our engineering hubs in Lahore and Karachi

Software team working together at desks in an open office
  1. 01

    Market

    Saudi Arabia

  2. 02

    Written for

    CTO, CISO

  3. 03

    Decision

    Commission a security test of an iOS and Android application

  4. 04

    Languages

    EN · AR

Cybersecurity credentials

  • National Cybersecurity Authority, Saudi Arabia

    NCA registration

    Registered cybersecurity service provider

  • ISO

    ISO/IEC 27001

    ISO/IEC 27001 certified

Certifications & registrations

The trust boundary

Three layers, and only one of them is defensible

We do not have an office in Saudi Arabia

We serve organisations there from our Riyadh office and our engineering hubs in Lahore and Karachi, travelling for the parts of an engagement that need to happen in person.

A mobile application has three places a defect can live: the binary and what it stores on the device, the connection between the device and the server, and the server itself. Only the third is under your control once the app is installed. Anything the app checks locally — whether the device is rooted, whether the build is genuine, whether the user is entitled to a feature — is a decision made on hardware the attacker owns and can be removed by someone who wants to remove it.

That does not make the local layer irrelevant, because it is where data sits. Authentication tokens written to a shared preferences file, personal data cached in a database with no encryption, a debug log retaining the full response body, a screenshot of the account screen written to the app switcher cache — these are the findings that matter on a lost or shared device, and they are common because the developer reasonably assumed the sandbox was the protection.

The test that produces the most value therefore runs in a specific order: remove the client-side protections first, then test the backend as an attacker who has removed them. Certificate pinning is bypassed not to report that it can be bypassed — it always can — but so the traffic behind it can be examined. A report whose headline finding is "pinning was defeated" has stopped at the point where the test should have started.

Coverage

What gets examined on each platform

01

Data at rest

Preferences files, SQLite databases, cached responses, the keychain and keystore, and what the app leaves behind on logout. Checked on a device with the screen lock removed, because that is the realistic loss scenario.

02

Transport

Whether traffic is encrypted everywhere including analytics and crash reporting, whether pinning is implemented and where, and whether the app falls back to an unpinned path when pinning fails.

03

Authentication and session

Biometric prompts that gate the interface rather than the data, session tokens that outlive the app, refresh flows that survive a password change, and whether a second device can hold the same session.

04

Platform integration

Exported activities and deep links reachable by another installed app, clipboard use, the app switcher snapshot, notification content on a locked screen, and what a backup contains.

05

The backend, unprotected

Every call the app makes, replayed with parameters the app would not send and from an account that should not be able to make them. This is where the severe findings are, and it is the part a binary-only assessment skips.

06

Build hygiene

Hard-coded keys and endpoints, debug builds shipped to production, third-party libraries with known issues, and what the app sends to analytics providers that a privacy notice does not mention.

Sequence

The order the test runs in

STAGE 01

1 · Builds and accounts

Signed builds for both platforms supplied directly, not pulled from a store — a store build cannot be instrumented on some configurations, and the version there is rarely the one under test. A test estate that matches what your users will run.

STAGE 02

2 · Static review

The package decompiled and read: secrets, endpoints, third-party libraries, and the logic behind any local entitlement or integrity check. A map of what the app knows and what it decides locally.

STAGE 03

3 · Runtime on a controlled device

Local protections removed, storage examined during and after use, and traffic intercepted with pinning bypassed. Findings on the device layer, and a clear path to the backend.

STAGE 04

4 · Backend testing through the opened channel

The calls the app makes, altered and replayed across accounts. Where the backend is also reachable outside the app, the API scope is agreed separately rather than assumed. The findings that determine the severity of the engagement.

Scope boundary

What the result establishes

What we do

  • Test both platforms where both exist, because the same feature is frequently implemented differently on each.
  • Report local findings by what they expose on a lost or shared device, rather than by whether a control is technically present.
  • Say plainly which backend operations were reached through the app and which were not in scope.

Where the application handles payment or banking data, the relevant supervisory framework sets what testing evidence is accepted and how often it must be renewed. Confirm that with the assessor before scoping rather than after the report is written.

Primary source

Common questions

What buyers ask

Our app has anti-tampering and root detection. Does that reduce the scope?+

It changes the first hour and nothing after it. Those controls raise the effort for an opportunistic attacker, which is a real benefit worth keeping, but they are defeated as a matter of routine in any serious assessment and they do not protect the backend. We remove them, note how much effort it took as useful context, and spend the engagement on what they were protecting.

Do we need to test both iOS and Android separately?+

Both, but not at double the cost. The backend testing is shared, and so is most of the logic review. What is genuinely per-platform is storage, transport implementation and platform integration, and those differ enough that testing one and assuming the other is how a finding survives. Cross-platform frameworks narrow the gap but do not close it — the storage and keychain behaviour is still native underneath.

Can you test against our production backend?+

Often we have to, because the staging backend rarely has the same authorisation configuration and testing against a permissive staging environment produces findings that do not apply. The conditions are the same as for any production test: test accounts rather than real customer data, a named contact who can stop the work, agreement on which operations are excluded, and no destructive actions outside a defined list.

Next step

Send signed builds for both platforms

A scoped mobile test covering both platforms and the backend they call, with builds supplied rather than pulled from a store.

Send signed builds for both platforms

What happens next

  1. 1We reply within one business day.
  2. 2A 30-minute scoping call with a senior consultant.
  3. 3A written proposal with scope, team, and timeline.

Or reach us directly

By submitting this form you agree to our Terms of Use and Privacy Policy.