VEX for mobile apps: which CVEs in your SBOM actually matter

A VEX marks each CVE in your app's SBOM as affected or not, and says why. Backed by a reachability test, it shows which updates can wait.

Run your app’s software bill of materials (SBOM) through a vulnerability scanner and you get a long list of CVEs. Many cannot be exploited in your app: the vulnerable code is missing from the build, never runs, or only sees trusted input. A VEX records which ones affect your app, and why, so your team knows what can wait.

TL;DR

  • Covers: How to read a VEX and how to back each “not affected” entry with a test, using two Android apps as examples. It also covers the CRA: from 11 December 2027 your app must be made available without known exploitable vulnerabilities, and your VEX records the investigation behind each CVE. A CVE that cannot be exploited stays out of your CRA reports, but you still handle it.
  • Not covered here: How to build the SBOM itself; whether the CRA applies to your app, answered in Does the CRA apply to my mobile app?; and where the VEX sits among the rest of your CRA evidence, in OWASP MASTG for CRA compliance.
  • First step: Check your last SBOM against the APK or IPA it describes, before you write any VEX entry.

Each entry on that list is a CVE: a publicly listed vulnerability with an identifier from the CVE Program. The scanner finds them by matching each component’s name and version against public databases such as the US National Vulnerability Database (NVD) or the European Vulnerability Database (EUVD), run by ENISA, the EU cybersecurity agency. For one version of your app and one CVE, a VEX (short for Vulnerability Exploitability eXchange) says whether the app is affected. You can write it in the Common Security Advisory Framework (CSAF 2.0) from the OASIS standards body, or in CycloneDX, the SBOM format that started at the OWASP security foundation.

Why does an SBOM scan flag CVEs that do not affect your app?

If the SBOM says your app ships Gson 2.8.6 and a CVE covers every Gson version before 2.8.9, the scanner reports that CVE. The scanner only compares version numbers, so what your app does with the library never enters into it. That Gson case is real, and the sections below follow it from the scan to the VEX entry.

Gson is Google’s library for converting Java objects to and from JSON. CVE-2022-25647 (in the EUVD, EUVD-2022-2402) affects Gson before version 2.8.9, and the NVD rates it high, at 7.5 out of 10 (the EUVD shows 7.7, the score from Snyk, the security company that assigned the CVE). The flaw is in the Java deserialization of some internal Gson classes, and the advisory describes the impact as a denial of service. The contributor who wrote the fix says that you are affected only if your code or your dependencies use Java serialization. They add that they never checked whether the denial of service is possible at all. Both remarks are in a comment on the pull request that fixed it, marked as not an official statement. Parsing JSON does not use Java serialization, so an app that only reads its API responses with Gson looks safe.

On Android, though, that reading also has to cover what other apps can send to yours, because Java deserialization can happen without a call in your code. Another app can put a Serializable value in the extras of an intent it sends to any exported component of yours, and the framework deserializes that value with your app’s class loader as soon as something reads those extras. On Android 8.1 to 12, that something can be the framework itself: at some points in the activity’s life, the framework checks the launch intent for an extra of its own, and that check deserializes every value in the intent, whatever its key. From Android 13, a value is deserialized only when something reads that value:

Android version What deserializes the extras
8.1 to 10 Any read of the extras, including the framework’s check when the activity finishes
11 and 12 Any read of the extras, including the framework’s check when the activity finishes, stops or starts another activity
13 and later Only a read of that particular value

The SBOM can also differ from the build, so check it against the APK it describes before you write a VEX. One reason is R8, the tool that shrinks Android builds: it removes code that nothing references, in the app and in its libraries. An SBOM generated from the Gradle build still lists the whole library, even when the APK, the package you publish, keeps only a few of its classes. To see which classes the APK really contains, run apkanalyzer dex packages with the R8 mapping file. R8 often helps with large libraries, but not with Gson, whose map classes are what JSON parsing uses. The gap also runs the other way, because a Gradle-based SBOM can miss code that is in the APK: a native library compiled into an SDK, or classes an SDK bundles inside its own package, get no line of their own.

Do you have to update every flagged library?

Updating is the default answer, and when the fix is a patch release it is often the quickest. The move from Gson 2.8.6 to 2.8.9 is one of those. Updates cost more, though, when the fix is in a major version that changes the API, when the library comes inside a third-party SDK you cannot update yourself, or when no fixed version exists yet. Every update also means a new release, with its regression tests and store review.

Given that cost, I think the most useful thing a VEX does is save your team the updates it does not need. The CVEs that affect the app get fixed first, and the rest wait for a planned release, where the update is cheaper, or for the SDK vendor’s next version. That only works if each “not affected” entry holds up. A “not reachable” entry, for example, needs an analysis of the build and a test that tried to reach the code. With both behind the entry, you can hand it to a customer or an auditor.

How do you read a VEX?

Each statement in a VEX ties one product version to one vulnerability and gives it a status. CSAF calls the status the product status and CycloneDX the analysis state. Most values match one to one, but CSAF has no status of its own for a wrong match:

What it means for your app CSAF 2.0 product status CycloneDX analysis state
Affected: act on it known_affected exploitable
Not affected known_not_affected not_affected
This version contains the fix fixed resolved
Still being analysed under_investigation in_triage
Wrongly matched: the app does not ship the component No status of its own: known_not_affected with component_not_present false_positive

A “not affected” status needs its reason and an “affected” one needs an action: CSAF requires both, and CycloneDX recommends them. In CSAF, every product marked not affected needs an impact statement, and every product marked affected needs an action statement, such as the fixed version to install (CSAF rules for VEX documents). CycloneDX has two fields for this: a justification, and a detail that describes the impact, including the methods used during the assessment and, when the app is not affected, why.

The justification for “not affected” covers the three reasons from the opening. CSAF writes it as flags or as free text in a threat of category impact, and CycloneDX as justification values:

  • The vulnerable code is not in the build, for example because R8 removed that part of the library. CSAF uses vulnerable_code_not_present and CycloneDX code_not_present, which the CycloneDX specification describes as code removed or tree-shaken. When the whole library is missing, CSAF has component_not_present. CycloneDX has no separate justification for that case. When the scanner matched a library the app does not ship at all, the CycloneDX false_positive state, meant for a vulnerability “falsely identified or associated”, fits better.
  • The code is in the build but no path reaches it. CSAF uses vulnerable_code_not_in_execute_path, which it defines as not reachable “including non-anticipated states of the product”, and CycloneDX uses code_not_reachable.
  • The code runs, but an attacker cannot control its input, for example because it only parses files the app wrote itself. CSAF uses vulnerable_code_cannot_be_controlled_by_adversary. CycloneDX has no value with that name, so the reason goes in the detail.

To see a full entry, take the Gson CVE in a fictional shopping app that parses its API responses with Gson and runs on Android 14 and later (minSdk 34). The app’s only exported component is the launcher activity. No code in the app or its libraries reads that activity’s intent extras, or uses Java deserialization in any other way. In a CycloneDX entry for that app, the affects reference points to the app version, declared at the top of the same file, because the statement is about the app; Gson 2.8.6 itself stays vulnerable. The entry marks the app not affected, and its detail records both the static analysis of the APK and the test:

CycloneDX field Value
id CVE-2022-25647
affects[].ref [email protected]
analysis.state not_affected
analysis.justification code_not_reachable
analysis.detail minSdk 34. The vulnerable path, Java deserialization of Gson’s internal classes, is not reachable. Static analysis of the APK: the only exported component is the launcher activity, and neither app nor library code reads its intent extras; no other code reads Serializable values from outside the app, and no app or library code uses ObjectInputStream. Dynamic test on Android 14 and 16: intents carrying a hand-built Java serialization stream of Gson’s LinkedTreeMap sent to the launcher activity, which was then stopped and finished; no deserialization observed and no crash.
analysis.lastUpdated 2026-10-22T00:00:00Z

