Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSupply crafted PKCS#12 PFX or PKCS#8 key
-
DeliveryApplication invokes Pkcs12Store.Load / key derivation
-
ExploitNegative iteration count skips loop exit
-
ExecutionDerivation wraps ~2^32 iterations
-
ImpactCPU exhaustion denial of service
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Loop termination conditions
MITRE ATT&CK
1 technique across 1 tactic: Impact The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | The victim application must call Bouncy Castle bc-csharp (before 2.7.0) code paths that process attacker-controlled input through Pkcs12ParametersGenerator - specifically loading a PKCS#12/PFX file (e.g. Pkcs12Store.Load) or decrypting a PKCS#8 private key that uses a PKCS#12 password-based encryption algorithm. The specific trigger is a MacData (or PBE) iteration count of zero or a negative value, which causes the derivation loop to wrap through ~2^32 iterations before any MAC/password validation. Key LIMITING factors: exploitation requires the application to actually accept and parse untrusted PFX/PKCS#8 data (UI:P / user-interaction-dependent), and impact is confined to CPU/availability exhaustion - there is no code execution, data disclosure, or integrity loss. Services that only process trusted, internally-generated keystores are not realistically exposed. |
| Impact | This is a genuine but bounded availability risk, not a high-severity critical. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:P/VC:N/VI:N/VA:H) scores 7.1 driven entirely by availability impact (VA:H) with zero confidentiality or integrity effect - consistent with a CWE-835 unbounded-loop DoS. The vector requires passive user interaction (UI:P), meaning exploitation depends on the victim application actually loading/parsing an attacker-supplied PKCS#12 (PFX) or PKCS#8 file, so this is not a fully autonomous network worm despite AV:N. No EPSS score, SSVC decision data, KEV listing, or POC was provided in the input, so there is no public exploit identified at time of analysis and no evidence of active exploitation; the practical priority therefore rests on how exposed the affected application's file-parsing path is to untrusted input. The one conflicting signal to verify: AV:N implies network reachability, but the real trigger is processing a malicious file (75-byte PFX with a negative/zero MacData iteration count), so actual reachability is application-specific - a backend service that ingests user-uploaded certificates is at real risk, whereas a library linked but never fed untrusted PFX data is not. Patch is available from the vendor (bc-csharp 2.7.0), which makes remediation straightforward and lowers residual risk. |
| Exploit ScenarioDerived | An attacker uploads a tiny (~75-byte) crafted PFX file, or supplies a PKCS#8 encrypted private key using a PKCS#12 password-based algorithm, to any service that parses it via Bouncy Castle's Pkcs12Store.Load or Pkcs12ParametersGenerator. Because the MacData iteration count is zero or negative, the key-derivation loop wraps through roughly 2^32 iterations before the MAC or password is ever checked, pinning a CPU core for many minutes per file. No public exploit code was provided, but the trigger is trivial to reproduce from the public description and patch diff. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 02, 2026
Uncontrolled CPU consumption in Legion of the Bouncy Castle Inc.'s bc-csharp library before 2.7.0 lets an attacker who can supply a crafted PKCS#12 (PFX) file, or a PKCS#8 encrypted private key that uses a PKCS#12 password-based encryption algorithm, pin a CPU core for minutes at a time. The root cause is CWE-835, a loop with an unreachable exit condition: the PKCS#12 key-derivation loop in Pkcs12ParametersGenerator compared its counter with '!=' rather than '<', so an iteration count of zero or a negative value caused roughly 2^32 iterations to run before the MAC or password could ever be validated; a 75-byte PFX with a negative MacData iteration count kept Pkcs12Store.Load busy for many minutes. The impact is availability-only (CVSS 4.0 7.1, AV:N/AC:L/PR:N/UI:P, VA:H, with no confidentiality or integrity effect), so the flaw is an unauthenticated denial of service that depends on the victim application actually parsing attacker-controlled keystore data; only services that accept untrusted PFX/PKCS#8 input are realistically exposed, and no public exploit code was identified at time of analysis.
RemediationAI
Upgrade to bc-csharp 2.7.0 or later - Vendor-released patch: 2.7.0, incorporating upstream commits 0c7a6dfd64c4a479577e35a728a766721b79aba7 and 7c0ed15f9783c9595b1a53f3900136461fd944f4, which change the derivation loop condition from 'j != mIterationCount' to 'j < mIterationCount' so zero or negative iteration counts no longer loop ~2^32 times; see the vendor advisory at https://github.com/bcgit/bc-csharp/wiki/CVE-2026-63575. Until the dependency can be updated, the most effective compensating control is to reject or pre-screen keystore input: validate that the MacData and PBE iteration counts in any untrusted PFX/PKCS#8 blob are positive and within a sane upper bound (for example, matching the highest value your legitimate keystores use) before handing the bytes to Pkcs12Store.Load or to PKCS#8 decryption - the trade-off is that a bound set too low will reject legitimately hardened keystores, and parsing the counts yourself means handling ASN.1 structures defensively. Because the flaw is pure CPU exhaustion, running keystore parsing in a process with a hard CPU/time budget (cancellation token or watchdog that aborts after a few seconds, or a resource-limited sandbox/container) contains the impact; the trade-off is that very high but legitimate iteration counts may occasionally be aborted on slow hardware. Where untrusted keystore upload or import is not a required feature, disable that endpoint or restrict it to authenticated, trusted clients - and rate-limit such endpoints so a single 75-byte payload cannot repeatedly occupy a worker thread.
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
bc-csharp is the .NET/C
port of the Bouncy Castle cryptography library, and the vulnerable component is Pkcs12ParametersGenerator, which implements the PKCS#12 password-based key derivation function (RFC 7292, Appendix B) used to derive keys and IVs from a password plus salt and iteration count. That KDF is invoked both when verifying the integrity MAC of a PKCS#12/PFX container (the MacData structure carries the iteration count) and when decrypting PKCS#8 EncryptedPrivateKeyInfo blobs that specify PKCS#12 PBE schemes such as pbeWithSHAAnd3KeyTripleDES-CBC or pbeWithSHAAnd40BitRC2-CBC. In GenerateDerivedKey the per-iteration loop was written as 'for (int j = 1; j != mIterationCount; j++)'; with an attacker-chosen iteration count of 0 or any negative number the equality test can never be satisfied legitimately, so the counter increments and wraps through roughly 2^32 iterations before terminating, burning CPU with no cryptographic progress and leaving the subsequent MAC or password check unreached. The upstream fix (commits 0c7a6dfd64c4a479577e35a728a766721b79aba7 and 7c0ed15f9783c9595b1a53f3900136461fd944f4) is the one-character class of correction 'for (int j = 1; j < mIterationCount; j++)', which makes non-positive counts fall through the loop immediately; note that this is a logic/loop-condition defect (CWE-835), not a memory-safety or cryptographic-strength weakness, and the underlying cryptographic primitive remains sound.
Know when Bc Csharp 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:N/PR:N/UI:P/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
Unauthenticated (PR:N) but requires the app to process an attacker-supplied file (UI:R); impact is pure CPU-exhaustion DoS, so C:N/I:N and A:H.
Primary rating from Vendor (bcorg).
CVSS VectorVendor: bcorg
DescriptionCVE.org
Loop with unreachable exit condition in the PKCS#12 key derivation (Pkcs12ParametersGenerator) in Legion of the Bouncy Castle Inc. bc-csharp before 2.7.0 allows an attacker who can supply a PKCS#12 (PFX) file, or a PKCS#8 encrypted private key that uses a PKCS#12 password-based encryption algorithm, to cause a denial of service through CPU exhaustion via an iteration count of zero or below, because the derivation loop ran until its counter equalled the count, so for such a count it wrapped through about 2^32 iterations before the MAC or the password could be checked. A 75-byte PFX file with a negative MacData iteration count kept Pkcs12Store.Load busy for many minutes.
Executive ViewAI
A high-severity flaw in the Bouncy Castle bc-csharp cryptography library (all versions before 2.7.0) lets an unauthenticated attacker pin a CPU core on a target system for minutes at a time simply by supplying a malformed PKCS#12 or encrypted PKCS#8 keystore file. Only organizations whose applications actually accept keystore or certificate data from untrusted sources are exposed, so the practical blast radius is narrower than the headline severity suggests, but those that are exposed face a cheap, repeatable service-disruption vector. Leadership should care because the risk is concentrated in certificate-onboarding, keystore-upload, and file-processing workflows that are typically internet-facing, and the effect is availability loss rather than any data compromise.
Apply vendor patch.
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
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Crafted small-order or out-of-range Diffie-Hellman values passed to DHAgreement.CalculateAgreement in Bouncy Castle C# (
Memory exhaustion in Bouncy Castle C# (bc-csharp) before 2.7.0 allows a remote, unauthenticated attacker to cause a deni
Memory-exhaustion denial of service in the C# DTLS implementation of Bouncy Castle (bc-csharp) before 2.7.0 lets a remot
Denial of service in Legion of the Bouncy Castle's C# cryptography library (bc-csharp) before 2.7.0 lets an unauthentica
Uncontrolled recursion in Bouncy Castle C# (bc-csharp) before 2.7.0 allows unauthenticated remote attackers to crash or
Denial of service in Legion of the Bouncy Castle Inc. bc-csharp before 2.7.0 allows unauthenticated remote attackers to
Denial of service in the Legion of the Bouncy Castle C# library (bc-csharp) affects all versions before 2.7.0, where qua
Authentication-tag forgery in Legion of the Bouncy Castle Inc. bc-csharp (Bouncy Castle C#) before 2.7.0 lets a remote,
Forged X.509 attribute certificates are accepted as valid by Legion of the Bouncy Castle Inc. bc-csharp versions before
Observable padding discrepancy in the IES/ECIES decryption path of Bouncy Castle C# (bc-csharp) before 2.7.0 lets an una
RSA PKCS#1 v1.5 key transport in the Bouncy Castle C# (bc-csharp) CMS implementation before 2.7.0 is vulnerable to a Ble
Information disclosure in Bouncy Castle C# (bc-csharp) versions before 2.7.0 allows unauthenticated remote attackers to
EUVD-2026-91226
GHSA-7c84-x75c-5j8m
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB