huzaifas-sidhpurwala/security-commit huggingface dataset:
CVE-2025-61919: rubygem-rack: Unbounded read in `Rack::Request` form parsing can lead to memory exhaustion
Component: rubygem-rack
Severity: Important
CWE: CWE-400 (Uncontrolled Resource Consumption)
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-10-10T19:22:42.454000+00:00

A memory-exhaustion vulnerability exists in Rack when parsing application/x-www-form-urlencoded request bodies. Rack::Request#POST reads the entire request body into memory without enforcing a maximum length or cap. Attackers can exploit this by sending large form submissions, potentially causing denial of service (DoS) through memory exhaustion. Even with configured parsing limits, the issue occurs before those limits are enforced, allowing unbounded memory allocation proportional to request size.

Statement: ~~~

Affectedness:

Rack 1.x, including 1.6.x, is not affected by this vulnerability. The issue exists only in Rack 2.x and 3.x, where request parsing was refactored into the QueryParser component. Since Rack 1.x does not include this component, it does not contain the vulnerable logic.

Ruby 2.x and 3.x versions shipped with Red Hat Enterprise Linux, Red Hat Openshift Core OS (RHOCS) and Red Hat In-Vehicle OS (RHIVOS) are not affected, as they do not bundle the rack RubyGem by default. Rack is a third-party gem that must be installed separately.

~~~

Affected upstream versions: < 2.2.20, >= 3.0, < 3.1.18, >= 3.2, < 3.2.3
Fixed upstream versions: v2.2.20
Upstream repository: https://github.com/rack/rack
Upstream fix commit: 4e2c903991a790ee211a3021808ff4fd6fe82881
CVE-2025-61920: authlib: Authlib Denial of Service
Component: authlib
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-10-10T19:25:07.679000+00:00

A denial of service flaw has been discovered in the python Authlib package. Authlib’s JOSE implementation accepts unbounded JWS/JWT header and signature segments. A remote attacker can craft a token whose base64url‑encoded header or signature spans hundreds of megabytes. During verification, Authlib decodes and parses the full input before it is rejected, driving CPU and memory consumption to hostile levels and enabling denial of service.


Affected upstream versions: < 1.6.5
Fixed upstream versions: v1.6.5
Upstream repository: https://github.com/authlib/authlib
Upstream fix commit: 867e3f87b072347a1ae9cf6983cc8bbf88447e5e
CVE-2025-61927: happy-dom: Happy-DOM VM Context Escape
Component: happy-dom
Severity: Important
CWE: CWE-94 (Improper Control of Generation of Code ('Code Injection'))
CVSS v3: 8.3 (CVSS:3.1/AV:N/AC:L/PR:H/UI:R/S:C/C:H/I:H/A:L)
Public date: 2025-10-10T19:38:19.835000+00:00

A code execution vector has been discovered in the npm happy-dom package. A Node.js VM Context is not an isolated environment, and if the user runs untrusted JavaScript code within the Happy DOM VM Context, it may escape the VM and get access to process level functionality. It seems like what the attacker can get control over depends on if the process is using ESM or CommonJS. With CommonJS the attacker can get hold of the `require()` function to import modules. Happy DOM has JavaScript evaluation enabled by default. This may not be obvious to the consumer of Happy DOM and can potentially put the user at risk if untrusted code is executed within the environment.


Affected upstream versions: < 20.0.0
Fixed upstream versions: v20.0.0
Upstream repository: https://github.com/capricorn86/happy-dom
Upstream fix commit: 819d15ba289495439eda8be360d92a614ce22405
CVE-2025-62156: github.com/argoproj/argo-workflows: Argo Workflows Zip Slip
Component: github.com/argoproj/argo-workflows
Severity: Important
CWE: CWE-22 (Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal'))
CVSS v3: 7.1 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:L)
Public date: 2025-10-14T14:52:44.502000+00:00

A zip slip flaw has been discovered in the Argo Workflows container engine. During artifact extraction the unpack/untar logic (workflow/executor/executor.go) uses filepath.Join(dest, filepath.Clean(header.Name)) without validating that header.Name stays within the intended extraction directory. A malicious archive entry can supply a traversal or absolute path that, after cleaning, overrides the destination directory and causes files to be written outside the /work/tmp extraction path and into system directories such as /etc inside the container. The vulnerability enables arbitrary file creation or overwrite in system configuration locations (for example /etc/passwd, /etc/hosts, /etc/crontab), which can lead to privilege escalation or persistence within the affected container.


