huzaifas-sidhpurwala/security-commit huggingface dataset:
CVE-2026-33252: encoding/json: golang: github.com/modelcontextprotocol/go-sdk: Go MCP SDK: Remote tool execution via cross-site request forgery
Component: encoding/json
Severity: Moderate
CWE: CWE-940 (Improper Verification of Source of a Communication Channel)
CVSS v3: 7.1 (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:H/A:L)
Public date: 2026-03-23T23:44:16.106000+00:00

A flaw was found in the Go MCP SDK's Streamable HTTP transport, which uses Go's standard `encoding/json` package. In deployments without authorization, a remote attacker can exploit this Cross-Site Request Forgery (CSRF) vulnerability. By sending browser-generated cross-site `POST` requests to a local server without proper validation of the `Origin` header or `Content-Type`, an attacker can potentially trigger unauthorized tool execution.


Affected upstream versions: < 1.4.1
Fixed upstream versions: v1.5.0
Upstream repository: https://github.com/modelcontextprotocol/go-sdk
Upstream fix commit: a433a831d6e5d5ac3b9e625a8095aa8eaa040dfc
CVE-2026-33349: fast-xml-parser: fast-xml-parser: Denial of Service via unbounded entity expansion due to incorrect configuration limit handling
Component: fast-xml-parser
Severity: Moderate
CWE: CWE-1284 (Improper Validation of Specified Quantity in Input)
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-03-24T19:35:47.908000+00:00

A flaw was found in fast-xml-parser. A remote attacker can exploit this vulnerability by providing specially crafted XML input to an application using the affected library. The DocTypeReader component incorrectly processes configuration limits for entity counts and sizes when these limits are explicitly set to zero, bypassing intended restrictions. This oversight allows for unbounded entity expansion, consuming excessive memory and leading to a Denial of Service (DoS) condition, which makes the application unavailable to legitimate users.


Affected upstream versions: >= 4.0.0-beta.3, < 5.5.7
Fixed upstream versions: v5.5.7
Upstream repository: https://github.com/NaturalIntelligence/fast-xml-parser
Upstream fix commit: 239b64aa1fc5c5455ddebbbb54a187eb68c9fdb7
CVE-2026-33412: vim: Vim: Arbitrary code execution via command injection in glob() function
Component: vim
Severity: Important
CWE: CWE-78 (Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection'))
CVSS v3: 7.3 (CVSS:3.1/AV:L/AC:L/PR:L/UI:R/S:U/C:H/I:H/A:H)
Public date: 2026-03-24T19:43:07.219000+00:00

A flaw was found in Vim. By including a newline character in a pattern passed to Vim's glob() function, an attacker may be able to execute arbitrary shell commands. This command injection vulnerability allows for arbitrary code execution, depending on the user's shell settings.


Affected upstream versions: < 9.2.0202
Fixed upstream versions: v9.2.0202
Upstream repository: https://github.com/vim/vim
Upstream fix commit: 645ed6597d1ea896c712cd7ddbb6edee79577e9a
CVE-2026-33414: podman: github.com/containers/podman: Podman: Arbitrary code execution via command injection in HyperV backend
Component: podman
Severity: Important
CWE: CWE-94 (Improper Control of Generation of Code ('Code Injection'))
CVSS v3: 8.8 (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H)
Public date: 2026-04-14T22:42:19.822000+00:00

A flaw was found in Podman, a tool for managing containers. This vulnerability, located in the HyperV machine backend, allows for command injection. An attacker who can manipulate the virtual machine (VM) image path can inject and execute arbitrary PowerShell commands. This could lead to unauthorized system-level code execution on Windows installations where Podman is running.

Statement: This flaw in Podman's HyperV backend does not affect Red Hat products. The vulnerable code path is exclusive to Windows installations, and the HyperV backend is not utilized on Red Hat Enterprise Linux or OpenShift Container Platform.

Affected upstream versions: >= 4.8.0, < 5.8.2
Fixed upstream versions: v6.0.0
Upstream repository: https://github.com/containers/podman
Upstream fix commit: 571c842bd357ee626019ea97d030fb772fc654ed
CVE-2026-33416: libpng: libpng: Arbitrary code execution due to use-after-free vulnerability
Component: libpng
Severity: Moderate
CWE: CWE-825 (Expired Pointer Dereference)
CVSS v3: 7.5 (CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H)
Public date: 2026-03-26T16:48:54.174000+00:00

A flaw was found in libpng, a library used for processing PNG (Portable Network Graphics) image files. This vulnerability arises from improper memory management where a heap-allocated buffer is aliased between internal data structures. When specific functions are called, a freed memory region can still be referenced, leading to a use-after-free condition. An attacker could potentially exploit this to achieve arbitrary code execution or cause a denial of service.


Affected upstream versions: >= 1.2.1, < 1.6.56
Fixed upstream versions: v1.6.56
Upstream repository: https://github.com/pnggroup/libpng
Upstream fix commit: 23019269764e35ed8458e517f1897bd3c54820eb
CVE-2026-33526: squid: Squid: Denial of Service via heap Use-After-Free vulnerability in ICP handling
Component: squid
Severity: Important
CWE: CWE-825 (Expired Pointer Dereference)
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: 2026-03-26T00:16:12.195000+00:00

A flaw was found in Squid. A remote attacker can exploit a heap Use-After-Free vulnerability when handling ICP (Internet Cache Protocol) traffic. This allows them to perform a reliable and repeatable Denial of Service (DoS) attack, making the Squid service unavailable. This attack is limited to deployments where ICP support is explicitly enabled.

Statement: Important: A heap Use-After-Free vulnerability in Squid's ICP handling can lead to a denial of service. This flaw affects Red Hat products where the Squid proxy is configured to explicitly enable Internet Cache Protocol (ICP) support by setting a non-zero `icp_port`. Deployments with default configurations, where ICP is typically disabled, are not affected.

Affected upstream versions: < 7.5
Fixed upstream versions: SQUID_7_5
Upstream repository: https://github.com/squid-cache/squid
Upstream fix commit: 8a7d42f9d44befb8fcbbb619505587c8de6a1e91
CVE-2026-33555: haproxy: HAProxy: Request smuggling via HTTP/3 parser desynchronization
Component: haproxy
Severity: Moderate
CWE: CWE-130 (Improper Handling of Length Parameter Inconsistency)
CVSS v3: 4 (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:C/C:N/I:L/A:N)
Public date: 2026-04-13T00:00:00+00:00

A flaw was found in HAProxy. A remote attacker could exploit this vulnerability by sending a specially crafted HTTP/3 request. The HTTP/3 parser fails to verify that the received body length matches the announced content-length when a stream is closed with an empty payload. This desynchronization with the backend server can lead to request smuggling, allowing an attacker to bypass security mechanisms and potentially access unauthorized resources.


Affected upstream versions: 2.6 < 3.3.6
Fixed upstream versions: 3.3.6
Upstream repository: https://github.com/haproxy/haproxy
Upstream fix commit: 05a295441c621089ffa4318daf0dbca2dd756a84
CVE-2026-33630: c-ares: c-ares: Use-after-free / double-free in query-completion handling
Component: c-ares
Severity: Important
CWE: CWE-416 (Use After Free)
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: 2026-07-07T00:00:00+00:00

A flaw was found in c-ares. A use-after-free / double-free vulnerability exists in the query-completion handling path, where a query callback is invoked while the query is still linked in internal lookup structures. A remote attacker can exploit this via ares_getaddrinfo() over TCP by sending crafted DNS responses that force an EDNS-downgrade retry followed by a connection reset, causing the internal completion handler to access freed memory. This leads to memory corruption and a crash (denial of service), with potential for further impact depending on the allocator and build configuration.

Statement: A use-after-free / double-free vulnerability was found in c-ares' query-completion handling. The flaw is remotely exploitable without application cooperation via ares_getaddrinfo() over TCP: a malicious or on-path DNS server can force a specific sequence of responses (FORMERR without OPT record, duplicate query ID response, TCP reset) that causes the internal completion handler to access freed memory. An attacker can force the client onto TCP by setting the truncation (TC) bit in a UDP response.

The consequence is memory corruption leading to a crash (denial of service).

This is a broader fix for the pattern previously addressed in CVE-2025-31498. All versions of c-ares prior to 1.34.7 are affected.

Affected upstream versions: <= curl-7_19_4
Upstream repository: https://github.com/c-ares/c-ares
Upstream fix commit: 1fa3b86a0b8d18fe7b60f3228a01d770feb026bc
CVE-2026-33636: libpng: libpng: Information disclosure and denial of service via out-of-bounds read/write in Neon palette expansion
Component: libpng
Severity: Moderate
CWE: CWE-124 (Buffer Underwrite ('Buffer Underflow'))
CVSS v3: 7.6 (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:L/A:H)
Public date: 2026-03-26T16:51:58.289000+00:00

A flaw was found in libpng. A remote attacker could exploit an out-of-bounds read and write vulnerability in the ARM/AArch64 Neon-optimized palette expansion path. This occurs when processing a final partial chunk of 8-bit paletted rows without verifying sufficient input pixels, leading to dereferencing pointers before the start of the row buffer and writing expanded pixel data to underflowed positions. This flaw can result in information disclosure and denial of service.


Affected upstream versions: >= 1.6.36, < 1.6.56
Fixed upstream versions: v1.6.36
Upstream repository: https://github.com/pnggroup/libpng
Upstream fix commit: 7734cda20cf1236aef60f3bbd2267c97bbb40869
CVE-2026-33671: picomatch: Picomatch: Regular Expression Denial of Service via crafted extglob patterns
Component: picomatch
Severity: Moderate
CWE: CWE-1333 (Inefficient Regular Expression Complexity)
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: 2026-03-26T21:20:48.191000+00:00

A flaw was found in Picomatch, a JavaScript glob matcher. This Regular Expression Denial of Service (ReDoS) vulnerability allows a remote attacker to cause excessive CPU consumption and block the Node.js event loop, leading to a denial of service. This occurs when untrusted users supply crafted extglob patterns, specifically those using quantifiers like `+()` and `*()` combined with overlapping alternatives or nested extglobs, which can trigger catastrophic backtracking in the compiled regular expressions.


Affected upstream versions: >= 4.0.0, < 4.0.4, >= 3.0.0, < 3.0.2, < 2.3.2
Fixed upstream versions: 4.0.4
Upstream repository: https://github.com/micromatch/picomatch
Upstream fix commit: 5eceecd27543b8e056b9307d69e105ea03618a7d
CVE-2026-33891: node-forge: node-forge: Denial of Service via infinite loop in BigInteger.modInverse()
Component: node-forge
Severity: Important
CWE: CWE-606 (Unchecked Input for Loop Condition)
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: 2026-03-27T20:43:37.725000+00:00

A flaw was found in the node-forge library, a JavaScript implementation of Transport Layer Security. This vulnerability, inherited from the bundled jsbn library, allows a remote attacker to cause a Denial of Service (DoS). When the BigInteger.modInverse() function is called with a zero value, it enters an infinite loop, causing the process to hang indefinitely and consume 100% of the CPU resources.


Affected upstream versions: < 1.4.0
Fixed upstream versions: v1.4.0
Upstream repository: https://github.com/digitalbazaar/forge
Upstream fix commit: 9bb8d67b99d17e4ebb5fd7596cd699e11f25d023
CVE-2026-33895: node-forge: Forge: Authentication bypass via forged Ed25519 cryptographic signatures
Component: node-forge
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: 2026-03-27T20:47:54.492000+00:00

A flaw was found in Forge (also called `node-forge`), a JavaScript library used for Transport Layer Security (TLS). The library's Ed25519 signature verification process does not correctly validate cryptographic signatures, allowing forged non-canonical signatures to be accepted. A remote attacker could exploit this signature malleability to bypass authentication and authorization logic. This vulnerability can also circumvent security checks in applications that rely on the uniqueness of cryptographic signatures for functions such as deduplication or preventing replay attacks.


Affected upstream versions: < 1.4.0
Fixed upstream versions: v1.4.0
Upstream repository: https://github.com/digitalbazaar/forge
Upstream fix commit: bdecf11571c9f1a487cc0fe72fe78ff6dfa96b85
CVE-2026-33896: node-forge: Forge (node-forge): Certificate validation bypass allows unauthorized certificate issuance
Component: node-forge
Severity: Important
CWE: CWE-295 (Improper Certificate Validation)
CVSS v3: 7.4 (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N)
Public date: 2026-03-27T20:50:03.418000+00:00

A flaw was found in Forge (also known as node-forge), a JavaScript implementation of Transport Layer Security (TLS). The `pki.verifyCertificateChain()` function does not properly enforce certificate validation rules. This oversight allows an intermediate certificate that lacks specific security extensions to enable any leaf certificate to function as a Certificate Authority (CA) and sign other certificates. Consequently, node-forge could accept these unauthorized certificates as valid, potentially leading to spoofing or the issuance of illegitimate certificates.


Affected upstream versions: < 1.4.0
Fixed upstream versions: v1.4.0
Upstream repository: https://github.com/digitalbazaar/forge
Upstream fix commit: 2e492832fb25227e6b647cbe1ac981c123171e90
CVE-2026-33937: handlebars.js: Handlebars: Remote Code Execution via crafted Abstract Syntax Tree object in compile()
Component: handlebars.js
Severity: Important
CWE: CWE-94 (Improper Control of Generation of Code ('Code Injection'))
CVSS v3: 9.8 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H)
Public date: 2026-03-27T21:03:46.748000+00:00

A flaw was found in Handlebars. An attacker can exploit this by supplying a crafted Abstract Syntax Tree (AST) object to the `Handlebars.compile()` function. This allows the injection and execution of arbitrary JavaScript code due to improper sanitization of the `value` field in `NumberLiteral` AST nodes. This vulnerability can lead to Remote Code Execution (RCE) on the server.

Statement: This is an Important vulnerability in Handlebars that allows for Remote Code Execution. The flaw occurs when the `Handlebars.compile()` function processes a specially crafted Abstract Syntax Tree (AST) object, leading to the injection and execution of arbitrary JavaScript code. Red Hat products utilizing Handlebars are affected if they process untrusted input through the `compile()` function.

Affected upstream versions: >= 4.0.0, < 4.7.9
Fixed upstream versions: v4.7.9
Upstream repository: https://github.com/handlebars-lang/handlebars.js
Upstream fix commit: 68d8df5a88e0a26fe9e6084c5c6aaebe67b07da2
CVE-2026-33938: handlebars: Handlebars: Arbitrary code execution via @partial-block overwrite
Component: handlebars
Severity: Important
CWE: CWE-917 (Improper Neutralization of Special Elements used in an Expression Language Statement ('Expression Language Injection'))
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: 2026-03-27T21:05:42.485000+00:00

