This entry references a vulnerability identified as CVE-2026-74419 related to the Microsoft product version 4.0. The description provided is generic and does not detail the nature of the vulnerability or its impact. No CVSS score or technical details are available, and no known exploits in the wild have been reported.
Guard Core is an API security core engine for the FastAPI-Guard, FlaskAPI Guard, and DjAPI Guard adapters. From 1.0.0 until 3.13.0, _extract_from_forwarded_header() in guard_core/utils.py returns the selected X-Forwarded-For entry without validating that it is an IP address. In deployments configured with trusted_proxies where the selected entry is attacker-controlled, the arbitrary client_ip string reaches BehaviorTracker in guard_core/handlers/behavior_handler.py and is interpolated into Redis key names and blocking KEYS glob patterns. Glob metacharacters can cause one request to count other clients' behavior events, embedded separators can disturb key parsing, and rotating identities can create unbounded keys while repeatedly scanning the shared Redis keyspace. A non-IP identity can also reach a ban action and cause an uncaught validation error. This issue is fixed in version 3.13.0.
mail-parser is a tool that parses emails by enhancing the Python standard library and extracting message details into a comprehensive object. From 3.7.0 until 4.6.3, receiveds_format() in src/mailparser/utils.py catches only TypeError and ValueError while converting the trailing date of an attacker-controlled Received header. An out-of-range year can cause calendar.timegm() to raise OverflowError, and a sufficiently large timezone offset can cause datetime.fromtimestamp() to raise OSError. These exceptions are outside the MailParserError hierarchy, so one crafted header can abort the entire message parse through every parse_from_* entry point and may drop a queued batch. This issue is fixed in version 4.6.3.
The MCUboot TLV iterator bootutil_tlv_iter_next() in boot/bootutil/src/tlv.c walks image trailer TLVs with a single loop guard (it->tlv_off < it->tlv_end) and advances by sizeof(struct image_tlv) + tlv.it_len using the attacker-controlled it_len field, without validating that the entry's header or payload stays within it->tlv_end. As a result the 4-byte header read can extend up to 3 bytes past the declared TLV area, and the returned (off, len) can describe a payload that runs past it.
The path is pre-authentication: TLVs are parsed during bootutil_img_validate() before the signature is verified, and a crafted image can be presented through DFU / serial-recovery / OTA. However the impact is contained by surrounding guards: bootutil_img_validate() first rejects a TLV area larger than bootutil_max_image_size(), the default LOAD_IMAGE_DATA sink is flash_area_read() which bounds-checks against the flash partition and fails an out-of-partition read, and every payload consumer (EXPECTED_HASH_TLV, EXPECTED_KEY_TLV, EXPECTED_SIG_TLV, IMAGE_TLV_SEC_CNT) clamps len against a fixed buffer before copying.
The residual effect in a default flash build is therefore an out-of-region read confined to the attacker's own slot partition whose result is never observable, yielding at worst a clean validation failure rather than memory corruption or information disclosure. A genuine (though still bounded) out-of-bounds read remains under the non-default MCUBOOT_RAM_LOAD configuration, where LOAD_IMAGE_DATA is an unchecked memcpy. The fix is to validate each entry's header and payload against it->tlv_end inside the iterator.
ComfyUI-Easy-Use version 1.3.6 contains a path traversal vulnerability in the `save_preview()` handler for POST `/easyuse/save/{name}`. The handler checks the source directory before appending a user-supplied filename and allows the request to select the `custom_nodes` directory as a copy destination. An unauthenticated attacker who can reach the ComfyUI server can overwrite an installed custom node’s Python entry point with an uploaded file. When ComfyUI restarts and loads the modified node, the attacker’s code runs with the privileges of the ComfyUI process.
The Gradle Shadow plugin's ShadowCopyAction does not sanitize ZIP entry names before including them in the output fat JAR, allowing path traversal entries to be reproduced verbatim. This vulnerability affects versions prior to 9.6.0. Malicious dependencies with crafted ZIP entries can cause arbitrary file overwrite when the shadow JAR is extracted by downstream tools that do not protect against Zip Slip attacks.
Kopia versions up to 0.23.1 have a path traversal vulnerability in the copyDirectoryContent function. This flaw allows users with repository write access to escape the intended restore directory by using crafted directory entry names such as '..'. As a result, during restore operations with default settings, attacker-controlled content can be written outside the designated restore directory.
CVE-2026-123973 is a path traversal vulnerability in the ZIP import functionality of SharePoint Products CopyMove for SharePoint 2019 and CopyMove for SharePoint V6. An authenticated user with permission to use the ZIP import can supply a crafted ZIP archive with malicious entry paths that cause files to be extracted outside the intended directory. This vulnerability has been fixed by adding validation to prevent extraction outside the designated directory.
The Redirection for Contact Form 7 WordPress plugin up to version 3.2.14 contains an authorization bypass vulnerability. This flaw allows unauthenticated attackers to write arbitrary post meta values to newly created lead posts and copy server-side files with allowed MIME types into the plugin's uploads directory. Exploitation requires a published Contact Form 7 form with the Save Entry (Save Lead) action enabled.
Elo is a purely functional expression language for no-code tools. Prior to 1.0.1, the Ruby backend in src/compilers/ruby.ts embeds attacker-controlled text in Ruby double-quoted strings without escaping #, so Ruby interpolation forms in the string-literal emitter or the labelled subtype-constraint branch become executable Ruby. The affected entry points include the /try playground with the Ruby target, bin/eloc -t ruby -x, and defaultFormats.elo.parse() followed by Ruby emission. A failing labelled subtype constraint evaluates its message, while an ordinary string literal is evaluated when the compiled Ruby runs, allowing Ruby code and shell command execution through backticks. JavaScript, Python, and SQL emission are not affected by this Ruby-specific path. This issue is fixed in version 1.0.1.
Several psqlODBC entry points use an application-supplied column number or row index as an array index without validating it. SQLBindCol with a column number above 32767 wraps the binding count negative and a later copy runs off the array. A negative SQL_DESC_COUNT on an application row descriptor unbinds columns at negative indexes. SQLColAttribute with a very large column number uses a negative index. SQLSetPos(SQL_ADD) does not check the row number against the rowset size. An application that forwards untrusted column or row numbers exposes its process to out-of-bounds reads and writes. Versions before psqlODBC 18.00.0006 are affected.
PyJWT versions up to 2.13.0 and current master at commit 7144e4534c34810f4525dc4578a32addd8212cff contain a vulnerability where the HMACAlgorithm.from_jwk method accepts an empty HMAC key from a symmetric oct JWK without rejection. This allows an attacker to forge tokens by using an empty key, bypassing signature verification when the key is resolved from a JWK/JWKS containing an empty 'k' value. The issue arises because the empty-key rejection added in 2.13.0 for string/bytes secrets was not applied to the JWK verification path. The vulnerability requires no authentication but depends on the verifier accepting a JWK with an empty key, which can happen due to misconfiguration or trusting a JWKS with such an entry. A fix is available in PyJWT version 5.43.0.
PyJWT versions up to 2.13.0 and the current master branch have a vulnerability in the HMAC key verification process when using JWK/JWKS with symmetric keys (kty=oct). Specifically, the library accepts an empty HMAC key from a JWK without error, allowing an attacker to forge tokens by exploiting this empty key acceptance. This occurs because the empty key rejection implemented for string/bytes secrets was not applied to the JWK verification path. The vulnerability requires that the verifier resolve the HMAC key from a JWK/JWKS containing an empty 'k' value, which can happen due to misconfiguration or trust in a JWKS with such an entry. A fix is available in version 2.8.2_16.
PyJWT versions up to 2.13.0 and the current master commit accept an empty HMAC key when verifying tokens via the JWK/JWKS path, allowing attackers to forge tokens without knowing a secret. This occurs because the from_jwk method does not reject empty keys, unlike the string/bytes secret path which was fixed in 2.13.0. The vulnerability requires the verifier to resolve an HMAC key from a JWK with an empty 'k' value, which can happen due to misconfiguration or trusting a JWKS with such an entry.
pypdf versions prior to 6.21.3 contain a vulnerability where opening a crafted PDF with cross-reference streams declaring very large entry counts can cause excessive memory consumption. This is due to the way highly compressible streams, /Prev chains, and negative /Index counts multiply the number of parsed entries, bypassing existing limits. The issue is fixed in version 6.21.3.