Affected upstream versions: < 3.6.12, >= 3.7.0, < 3.7.3
Fixed upstream versions: v3.7.3
Upstream repository: https://github.com/argoproj/argo-workflows
Upstream fix commit: 5659ad9b641fcf52c04ed594cd6493f9170f6011
CVE-2025-62164: vllm: VLLM deserialization vulnerability leading to DoS and potential RCE
Component: vllm
Severity: Important
CWE: CWE-787 (Out-of-bounds Write)
CVSS v3: 8.8 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H)
Public date: 2025-11-21T01:18:38.803000+00:00

A vulnerability in vLLM allows attackers to supply malicious serialized prompt-embedding tensors that are deserialized using torch.load() without validation. Due to PyTorch 2.8.0 disabling sparse-tensor integrity checks by default, a crafted tensor can bypass bounds checks and cause an out-of-bounds write during to_dense(), leading to a crash (DoS) and potentially remote code execution on the vLLM server.

Statement: This vulnerability is considered important rather than moderate because it involves unsafe deserialization leading to memory corruption in a network-reachable, unauthenticated API path. Unlike typical moderate flaws that may only allow limited DoS or require specific conditions, this issue allows an attacker to supply a crafted sparse tensor that triggers an out-of-bounds memory write during PyTorch’s to_dense() conversion. Memory corruption in a server process handling untrusted input significantly elevates security risk because it can lead not only to a reliable crash but also to potential remote code execution, enabling full compromise of the vLLM service. Additionally, the affected code path is part of the standard Completions API workflow, making the attack surface broadly exposed in real deployments. The combination of remote exploitability, unauthenticated access, memory corruption, and potential RCE clearly positions this issue above a moderate classification and into an important severity level.

Affected upstream versions: >= 0.10.2, < 0.11.1
Fixed upstream versions: v0.11.1
Upstream repository: https://github.com/vllm-project/vllm
Upstream fix commit: 58fab50d82838d5014f4a14d991fdb9352c9c84b
CVE-2025-62168: squid-cache: Squid vulnerable to information disclosure via authentication credential leakage in error handling
Component: squid-cache
Severity: Important
CWE: CWE-209 (Generation of Error Message Containing Sensitive Information)
CVSS v3: 8.6 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:N/A:N)
Public date: 2025-10-17T16:21:30.156000+00:00

A Information Disclosure vulnerability has been identified in the Squid web caching proxy. This flaw occurs when the application fails to properly redact sensitive Hypertext Transfer Protocol (HTTP) authentication credentials from an error response. A remote client can exploit this by triggering an error condition, which allows a malicious script to bypass browser security and disclose the username and password a trusted client uses for access. This directly compromises the security of internal application credentials and security tokens, especially when Squid is configured for backend load balancing.

Statement: This vulnerability has rated as having the severity of Important by the Red Hat Product Security team as a successful exploitation may lead to sensitive information stored in the squid cache to be leaked, that may include authentication tokens for applications hosted behind the squid cache.

The leak happens due to squid cache not properly redacting request headers that may contain sensitive information out from error reports containing the request which triggered the error, resulting in a high confidentiality impact. The attacker does not need to have any kind of authentication to exploit this vulnerability.

To a squid instance to be considered vulnerable the email_err_data configuration may need to be turned on in the application configuration file. If the configuration entry is not present, the default behavior is to share such data letting the instance vulnerable.

The default behavior for squid in Red Hat Enterprise Linux distributions is to have email_err_data option enabled.

Affected upstream versions: < 7.2
Fixed upstream versions: SQUID_7_2
Upstream repository: https://github.com/squid-cache/squid
Upstream fix commit: 0951a0681011dfca3d78c84fd7f1e19c78a4443f
CVE-2025-62171: ImageMagick: ImageMagick vulnerable to denial of service via integer overflow in BMP decoder on 32-bit systems
Component: ImageMagick
Severity: Moderate
CWE: CWE-190 (Integer Overflow or Wraparound)
CVSS v3: 4.8 (CVSS:3.1/AV:N/AC:H/PR:L/UI:R/S:U/C:N/I:N/A:H)
Public date: 2025-10-17T16:30:27.144000+00:00

A vulnerability for an integer overflow has been identified in the ImageMagick image processing software suite on 32-bit systems with non-default resource limits. An attacker can exploit this flaw by providing a specially crafted malicious image file (BMP format) for processing. Successful exploitation leads to an out-of-bounds write, which could result in a denial of service by crashing the application.

