Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessApp encrypts in place over key array
-
DeliveryNative cipher releases key via JNI mode 0
-
ExploitKey bytes overwrite produced ciphertext
-
ExecutionApp transmits or stores output believing it is ciphertext
-
ImpactObserver recovers raw AES key from output
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V14 - Data Protection Data exposure prevention
MITRE ATT&CK
2 techniques across 2 tactics: Collection, Discovery The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires all of the following: the application uses the native (not pure-Java) one-shot packet cipher implementations in Bouncy Castle for Java LTS before 2.73.13 for AES-CBC, CCM, CFB, CTR, GCM or GCM-SIV; it performs in-place encryption passing the same Java array as both input and destination buffer, specifically over a secret array such as KeyParameter.getKey(); and it runs on a JVM that returns a copy rather than a pin for JNI GetByteArrayElements. Limiting factors that reduce real-world risk: this in-place-over-the-key pattern is non-default application behavior; bcprov (the standard non-LTS provider) is entirely unaffected as it ships no native code; native streaming modes and all pure-Java packet ciphers are unaffected; and there is no attacker-controlled input or privilege path - the flaw manifests only through the victim application's own usage. |
| Impact | This is a genuine high-severity confidentiality flaw, but one with an unusually narrow and specific trigger that makes it far less broadly exploitable than the 8.2 base score suggests. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:N/VC:H) scores VC:H because the leaked secret is the raw AES key, and AT:P (Attack Requirements: Present) correctly signals that exploitation is not universal - it depends on a specific coding pattern and JVM behavior. No EPSS score, CISA KEV listing, or POC was provided in the intelligence, so this is not confirmed to be actively exploited and there is no public exploit identified at time of analysis. Importantly, this is not a classic attacker-driven network exploit: there is no remote adversary sending a payload. Rather, a vulnerable application silently self-leaks its own symmetric key into output it believes is ciphertext; the 'attacker' is any party who later receives or can read that output. The CVSS AV:N reflects that the leaked key is typically transmitted over a network, not that an attacker reaches in remotely. Net priority: real and serious for the specific affected deployments (native BC-LTS-Java packet ciphers used for in-place encryption over the key array), but low likelihood of mass exploitation because the triggering pattern is non-default and application-specific. |
| Exploit ScenarioDerived | An application using Bouncy Castle for Java LTS native one-shot packet ciphers (e.g. AES-GCM) encrypts a message in place, reusing the same Java byte array as both input and output - for example encrypting over the array returned by KeyParameter.getKey(). Because the native code releases the read-only key array with JNI mode 0, the unchanged key bytes are written back over the freshly produced ciphertext, and the correct output length is still returned with no error. A passive network observer, or anyone able to read the stored/transmitted output, recovers the raw AES key and can decrypt all data protected by it. No public POC was identified in the provided intelligence. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 03, 2026
In-place encryption over a secret key buffer in Bouncy Castle for Java LTS before 2.73.13 can silently replace freshly produced ciphertext with the raw AES key, because native one-shot packet ciphers release read-only input arrays with JNI mode 0 and a later copy-back overwrites the output. The trigger is narrow and application-dependent-it requires the non-default pattern of passing the same Java array as both input and destination (for example, encrypting over KeyParameter.getKey()) on a JVM that copies rather than pins JNI array elements-so real-world exploitability is far lower than the 8.2 base score implies; bcprov, pure-Java packet ciphers, and native streaming modes are unaffected. No public exploit identified at time of analysis.
RemediationAI
Vendor-released patch: upgrade Bouncy Castle for Java LTS to 2.73.13 or later, which releases read-only input arrays with JNI_ABORT and reserves JNI mode 0 for arrays written by native code. If immediate upgrade is not possible, avoid in-place encryption where the same Java array serves as both input and destination-especially do not encrypt over KeyParameter.getKey(); use separate input and output arrays, or switch to the pure-Java packet ciphers, the unaffected native streaming modes, or the bcprov provider for the affected operations. Note that relying on the JVM pinning rather than copying JNI arrays is not a reliable mitigation because it depends on runtime behavior. See the vendor advisory at https://github.com/bcgit/bc-java/wiki/CVE%E2%80%902026%E2%80%9071883 for details.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Bouncy Castle for Java LTS (CPE cpe:2.3:a:legion_of_the_bouncy_castle_inc.:bc-lts-java:*:*:*:*:*:*:*:*) ships native JNI implementations of one-shot AES-CBC, CCM, CFB, CTR, GCM, and GCM-SIV packet ciphers. JNI's ReleaseByteArrayElements with mode 0 instructs the JVM to commit the native buffer back into the Java array after a critical region, whereas JNI_ABORT frees the native buffer without copying back. In the affected versions, arrays passed as read-only input-key, IV, and additional authenticated data-were released with mode 0, and the output buffer was processed through a separate critical region and committed first. On a JVM that returns a copy rather than a pin from GetByteArrayElements, the native copy still holds the original input bytes, so the later mode-0 release of the key array writes the unchanged key back over the Java array. If the application uses that same array as the output destination (in-place encryption over KeyParameter.getKey()), the ciphertext produced moments earlier is replaced by the raw key, while the API still reports the correct output length. The root cause maps to CWE-200 (Exposure of Sensitive Information to an Unauthorized Actor); the patch reserves JNI_ABORT for read-only input arrays and mode 0 only for arrays the native code wrote. The pure-Java packet ciphers and native streaming modes do not perform this in-place read-only release pattern and are not affected, and bcprov ships no native implementations.
Know when Java gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:N/VA:N/SC:N/SI:N/SA:N/U:Amber
AC:H because exploitation depends on a specific in-place-over-key usage pattern plus JVM copy behavior; C:H for raw AES key disclosure; no integrity or availability impact; AV:N as the key is transmitted in output.
Primary rating from Vendor (bcorg).
CVSS VectorVendor: bcorg
Lifecycle Timeline
2DescriptionCVE.org
In Bouncy Castle for Java LTS before 2.73.13, the one-shot native packet ciphers for AES-CBC, CCM, CFB, CTR, GCM and GCM-SIV released the caller's key, IV and additional authenticated data arrays with JNI's ReleaseByteArrayElements in mode 0, which commits the native copy back into the Java array. Those arrays are read-only to the native code, and on a JVM that returns a copy rather than a pin the copy still holds the input bytes as they were read. The output buffer is taken through a separate critical region and committed first, so where an application passed the same Java array as both an input and the destination - encrypting in place over KeyParameter.getKey(), for example - the later mode-0 release of the key wrote the unchanged key bytes over the ciphertext that had just been produced. The call still returned the correct output length, so an application encrypting in place over its own key array was handed the raw AES key where it expected ciphertext, with nothing in the API to indicate it, and would transmit or store the key in place of the message. The read-only input arrays are now released with JNI_ABORT, freeing the native copy without copying it back, and mode 0 is reserved for arrays the native code wrote. The pure-Java packet ciphers and the streaming native modes are not affected. Bouncy Castle for Java (bcprov) is not affected, as it ships no native implementations.
Articles & Coverage 1
Executive ViewAI
Bouncy Castle for Java LTS is a cryptographic library embedded in many of our Java applications and third-party products, and versions before 2.73.13 can, under a narrow non-default coding pattern, output a raw AES key where encrypted data was expected - a silent loss of confidentiality rather than a crash or outage. Applications are only exposed if they perform in-place encryption using the same array as input and destination while relying on native one-shot packet ciphers, so the practical exposure is far smaller than the 8.2 base score suggests, but any application that does hit the condition may have written unprotected key material into storage, logs, or network traffic. Leadership should care because the consequence is disclosure of the very secret protecting our encrypted data, and there is currently no vendor-released patch identified.
No vendor-released patch identified at time of analysis. Interim mitigations: eliminate the aliasing pattern by using distinct input and output arrays for all encryption calls; replace native one-shot packet ciphers with pure-Java packet ciphers or native streaming modes, which the advisory states are unaffected; rotate and re-issue any AES keys that may have been passed as the in-place buffer, since raw key material may have been written in place of ciphertext; review and purge stored ciphertext and logs produced by affected code paths; restrict deployment of affected components to non-production until the library is upgraded to 2.73.13 or later when the vendor makes it available. Exploitation status: no public exploit identified at time of analysis.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Oracle Java SE 7 Update 6 and earlier contains multiple sandbox bypass vulnerabilities via the ClassFinder and forName m
Remote code execution in IBM Sterling B2B Integrator, Sterling Integrator, and Tivoli Common Reporting allows unauthenti
Java Runtime Environment sandbox bypass via incorrect image channel verification in 2D component allows remote unauthent
Oracle Java SE JDK/JRE 7 and 6 Update 27 and earlier allows remote code execution with complete system compromise throug
JBoss Seam 2 in Red Hat JBoss EAP 4.3.0 fails to sanitize JBoss Expression Language inputs, allowing remote attackers to
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 update 4 and earlier, 6 up
Multiple vulnerabilities in Oracle Java 7 before Update 11 allow remote attackers to execute arbitrary code by (1) using
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 2 and earlier, 6 Up
The WLS Security component in Oracle WebLogic Server 10.3.6.0, 12.1.2.0, 12.1.3.0, and 12.2.1.0 allows remote attackers
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 7 and earlier allow
Remote unauthenticated attackers can execute arbitrary code on Adobe ColdFusion servers through Java deserialization fla
The ExceptionDelegator component in Apache Struts before 2.2.3.1 interprets parameter values as OGNL expressions during
EUVD-2026-91992
GHSA-f5wg-4mfp-h458
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB