Yu Bao

A flaw was found in RESTEasy's default exception mapper. When an unhandled exception other than a WebApplicationException is not handled by an application exception mapper, RESTEasy returns the exception's localized message in the HTTP 500 response body. A remote unauthenticated attacker who can trigger such an exception may obtain information contained in that message. The behavior was reproduced with RESTEasy 7.0.2.Final.

An uncontrolled recursion flaw exists in the Java bindings of Apache Thrift. Uncontrolled recursion occurs when a program calls itself repeatedly without a proper termination condition, which can lead to a stack overflow and cause the application to crash.

An uncontrolled resource allocation issue exists in the `unflatten()` function. Attackers can provide flattened keys containing unbounded numeric values, such as a.4294967294, to create massive sparse arrays. This can lead to the Node.js event loop being blocked during operations like `forEach`, spread, or `JSON.stringify`.

A type confusion issue exists where code in one class loader can substitute objects into another. This occurs because a shared ObjenesisStd instance caches instantiators using the `clazz.getName()` method within the `getInstantiatorOf()` function. When classes with the same name are used across different class loaders, they collide, leading the `newInstance()` function to return objects of the wrong class and resulting in ClassCastException failures.

Validation of an MLS (RFC 9420) external commit's proposal list in the `validateExternalCachedProposals()` function of `org.bouncycastle.mls.protocol.Group` failed to verify that a removed leaf was associated with the joiner. While RFC 9420 allows a joiner to remove an old version of themselves via a Remove proposal, the implementation did not ensure the LeafNode met the necessary credential criteria for the removed participant. Consequently, any party with the group's public GroupInfo could submit a Remove proposal specifying any member's `LeafIndex`, allowing them to evict that member and occupy their slot in the ratchet tree. This issue affected callers of the `Group.externalJoin` and `Group.handle` APIs, as the required credential check was only present in the gRPC interop harness.

Opt-in key-size validation for CMS key-transport recipients fails to execute for messages using RFC 9709 content-encryption key derivation (`id-alg-cek-hkdf-sha256`). This occurs because the system incorrectly compares an encrypted-key byte array against an `ASN1ObjectIdentifier`, resulting in a failed check that bypasses the key-size lookup. Consequently, `EnvelopedData` or `AuthEnvelopedData` with an HKDF-derived content-encryption key that does not match the advertised algorithm's key size is accepted, even when validation is enabled via the `setKeySizeValidation(true)` method in the `org.bouncycastle.cms.jcajce.JceKeyTransRecipient` class. This effectively disables the API mechanism for enforcing recovered key size for these specific messages.

Both `org.bouncycastle.pkix.jcajce.PKIXCertPathReviewer` and the legacy `org.bouncycastle.x509.PKIXCertPathReviewer` fail to apply X.509 name constraints to the end-entity certificate. This occurs because the `checkNameConstraints()` function processes the certificate path using a loop bound that excludes index zero, which represents the target certificate. Consequently, permitted and excluded subtree checks are not performed against the leaf certificate's subject DN or its subjectAltName. This allows a certificate chain to be validated as true even if the leaf violates name constraints imposed by its issuing CA, potentially leading an application to accept a certificate that the CA was not authorized to issue.

Several password-based key derivation function (KDF) entry points process cost parameters from untrusted input without proper bounding. This allows a small input to trigger an excessive amount of computational work before any password or integrity check can reject the request. The affected paths include the RFC 9579 PBMAC1 MAC calculator builders, which use the PBKDF2 iteration count and derived-key length from `PBMAC1Params` via `JcePBMac1CalculatorBuilder` and `PKCS12PBEUtils.createPBMac1Calculator` (accessed from `PKCS12PfxPdu.isMacValid`). Additionally, the scrypt parallelization parameter `p` in PKCS#8 and PKCS#12 cost guards is not bounded, allowing the memory ceiling to be bypassed since the scratch buffer scales with `r` times `p`. Other affected components include the raw JCA PBKDF2 provider (`org.bouncycastle.jcajce.provider.symmetric.PBEPBKDF2`) and the bcrypt round count read from encrypted OpenSSH v1 private key `kdfoptions`.

A weakness in the Mailto Header Handler component allows a remote attacker to cause an uncaught exception. This occurs through the manipulation of arguments passed to the `URI.parse()` function within the `src/schemes/mailto.ts` file.

A flaw exists in the `CorsFilter` component. When configured to allow all origins using the "*" wildcard, the filter reflects the request's Origin header in the `Access-Control-Allow-Origin` response while simultaneously setting `Access-Control-Allow-Credentials` to true. This configuration enables a malicious website to perform credentialed cross-origin requests and access authenticated responses from a user's session, leading to a loss of confidentiality.

A flaw exists in the `IIOImageProvider` component that decodes image request bodies without enforcing limits on declared image dimensions or pixel counts. A remote, unauthenticated attacker can send a small, crafted image with enormous declared dimensions to trigger a massive memory allocation. This process exhausts the JVM heap, leading to a denial of service.

A buffer overflow occurs in the `Snappy.compress(ByteBuffer, ByteBuffer)` function when processing incompressible data that exceeds the remaining capacity of the destination buffer. This allows the process to write past the end of the buffer, leading to off-heap memory corruption and JVM termination, which can result in a Denial of Service (DoS) when untrusted data is compressed into fixed-size direct buffers.

A buffer overflow exists in typed `Snappy.uncompress*Array` methods. The issue occurs because output arrays are allocated by dividing the uncompressed length by the element size, but the undivided length is passed to the native code. An attacker providing malicious compressed input can cause misaligned length values, leading to writes past array bounds and corruption of heap memory.

A remote attack can trigger a use after free condition within the Dictionary Sharing component. This issue occurs in the `ZstdCompressCtx.loadDict()` function located in the `ZstdCompressCtx.java` file. Use after free is a memory corruption issue where an application continues to use a pointer after it has been freed, which can lead to crashes or arbitrary code execution.

A security flaw exists in the `getRevokedKeys()` function within the `src/main/java/com/jcraft/jsch/KnownHosts.java` file. A remote attacker can manipulate the `known hosts` argument to cause an improper check for certificate revocation. This attack is characterized by high complexity and is difficult to exploit.

Local manipulation of the `recordDetectedPause()` function within the `PauseDetector` component can lead to memory corruption. This issue occurs in the file src/main/java/org/LatencyUtils/LatencyStats.java.

The default consent page renders user-controlled values without HTML entity encoding. When using the `DefaultConsentPage`, an attacker can craft an OAuth2 authorization request containing a malicious value that is stored server-side and subsequently rendered unencoded in the consent page presented to the end user.

The default consent page of the Spring Security Authorization Server renders user-controlled values without applying HTML entity encoding. This lack of encoding can lead to the execution of malicious scripts in the user's browser.

The `UnZipTransformer` does not limit the decompressed entry size or the entry count when processing archives. This allows an attacker to send a specially crafted zip archive, known as a zip-bomb, which can exhaust the JVM heap memory and lead to a denial-of-service outage.

An issue exists where the Reactor Netty HTTP server consumes an excessive amount of memory when a client sends HTTP/1.1 pipelined requests over a single connection. Pipelining is a technique where multiple HTTP requests are sent on a single TCP connection without waiting for the corresponding responses.