If someone doubts the status, the detail shows them what was analysed in the build and what was tried while the app ran.

The case changes if you lower the minimum to Android 12. On Android 12 the framework reads the launch intent’s extras when the activity stops or finishes, so any app on the device can make the shopping app deserialize the Gson classes. On that version, another app can already crash the shopping app by sending a class the app does not have, so Gson adds little. Still, until a test settles the question, the entry stays under investigation, and the patch release to Gson 2.8.9 is the cheap way out.

How do you prove a CVE does not affect your app?

For each CVE, work on the build you ship:

  1. Check the SBOM against the APK: components missing from the SBOM, listed at the wrong version, or partly removed by R8.
  2. Find the vulnerable code from the advisory and the fix, and the ways it can be reached, including through the framework, as with Java deserialization on Android.
  3. Run the app on the oldest and newest Android versions it supports, and drive it through the flows and entry points that could reach that code, including intents sent by other apps and the screen lifecycle that follows them.
  4. Try to trigger the vulnerability.

A test that never sees the function run may only have missed the path. That is why a “not affected” entry needs the code to be absent from the build, or every path to it ruled out in the code, with the test confirming the result. If the test triggers the vulnerability, the entry is affected and comes with the proof of concept. If the analysis and the test leave the question open, the entry stays under investigation until there are more details about the exploit and the test is repeated. Your team can update in the meantime.

vulnit builds that VEX for Android and iOS apps. We extract the SBOM from your APK or IPA with our own black-box tool, which needs no source code, and compare it with the SBOM you declare. Then we run the app: Android apps in Chameleon, our own Android build for app analysis, and iOS apps on physical devices. With Gson, the fix shows which classes are involved, so we know which code to look for in the app. When an advisory gives only a version range, there is more to find, and those entries are more likely to stay under investigation. You can ask for the VEX on its own, or as part of our CRA testing for mobile apps.

Does a VEX make the OWASP MASTG test pass?

Not as the test is worded. If a customer asks you for OWASP Mobile Application Security (MAS), the long list from your scanner is exactly what the MAS test checks. The app must use only components without known vulnerabilities (control MASVS-CODE-3 in the standard, MASVS v2.1.0 of 18 January 2024). The test for that control runs the SBOM through a vulnerability scanner, such as Dependency-Track, and fails if any dependency has a known vulnerability (MASTG-TEST-0274, in the testing guide, MASTG v2.0.0 of 30 June 2026). The test does not ask whether the vulnerability can be exploited in the app, so the VEX goes next to the MASTG report and tells the reader which of those failures can hurt your app.

What does a real VEX look like?

To show the whole path on an app anyone can rebuild, we took OWASP’s test app and added OkHttp 4.9.1, the vulnerable library of demo MASTG-DEMO-0050, then built it as the MASTG demos are built: a debug build, with R8 off. We generated the SBOM from Gradle to show the list a typical scan starts from. Gradle listed 239 components across 27 configurations, and on 27 October 2026 OSV, Google’s open source vulnerability database, matched 8 CVEs in 7 of them.

Six of those CVEs, in Guava, Bouncy Castle, Apache Commons Lang and Apache HttpClient, should not have been on the list. Those libraries belong to Android lint, the code checker that runs on the developer’s or the CI machine, and the APK contains none of the classes those CVEs affect. They got onto the list because the components came from every Gradle configuration. An SBOM built from the release runtime classpath leaves them out, and one extracted from the APK never lists them. In the VEX they are false_positive. CSAF, which has no such status, would record them as known_not_affected with component_not_present.

The other two, CVE-2021-0341 in OkHttp and CVE-2023-3635 in Okio, are in the APK, because the debug build ships both libraries whole. In the bytecode, only classes from those two libraries refer to them. Other apps can still run some code in OkHttp and Okio, by two paths. First, this debug build exports Compose’s PreviewActivity, a developer tool that loads any class named in an intent extra. Second, Okio’s ByteString is Serializable, which matters on Android 10 to 12: those are the versions the test app supports among the ones where the framework deserializes intent extras. Neither path runs the vulnerable code: the hostname check in OkHostnameVerifier and reads through GzipSource.