A flaw was found in Handlebars. A remote attacker can exploit this vulnerability by manipulating the `@partial-block` special variable within the template data context. By overwriting `@partial-block` with a specially crafted Abstract Syntax Tree (AST) through a helper, a subsequent invocation of `{{> @partial-block}}` will compile and execute the malicious AST. This enables arbitrary JavaScript execution on the server, leading to potential compromise of the system.

Statement: Important: A flaw in Handlebars allows arbitrary code execution when processing untrusted input. This occurs if an attacker can manipulate the `@partial-block` special variable through a helper, leading to the execution of a crafted Abstract Syntax Tree. Red Hat products are affected if they use Handlebars versions 4.0.0 through 4.7.8 in server-side applications where untrusted input can influence template data or context objects. Deployments utilizing the Handlebars runtime-only build are not vulnerable.

Affected upstream versions: >= 4.0.0, < 4.7.9
Fixed upstream versions: v4.7.9
Upstream repository: https://github.com/handlebars-lang/handlebars.js
Upstream fix commit: 68d8df5a88e0a26fe9e6084c5c6aaebe67b07da2
CVE-2026-33939: handlebars.js: Handlebars.js: Denial of Service via malformed decorator syntax in template compilation
Component: handlebars.js
Severity: Important
CWE: CWE-248 (Uncaught Exception)
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: 2026-03-27T21:08:24.664000+00:00

A flaw was found in Handlebars.js. A remote attacker can exploit this by submitting a malformed Handlebars template that includes decorator syntax referencing an unregistered decorator. When the application attempts to compile this template without proper error handling, it triggers an unhandled `TypeError`. This error causes the Node.js process to crash, resulting in a Denial of Service (DoS) for the affected application.

Statement: This is an Important denial of service flaw in Handlebars.js affecting applications that compile user-supplied templates without proper error handling. A remote attacker can submit a malformed template containing unregistered decorator syntax, leading to an unhandled `TypeError` and crashing the Node.js process. Red Hat products are vulnerable if they use Handlebars.js in a configuration that allows untrusted input to be compiled at runtime without implementing `try/catch` blocks or input validation.

Affected upstream versions: >= 4.0.0, < 4.7.9
Fixed upstream versions: v4.7.9
Upstream repository: https://github.com/handlebars-lang/handlebars.js
Upstream fix commit: 68d8df5a88e0a26fe9e6084c5c6aaebe67b07da2
CVE-2026-33940: handlebars.js: Handlebars.js: Arbitrary code execution via crafted template context
Component: handlebars.js
Severity: Important
CWE: CWE-94 (Improper Control of Generation of Code ('Code Injection'))
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: 2026-03-27T21:11:10.719000+00:00

A flaw was found in Handlebars.js. A remote attacker can exploit this vulnerability by providing a specially crafted object within the template context. This crafted object, when processed by a dynamic partial lookup, can bypass security checks and be interpreted as malicious code. This allows the attacker to execute arbitrary commands on the server where Handlebars.js is running.

Statement: This is an Important arbitrary code execution vulnerability in Handlebars.js. The flaw can be exploited when an application uses Handlebars.js with dynamic partial lookups and processes user-controlled data within the template context. Red Hat products bundling Handlebars.js are affected if they meet these specific conditions for exploitation.

Affected upstream versions: >= 4.0.0, < 4.7.9
Fixed upstream versions: v4.7.9
Upstream repository: https://github.com/handlebars-lang/handlebars.js
Upstream fix commit: 68d8df5a88e0a26fe9e6084c5c6aaebe67b07da2
CVE-2026-33941: handlebars.js: Handlebars: Arbitrary code execution via CLI precompiler input sanitization flaw
Component: handlebars.js
Severity: Important
CWE: CWE-94 (Improper Control of Generation of Code ('Code Injection'))
CVSS v3: 8.2 (CVSS:3.1/AV:L/AC:L/PR:L/UI:R/S:C/C:H/I:H/A:H)
Public date: 2026-03-27T21:13:15.437000+00:00

A flaw was found in Handlebars. The Handlebars command-line interface (CLI) precompiler concatenates user-controlled strings, such as template file names and CLI options, directly into the generated JavaScript without proper escaping or sanitization. An attacker capable of influencing these inputs can inject arbitrary JavaScript code. This can lead to arbitrary code execution when the generated JavaScript bundle is loaded in a Node.js environment or a web browser.

Statement: Important: This flaw in Handlebars allows arbitrary code execution when the CLI precompiler processes untrusted inputs. An attacker who can influence template filenames or command-line arguments can inject malicious JavaScript, which executes when the generated bundle is loaded. Red Hat products utilizing the Handlebars CLI precompiler in environments where untrusted inputs are processed may be affected.

Affected upstream versions: >= 4.0.0, < 4.7.9
Fixed upstream versions: v4.7.9
Upstream repository: https://github.com/handlebars-lang/handlebars.js
Upstream fix commit: 68d8df5a88e0a26fe9e6084c5c6aaebe67b07da2
CVE-2026-33947: jq: unbounded Recursion in jv_setpath() / jv_getpath() / delpaths_sorted()
Component: jq
Severity: Moderate
CWE: CWE-674 (Uncontrolled Recursion)
CVSS v3: 6.2 (CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H)
Public date: 2026-04-13T21:50:18.814000+00:00

A flaw was found in jq, a command line JSON processor. Processing a crafted JSON document, specifically when a large array is used as a path argument to the `jv_setpath`, `jv_getpath` and `delpaths_sorted` functions can lead to an uncontrolled recursion and exhausts the call stack, causing an application crash and resulting in a denial of service.

Statement: To exploit this issue, an attacker needs to supply a crafted JSON input to be processed by jq with the `setpath`, `getpath` or `delpaths` builtins. This allows the attacker to cause an application crash with no other security impact. Due to these reasons, this flaw has been rated with a moderate severity.

Affected upstream versions: < fb59f1491058d58bdc3e8dd28f1773d1ac690a1f
Fixed upstream versions: jq-1.8.2
Upstream repository: https://github.com/jqlang/jq
Upstream fix commit: fb59f1491058d58bdc3e8dd28f1773d1ac690a1f
CVE-2026-33948: jq: jq: Input validation bypass via embedded NUL bytes allows parser differential attacks
Component: jq
Severity: Low
CWE: CWE-170 (Improper Null Termination)
CVSS v3: 3.8 (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:C/C:N/I:L/A:N)
Public date: 2026-04-13T23:51:04.144000+00:00

A flaw was found in jq, a command-line JSON processor. This vulnerability allows a remote attacker to bypass input validation by crafting malicious JSON input containing embedded null (NUL) bytes. Due to incorrect handling of input buffer lengths, jq truncates the input at the first NUL byte, validating only the benign prefix and silently discarding any malicious data that follows. This can lead to parser differential attacks where downstream systems, relying on jq for validation, may process the full, unvalidated input, potentially leading to unexpected behavior or security compromises.

Statement: This vulnerability in `jq` allows an attacker to bypass input validation by embedding NUL bytes in JSON input. This is relevant in Red Hat environments where `jq` is used to validate untrusted JSON before it is processed by other tools, potentially leading to parser differential attacks and unexpected behavior in downstream systems. The `jq` command line tool is not exposed to the network in default configurations of Red Hat products.

Affected upstream versions: < 6374ae0bcdfe33a18eb0ae6db28493b1f34a0a5b
Fixed upstream versions: jq-1.8.2
Upstream repository: https://github.com/jqlang/jq
Upstream fix commit: 6374ae0bcdfe33a18eb0ae6db28493b1f34a0a5b