Statement: This vulnerability is rated Moderate for Red Hat because it only affects 32-bit builds of ImageMagick. Exploitation requires that default resource limits for image processing (width, height, and area) have been manually increased beyond their defaults. Red Hat Enterprise Linux systems running 64-bit builds of ImageMagick or using default resource limits are not affected.

Affected upstream versions: < 6.9.13-32, >= 7.0.0-0, < 7.1.2-7
Fixed upstream versions: 7.1.2-6
Upstream repository: https://github.com/ImageMagick/ImageMagick
Upstream fix commit: cea1693e2ded51b4cc91c70c54096cbed1691c00
CVE-2025-62372: vllm: vLLM vulnerable to DoS with incorrect shape of multimodal embedding inputs
Component: vllm
Severity: Moderate
CWE: CWE-129 (Improper Validation of Array Index)
CVSS v3: 6.5 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H)
Public date: 2025-11-21T01:22:37.121000+00:00

A denial-of-service vulnerability in vLLM allows an attacker with API access to crash the engine by submitting multimodal embedding tensors that have the correct number of dimensions but an invalid internal shape. Because vLLM validates only the tensor’s ndim and not the full expected shape, malformed embeddings trigger shape mismatches or validation failures during processing, causing the inference engine to terminate.

Statement: This flaw is rated Moderate rather than Important because its impact is strictly limited to availability and requires low but existing privileges to exploit. The issue arises from incomplete shape validation of multimodal embedding tensors, which can cause deterministic crashes in the inference engine, but it does not enable memory corruption, data leakage, integrity compromise, or execution of arbitrary code. Exploitation requires an authenticated or API-key-holding user to submit malformed multimodal inputs, meaning it cannot be triggered by an unauthenticated attacker on an exposed endpoint. Additionally, the failure mode is a clean crash rather than undefined behavior, so the blast radius is constrained to service interruption rather than broader systemic compromise. These factors—PR:L requirement, no confidentiality/integrity impact, deterministic failure mode, and scoped DoS only—technically align the issue with Moderate severity instead of an Important flaw.

Affected upstream versions: >= 0.5.5, < 0.11.1
Fixed upstream versions: v0.11.1
Upstream repository: https://github.com/vllm-project/vllm
Upstream fix commit: 58fab50d82838d5014f4a14d991fdb9352c9c84b
CVE-2025-62408: c-ares: c-ares: Denial of Service due to query termination after maximum attempts
Component: c-ares
Severity: Moderate
CWE: CWE-416 (Use After Free)
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: 2025-12-08T22:04:08.565000+00:00

A flaw was found in c-ares. This vulnerability allows a Denial of Service (DoS) via terminating a query after maximum attempts when using `read_answer()` and `process_answer()` functions.

Statement: This vulnerability is rated Moderate for Red Hat products. The flaw in c-ares can lead to a Denial of Service when the library is used to resolve queries, specifically when `read_answer()` and `process_answer()` functions are called and a query terminates after maximum attempts. This could impact applications that rely on c-ares for asynchronous DNS resolution.

Affected upstream versions: > 1.32.3, < 1.34.6
Upstream repository: https://github.com/c-ares/c-ares
Upstream fix commit: 714bf5675c541bd1e668a8db8e67ce012651e618
CVE-2025-62426: vllm: vLLM vulnerable to DoS via large Chat Completion or Tokenization requests with specially crafted `chat_template_kwargs`
Component: vllm
Severity: Moderate
CWE: CWE-770 (Allocation of Resources Without Limits or Throttling)
CVSS v3: 6.5 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H)
Public date: 2025-11-21T01:21:29.546000+00:00

A vulnerability in vLLM allows an authenticated user to trigger unintended tokenization during chat template processing by supplying crafted chat_template_kwargs to the /v1/chat/completions or /tokenize endpoints. By forcing the server to tokenize very large inputs, an attacker can block the API server’s event loop for extended periods, causing a denial of service and delaying all other requests.

Statement: The flaw is limited to a denial-of-service vector that requires an authenticated user and relies on abusing an optional, non-security-critical parameter (chat_template_kwargs) to force unexpected tokenization during template application, which is computationally expensive but not indicative of data corruption, privilege escalation, or code execution. The attacker cannot break isolation boundaries or execute arbitrary logic—they can only cause the server’s event loop to stall through large crafted inputs, and only if they already have access to the vLLM API. Moreover, the DoS condition is resource-intensive, depends heavily on model size and server configuration, and does not persist once the malicious request completes. Because the impact is bounded to temporary availability degradation without confidentiality or integrity loss, and because exploitation requires legitimate API access and large payloads, this issue aligns with a Moderate severity rather than an Important/High flaw.

Affected upstream versions: >= 0.5.5, < 0.11.1
Fixed upstream versions: v0.11.1
Upstream repository: https://github.com/vllm-project/vllm
Upstream fix commit: 3ada34f9cb4d1af763fdfa3b481862a93eb6bd2b
CVE-2025-62593: ray: Ray is vulnerable to RCE via Safari & Firefox Browsers through DNS Rebinding Attack
Component: ray
Severity: Important
CWE: CWE-94 (Improper Control of Generation of Code ('Code Injection'))
CVSS v3: 8.8 (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H)
Public date: 2025-11-26T22:28:28.577000+00:00

A flaw was found in Ray’s HTTP API endpoint handling (e.g. /api/jobs, /api/job_agent/jobs/), which allows a remote attacker to trigger arbitrary code execution when a developer using Ray visits a malicious website in a vulnerable browser (e.g. Firefox or Safari). The root cause is an insufficient defense relying solely on the User-Agent header starting with “Mozilla”, which can be manipulated under the fetch specification — enabling a DNS-rebinding attack to bypass browser-based protections.

Statement: Red Hat has chosen to keep this as Important instead of Critical severity because the successful exploitation of this vulnerability requires user interaction in conjunction with a DNS rebinding attack.

Affected upstream versions: < 2.52.0
Fixed upstream versions: ray-2.52.0
Upstream repository: https://github.com/ray-project/ray
Upstream fix commit: 70e7c72780bdec075dba6cad1afe0832772bfe09
CVE-2025-6269: hdf5: HDF5 heap-based overflow
Component: hdf5
Severity: Moderate
CWE: CWE-787 (Out-of-bounds Write)
CVSS v3: 5.3 (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:L)
Public date: 2025-06-19T16:00:17.595000+00:00

A vulnerability was found in the H5C__reconstruct_cache_entry function of the H5Cimage.c file in HDF5. Input manipulation can occur, which leads to a heap-based buffer overflow. Exploitation of this vulnerability requires local system access.


Affected upstream versions: 1.14.0, 1.14.1, 1.14.2, 1.14.3, 1.14.4, 1.14.5, 1.14.6
Fixed upstream versions: 2.0.0
Upstream repository: https://github.com/HDFGroup/hdf5
Upstream fix commit: 7f27ba8c3a8483c3d7e5e2cb21fefb2c7563422d
CVE-2025-62706: authlib: Authlib : JWE zip=DEF decompression bomb enables DoS
Component: authlib
Severity: Moderate
CWE: CWE-770 (Allocation of Resources Without Limits or Throttling)
CVSS v3: 6.5 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H)
Public date: 2025-10-22T21:31:10.997000+00:00

A denial-of-service vulnerability exists in Authlib’s JWE (JSON Web Encryption) handling for zip=DEF compression. In versions prior to 1.6.5, the library performs unbounded DEFLATE decompression when processing JWE tokens with "zip": "DEF" in the header, without imposing a maximum size limit on the output. An attacker able to supply decryptable tokens could craft a compressed JWE ciphertext that expands to an arbitrarily large size, causing excessive memory and CPU consumption and potentially exhausting system resources.


Affected upstream versions: < 1.6.5
Fixed upstream versions: v1.6.5
Upstream repository: https://github.com/authlib/authlib
Upstream fix commit: e0863d5129316b1790eee5f14cece32a03b8184d
CVE-2025-62707: pypdf: pypdf affected by possible infinite loop when reading DCT inline images without EOF marker
Component: pypdf
Severity: Moderate
CWE: CWE-834 (Excessive Iteration)
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-10-22T21:36:32.754000+00:00

A denial of service vulnerability exists in the Pypdf,such that an attacker using carefully crafted pdf file can make the parsing of the  DCTDecode filter to enter a infinite loop leading to damage of system availability.


Affected upstream versions: < 6.1.3
Fixed upstream versions: 6.1.3
Upstream repository: https://github.com/py-pdf/pypdf
Upstream fix commit: f2864d6dd9bac7cecd3f4f54308b25ebbfa178f8
CVE-2025-62727: starlette: Starlette DoS via Range header merging
Component: starlette
Severity: Important
CWE: CWE-407 (Inefficient Algorithmic Complexity)
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-10-28T20:14:53.655000+00:00

A denial of service vulnerability has been discovered in the python Starlette framework. an unauthenticated attacker can send a crafted HTTP Range header that triggers quadratic-time processing in Starlette's FileResponse Range parsing/merging logic. This induces CPU exhaustion per request, causing a denial‑of‑service for endpoints serving files.


Affected upstream versions: >= 0.39.0, < 0.49.1
Fixed upstream versions: 0.49.1
Upstream repository: https://github.com/Kludex/starlette
Upstream fix commit: 4ea6e22b489ec388d6004cfbca52dd5b147127c5
CVE-2025-64329: github.com/containerd/containerd: containerd: Memory exhaustion via CRI Attach implementation goroutine leaks
Component: github.com/containerd/containerd
Severity: Moderate
CWE: CWE-771 (Missing Reference to Active Allocated Resource)
CVSS v3: 6.5 (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:C/C:N/I:N/A:H)
Public date: 2025-11-07T04:15:09.381000+00:00

A flaw was found in containerd. This vulnerability allows a user to exhaust memory on the host due to goroutine leaks via a bug in the CRI (Container Runtime Interface) Attach implementation.

Statement: The highest threat of this vulnerability is to system availability. A flaw in containerd's CRI Attach implementation allows a user to exhaust memory on the host due to goroutine leaks, leading to a denial of service.

Affected upstream versions: < 1.7.29, < 2.0.7, >= 2.1.0-beta.0, < 2.1.5, >= 2.2.0-beta.0, < 2.2.0
Fixed upstream versions: api/v1.11.0
Upstream repository: https://github.com/containerd/containerd
Upstream fix commit: 083b53cd6f19b5de7717b0ce92c11bdf95e612df
CVE-2025-64459: django: Django SQL injection
Component: django
Severity: Important
CWE: CWE-89 (Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection'))
CVSS v3: 8.3 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:L/I:L/A:L)
Public date: 2025-11-05T15:09:58.239000+00:00

A potential SQL injection vulnerability has been discovered in the Django web framework. The methods QuerySet.filter(), QuerySet.exclude(), and QuerySet.get(), and the class Q() were subject to SQL injection when using a suitably crafted dictionary, with dictionary expansion, as the _connector argument.

Statement: The impact of this vulnerability on Red Hat products is limited to the effective user scope of the running process.

Affected upstream versions: 5.2 < 5.2.8, 5.1 < 5.1.14, 4.2 < 4.2.26
Fixed upstream versions: 4.2.26, 5.1.14, 5.2.8
Upstream repository: https://github.com/django/django
Upstream fix commit: c880530ddd4fabd5939bab0e148bebe36699432a
CVE-2025-64503: cups: cups-filters: cups-filters: Out-of-bounds write via crafted PDF MediaBox
Component: cups
Severity: Moderate
CWE: CWE-787 (Out-of-bounds Write)
CVSS v3: 4 (CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L)
Public date: 2025-11-12T22:04:03.750000+00:00

A flaw was found in cups-filters. This vulnerability allows an out-of-bounds write via a crafted Portable Document Format (PDF) file with a large MediaBox value.

Statement: This vulnerability is rated Moderate for Red Hat Enterprise Linux because a specially crafted PDF file, when processed by the `cups-filters` `pdftoraster` tool, can lead to an out-of-bounds write, potentially causing a denial of service. This affects Red Hat Enterprise Linux 7, 8, 9, and 10, as well as Fedora.

Affected upstream versions: cups-filters < 1.28.18, libcupsfilters >= 2.0.0, < 2.1.2
Upstream repository: https://github.com/OpenPrinting/cups-filters
Upstream fix commit: 50d94ca0f2fa6177613c97c59791bde568631865
CVE-2025-64505: libpng: LIBPNG heap buffer overflow via malformed palette index
Component: libpng
Severity: Moderate
CWE: CWE-125 (Out-of-bounds Read)
CVSS v3: 4.4 (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:L)
Public date: 2025-11-24T23:38:40.405000+00:00

A heap buffer over-read vulnerability exists in libpng's png_do_quantize function when processing PNG files with malformed palette indices. The vulnerability occurs when palette_lookup array bounds are not validated against externally-supplied image data, allowing an attacker to craft a PNG file with out-of-range palette indices that trigger out-of-bounds memory access.

Statement: This vulnerability is rated Moderate for Red Hat products. It affects applications that process specially crafted PNG files using the vulnerable `libpng` library. Exploitation requires user interaction, where a victim must open or process a malicious PNG image, leading to a heap buffer over-read. This could result in information disclosure or application crash.

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

Affected upstream versions: < 1.6.51
Fixed upstream versions: v1.6.51
Upstream repository: https://github.com/pnggroup/libpng
Upstream fix commit: 6a528eb5fd0dd7f6de1c39d30de0e41473431c37