Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify application accepting memoable SHA3/SHAKE state on ARM
-
DeliveryCraft malicious serialized SHA3/SHAKE state blob
-
ExploitDeliver crafted payload to application input surface
-
ExecutionTrigger out-of-bounds write in native ARM SHA3/SHAKE code
-
ImpactAccess corrupted adjacent memory to achieve confidentiality impact
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, write limits
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires all of the following conditions to be met simultaneously: the application must be running on ARM hardware, as the flaw is in ARM-specific native C code and does not affect other architectures; the application must be using BC-LTS bcprov-lts8on versions 2.73.0 through 2.73.12.0; and the application must be explicitly accepting and restoring memoable SHA3 or SHAKE cryptographic state from a source that an attacker controls or can influence, such as user-supplied bytes, external API payloads, or deserialized input. The CVSS 4.0 vector rates complexity as High (AC:H) with specific precondition requirements (AT:P) and required active interaction (UI:A), confirming that exploitation is not trivial even when all conditions are present. Applications using BC-LTS only for conventional SHA3/SHAKE hashing without memoable state, or that restore state exclusively from internally-generated, trusted sources, are entirely unexposed. Non-ARM deployments are not vulnerable under any configuration. |
| Impact | The CVSS 4.0 base score of 1.7, combined with the supplemental E:U (exploitation unreported), accurately conveys that real-world risk is very narrow despite the High confidentiality impact metric. The attack vector is local (AV:L), attack complexity is high (AC:H), specific attack target preconditions apply (AT:P), and active user or operator interaction is required (UI:A) - collectively meaning exploitation demands ARM hardware, a specific BC-LTS version, and an application that explicitly exposes memoable SHA3/SHAKE state restoration to attacker-controlled input. The VC:H rating is notable for a CWE-787 write flaw, as out-of-bounds writes more typically manifest as integrity or availability impacts rather than confidentiality; this may reflect adjacent-memory read potential through a write-then-read exploitation chain, but this mechanism is not confirmed from available data and should be verified against the vendor advisory. No EPSS score was provided in the input data. No CISA KEV listing and no public exploit code exist at time of analysis. The supplemental S:P (provider urgency: Amber) indicates the vendor considers this a real but non-emergency concern, consistent with a meaningful but tightly scoped vulnerability requiring upgrade rather than immediate incident response. |
| Exploit ScenarioDerived | An attacker who can supply a crafted memoable SHA3/SHAKE state blob to a Java application using BC-LTS on ARM - for example, through a file upload endpoint, a deserialization flow, or an API that accepts externally-provided cryptographic state - could trigger the out-of-bounds write in the native C layer. Given the high complexity and multiple required preconditions, exploitation would require application-level research to identify a viable input path that reaches the memoable state restoration logic. No public proof-of-concept code exists at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jul 16, 2026
Out-of-bounds write in Bouncy Castle BC-LTS bcprov-lts8on affects ARM deployments running versions 2.73.0 through 2.73.12.0, with high confidentiality impact if successfully exploited. The flaw resides in ARM-specific native C implementations of SHA3 and SHAKE algorithms and is only triggered when an application accepts memoable SHA3/SHAKE cryptographic states from potentially untrusted external sources. No public exploit code exists and no active exploitation has been confirmed at time of analysis; the CVSS 4.0 score of 1.7 reflects the very narrow exploitation conditions required to reach this code path.
RemediationAI
The primary remediation is to upgrade BC-LTS bcprov-lts8on to version 2.73.12.1 or later, which resolves the out-of-bounds write in the ARM SHA3/SHAKE native code. Full upgrade guidance is available in the vendor advisory at https://github.com/bcgit/bc-lts-java/wiki/CVE-2026-15997. If immediate upgrade is not feasible, the most effective and targeted compensating control is to audit application code and ensure that no SHA3/SHAKE memoable state objects sourced from untrusted or externally-controlled inputs are accepted or processed - the CVE description explicitly limits exposure to this code path. Applications that use BC-LTS SHA3/SHAKE only for standard hashing (not memoable state save/restore), or that only restore state from internally-trusted sources, are not exposed regardless of the deployed version. Restricting or removing the API surface that accepts encoded SHA3/SHAKE state from untrusted callers carries minimal functional trade-off for most deployments and is a well-scoped, low-risk interim measure until the patch can be applied.
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
The vulnerability exists in native ARM C code within the BC-LTS Java cryptography library, specifically in native_c/arm/sha/shake.c and native_c/arm/sha/sha3.c. These files provide ARM-optimized implementations of the SHA-3 family of hash functions, including SHAKE128 and SHAKE256 extendable-output functions. The root cause is CWE-787 (Out-of-Bounds Write), a memory safety flaw where data is written beyond the bounds of an allocated buffer. The SHA3/SHAKE implementation in BC-LTS supports a 'memoable' state interface - a mechanism to serialize and restore the internal cryptographic state of a running hash operation. If a maliciously crafted state blob is supplied to the restore path on an ARM host, the native layer can write outside its allocated buffer, potentially corrupting adjacent memory in a way that results in confidentiality compromise of adjacent data. The affected CPE is cpe:2.3:a:legion_of_the_bouncy_castle_inc.:bc-lts:*:*:*:*:*:*:*:*. Non-ARM platforms use separate code paths and are not affected.
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:L/AC:H/AT:P/PR:N/UI:A/VC:H/VI:N/VA:N/SC:N/SI:N/SA:N/E:U/S:P/AU:N/R:A/V:D/RE:M/U:Amber
Local vector and high complexity reflect ARM-only native code path and mandatory memoable-state feature exposure; no integrity or availability impact is asserted; confidentiality impact aligns with official CVSS 4.0 VC:H rating.
Primary rating from Vendor (bcorg).
CVSS VectorVendor: bcorg
Lifecycle Timeline
1DescriptionCVE.org
Out-of-bounds write vulnerability in Legion of the Bouncy Castle Inc. BC-LTS bcprov-lts8on on ARM allows Overflow Buffers.
This vulnerability is associated with program files https://github.Com/bcgit/bc-lts-java/blob/main/native_c/arm/sha/shake.C, https://github.Com/bcgit/bc-lts-java/blob/main/native_c/arm/sha/sha3.C.
This issue affects BC-LTS: from 2.73.0 before 2.73.12.1.
Issue is only applicable if application involved is accepting memoable SHA3 / SHAKE states from potentially untrusted sources.
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
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.
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-45068
GHSA-hcmw-xv23-7hqq
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB