Mobile pentest findings: which are real and what to fix first

A failed test shows a weakness. Here is how to prove a mobile app finding is exploitable, close the ones that are not and rank fixes with a CVSS 4.0 vector.

Your scanner report lists dozens of findings, and the top one is a Google Maps key that the app needs to draw its map. A finding is a proven vulnerability once someone has exploited it on a real device and recorded how they got in, what they needed and what they got. Then a CVSS 4.0 score and your app’s data set the order of fixes.

TL;DR

  • Covers: How to tell which findings in a mobile app report are exploitable, whether the report comes from a scanner or a pentest, and how to rank the fixes with a CVSS 4.0 vector.
  • Not covered here: Exploitation on iOS, since the example is an Android app, although the questions at the end apply there too. The MAS testing profiles are in Jacobo Casado’s which MASVS profile does your app need, and what the CRA expects after a failed MASTG test is in OWASP MASTG for CRA compliance.
  • First step: Take the top line of your report and ask whether anyone has exploited it on a phone set up like your customers’ phones, and with what evidence.

The labels in a mobile report, ours included, come from OWASP Mobile Application Security (MAS). Within MAS, each kind of mobile weakness has an ID in the Mobile Application Security Weakness Enumeration (MASWE, v1.0.0, 17 August 2026), as software weaknesses in general have in the Common Weakness Enumeration (CWE). The test that checks whether your app has that weakness is in the Mobile Application Security Testing Guide (MASTG, v2.0.0, 30 June 2026), and the controls, the requirements a secure app meets, are in the Mobile Application Security Verification Standard (MASVS, v2.1.0, 18 January 2024). The severity label usually comes from the Common Vulnerability Scoring System (CVSS) 4.0, which FIRST published on 1 November 2023: a short string of metric values, the vector, from which a calculator gives a score out of 10.

The example: a scanner report for a car-sharing app

Imagine a car-sharing app, whose scanner report the rest of this article works through. Customers find a car on a map, book it, and the app asks the backend to unlock it. They pay by the minute with a saved card. The app keeps a long-lived session token so that customers stay logged in, and it opens promotion pages in a WebView, a browser component embedded in the app. Because it handles location, payments and that token, the team chose the MAS-L2 and MAS-P profiles for it: L2 assumes that an attacker may get hold of the phone, and P covers personal data.

An automated scan of the Android build returns, among others, these five lines, and it rates the Google Maps key highest. The severity column is the scanner’s own label; the CVSS scores come later:

Scanner line Scanner severity What the line means
Hardcoded Google API key High A key is stored in the app package (MASWE-0004)
Sensitive data not excluded from backup Medium The session token goes into Android backups (MASWE-0006)
JavaScript interface in WebView Medium Web pages in the WebView can call app code through a “bridge” (MASWE-0033)
Deep link parameter not validated Low A link can open an app screen with values the app does not check (MASWE-0029)
No debugger detection Low The app does not notice when someone attaches a debugger (MASWE-0064)

The example is an Android app. On iOS the routes differ, but the questions at the end of the article work the same way.

Is a failed test a vulnerability?

Take the backup line. The weakness behind it is that the app lets sensitive data go into the device’s backups (MASWE-0006). To check for it, the tester uses the app, backs it up, reinstalls it and lists the files that come back (MASTG-TEST-0216). The usual way to make that backup runs adb root (MASTG backup technique), and adb root works on an emulator or a test build of Android. If the file with the session token comes back, the test fails.

So the token is in the backup. But whether anyone other than the tester can get it out of a customer’s phone, which has no root, is still open. Our rule is that a finding we have not exploited is not proven. Until someone shows a route that works on a customer’s phone, this finding is a weakness: still worth fixing, and reported as a weakness.

How do you prove a finding is exploitable in a mobile app?

You do what the attacker would do, on a phone set up the way your customers’ phones are, and you record the route, what the attacker needs before starting, and what they get at the end.

Each MAS profile assumes a different attacker, and that tells you which routes to try:

Profile Attacker it assumes
MAS-L1 Another app installed on the same phone
MAS-L2 Someone who may have the phone in their hands, on an operating system that cannot be trusted
MAS-R The user of the phone as well, as in reverse engineering or cheating
MAS-P None: the profile is about personal data rather than an attacker

Whatever the profile, we also try the routes that reach the app from outside: someone on the network, and a link the customer taps.

Each route ends up in the CVSS vector. These are its base metrics and what each one records:

Metric What it records
Attack Vector (AV) Whether the attacker comes over the network (N), from nearby, as over Bluetooth (A), works locally (L) or must touch the device (P)
Attack Complexity (AC) High only when the attacker has to defeat a protection
Attack Requirements (AT) Present when the attack depends on conditions the attacker does not control, such as an old Android version
Privileges Required (PR) Whether the attacker needs an account
User Interaction (UI) Whether the victim has to do something
VC, VI and VA The harm to confidentiality, integrity and availability in the app
SC, SI and SA The same harm to other systems

The score from these metrics alone is the base score.

For the backup token, the car-sharing app is MAS-L2, so someone holding a customer’s unlocked phone is in scope. For apps that target Android 12 or higher, adb backup no longer exports app data on Android 12 and higher, but this app also installs on Android 10 and 11, where that restriction does not exist. On a stock Android 11 phone, unlocked, with USB debugging switched on from its settings, adb backup exports the app’s files and the token in them. Copied to another device, the token keeps the account open after the phone goes back to its owner. Cloud backups are no shortcut: they sit in the customer’s Google account and, from Android 9 with a screen lock set, are end-to-end encrypted with the device PIN, pattern or password. For customers on Android 12 and higher, that leaves one route to try: a device-to-device transfer to a phone the attacker controls. Until a tester shows that one working, the same failed test is a vulnerability for customers on Android 11 and lower and a weakness for the rest.

The fix covers both groups: exclude the token in both sections of the dataExtractionRules file (cloud backup and device-to-device transfer) and in the older fullBackupContent file that Android 11 and lower read. Encrypting the token with a key from the Android Keystore also works, because the key stays on the phone and a copied token cannot be decrypted.

The bridge and the deep link are two separate lines in the report, and together they give an attacker the account. The bridge has a method that returns the session token, so that promotion pages can call the API as the customer. That method only matters if a page the attacker controls can load in the WebView, and the deep link makes that possible: carshare://promo?url= opens any address in the WebView, because the app does not check the host. The attacker puts the link on a web page and gets customers to visit it. When a customer taps the link, the app opens the attacker’s page, and a line of JavaScript on that page calls the bridge and posts the token to the attacker’s server. To prove the chain, the tester does exactly that on a test device with a test account, sees the token arrive and books a car with it. The attacker needs one tap from the customer and gets the account: trip history, and bookings charged to the customer’s saved card.

The fix is to check the host in the deep link, take the token method out of the bridge, and use origin-scoped messaging, which offers the bridge only to pages from origins the app allows. OWASP recommends origin-scoped messaging (MASTG-BEST-0035) because addJavascriptInterface is exposed to every page and frame in the WebView.

In older apps the same bridge line meant code execution. In apps that targeted API level 16 (Android 4.1) or earlier, JavaScript in a WebView could reach the bridged object through Java reflection and run arbitrary code in the app (CVE-2012-6636). Current apps target far higher API levels and run on far newer Android, where only methods marked with @JavascriptInterface are exposed, so today the risk depends on what those methods do and which pages can reach them.

The debugger line is not a vulnerability in this app, although the gap it reports is real. Sergio García ported the anti-debugging tests to MASTG v2.0.0, for Android and iOS. The new Android tests look for calls that detect a debugger, such as reading the TracerPid field of /proc/self/status, and check whether the app uses them at run time. When they fail, a reverse engineer can step through the code without being noticed.

But debugger detection belongs to MAS-R, and OWASP says that missing MAS-R measures do not, on their own, introduce vulnerabilities, provided the app meets the rest of the MASVS controls for its threat model, the list of attackers and goals the team decided to defend against. The car-sharing team did not choose MAS-R. The backend also checks every booking and every unlock, so a customer who debugs their own copy gets only what they could already get by using it. If the app unlocked cars over Bluetooth with keys stored on the phone, the customer would become an attacker worth modelling, and this line would need a decision.

Why can’t a scanner tell you which findings are exploitable?

A scanner reads the app and matches patterns, one rule per weakness. It covers the whole app in minutes and finds the same problem again in the next build, and the MASVS encourages automated tools for that efficiency. But the same standard says that MASVS verification cannot be completed with tools alone, because each app has its own architecture and business logic. That limit is built into the MASTG tests. The test for code exposed through WebViews (MASTG-TEST-0334), for example, ends with the result “Further Validation Required”: someone has to check whether the exposed methods handle sensitive actions and whether untrusted content can reach them. In the car-sharing app, the deep link is how untrusted content reaches the bridge, and no rule that looks at one weakness at a time connects the two.

With the Maps key, the scanner is right that the key is in the app, and it has to be: the Maps SDK reads it from there. What a pattern match cannot see, though, is what the key is allowed to do. That is set by the key’s restrictions, and Google advises you to restrict each key to your apps and to the APIs they need. On Android, the app restriction is checked through the X-Android-Package and X-Android-Cert headers (Google’s mobile guidance), and both values are in every copy of the APK, so the API restriction is what limits a key someone has extracted. The tester reads the key’s API restrictions with the team, finds it limited to the Maps SDK for Android, and confirms that limit with a call from a laptop to another Google API, which is refused. The finding is a correct detection with nothing to exploit beyond the Maps SDK. It is closed with that evidence.

That closure depends on a setting outside the app. In February 2026, Truffle Security reported that enabling the Gemini API in a Google Cloud project silently gave Gemini access to existing keys in that project that were unrestricted or allowed it: access to files uploaded to Gemini, and calls billed to the project owner. They found 2,863 such live keys in public web pages. A key limited to the Maps SDK is outside that case, as long as it stays limited. So someone on the team should own that key’s restrictions and the list of APIs enabled in its project, and check them whenever either changes.

Does the CRA treat a failed test as an exploitable vulnerability?

Not by itself, and the bar is lower than exploitation. If you sell in the EU, the Cyber Resilience Act (CRA) calls a vulnerability exploitable when it has “the potential to be effectively used by an adversary under practical operational conditions” (Article 3(41)), and the Commission’s guidance asks you to investigate each finding, because a finding alone does not show that it is exploitable (points 234 and 235). Exploiting it is the strongest answer, and for a weakness you could not exploit, you record why you think it cannot be used in practice, as Using OWASP MASTG for CRA compliance explains.

How do you prioritize the findings?

Rank the exploited findings by their CVSS 4.0 score, completed for your app, and move up the ones that are cheap to attack. Weaknesses and closed findings come after, each with its reason.

For the car-sharing chain (the deep link plus the bridge), this base vector scores 8.5 (High) in the FIRST calculator:

CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:A/VC:H/VI:H/VA:N/SC:N/SI:N/SA:N

Attack Vector is Network because the vulnerable app itself loads the attacker’s page, which is how the CVSS user guide treats a component that receives malicious data over the network. User Interaction is Active because the customer has to tap the link. We rate the account and the bookings as impact on the vulnerable system (VC, VI), because the app and its API are one product run by the same company; if you also rate the backend as a separate system (adding SC:H and SI:H), the chain scores 9.3 (Critical). CVSS rates single vulnerabilities, so the user guide’s rule for chains applies: take the least restrictive exploitability of the parts and the worst impact, and list each part with its own score next to the chain’s.

The backup token on Android 11 scores 5.3 (Medium) with this vector:

CVSS:4.0/AV:P/AC:L/AT:P/PR:N/UI:N/VC:H/VI:H/VA:N/SC:N/SI:N/SA:N