We then ran the app in Chameleon on Android 16 through its only flow, the Start button, sent it to the background and brought it back, and listed the classes it had loaded: 28 of its own and none from OkHttp or Okio. The Android 10 to 12 path rests on the static analysis, and here that is enough, because deserializing a ByteString runs neither the hostname check nor GzipSource. With Gson the static analysis would not be enough, since the classes that get deserialized there are the vulnerable code. So both entries in the VEX are not_affected with code_not_reachable, and each detail records the static check and the test.

A release build would give a different VEX. It drops PreviewActivity, and with R8 on, the classes of both libraries would be removed, so the entries would become code_not_present. In an app that does make HTTP calls with OkHttp, these two CVEs would need the full analysis.

None of the eight CVEs affects the app, but the reason depends on where the code is and on the build:

CVEs Where the vulnerable code is VEX state
Six, in Guava, Bouncy Castle, Apache Commons Lang and Apache HttpClient Only in Android lint, on the developer’s or the CI machine. The APK contains none of the affected classes. false_positive
CVE-2021-0341 in OkHttp and CVE-2023-3635 in Okio, debug build In the APK, but no path reaches the hostname check in OkHostnameVerifier or reads through GzipSource not_affected with code_not_reachable
The same two, release build with R8 on Removed from the APK not_affected with code_not_present

You can download the VEX for this build, a CycloneDX JSON file that any text editor opens, and check it with the questions at the end of this article.

What does the CRA say about CVEs that cannot be exploited?

The EU Cyber Resilience Act (CRA) applies if your app is on the EU market as part of your business, paid or free. On known vulnerabilities, its bar is lower than MASVS-CODE-3: from 11 December 2027, and on the basis of your risk assessment, the app must be made available without known exploitable vulnerabilities (Annex I, Part I, point (2)(a)). You are expected to investigate each reported vulnerability and confirm whether it applies to your product (the Commission’s guidance, point 235). Your VEX records that investigation, with a status for each CVE and the evidence behind it. Our OWASP MASTG for CRA compliance article shows where the VEX sits among the rest of the CRA evidence.

Since 11 September 2026 you also have to report vulnerabilities that are actively exploited in your product (Article 14(1)). The fictional Gson entry above is neither exploitable nor exploited in the shopping app. It is therefore not reportable (the guidance, point 218), but you still handle it under the vulnerability handling rules of Annex I, Part II, which ask you to address and remediate vulnerabilities without delay, in relation to the risks they pose. If you find a vulnerability yourself in a component, you also have to report it to whoever makes or maintains that component (Article 13(6)).

Five questions to ask of any VEX

Use these questions on any VEX you receive, from an SDK vendor, a testing provider or your own team:

  1. Which build does it cover? A VEX is about one version of the app. Check that the product and version in it match the build you ship, and ask for a new one with each release and whenever a new CVE hits a component of a build you still ship.
  2. Which SBOM was it checked against? Ask whether that SBOM was compared with the APK (or the IPA, if the VEX covers iOS), and what differed.
  3. How was each “not affected” entry established? Look for a justification and a detail that names the method: code absent from the binary, no path in the code, the entry points tested and the date.
  4. What should you do about each “affected” entry? Each one needs an action: a fixed version, a workaround or mitigation, or a statement that no fix is available yet or none is planned.
  5. When will the open entries be closed? For anything still under investigation, ask what is missing and when the test will be repeated, and decide meanwhile whether updating is cheaper than waiting.

If you already have an SBOM scan, tell us which app and build it covered. You get back a VEX for that build, with a status for each CVE and the evidence behind it, like the sample for OWASP’s test app. If you have no SBOM yet, send us the build: we extract the SBOM from the APK or IPA and write the VEX from there.

References

Portrait of Javier Tallón

Javier Tallón

Co-Founder & CBDO

LinkedIn · View all posts

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