Inefficient algorithmic complexity in X.509 distinguished name string conversion (X509Name.ToString and IetfUtilities.ValueToString) in Legion of the Bouncy Castle Inc. bc-csharp before 2.7.0 allows a remote unauthenticated attacker to cause a denial of service through CPU exhaustion via a certificate, CRL, certification request or other structure whose name contains a long attribute value made up of characters that must be escaped, such as commas, or of leading or trailing spaces, because each escaping backslash was inserted into the buffer being scanned, so the work grew quadratically with the length of the value. Applications are exposed when they convert such a name to a string, for example to log or display it, or compare it with IetfUtilities.RdnAreEqual, as PKIX path validation does for directoryName name constraints.
Memory allocation with excessive size value in the HSS/LMS signature code (HssPublicKeyParameters, HssSignature) in Legion of the Bouncy Castle Inc. bc-csharp before 2.7.0 allows a remote unauthenticated attacker who can supply both an HSS public key and a signature to cause a denial of service through memory exhaustion via a public key encoding with an excessive level count, because the level count L read when parsing an HSS public key was not checked against the RFC 8554 maximum of 8, and signature parsing then allocated an array of L - 1 entries before reading any further signature data. A single verification can commit up to about 17 GB of memory or fail with an OutOfMemoryException.
Improper certificate validation in PkixNameConstraintValidator in Legion of the Bouncy Castle Inc. bc-csharp before 2.7.0 allows an attacker who controls, or can obtain certificates from, a name-constrained intermediate CA to have certificates accepted during PKIX certification path validation for email addresses, DNS names or URI hosts that lie within excluded subtrees applying to that CA, via an rfc822Name, dNSName or uniformResourceIdentifier name whose host ends with a dot, because names and constraints were compared without first removing the RFC 1034 root-label trailing dot, so a fully qualified host name did not match an excluded subtree for the same host written without the dot.
Release of unverified plaintext in the CCM (CcmBlockCipher) and DSTU 7624 CCM (KCcmBlockCipher) AEAD modes in Legion of the Bouncy Castle Inc. bc-csharp before 2.7.0 allows a remote attacker to obtain decryptions of ciphertexts of their choosing via forged messages sent to an application that lets the output buffer of a failed decryption be observed, for example through buffer reuse or logging, because decryption wrote the recovered plaintext into the caller-supplied output buffer before checking the authentication tag and left it there when the check failed. Only decryption into a caller-supplied buffer is affected; methods that return a newly allocated array are not.
Uncontrolled recursion in the ASN.1 parser (Asn1InputStream, Asn1StreamParser) in Legion of the Bouncy Castle Inc. bc-csharp before 2.7.0 allows a remote unauthenticated attacker to cause a denial of service via a crafted ASN.1 encoding of deeply nested constructed elements (for example SEQUENCE inside SEQUENCE, in definite-length DER or indefinite-length BER form), because each nesting level is parsed by a further recursive call with no bound on depth. About 2,000 levels (8 KB of DER) are enough to exhaust a 1.5 MB thread stack, the .NET main-thread default on Windows, and raise a StackOverflowException, which .NET cannot catch and which terminates the whole process; on threads with larger stacks, parse time instead grows quadratically with depth (about 9 seconds of CPU for a 64 KB input). Any path that parses untrusted ASN.1 is exposed, including X.509 certificates and CRLs, CMS/PKCS#7, PKCS#8/PKCS#12, OCSP and TLS Certificate messages.
CVE-2026-63578 is a resource exhaustion vulnerability in the Legion of the Bouncy Castle Inc. bc-csharp library before version 2.7.0. It occurs in the password-based private-key decryption function (PbeUtilities.GenerateCipherParameters) where an attacker can supply an encrypted private key with an iteration count near 2^31. This count is taken from unauthenticated algorithm parameters without an upper bound, causing excessive CPU consumption and denial of service. The vulnerability affects PKCS#5 PBES1 and PBES2 (PBKDF2), PKCS#12 PBE algorithms, and CMS password recipients. The issue is fixed in version 2.7.0.
CVE-2026-63577 is a high-severity vulnerability in Legion of the Bouncy Castle Inc.'s bc-csharp library before version 2.7.0. It involves improper certificate validation in the directoryName name-constraint check during PKIX path validation. An attacker controlling or having certificates issued by a name-constrained intermediate CA can bypass constraints by manipulating the subject distinguished name or directoryName subjectAltName. This occurs because the validation incorrectly searches for the constraint's first RDN anywhere in the name rather than requiring it as an initial prefix, violating RFC 5280 requirements. The issue is fixed in version 2.7.0.
CVE-2026-63576 is a high-severity vulnerability in Legion of the Bouncy Castle Inc.'s bc-csharp library before version 2.7.0. It involves improper certificate validation in the PkixNameConstraintValidator component, specifically in the ExtractHostFromURL function. The flaw allows a name-constrained subordinate CA or an attacker with certificates containing crafted subjectAltName URIs to bypass URI name constraints during certification path validation. This occurs because the host extraction logic uses string slicing without properly isolating the RFC 3986 authority component, leading to incorrect host comparisons when URIs contain characters like '@' or ':'. The issue is fixed in version 2.7.0.
CVE-2026-63575 is a high-severity vulnerability in Legion of the Bouncy Castle Inc.'s bc-csharp library before version 2.7.0. It involves an infinite loop in the PKCS#12 key derivation process (Pkcs12ParametersGenerator) triggered by an iteration count of zero or below. An attacker supplying a crafted PKCS#12 (PFX) file or PKCS#8 encrypted private key with a negative or zero iteration count can cause CPU exhaustion, resulting in a denial of service. The loop counter wraps around causing approximately 2^32 iterations before the password or MAC is checked, significantly delaying processing. This affects versions from 0 up to but not including 2.7.0.
CVE-2026-63574 is a high-severity vulnerability in Legion of the Bouncy Castle Inc.'s bc-csharp library before version 2.7.0. It involves memory allocation with an excessive size value in the OpenPGP signature and user attribute subpacket parsers. An unauthenticated remote attacker can supply a crafted OpenPGP public key, certificate, or signature that triggers a denial of service by causing an OutOfMemoryException or memory exhaustion during parsing. This occurs because the parser uses the declared length from a subpacket header to allocate memory without upper bounds or validation against the enclosing packet size, potentially requesting up to about 2 GB of memory. The vulnerability affects all versions from 0 up to but not including 2.7.0.
CVE-2026-63573 is a high-severity vulnerability in Legion of the Bouncy Castle Inc.'s bc-csharp library before version 2.7.0. It involves an observable discrepancy in the CMS RSA PKCS#1 v1.5 key-transport unwrap process. This discrepancy allows a remote attacker, who can submit many modified CMS EnvelopedData messages to an application using the vulnerable library, to perform a Bleichenbacher-style adaptive chosen-ciphertext attack. The attacker can recover the content-encryption key of a captured message by distinguishing between different error messages during decryption, thus potentially decrypting the message content.
CVE-2026-63572 is a high-severity vulnerability in Legion of the Bouncy Castle Inc.'s bc-csharp library before version 2.7.0. It involves allocation of resources without limits during PKCS#12 keystore loading, allowing an attacker to cause denial of service via CPU exhaustion by supplying a specially crafted PKCS#12 file with a very high iteration count. This iteration count is used in key derivation before password verification, leading to excessive CPU usage. The vulnerability affects the Pkcs12Store.Load method and Pkcs12Utilities.ConvertToDefiniteLength. Versions from 0 up to but not including 2.7.0 are affected.
CVE-2026-63571 is a high-severity vulnerability in Legion of the Bouncy Castle Inc.'s bc-csharp library before version 2.7.0. It involves improper verification of cryptographic signatures in the attribute certificate path validator, allowing a remote attacker to forge X.509 attribute certificates. This flaw permits acceptance of forged certificates that name a trusted attribute authority as issuer but are not actually signed by it. Only applications using these specific classes for attribute certificate validation are affected.
CVE-2026-63570 is a high-severity vulnerability in Legion of the Bouncy Castle Inc.'s bc-csharp library before version 2.7.0. It involves an infinite loop in the Pkcs12Store.GetCertificateChain method when processing crafted PKCS#12 files containing certificate chains with cyclic issuer links. This causes a denial of service by consuming CPU and memory until an OutOfMemoryException occurs.
CVE-2026-63569 is a critical improper input validation vulnerability in the DHAgreement.CalculateAgreement method of Legion of the Bouncy Castle Inc.'s bc-csharp library before version 2.7.0. It allows an attacker who can intercept or act as a peer in the Diffie-Hellman key agreement to force the local party to compute a known agreed value, bypassing key authentication. Additionally, the attacker can learn partial information about the local static private key and potentially recover it entirely in certain group conditions. This flaw arises from missing range and subgroup-membership checks on ephemeral values used in the key agreement. Only applications directly invoking DHAgreement are affected. The issue is fixed in version 2.7.0.
Allocation of resources without limits or throttling in the CMP/CRMF password-based MAC verifier (PKMacBuilder) in Legion of the Bouncy Castle Inc. bc-csharp before 2.7.0 allows a remote unauthenticated attacker to cause a denial of service through CPU exhaustion via a CMP message or CRMF certificate request whose PBMParameter declares a very large iteration count, because PKMacBuilder enforced its iteration-count ceiling only when the caller had supplied an explicit maximum through the PKMacBuilder(IPKMacPrimitivesProvider, int) constructor. With any other constructor, ProtectedPkiMessage.Verify and CertificateRequestMessage.IsValidSigningKeyPop performed as many hash iterations as the sender requested, up to about 2^31, before the MAC could be checked.
Observable discrepancy in IesEngine.DecryptBlock in Legion of the Bouncy Castle Inc. bc-csharp before 2.7.0 allows a remote attacker who has captured an IES or ECIES ciphertext, and who can submit modified ciphertexts for decryption under the same key pair, to recover its plaintext via a CBC padding-oracle attack, because in block-cipher mode the engine decrypts the ciphertext and removes its padding before verifying the MAC. A padding failure is therefore reported with a different error message, and without the MAC computation, compared with a MAC failure. Only applications that construct IesEngine directly with a padded block cipher, such as AES in CBC mode with PKCS#7 padding, are affected; stream-mode IES is not.
Memory allocation with excessive size value in the DTLS handshake reassembly (DtlsReliableHandshake, DtlsReassembler) in Legion of the Bouncy Castle Inc. bc-csharp before 2.7.0 allows a remote unauthenticated DTLS peer to cause a denial of service through memory exhaustion via crafted handshake message fragments, because the reassembly buffer for each incoming handshake message was allocated at the 24-bit length declared in the fragment header, without the check against the peer's maximum handshake message size that TLS already applied. A fragment carrying no payload can force an allocation of almost 16 MB, for each of up to 16 pending messages per handshake, before the handshake is authenticated. DTLS servers and DTLS clients are both affected; TLS is not.
Exposure of the message authentication key through the encryption keystream in the stream mode of IesEngine (an IesEngine constructed without a block cipher) in Legion of the Bouncy Castle Inc. bc-csharp before 2.7.0 allows a remote attacker who has observed one encrypted message with known plaintext to forge shorter messages of their choosing that the recipient accepts as authentic, via a crafted ciphertext and MAC tag, because the MAC key was taken from the key derivation output directly after a keystream as long as the message, while the derivation input depends only on the static key pair and fixed parameters. The keystream revealed by that one message therefore contains the MAC key for every sufficiently shorter message.
Missing cryptographic step in the DSTU 7624 CCM mode implementation (KCcmBlockCipher) in Legion of the Bouncy Castle Inc. bc-csharp before 2.7.0 allows an attacker who can observe encrypted messages of known or chosen content to forge ciphertexts with valid authentication tags, via messages encrypted without associated data. The cause is that the G1 block, which binds the nonce, the message length and the parameter flags into the CBC-MAC, was processed only when associated data was present. Without associated data the tag was a CBC-MAC of the plaintext alone, independent of the nonce. Only applications that use KCcmBlockCipher directly and supply no associated data are affected.