huzaifas-sidhpurwala/security-commit huggingface dataset:
CVE-2025-64506: libpng: LIBPNG heap buffer over-read
Component: libpng
Severity: Moderate
CWE: CWE-125 (Out-of-bounds Read)
CVSS v3: 6.1 (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:H)
Public date: 2025-11-24T23:41:09.207000+00:00

A buffer over read flaw has been discovered in libpng. A heap buffer over-read vulnerability exists in libpng's png_write_image_8bit function when processing 8-bit images through the simplified write API with convert_to_8bit enabled. The vulnerability affects 8-bit grayscale+alpha, RGB/RGBA, and images with incomplete row data. A conditional guard incorrectly allows 8-bit input to enter code expecting 16-bit input, causing reads up to 2 bytes beyond allocated buffer boundaries.

Statement: This vulnerability is rated Moderate for Red Hat products. A heap buffer over-read in libpng's `png_write_image_8bit` function can occur when processing specially crafted 8-bit PNG images. Exploitation requires user interaction, such as opening a malicious PNG file, and could lead to an application level denial of service or information disclosure.

java-*-openjdk-headless packages do not contain libsplashscreen.so, hence are not affected.

Affected upstream versions: >= 1.6.0, < 1.6.51
Fixed upstream versions: v1.6.51
Upstream repository: https://github.com/pnggroup/libpng
Upstream fix commit: 2bd84c019c300b78e811743fbcddb67c9d9bf821
CVE-2025-64518: cyclonedx-core-java: CycloneDX Core (Java): BOM validation is vulnerable to XML External Entity injection
Component: cyclonedx-core-java
Severity: Important
CWE: CWE-611 (Improper Restriction of XML External Entity Reference)
CVSS v3: 7.5 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N)
Public date: 2025-11-10T22:08:06.229000+00:00

An XML External Entity (XXE) injection vulnerability was found in the CycloneDX Java core library’s XML validation step where the XML Validator was not configured securely. When a specially crafted CycloneDX BOM (XML) is validated, external XML entities can be processed (XXE), allowing an attacker to cause the application to disclose local files or make requests to internal network resources. This can occur when untrusted BOM XML is parsed or validated by the library.

Statement: The flaw has been rated High severity, because a remote attacker could craft a malicious CycloneDX SBOM that, when validated by an affected system, may result in disclosure of sensitive information from local files or internal network resources. Exploitation does not require authentication or user interaction, but it depends on the application accepting and processing untrusted CycloneDX XML input, the environments that automatically ingest SBOMs from external or untrusted sources.

~~~

This issue was introduced in cyclonedx-core-java v2.1.0 via commit https://github.com/CycloneDX/cyclonedx-core-java/commit/162aa594f347b3f612fe0a45071693c3cd398ce9.

This vulnerability is related to, but distinct from, the previously fixed CVE-2024-38374, which addressed a similar XML External Entity (XXE) flaw in the SBOM parsing logic. That earlier fix secured the XML parser but did not cover the separate validation process, leaving this secondary XXE path unprotected. This new CVE closes that remaining gap by securing the XML validator used during schema validation.

~~~
~~~

For rhint-camel-spring-boot-4, the impact is assessed as Low.
The vulnerable component (cyclonedx-core-java) is part of the build-time plugin (cyclonedx-maven-plugin) used to generate SBOM metadata. That plugin runs only during the build, and is not included, shipped, or executed at runtime in the delivered product. Consequently, the vulnerability does not affect runtime behavior or security of deployed instances, and cannot be exploited in customer environments.

~~~

Affected upstream versions: >= 2.1.0, <11.0.1
Fixed upstream versions: cyclonedx-core-java-2.1.0
Upstream repository: https://github.com/CycloneDX/cyclonedx-core-java
Upstream fix commit: 162aa594f347b3f612fe0a45071693c3cd398ce9
CVE-2025-64718: js-yaml: js-yaml prototype pollution in merge
Component: js-yaml
Severity: Moderate
CWE: CWE-1321 (Improperly Controlled Modification of Object Prototype Attributes ('Prototype Pollution'))
CVSS v3: 5.3 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N)
Public date: 2025-11-13T15:32:44.634000+00:00

A prototype pollution flaw has been discovered in the js-yaml npm library. It's possible for an attacker to modify the prototype of the result of a parsed yaml document via prototype pollution (__proto__). All users who parse untrusted yaml documents may be impacted.