Attack Vector is Physical because the attacker must hold the unlocked phone, and Attack Requirements Present because it works only on older Android versions.

A base score measures severity, not risk, so you complete it, as the user guide asks. The tester proposes the Environmental values in the report and you confirm them, because they describe your system. For the car-sharing app, confidentiality and integrity stay High, which is also what CVSS assumes when you leave them blank, and availability drops to Low (AR:L). The Threat metric, Exploit Maturity, comes from what is publicly known, and left blank it counts as “attacked”, the worst case. For findings the tester has just made, nothing is public, so Exploit Maturity is Unreported. With both groups filled in, the chain scores 5.9 (Medium) and the backup token 1.5 (Low). Those numbers fall mainly because no exploit is public yet, while the attack stays as easy as it was.

The cost of the attack covers what the completed score leaves out: a cheap attack should move up the list even when the score does not. The chain is cheap because it needs only a web page and a link that can reach thousands of customers at once, and it works without root, a second app or access to the phone. The cheapest attacks of all have their own supplemental metric, Automatable: it asks whether every step up to exploitation can be automated across many targets, and it does not change the score. The chain is not Automatable, because each customer has to tap. The exposed Gemini keys, by contrast, were Automatable: Truffle found them by scanning a public web archive, and anyone holding one can call the API.

After validation, the car-sharing report reads:

Finding Verdict Score: base / with Threat and Environmental Why it ranks here When to fix
Deep link that opens any page in the WebView, plus the token bridge Exploitable vulnerability 8.5 / 5.9 Account takeover with one tap, cheap to send at scale Now, in a hotfix
Session token in backups Exploitable on Android 11 and lower; weakness on Android 12 and higher 5.3 / 1.5 Needs the unlocked phone; the token keeps working afterwards Next planned release
Google Maps key in the app Correct detection, nothing to exploit None Key limited to the Maps SDK; another API refuses it Closed; recheck when the key or the project changes
No debugger detection Outside this app’s threat model None MAS-R not chosen; the backend checks bookings and unlocks No fix now; revisit if unlocks move to the phone

The scanner ranked the key first. After validation the key is closed, and the two lines the scanner rated Medium and Low are the hotfix.

Questions to ask about each finding before you fix it or close it

For every line in a report, your team, or your testing vendor, should be able to answer these:

  1. Which weakness is it, and which test failed? The MASWE ID and the MASTG test, so that everyone means the same thing.
  2. Who is the attacker, and is that attacker in your threat model? Another app, someone holding the phone, someone on the network, someone who sends a link, or the user. Check it against the MAS profiles your team chose for the app.
  3. What does the attacker need first? Root, an unlocked phone, a tap, an old Android version, a setting on your server.
  4. What does the attacker get in this app? Data, money, an account, or nothing useful.
  5. Has someone exploited it, on which build, device and Android version, and with what evidence? If not, it is a weakness, and the report should list the routes that were tried.
  6. Does it combine with another finding? In the car-sharing app, two lines the scanner rated Medium and Low made one finding with a High base score.
  7. What is its CVSS 4.0 vector, and how cheap is the attack? With the Environmental values for your app, and the Threat metric as it stands today.
  8. If you close it, on what evidence, and what would reopen it? A key restriction, a minimum Android version, a server rule.

What does a mobile app pentest add to a scanner report?

A pentest is where those questions get answered, finding by finding. In a mobile app pentest at vulnit, each finding in the report comes with its evidence, its reproduction steps and its CVSS 4.0 vector, and our specialists validate every result, on Android and on iOS. On Android, our AI agents and our specialists work on Chameleon, our own Android build for app analysis; on iOS we use physical devices. You can see the format in our sample pentest report. If you have a report you cannot rank, from a scanner or a pentest, tell us what it found and when your next release is due.

References

Portrait of Darío Abad

Darío Abad

Co-Founder & COO

LinkedIn · View all posts

A necessary cookie remembers your choices for up to 180 days. Privacy policy.