A2B Attacks: How Attackers Reach Your Backend Through Your Mobile App
An A2B (App-to-Backend) attack analyses a public mobile app, extracts its API endpoints and embedded keys, then calls the backend directly. This post explains the attack Japan's NICT and JPCERT/CC warned about in October 2026, how Ostorlab tests the same path from the app to its API, and four real-world cases.
Your mobile app is public. Anyone can download it, take it apart and read what it contains: API endpoints, request formats and, too often, keys. From there, they no longer need the app. They can call your backend directly.
In October 2026, Japan's National Institute of Information and Communications Technology (NICT) called this an A2B attack (App-to-Backend Attack) and asked app publishers to check their backends. Eight days later, JPCERT/CC published what it found on the attackers' servers: downloaded Android apps, decompilers and scripts to test the backends behind them.
This post explains how the attack works, how Ostorlab tests an app and its API along the same path, and what we found doing it in four real assessments.
What is an A2B attack? (TL;DR)
An A2B attack starts with a public app and ends at its backend. The attacker analyses the app, pulls out the API endpoints and any keys compiled into it, then calls the API directly, without the app. The weaknesses it exploits are on the server: missing authorization checks, keys that work outside the app, and endpoints that fetch any URL they are given.
How does an A2B attack work?
The attack has three steps.
- Take the app apart. Android apps are easy to download and decompile. JPCERT/CC found APK files, the jadx decompiler and Blutter, a tool for analysing Flutter apps, on the attackers' servers.
- Pull out what the backend trusts. The app's code contains the API endpoints, the request formats and, often, API keys, tokens or credentials.
- Call the backend directly. With those, the attacker sends requests the server accepts as coming from the app. If the server only checks that a request carries a valid key, it has no way to tell the difference.
From there, NICT asked publishers to check four kinds of backend weakness: broken object-level authorization (IDOR/BOLA), server-side request forgery (SSRF), remote code execution and SQL injection. JPCERT/CC also found scripts that test SSRF through HTTP redirects, to get around checks on the URL a server is allowed to fetch.
None of these steps needs a jailbroken or rooted device, or access to the company's network.
Why does testing only the app or only the API miss A2B attacks?
An app scan that finds a hardcoded key reports a finding. An API scan that uses valid test credentials sees a server answering valid requests. Neither one tests the chain: whether the key in the app actually opens the API, and what it gives access to.
We covered this in more detail in Why API Security Testing Misses Cross-Asset Attack Chains. An A2B attack is exactly that kind of chain, starting from a mobile app.
How does Ostorlab test the path from the app to the backend?
Ostorlab tests the app and its backend in the same assessment, in the order an attacker would.
1. Analyse the app
Ostorlab analyses the app and lists the API endpoints it calls and the secrets it contains: API keys, tokens, credentials and internal hostnames.
2. Check whether each key really works
A key in an app is not always a vulnerability. Some are meant to be public, and some no longer work. For each key it finds, Ostorlab checks whether the key is valid, using read-only requests only. A key that works, and what it gives access to, is what turns a finding into a risk.
3. Check API authorization
Next, Ostorlab checks whether one user can read another user's data, by changing object IDs in requests (IDOR/BOLA). An A2B attack depends on this server-side check being missing.
4. Test SSRF, redirects included
On APIs that take a URL, Ostorlab tests whether the server can be made to fetch a destination it shouldn't, including through redirects, the technique JPCERT/CC found in the attackers' scripts.
5. Prove each result
Every result comes with the steps to reproduce it and the evidence: the requests and the responses. Your team can confirm the issue and check the fix without redoing the analysis.
What do A2B attacks look like in real assessments?
These cases come from Ostorlab assessments. They are named by industry only, and each one is described exactly as far as it went.
| Industry | What we found | Limits |
|---|---|---|
| Consumer services | API keys and credentials recovered from a Flutter iOS app, without a jailbroken device | Extraction only: backend use of the credentials was not tested |
| Aviation | A static API key embedded in the app obtained a service token without a login, and the token reached a member API | The data returned was limited to two permission flags of a test account |
| Industrial distribution | A leaked credential, plus changed user IDs in requests, retrieved other users' data (BOLA) | The credential came from web client code, not a mobile app |
| Media and broadcasting | A redirect bypassed the server's URL check, proving an SSRF | The server reached an external test endpoint only; no internal service was reached |
The pattern is the same in each one: something shipped in a client, and a server that trusted it.
How do you protect a backend from A2B attacks?
NICT and JPCERT/CC recommend the same measures:
- Assume your app will be analysed. Don't ship secrets in it. If a key must be in the app, limit what it can do on the server.
- Revoke and reissue any credential that has been in a released app.
- Check authorization on every request, for every object, on the server. A valid key or token is not proof that the caller may read this record.
- Rate-limit your APIs, so that enumerating IDs is slow and visible.
- Validate the destinations of any server-side fetch, and check redirects too, not only the first URL.
- Test the whole path, from the published app to the backend, not each part on its own.
How can you test your app the way an attacker would?
An A2B attack doesn't need anything special: a public app, free tools and a backend that trusts what the app sends. To see what an attacker would find in yours, start a mobile scan with your Android or iOS build.
What has Ostorlab's security research produced?
Ostorlab's AI engine, Neutron, verified exploits for 97.1% of tasks (1,463 of 1,507) on UC Berkeley's CyberGym, a benchmark of known vulnerabilities in open-source C/C++ projects. The result is reported by Ostorlab; the method is in the technical write-up.
Our research has also produced 40 published CVEs, with 70 more under publication, in projects such as VLC for Android, react-native-webview, GoPhish, Keycloak and LibreSSL.
Sources
- NICT CYNEX, alert on A2B attacks, 13 October 2026: cynex.nict.go.jp/library/261013-01.html (Japanese)
- JPCERT/CC Eyes, 21 October 2026: blogs.jpcert.or.jp/en/2026/10/web_api_attacks.html