Affected upstream versions: >= 4.0.0, < 4.1.1, < 3.14.2
Fixed upstream versions: 4.1.1
Upstream repository: https://github.com/nodeca/js-yaml
Upstream fix commit: 383665ff4248ec2192d1274e934462bb30426879
CVE-2025-64720: libpng: LIBPNG buffer overflow
Component: libpng
Severity: Important
CWE: CWE-125 (Out-of-bounds Read)
CVSS v3: 7.1 (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:H)
Public date: 2025-11-24T23:45:38.315000+00:00

A buffer overflow flaw has been discovered in libpng. An out-of-bounds read vulnerability exists in png_image_read_composite when processing palette images with PNG_FLAG_OPTIMIZE_ALPHA enabled. The palette compositing code in png_init_read_transformations incorrectly applies background compositing during premultiplication, violating the invariant component ≤ alpha × 257 required by the simplified PNG API.

Statement: This vulnerability is rated Important for Red Hat products. An out-of-bounds read in libpng can occur when processing specially crafted palette images with `PNG_FLAG_OPTIMIZE_ALPHA` enabled. Successful exploitation requires a user to process a malicious PNG file, leading to potential application crash or information disclosure.

java-*-openjdk-headless packages do not contain libsplashscreen.so, hence are not affected.

Affected upstream versions: >= 1.6.0, < 1.6.51
Fixed upstream versions: v1.6.51
Upstream repository: https://github.com/pnggroup/libpng
Upstream fix commit: 08da33b4c88cfcd36e5a706558a8d7e0e4773643
CVE-2025-64756: glob: glob: Command Injection Vulnerability via Malicious Filenames
Component: glob
Severity: Important
CWE: CWE-78 (Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection'))
CVSS v3: 7.5 (CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H)
Public date: 2025-11-17T17:29:08.029000+00:00

A flaw was found in glob. This vulnerability allows arbitrary command execution via processing files with malicious names when the glob command-line interface (CLI) is used with the -c/--cmd option, enabling shell metacharacters to trigger command injection.

Statement: This flaw in glob allows arbitrary command execution when the `glob` command-line interface is used with the `-c/--cmd` option to process files with malicious names. The vulnerability is triggered by shell metacharacters in filenames, leading to command injection. The glob CLI tool utilizes the -c option to execute shell commands over the files which matched the searched pattern by using the shell:true parameter when creating the subprocess which will further execute the command informed via '-c' option, this parameter allows the shell meta characters to be used and processed when executing the command. Given that information glob misses to sanitize the file name to eliminate such characters and expressions from the filename, leading to code execution as when performing the shell expansion such characters will be interpreted as shell commands.

To exploit this vulnerability the targeted system should run the glob CLI over a file with a maliciously crafted filename, additionally the attacker needs to have enough permission to create such file or trick the user to download and process the required file with the glob CLI.

This flaw is present in the command line interface of the nodejs-glob package. When the package is used by npm, the command line interface is not used at all, so it cannot be triggered. However, the command line interface implementation is still present on the system, but not directly exposed to the user's $PATH. To reflect this condition, nodejs packages have been rated with a low severity.

Affected upstream versions: >= 10.2.0, < 10.5.0, >= 11.0.0, < 11.1.0
Fixed upstream versions: v11.1.0
Upstream repository: https://github.com/isaacs/node-glob
Upstream fix commit: 47473c046b91c67269df7a66eab782a6c2716146
CVE-2025-65018: libpng: LIBPNG heap buffer overflow
Component: libpng
Severity: Important
CWE: CWE-787 (Out-of-bounds Write)
CVSS v3: 7.1 (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:H/A:H)
Public date: 2025-11-24T23:50:18.294000+00:00

A buffer overflow flaw has been discovered in libpng. There is a heap buffer overflow vulnerability in the libpng simplified API function png_image_finish_read when processing 16-bit interlaced PNGs with 8-bit output format. Attacker-crafted interlaced PNG files cause heap writes beyond allocated buffer bounds.

Statement: This vulnerability is rated Important for Red Hat products. A heap buffer overflow exists in the libpng library's png_image_finish_read function when processing specially crafted 16-bit interlaced PNG images with an 8-bit output format. Successful exploitation requires a user or an automated system to process a malicious PNG file, which could lead to application crashes or arbitrary code execution.

java-*-openjdk-headless packages do not contain libsplashscreen.so, hence are not affected.

Affected upstream versions: >= 1.6.0, < 1.6.51
Fixed upstream versions: v1.6.51
Upstream repository: https://github.com/pnggroup/libpng
Upstream fix commit: 16b5e3823918840aae65c0a6da57c78a5a496a4d
CVE-2025-6545: pbkdf2: pbkdf2 silently returns predictable key material
Component: pbkdf2
Severity: Important
CWE: CWE-20 (Improper Input Validation)
CVSS v3: 8.1 (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H)
Public date: 2025-06-23T18:41:18.771000+00:00

A flaw was found in the npm pbkdf2 library, allowing signature spoofing. When executing in javascript engines other than Nodejs or Nodejs when importing pbkdf2/browser, certain algorithms will silently fail and return invalid data. The return values are predictable, which undermines the security guarantees of the package.

Statement: This flaw is rated important because it causes the pbkdf2 module to quietly return weak or zero-filled keys when certain algorithm names are used incorrectly in browsers or bundled code, this causes the function to silently return a predictable value (such as a zero-filled buffer or uninitialized memory) instead of a securely derived key, completely undermining the confidentiality and integrity of any cryptographic operation where attackers could guess or reuse these keys to access or change protected data.

Affected upstream versions: 3.0.10 <= 3.1.2
Fixed upstream versions: v3.0.10
Upstream repository: https://github.com/browserify/pbkdf2
Upstream fix commit: 9699045c37a07f8319cfb8d44e2ff4252d7a7078
CVE-2025-6547: pbkdf2: pbkdf2 silently returns static keys
Component: pbkdf2
Severity: Important
CWE: CWE-20 (Improper Input Validation)
CVSS v3: 8.1 (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H)
Public date: 2025-06-23T19:00:45.472000+00:00

A flaw was found in the npm pbkdf2 library, allowing signature spoofing. Under specific use cases, pbkdf2 may return static keys. This issue only occurs when running the library on Node.js.

Statement: This vulnerability is rated as an Important severity because a logic flaw was found in the npm pbkdf2 library where the vulnerability, located in the toBuffer method, causes password and salt inputs provided as Uint8Array objects to be silently ignored. This results in the function returning a static, predictable key derived from empty inputs, completely undermining the security guarantees of any feature that relies on the generated key, this allows an attacker to forge signatures, leading to a complete compromise of the application's data confidentiality, integrity, and availability.

Affected upstream versions: >= 1 <=3.1.2
Fixed upstream versions: v3.1.3
Upstream repository: https://github.com/browserify/pbkdf2
Upstream fix commit: e3102a8cd4830a3ac85cd0dd011cc002fdde33bb
CVE-2025-65945: node-jws: auth0/node-jws: Improper signature verification in HS256 algorithm
Component: node-jws
Severity: Important
CWE: CWE-347 (Improper Verification of Cryptographic Signature)
CVSS v3: 7.5 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N)
Public date: 2025-12-04T18:45:37.517000+00:00

A flaw was found in auth0/node-jws. This vulnerability allows improper signature verification via using the HS256 (Hash-based Message Authentication Code using SHA-256) algorithm under specific conditions, where applications use the jws.createVerify() function for HMAC (Keyed-Hash Message Authentication Code) algorithms and user-provided data from the JSON (JavaScript Object Notation) Web Signature protected header or payload in HMAC secret lookup routines.


Affected upstream versions: < 3.2.3, >= 4.0.0, <= 4.0.1
Fixed upstream versions: v4.0.1
Upstream repository: https://github.com/auth0/node-jws
Upstream fix commit: 34c45b2c04434f925b638de6a061de9339c0ea2e
CVE-2025-66031: node-forge: node-forge ASN.1 Unbounded Recursion
Component: node-forge
Severity: Moderate
CWE: CWE-674 (Uncontrolled Recursion)
CVSS v3: 5.3 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L)
Public date: 2025-11-26T22:23:26.013000+00:00

An ASN.1 Denial of Service (Dos) vulnerability exists in the node-forge asn1.fromDer function within forge/lib/asn1.js. The ASN.1 DER parser implementation (_fromDer) recurses for every constructed ASN.1 value (SEQUENCE, SET, etc.) and lacks a guard limiting recursion depth. An attacker can craft a small DER blob containing a very large nesting depth of constructed TLVs which causes the Node.js V8 engine to exhaust its call stack and throw RangeError: Maximum call stack size exceeded, crashing or incapacitating the process handling the parse. This is a remote, low-cost Denial-of-Service against applications that parse untrusted ASN.1 objects.


Affected upstream versions: < 1.3.2
Fixed upstream versions: v1.3.2
Upstream repository: https://github.com/digitalbazaar/forge
Upstream fix commit: 260425c6167a38aae038697132483b5517b26451
CVE-2025-66034: fonttools: fontTools: Arbitrary file write leading to remote code execution via malicious .designspace file
Component: fonttools
Severity: Moderate
CWE: CWE-91 (XML Injection (aka Blind XPath Injection))
CVSS v3: 6.3 (CVSS:3.1/AV:L/AC:H/PR:N/UI:R/S:C/C:N/I:H/A:L)
Public date: 2025-11-29T01:07:12.193000+00:00

This vulnerability in fontTools varLib allows a crafted .designspace file to trigger arbitrary file writes and XML-based content injection during variable-font generation. Because filenames are not sanitized, an attacker can use path traversal to overwrite files anywhere on the filesystem, and malicious payloads embedded in XML labelname elements can be injected directly into the generated output. When these overwritten files reside in executable or web-served locations, this can enable local remote-code execution or corruption of application or configuration files. The issue affects the varLib CLI and any code that invokes fontTools.varLib.main().

Statement: This issue is rated Moderate rather than Important because the exploitability hinges on several limiting technical factors despite the high integrity impact. The arbitrary file-write and XML-injection pathways are only reachable when a user or automated workflow locally processes a malicious .designspace file, giving the flaw a local attack vector (AV:L) and requiring explicit user interaction (UI:R)—meaning an attacker cannot trigger it remotely over the network. The attack also involves high complexity (AC:H), as it depends on crafted designspace structures, controlled font sources, and specific invocation of fonttools varLib or code that directly calls varLib.main(). Additionally, the vulnerability does not expose confidentiality, and availability effects are limited to potential file corruption. These constraints significantly narrow real-world exposure, keeping the risk profile in the Moderate range despite the possibility of high local integrity impact when exploited.

Affected upstream versions: >= 4.33.0, < 4.60.2
Fixed upstream versions: 4.60.2
Upstream repository: https://github.com/fonttools/fonttools
Upstream fix commit: a696d5ba93270d5954f98e7cab5ddca8a02c1e32
CVE-2025-66199: openssl: OpenSSL: Denial of Service due to excessive memory allocation in TLS 1.3 certificate compression
Component: openssl
Severity: Low
CWE: CWE-770 (Allocation of Resources Without Limits or Throttling)
CVSS v3: 5.9 (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H)
Public date: 2026-01-27T00:00:00+00:00

A flaw was found in OpenSSL. A remote attacker can exploit this vulnerability by sending a specially crafted CompressedCertificate message during the TLS 1.3 handshake. This can cause excessive per-connection memory allocations, leading to resource exhaustion and a Denial of Service (DoS) for affected clients and servers. This issue occurs when TLS 1.3 certificate compression is enabled and negotiated.

Statement: This vulnerability is rated Low for Red Hat products. The flaw in OpenSSL 3.3, 3.4, 3.5, and 3.6 allows an attacker to cause excessive memory allocation during TLS 1.3 handshake with certificate compression, potentially leading to a Denial of Service. This affects both clients and servers in mutual TLS scenarios where certificate compression is negotiated. Servers not requesting client certificates are not vulnerable to client-initiated attacks.

Affected upstream versions: 3.6.0 < 3.6.1, 3.5.0 < 3.5.5, 3.4.0 < 3.4.4, 3.3.0 < 3.3.6
Fixed upstream versions: 3.3.6, 3.4.4, 3.5.5, 3.6.1
Upstream repository: https://github.com/openssl/openssl
Upstream fix commit: 6184a4fb08ee6d7bca570d931a4e8bef40b64451
CVE-2025-66293: libpng: LIBPNG out-of-bounds read in png_image_read_composite
Component: libpng
Severity: Important
CWE: CWE-125 (Out-of-bounds Read)
CVSS v3: 7.1 (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:H)
Public date: 2025-12-03T20:33:57.086000+00:00

An out of bounds read vulnerability has been discovered in libpng. This vulnerability is in libpng's simplified API allows reading up to 1012 bytes beyond the png_sRGB_base[512] array when processing valid palette PNG images with partial transparency and gamma correction. The PNG files that trigger this vulnerability are valid per the PNG specification; the bug is in libpng's internal state management.

Statement: The Red Hat Product Security team has rated this vulnerability as Important as it affects libpng, a widely used library for PNG image processing. The flaw is due to an out-of-bounds read in libpng’s simplified API when handling specially crafted PNG images containing partial transparency and gamma correction data. Successful exploitation could result in information disclosure or cause application crashes in applications processing untrusted PNG content.

For `java-17-openjdk-headless` and `java-21-openjdk-headless`, while the affected code is present in the bundled sources, it is not exercised by these headless packages.

Affected upstream versions: < 1.6.52
Fixed upstream versions: v1.6.52
Upstream repository: https://github.com/pnggroup/libpng
Upstream fix commit: 788a624d7387a758ffd5c7ab010f1870dea753a1
CVE-2025-66412: angular: Angular Stored XSS Vulnerability via SVG Animation, SVG URL and MathML Attributes
Component: angular
Severity: Important
CWE: CWE-79 (Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting'))
CVSS v3: 8.1 (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:N)
Public date: 2025-12-01T22:35:59.211000+00:00

A flaw exists in the template compiler of Angular as it fails to properly classify certain URL-bearing attributes (including SVG and MathML attributes such as href, xlink:href, or the attributeName of SVG animation elements) as requiring strict sanitization. As a result, an attacker who can supply untrusted data bound to those attributes may inject a malicious javascript: URL or script that persists (Stored XSS), which can execute in the context of the application's origin when rendered.


Affected upstream versions: >= 21.0.0-next.0 < 21.0.2, >= 20.0.0-next.0 < 20.3.15, >= 19.0.0-next.0 < 19.2.17, <= 18.2.14
Fixed upstream versions: zone.js-0.16.1
Upstream repository: https://github.com/angular/angular
Upstream fix commit: 1c6b0704fb63d051fab8acff84d076abfbc4893a
CVE-2025-66416: mcp: DNS Rebinding Protection Disabled by Default in Model Context Protocol Python SDK
Component: mcp
Severity: Important
CWE: CWE-1188 (Initialization of a Resource with an Insecure Default)
CVSS v3: 8.1 (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:N)
Public date: 2025-12-02T18:14:28.310000+00:00

A DNS rebinding flaw has been discovered in the pypi mcp library. The Model Context Protocol (MCP) Python SDK does not enable DNS rebinding protection by default for HTTP-based servers. When an HTTP-based MCP server is run on localhost without authentication using FastMCP with streamable HTTP or SSE transport, and has not configured TransportSecuritySettings, a malicious website could exploit DNS rebinding to bypass same-origin policy restrictions and send requests to the local MCP server. This could allow an attacker to invoke tools or access resources exposed by the MCP server on behalf of the user in those limited circumstances.


Affected upstream versions: < 1.23.0
Fixed upstream versions: v1.23.0
Upstream repository: https://github.com/modelcontextprotocol/python-sdk
Upstream fix commit: d3a184119e4479ea6a63590bc41f01dc06e3fa99
CVE-2025-66418: urllib3: urllib3: Unbounded decompression chain leads to resource exhaustion
Component: urllib3
Severity: Important
CWE: CWE-770 (Allocation of Resources Without Limits or Throttling)
CVSS v3: 7.5 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H)
Public date: 2025-12-05T16:02:15.271000+00:00

A flaw was found in urllib3 Python library that could lead to a Denial of Service condition. A remote, malicious server can exploit this flaw by responding to a client request with an HTTP message that uses an excessive number of chained compression algorithms. This unlimited decompression chain causes the client system to consume a virtually unbounded amount of CPU resources and memory. The high resource usage leads to service disruption, making the application unresponsive.


Affected upstream versions: >= 1.24, < 2.6.0
Fixed upstream versions: 2.6.0
Upstream repository: https://github.com/urllib3/urllib3
Upstream fix commit: 24d7b67eac89f94e11003424bcf0d8f7b72222a8
CVE-2025-66448: vllm: vLLM: Remote Code Execution via malicious model configuration
Component: vllm
Severity: Important
CWE: CWE-94 (Improper Control of Generation of Code ('Code Injection'))
CVSS v3: 7.5 (CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H)
Public date: 2025-12-01T22:45:42.566000+00:00

A remote code execution vulnerability has been identified in vLLM. An attacker can exploit a weakness in the model loading process to silently fetch and run unauthorized, malicious Python code on the host system. This happens because the engine mistakenly executes code from a remote repository referenced in a model's configuration, even when explicit security measures are set to prevent it.

Statement: This vulnerability is rated Important for Red Hat because vLLM, when deployed in a Red Hat environment, is susceptible to remote code execution. An attacker can craft a malicious model configuration that, when loaded, fetches and executes arbitrary Python code from a remote repository, even if `trust_remote_code` is explicitly set to `False`.

Affected upstream versions: < 0.11.1
Fixed upstream versions: v0.11.1
Upstream repository: https://github.com/vllm-project/vllm
Upstream fix commit: ffb08379d8870a1a81ba82b72797f196838d0c86