Buffer Overflow

Out-of-bounds memory read in the GPU component of Google Chrome on Android (prior to 152.0.7977.65) exposes process memory outside the renderer sandbox when a victim visits a crafted HTML page. The flaw targets Android-specific GPU code paths in Chrome's rendering pipeline, producing a high confidentiality impact limited to the GPU process memory space, with no integrity or availability consequence. No public exploit has been identified at time of analysis, and an EPSS probability of 0.24% at the 15th percentile indicates low near-term opportunistic exploitation likelihood.

Heap buffer overflow in PyOpenEXR Python bindings versions 3.3.0-3.3.12 and 3.4.0-3.4.13 causes memory corruption and process crash when opening a crafted deep scanline EXR file. A specific channel naming collision - a literal channel 'left' coexisting with layer-prefixed 'left.R', 'left.G', 'left.B' - causes the wrapper to allocate scalar-shaped deep sample storage and then write into it at RGB stride (three lanes), overflowing the heap allocation. No public exploit or CISA KEV listing exists at time of analysis; vendor-confirmed fixes are available in versions 3.3.13 and 3.4.14.

Buffer overflow in Apple macOS allows a locally-running app with standard user privileges to cause unexpected system termination or write arbitrary data into kernel memory. Affected versions include macOS Sequoia before 15.7.7 and macOS Sonoma before 14.8.7. No public exploit code or active exploitation has been identified at time of analysis; EPSS sits at 0.11% (1st percentile), consistent with SSVC's assessment of no current exploitation.

Out-of-bounds read in the OpenEXR HTJ2K decoder (versions 3.4.0-3.4.12) crashes any application that opens a crafted EXR file containing a malformed PLEN (payload length) header field. The decoder advances a raw pointer into the compressed data buffer by the attacker-supplied header size without first verifying it fits within the buffer, passing the resulting out-of-bounds offset to the OpenJPH memory-input path and causing a process crash. No active exploitation has been identified and no public proof-of-concept exists; vendor-released patch v3.4.13 resolves the flaw.

Crash-inducing out-of-bounds read in OpenEXR's multipart file processing allows an attacker to cause a denial of service by supplying a crafted EXR file with an empty multiView header attribute. Affected are OpenEXR releases before 3.2.11, within the 3.3.x branch before 3.3.13, and within the 3.4.x branch before 3.4.14 - all maintained by the Academy Software Foundation. Exploitation requires user interaction to open the malicious file, limiting impact to availability only; no public exploit code or active exploitation has been identified at time of analysis.

Heap out-of-bounds read in OpenEXR's RLE decompression path crashes the decoding process on ILP32 (32-bit) builds across versions 3.2.0-3.2.10, 3.3.0-3.3.12, and 3.4.0-3.4.13. A crafted .exr file with a malicious RLE-compressed payload causes the 64-bit unpacked size to truncate before buffer allocation in OpenEXRCore decoding.c, after which unpack_32bit() reads past the allocated buffer boundary, resulting in denial of service. Exploitation requires a victim or automated pipeline to open the malicious file; no public exploit identified at time of analysis, and the vulnerability is constrained to ILP32 build environments.

Out-of-bounds write in OpenEXR's B44 decompression path on ILP32 (32-bit) builds allows an attacker to corrupt heap memory and crash any application that opens a crafted EXR file, affecting the C++ libraries, CLI tools, and PyOpenEXR bindings across versions 3.1.0-3.2.10, 3.3.0-3.3.12, and 3.4.0-3.4.13. When a malformed B44-compressed scanline image triggers integer truncation in the scratch buffer size calculation before allocation, uncompress_b44_impl() subsequently writes using the full attacker-controlled channel width into the undersized buffer, producing a heap out-of-bounds write. Patches are confirmed available in 3.2.11, 3.3.13, and 3.4.14; no public exploit is identified at time of analysis.

Out-of-bounds read in OpenEXR's ILP32 builds enables denial of service via crafted uncompressed deep-tile EXR files across three active release branches (before 3.2.11, 3.3.0-3.3.12, and 3.4.0-3.4.13). The root cause is a 32-bit integer overflow in OpenEXRCore's sample-count table size calculation that causes unpack_sample_table() to iterate beyond an undersized allocation. No public exploit or active exploitation has been identified; vendor-released patches are available for all three affected branches.

Out-of-bounds read in Adobe Substance 3D Painter exposes sensitive process memory when a victim opens a specially crafted malicious file. The flaw, classified as CWE-125, causes the application to read beyond allocated buffer boundaries during file parsing, potentially leaking in-memory data such as credentials or session tokens accessible to the attacker. Adobe has published security advisory APSB26-129 addressing the issue; no public exploit code has been identified at time of analysis.

Stack overflow denial of service in github.com/graphql-go/graphql (through v0.8.1) crashes any Go server process embedding the library when an attacker submits a specifically crafted GraphQL request containing a deeply nested scalar value of a mismatched type. The `coerceString` and `coerceBool` functions in `scalars.go` violate the GraphQL specification by accepting type-mismatched scalar input instead of returning a request error, and under specific deep-nesting conditions exhaust Go's call stack and trigger an unrecoverable fatal error that immediately terminates the host process. A publicly available proof-of-concept exists via the Openwall security list; however, no active exploitation is confirmed in CISA KEV, and the CVSS 4.0 vector (AV:L, AT:P) combined with the description's explicit caveat that this is not triggered by typical web JSON traffic indicates exploitation requires a non-standard input path.

Out-of-bounds read in Adobe Illustrator Desktop 2025 and 2026 exposes sensitive process memory to disclosure when a victim opens a specially crafted file. The vulnerability carries a CVSS 3.1 score of 5.5 (Medium) with a local attack vector and required user interaction, limiting opportunistic exploitation but making it viable in targeted social-engineering campaigns. No public exploit code has been identified and the vulnerability is not listed in the CISA KEV catalog at time of analysis.

Integer overflow leading to out-of-bounds write in NI LabVIEW 2026 Q3 and prior enables information disclosure or arbitrary code execution when a user opens a specially crafted VI file. The attack is file-based and requires social engineering to deliver a malicious Virtual Instrument file to a target, making it a credible threat in engineering, research, and industrial automation environments where VI files are routinely shared. No public exploit identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog.

Out-of-bounds read in the NVIDIA DGX Spark standalone Memory Management (MM) firmware enables a local high-privileged attacker to read beyond allocated buffer boundaries, leaking potentially sensitive memory contents across security boundaries (S:C/C:H per the CVSS vector). The scope change in the CVSS vector suggests that data disclosed may originate from security domains beyond the firmware itself, such as the host OS or adjacent processes. No public exploit code or active exploitation has been identified at time of analysis, and the high-privilege local access requirement substantially constrains the realistic attacker population.

Out-of-bounds read in NI LabVIEW 2026 Q3 and all prior versions can result in information disclosure or arbitrary code execution when the application processes a maliciously crafted VI file containing a specially structured image. The root cause is a signed-to-unsigned integer conversion error (CWE-195) in the image-loading code path, causing the parser to read beyond intended memory boundaries. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in the CISA Known Exploited Vulnerabilities catalog.

Out-of-bounds read in the Zephyr ext2 filesystem driver crashes any device that mounts a crafted ext2 image. The superblock fields s_blocks_count and s_first_data_block are consumed verbatim without being bounded against the single-group bitmap capacity, allowing a malicious image to drive ext2_bitmap_count_set() roughly 512 MB past the allocated bitmap block. The resulting memory access crosses an unmapped or MPU-protected region and faults, producing a denial-of-service crash. No public exploit exists and the vulnerability is not in CISA KEV; real-world risk is bounded by the requirement to supply untrusted ext2 media to a target device.

Stack buffer overflow in Zephyr RTOS's virtio PCI driver (drivers/virtio/virtio_pci.c) allows a malicious virtio device to corrupt the kernel stack with up to ~228 bytes of device-controlled data, or trigger a near-unbounded write via unsigned underflow, during boot-time device probe. All Zephyr versions are potentially affected (CPE: cpe:2.3:a:zephyrproject:zephyr:*:*:*:*:*:*:*:*) when compiled with CONFIG_ASSERT disabled, which is the production default. Exploitable scenarios are limited to bare-metal systems with untrusted physical or passthrough virtio PCIe devices, or confidential computing deployments where the Zephyr guest must be defended against a potentially malicious hypervisor. No public exploit identified at time of analysis; upstream patch is available at commit d98dacee.

Heap-based buffer under-read in libxml2's XML Schema identity constraint processor affects all Nokogiri releases prior to 1.18.8, which bundle the vulnerable libxml2 library. The flaw in xmlSchemaIDCFillNodeTables can be triggered by supplying a crafted XSD schema or by submitting untrusted XML documents for validation against trusted schemas that combine xsd:keyref with recursively defined types carrying additional identity constraints. No public exploit has been identified at time of analysis, and upstream libxml2 maintainers and MITRE independently rate actual exploitability as low - in notable conflict with the NVD-assigned CVSS 4.0 base score of 8.7.

Resource exhaustion via crafted SASL UNBIND in 389 Directory Server (389-ds-base) allows a remote authenticated attacker to stall connections and deny LDAP service to legitimate users. Affected deployments span Red Hat Directory Server 11, 12, and 13, plus 389-ds-base as packaged across RHEL 6 through 10. No public exploit code or CISA KEV listing has been identified at time of analysis, though the CVSS 6.5 rating (AV:N/AC:L/PR:L) indicates low-complexity network exploitation requiring only a low-privilege LDAP bind - a realistic bar in any environment with shared directory users.

Stack buffer overflow in file-roller's archive extraction path causes denial of service when a victim opens or extracts a crafted 7z or RAR archive containing an excessively long file path entry. The unbounded string copy in the progress-line parsing routine overwrites a fixed-size stack buffer, crashing the application with no confidentiality or integrity impact. No public exploit code or CISA KEV listing has been identified at time of analysis, and exploitation is gated entirely on user interaction with a malicious archive.

Stack-based buffer overflow in SKYSEA Client View and SKYMEC IT Manager (SKY Co., Ltd.) enables an authenticated attacker to remotely execute arbitrary code on other Windows hosts running the same software via crafted UDP packets. The vulnerability functions as a lateral movement primitive: an attacker who has already obtained a login on one managed endpoint can exploit the product's UDP listener on any other reachable managed host, without requiring further interaction from the target. Reported by JPCERT/CC via JVN#JVN33423625, no public exploit or CISA KEV listing has been identified at the time of analysis.

Out-of-bounds write in Zephyr RTOS's ext2 filesystem driver enables supervisor-mode memory corruption when a device mounts a crafted ext2 image from a physical storage medium such as an SD card. The driver's superblock validation function omits bounds-checking the s_log_block_size field, allowing an attacker-controlled value to produce an inflated block size that silently misconfigures the kernel memory slab allocator beyond its static backing buffer, with impact ranging from denial of service to potential code execution in kernel mode. No confirmed active exploitation or public POC is identified at time of analysis; a vendor patch is available as upstream commit f270f4bd0e59585da31e1fbaa79c5abf73f1364b.

Heap out-of-bounds write in OpenEXR's DeepImage API affects all versions prior to 3.2.10, 3.3.12, and 3.4.13, exploitable by processing a crafted deep image EXR file. A coordinate axis confusion bug in `Imf_4_0::SampleCountChannel::set()` uses `dataWindow.min.x` instead of `dataWindow.min.y` when computing a target Y coordinate, causing memory writes before the allocated `_numSamples` heap buffer when `min.x ≠ min.y`. No public exploit identified at time of analysis; SUSE Linux Enterprise distributions have received vendor-released patches confirming active remediation.

Stack-based out-of-bounds write in OpenEXR's HTJ2K decode path allows remote attackers to crash applications that process crafted EXR image files. Affected are OpenEXR versions 3.4.0 through 3.4.13, where the vendored OpenJPH AVX2 decoder fails to reject JPEG 2000 SIZ marker geometries in which the first tile does not intersect the visible image, leading to invalid codeblock computation and a stack memory corruption that terminates the process. No public exploit identified at time of analysis; a vendor-released patch is available in version 3.4.14.

Stack exhaustion and a bounded memory over-read in GIMP's file-pix (ESM) plugin allow a crafted PIX image to crash the application and leak 21 bytes of stack memory into an intermediate file. Users running GIMP on Red Hat Enterprise Linux 6 through 9 are affected when opening untrusted PIX format images. No public exploit code and no active exploitation (CISA KEV) have been identified at time of analysis, though the DoS impact is reliable and the delivery vector - a malicious image file - is realistic for desktop users.

Zephyr RTOS's Hearing Access Service (HAS) GATT peripheral crashes when a previously bonded Bluetooth peer reconnects during a boot-time race window before bt_has_register() completes service initialization. The security_changed() callback - registered unconditionally via BT_CONN_CB_DEFINE - fires against NULL attribute pointers, triggering either a kernel assertion or a NULL dereference in bt_gatt_is_subscribed(). With CVSS AV:A/AC:H and confirmed DoS-only impact, this represents a medium-severity availability risk against embedded hearing-aid devices running Zephyr 3.6.0 through 4.4.1; no public exploit code has been identified, and a vendor patch is confirmed at 4.4.2.

Denial of service in OpenThread, the open-source Thread networking stack embedded in Google Nest devices (identified as Nest 3.78.518349), lets an attacker who has already joined the same Thread mesh send crafted Mesh Link Establishment (MLE) packets that trigger reachable assertion failures and a stack-based buffer overflow, crashing affected nodes. The flaw carries a vendor CVSS 4.0 score of 10.0, though the description scopes real-world impact to denial of service rather than the code execution the score's high confidentiality/integrity metrics would imply. There is no public exploit identified at time of analysis and it is not on CISA KEV.

Out-of-bounds write in warmcat libwebsockets 4.5.0 allows remote unauthenticated attackers to corrupt process memory by submitting crafted CBOR-encoded data to any network-accessible endpoint using the LECP CBOR parser. The root cause is a dual defect in `lecp_parse` and `report_raw_cbor` within `lib/misc/lecp.c`: an equality-only bounds check (`== sizeof(ctx->cbor)`) fails to catch cases where `cbor_pos` has already exceeded the buffer limit, and `cbor_pos` was reset after rather than before the flush callback, creating a window for sequential over-increment. No public exploit identified as confirmed active exploitation (CISA KEV), but a public proof-of-concept is confirmed at the referenced GitHub repository, and a patch commit has been issued upstream.

Heap-based buffer overflow in Open5GS 2.8.0's HSS S6a Authentication-Information-Request handler allows network-adjacent authenticated Diameter peers to corrupt process heap memory by supplying a malformed Visited-PLMN-Id AVP with an incorrect octet-string length. The vulnerable function `hss_ogs_diam_s6a_air_cb` in `src/hss/hss-s6a-path.c` passes raw AVP data to cryptographic key derivation (`ogs_auc_kasme`) without first validating that the PLMN identifier length matches the expected 3-byte constant `OGS_PLMN_ID_LEN`. No active exploitation is confirmed (no CISA KEV listing), but a proof-of-concept signal is present in the CVSS 4.0 threat metric (E:P); an upstream fix commit is available though a formally tagged patched release is not independently confirmed.

Out-of-bounds read in Open5GS 2.8.0 PCRF Rx AA-Request handler allows remote low-privileged attackers with Diameter Rx interface access to send crafted AA-Request messages containing null or incorrectly-sized Framed-IP-Address or Framed-IPv6-Prefix AVPs, triggering memory reads beyond allocated boundaries. The patch commit c18dc6938bf63cc7374315d3dca303d92066e746 adds missing null and length validation for both AVP types; a tagged release incorporating it has not been independently confirmed. No active exploitation is recorded in CISA KEV, though the CVSS 4.0 E:P flag indicates proof-of-concept code is known to exist.

Out-of-bounds memory corruption in SpaceDot AcubeSAT On-Board Computer software's CAN message parsing crashes the system when processing malformed ECSS telecommand packet headers. The vulnerable component MessageParser::parseECSSTCHeader at commit eaf90ec performs insufficient bounds checking, enabling denial-of-service against the spacecraft's onboard computer via a crafted CAN message. No active exploitation has been confirmed; an EPSS of 0.15% (4th percentile) is consistent with the highly specialized and niche deployment context of this aerospace platform.

Out-of-bounds read in S2OPC's AddNodes service allows remote attackers to trigger memory read violations via a crafted UserAccessLevel argument, causing low-severity availability impact on vulnerable server instances running version 1.7.3 and earlier. The flaw resides in SOPC_NodeMgtHelperInternal_AddVariableNodeAttributes within the address space management layer of this OPC UA stack, which is deployed primarily in industrial automation and ICS/SCADA environments. A public proof-of-concept exploit has been disclosed, though high attack complexity (AC:H) limits opportunistic exploitation; no public exploit identified at time of analysis as a KEV-confirmed active threat.

In the Linux kernel, the following vulnerability has been resolved: soc: aspeed: lpc-snoop: Fix usercopy overflow in snoop_file_read put_fifo_with_discard() acts as both producer and consumer on the kfifo: it calls kfifo_skip() (advances out) and kfifo_put() (advances in) from the IRQ handler without synchronizing with snoop_file_read(), which also consumes via kfifo_to_user(). On SMP systems this concurrent access can leave (in - out) larger than the ring buffer, so __kfifo_to_user()'s clamp to (in - out) is ineffective and kfifo_copy_to_user() can attempt a copy_to_user() past the kmalloc-2k backing store: usercopy: Kernel memory exposure attempt detected from SLUB object 'kmalloc-2k' (offset 0, size 2049)! kernel BUG at mm/usercopy.c! Call trace: usercopy_abort __check_heap_object __check_object_size kfifo_copy_to_user __kfifo_to_user snoop_file_read vfs_read Serialize kfifo access with a per-channel spinlock shared between the IRQ handler (producer) and the file reader (consumer). Annotate @fifo with __guarded_by(&lock) and opt the driver into context analysis so the compiler enforces that all fifo access holds the lock.

In the Linux kernel, the following vulnerability has been resolved: hwmon: (ltc4282) Clamp negative current limits When a negative value is passed to ltc4282_write_curr(), the signed long val is cast directly to u64: drivers/hwmon/ltc4282.c:ltc4282_write_curr() { /* need to pass it in millivolt */ u32 in = DIV_ROUND_CLOSEST_ULL((u64)val * st->rsense, DECA * MICRO); ... } This cast converts negative inputs into large positive values. The subsequent division result overflows the u32 in variable, truncating to a pseudo-random positive value. When this is passed to ltc4282_write_voltage_byte(), it is clamped to the maximum limit instead of zero. Clamp val to 0 and to the maximum supported upper limit before the cast and assign the result to a 64-bit temporary variable before the division to avoid the underflow and an also possible overflow.

In the Linux kernel, the following vulnerability has been resolved: Input: evdev - sanitize event type index when fetching event masks The user-supplied event type index passed to EVIOCGMASK / EVIOCSMASK ioctls is used to index the static counts array in evdev_get_mask_cnt() and client evmasks array in evdev_get_mask(). While the event type is architecturally bounded by EV_CNT, speculative execution may mispredict bounds checks and perform out-of-bounds loads. Sanitize the event type index in evdev_get_mask_cnt() branchlessly using array_index_mask_nospec(). This clamps the index to 0 for safe array access and forces the returned count to 0 speculatively when the index is out of bounds. We do not need additional array_index_nospec() calls in evdev_get_mask() because evdev_get_mask_cnt() speculatively forces the count (and resulting xfer_size) to 0 for out-of-bounds types, preventing any speculative memory access to client evmasks array.

In the Linux kernel, the following vulnerability has been resolved: ALSA: usb-audio: fix OOB write on Type II inbound URBs data_ep_set_params() sizes each URB transfer buffer before it adds the Format Type II transfer delimiter: u->packets = urb_packs; u->buffer_size = maxsize * u->packets; if (fmt->fmt_type == UAC_FORMAT_TYPE_II) u->packets++; /* for transfer delimiter */ u->urb = usb_alloc_urb(u->packets, GFP_KERNEL); buffer_size is computed from the pre-increment packet count and never recomputed, so for a Type II endpoint the buffer is one packet short of the packet count the URB is built with. prepare_inbound_urb() then lays out one iso frame per packet and never consults buffer_size: offs = 0; for (i = 0; i < urb_ctx->packets; i++) { urb->iso_frame_desc[i].offset = offs; urb->iso_frame_desc[i].length = ep->curpacksize; offs += ep->curpacksize; } urb->transfer_buffer_length = offs; urb->number_of_packets = urb_ctx->packets; The last descriptor therefore points one packet past the end of the transfer buffer, where the host controller writes device data on every inbound transfer. prepare_silent_urb() and prepare_playback_urb() bound their fill loops by ctx->buffer_size, so only capture is affected. fmt_type comes from the device's audio streaming descriptors, so any device advertising a Type II capture format hits this once userspace sets hw_params on the stream. KASAN on 7.2.0-rc5 (arm64) with a dummy_hcd/raw-gadget device, one report per inbound transfer: BUG: KASAN: slab-out-of-bounds in dummy_timer Write of size 64 at addr ffff0000186171c0 by task cons02/166 __asan_memcpy dummy_timer hrtimer_run_softirq Allocated by task 166: usb_alloc_coherent snd_usb_endpoint_set_params The buggy address is located 0 bytes to the right of allocated 64-byte region [ffff000018617180, ffff0000186171c0) Compute buffer_size after the delimiter packet has been accounted for, and bound the fill loop by buffer_size, as prepare_silent_urb() already does on the outbound side. This grows every Type II URB allocation by one maxsize packet. Discovered by XBOW, triaged by Baul Lee <baul.lee@xbow.com>

In the Linux kernel, the following vulnerability has been resolved: usb: gadget: f_ncm: Use unsigned int for ndp_index The variable ndp_index is declared as a signed integer, but it stores the return value of get_ncm(), which is unsigned. A malicious host can supply a large offset that overflows the signed ndp_index, making it negative. Because ndp_index is compared against unsigned bounds, this negative value bypasses sanity checks and leads to an out-of-bounds read when calculating the address of the NDP block (ntb_ptr + ndp_index). Fix this by changing ndp_index to unsigned int to ensure consistent unsigned comparisons throughout the function.

In the Linux kernel, the following vulnerability has been resolved: ima: fix out-of-bounds read in xattr_verify() The digest-length check in xattr_verify() mixes int and size_t: if (xattr_len - sizeof(xattr_value->type) - hash_start >= iint->ima_hash->length) sizeof() yields size_t, so the usual arithmetic conversions promote the whole left-hand side to unsigned 64-bit before the subtraction runs. For a truncated xattr this underflows instead of going negative: a 1-byte IMA_XATTR_DIGEST_NG xattr (xattr_len == 1, hash_start == 1) turns "1 - 1 - 1" into SIZE_MAX, which is trivially >= ima_hash->length. The check then passes and the following memcmp() reads iint->ima_hash->length bytes starting past the end of the buffer vfs_getxattr_alloc() allocated for it. Nothing upstream clamps xattr_len back into a safe range first: ima_get_hash_algo() only special-cases xattr_len < 2 to pick a default algorithm, and evm_verifyxattr() returns INTEGRITY_UNKNOWN rather than failing when no HMAC key is loaded, so a truncated security.ima value reaches the length check as-is. Rewrite the comparison so every operand stays a signed int and no implicit conversion to size_t can occur.

In the Linux kernel, the following vulnerability has been resolved: staging: rtl8723bs: fix OOB read in WMM_param_handler() WMM_param_handler() copies a fixed-size WMM parameter element out of a received information element without checking that the element is long enough, causing an out-of-bounds read for a short WMM IE. The handler reads sizeof(struct WMM_para_element) (18) bytes at pIE->data + 6, so it requires pIE->length to be at least 24 (WLAN_WMM_LEN), but it never validates the length. Two of its three callers reach it after matching only the WMM OUI: OnAssocRsp() in rtw_mlme_ext.c matches a 6-byte OUI, and join_cmd_hdl() matches a 4-byte OUI, before calling the handler. A vendor-specific IE carrying the WMM OUI but a length between 6 and 23, placed in an association response or in the IE blob handed to join_cmd_hdl(), passes the OUI check and then makes the memcmp() and memcpy() at pIE->data + 6 read past the end of the element. OnAssocRsp() parses a frame received from the AP, so this is reachable from a remote peer. The remaining caller in rtw_wlan_util.c already guards the handler with "pIE->length == WLAN_WMM_LEN". Move the equivalent check into the handler itself so every caller is covered; the sibling IE handlers in the same parsing loop (HT_caps_handler(), HT_info_handler(), ERP_IE_handler()) likewise bound their accesses by pIE->length.

In the Linux kernel, the following vulnerability has been resolved: mm/page_table_check: skip special zero mappings page_table_check_set() and page_table_check_clear() account mappings based on PageAnon(). Shared zero-page PTEs and huge zero PMDs are special mappings, but page_table_check can still account them as file-backed pages. An unprivileged process can populate enough zero mappings to overflow file_map_count and hit the existing BUG_ON(). The PTE path can do this with the shared zero page, and the PMD path can do the same with huge zero mappings. Skip special zero mappings in the user page-table accounting paths. Keep the PTE-side pte_special() check, and identify huge zero PMDs from the mapped folio instead of pmd_special(). That covers architectures where pmd_special() is a no-op without adding huge_zero_pfn checks to the generic counter helpers.

In the Linux kernel, the following vulnerability has been resolved: thunderbolt: Bound the DROM dual link port number before indexing sw->ports tb_drom_parse_entry_port() validates the device-supplied header->index against sw->config.max_port_number before indexing sw->ports[], but the sibling field entry->dual_link_port_nr -- a 6-bit value also read from the DROM -- indexes the same array with no such check. A malicious or malformed Thunderbolt device can set dual_link_port_nr beyond the allocated sw->ports[] (max_port_number + 1 entries), producing an out-of-bounds tb_port pointer that is stored and later dereferenced. Reject a port entry whose dual_link_port_nr exceeds max_port_number, the same bound already applied to header->index.

Heap buffer overflow in hashcat through version 7.1.2 allows an attacker who controls a hash file to crash the process and corrupt heap memory when an operator runs hashcat with the --username --show flags. The outfile_write() function in src/outfile.c sequentially appends username, separator, hash, and plaintext into a fixed ~16 MB heap buffer (HCBUFSIZ_LARGE) via memcpy without tracking accumulated length against buffer capacity, enabling an out-of-bounds write. No active exploitation has been confirmed (not in CISA KEV), and a vendor patch has been released via upstream commit.

Out-of-bounds heap write in hashcat's fgetl() function affects all versions through 7.1.2, triggered by supplying any input file - hash file, potfile, or wordlist - containing a line of exactly HCBUFSIZ_LARGE bytes, causing a one-byte null write past the caller's buffer. The resulting heap corruption can crash hashcat or, in a worst case, create memory exploitation primitives; confidentiality is unaffected (VC:N per the CVSS 4.0 vector) while availability impact is rated high. No public exploit or active exploitation has been identified at time of analysis, and a vendor-released patch commit is available.

Heap-based buffer overflow in luci-lib-px5g's native ASN.1 encoding routine allows a locally authenticated attacker to write one byte beyond a heap-allocated buffer during certificate signing, with a high availability impact and limited confidentiality and integrity exposure. The flaw is triggered specifically when signing with a 2040-bit RSA key via the exported Lua interface create_selfsigned(), where a DER length encoding miscalculation causes an allocation of 259 bytes for a payload requiring 260. Remote exploitability is not confirmed - it depends entirely on whether the embedding application exposes this interface externally. No public exploit code has been identified at time of analysis, and this CVE is not listed in the CISA KEV catalog.

Out-of-bounds read in iccDEV (all versions prior to 2.3.2.1) crashes the ICC profile parser via a size_t integer underflow in CIccEmbedIO::Read8() when processing embedded ICC v5 profiles. Unauthenticated remote attackers can trigger the denial-of-service condition by delivering a maliciously crafted ICC profile that requires user interaction to parse (e.g., opening a file in an application backed by this library). No public exploit code and no CISA KEV listing exist at time of analysis; vendor-released patch version 2.3.2.1 is available.

Unexpected application termination in Apple macOS arises when processing a maliciously crafted file, triggering an out-of-bounds read (CWE-125) that crashes the handling application. Affected versions span all three active macOS release trains: Sonoma prior to 14.8.5, Sequoia prior to 15.7.5, and Tahoe prior to 26.4. No public exploit code has been identified and EPSS sits at the 5th percentile (0.15%), indicating low real-world exploitation probability; vendor-released patches are available for all three tracks.

Out-of-bounds write in IBM AIX 7.2/7.3 and PowerVM VIOS 4.1 enables a local, low-privileged attacker to crash the affected system, resulting in a denial of service. The CVSS scope-change metric (S:C) is particularly significant in the PowerVM context: a crash of the VIOS host can simultaneously disrupt I/O services for all co-hosted guest logical partitions (LPARs) sharing that VIOS, amplifying the blast radius well beyond the directly exploited node. No public exploit code and no confirmed active exploitation have been identified at time of analysis.

Kernel memory disclosure in IBM AIX 7.2 and 7.3, and IBM PowerVM VIOS 4.1 allows a local attacker with standard user privileges to read sensitive out-of-bounds kernel memory via an unspecified vulnerability. The CVSS vector (AV:L/AC:L/PR:L/UI:N) confirms exploitation requires only a local shell account with no elevated rights, making it viable for any authenticated local user or a compromised service account. No public exploit code has been identified at time of analysis, and IBM has released a patch via the vendor advisory.

Heap-based buffer overflow in IBM AIX 7.2, 7.3 and PowerVM VIOS 4.1 enables a local authenticated attacker with high privileges to execute arbitrary code on affected systems. The vulnerability is rooted in improper memory management (CWE-787) and carries a CVSS 3.1 score of 6.7, reflecting the local access requirement and elevated privilege prerequisite that constrain real-world exploitability. IBM has released a patch via its support portal; no public exploit code or CISA KEV listing has been identified at time of analysis.

Out-of-bounds read in Capstone's SuperH (SH) architecture disassembler crashes the host process when fed crafted SH2A or SH4A bytecode. Versions 6.0.0-Alpha9 and earlier are affected when the library handle is configured with CS_ARCH_SH plus CS_MODE_SH2A or CS_MODE_SH4A and CS_MODE_SHFPU; the disassembler derives an idx value from a raw 16-bit instruction and dereferences a mode-specific decode[] function-pointer table without a bounds check. The demonstrated impact is limited to process termination - no code execution or information disclosure was shown - and a vendor-released patch is available in 6.0.0-Alpha10.

Heap buffer overflow in libvips prior to 8.18.3 allows up to 4032 bytes to be written beyond an allocated heap buffer during processing of untrusted uncompressed PPM images via custom source objects, potentially causing memory corruption or a process crash. The flaw exists specifically in vips_source_read_to_memory in libvips/iofuncs/source.c, where VIPS_MAX was used instead of VIPS_MIN when computing the remaining read size. No public exploit code exists and this is not listed in CISA KEV; the CVSS 4.0 score of 5.8 reflects meaningful constraints including local attack vector, high complexity, and a prerequisite of non-default custom source configuration.

Heap out-of-bounds read in libvips before 8.18.3 leaks four bytes of adjacent heap memory when parsing a crafted Radiance HDR image whose first scanline begins with an RLE repeat marker. The old-style decoder in `scanline_read_old` dereferences `q[-1]` without confirming a prior pixel exists, disclosing data most likely belonging to adjacent image buffers. No public exploit or active exploitation has been identified; the fix is confirmed in the v8.18.3 release.

Heap buffer over-read in libvips prior to 8.18.3 allows disclosure of adjacent heap memory or process crash when processing JPEG images through the UltraHDR save pipeline. The flaw in `vips_foreign_save_uhdr_set_raw_hdr` stems from using raw pixel dimension arithmetic instead of the library's safe `VIPS_IMAGE_N_PELS` macro to size an output buffer, producing an undersized allocation when a pipeline enlarges an incoming JPEG before gain-map encoding. No active exploitation is confirmed (not in CISA KEV), no public exploit code exists, and a vendor-released patch is available in v8.18.3.

Binary HTTP parser in Netty's `netty-incubator-codec-bhttp` (all versions through 0.0.22.Final) crashes with an unchecked `ArrayIndexOutOfBoundsException` when processing a 15-byte crafted payload, enabling remote unauthenticated denial of service. The parser accumulates attacker-controlled varint field lengths - read correctly as `long` - into `int` offset counters; a value of 2^31 silently wraps the accumulator negative via Java's compound-assignment narrowing, bypassing the readable-bytes guard and reaching unchecked buffer index arithmetic. Publicly available exploit code exists per the GitHub advisory GHSA-pgrf-4654-3gq8; no active exploitation is confirmed in CISA KEV.

Heap buffer overflow in msgpack-c through version 7.0.1 results from an integer overflow in msgpack_unpacker_expand_buffer, where unchecked size_t addition of the requested reservation size and current buffer usage wraps to near-zero on near-SIZE_MAX inputs, causing the allocator to receive a massively undersized target while the function falsely reports success to the caller. Integrations that pass attacker-controlled lengths to the msgpack_unpacker_reserve_buffer API - such as custom length-prefixed streaming transports - can trigger subsequent heap overwrites when the caller writes the full declared length into the undersized buffer. No public exploit code or CISA KEV listing exists at time of analysis; exploitation requires a specific non-default integration pattern not present in msgpack-c's own internal decode paths.

Use-after-free memory corruption in libevent's evbuffer_add_buffer_reference (buffer.c) allows a caller that can drive a specific empty-buffer state to trigger process crashes or heap corruption in any application linking the library. Affected are libevent stable releases before 2.1.13 and development releases 2.2.0-alpha through 2.2.2-alpha; the root cause is that evbuffer_free_all_chains frees the initial empty chain without nullifying the three outbuf chain-tracking pointers, after which APPEND_CHAIN_MULTICAST dereferences the now-dangling pointer. No public exploit code and no active exploitation (CISA KEV) has been identified at time of analysis; vendor-released patches are available for both stable and alpha branches.

Heap buffer overflow in SumatraPDF 3.6.1 and earlier enables an attacker who delivers a crafted CHM file to corrupt parser heap memory via malformed LZX Huffman code lengths. The PRETREE path in make_decode_table writes internal Huffman tree nodes beyond the 104-entry PRETREE_table boundary into adjacent struct LZXstate heap memory, reachable through the chm_open → chm_retrieve_object → LZXdecompress → BUILD_TABLE call chain. No public exploit or active exploitation is confirmed; arbitrary code execution has not been demonstrated, though the upstream fix commit validates that reliable heap corruption is achievable.

Arbitrary code execution is possible on Sony XAV-9500ES car AV receiver devices through a buffer overflow in the gpsd daemon's NMEA data processing, requiring the attacker to be physically present with the device. The flaw (CWE-120) stems from the absence of length validation before copying externally supplied NMEA input into a fixed-size stack or heap buffer within gpsd. Exploitation requires chaining with at least one additional vulnerability to achieve meaningful code execution, and no public exploit code or CISA KEV listing has been identified at time of analysis.

Out-of-bounds read in the prh_l2_decode_packet function of Sony XAV-9500ES car head unit firmware 3.02.0.0 exposes device memory contents to network-adjacent attackers over Bluetooth. Exploitation requires a malicious Bluetooth device to be paired with the target unit, after which crafted L2CAP packets trigger a read past the end of an allocated buffer, leaking sensitive memory. While the standalone impact is information disclosure, ZDI notes this vulnerability can be chained with additional flaws to achieve arbitrary code execution on the device; no public exploit identified at time of analysis.

Heap-based buffer overflow in the vCardParser class of the Kenwood DNR1007XR automotive multimedia receiver allows physically present, unauthenticated attackers to execute arbitrary code with root privileges. The flaw stems from missing bounds validation when copying attacker-controlled string data into a heap-allocated buffer during vCard contact parsing. No public exploit code or active exploitation has been identified at time of analysis; ZDI tracked this internally as ZDI-CAN-28974 and issued advisory ZDI-26-488.

Out-of-bounds write in Kenwood DNR1007XR firmware enables physically present, unauthenticated attackers to execute arbitrary code at root privilege via the tchdr_bytestream_read function. The device - an in-vehicle infotainment/navigation unit - fails to bounds-check user-supplied data during bytestream parsing, resulting in a heap or stack write past the allocated buffer. No public exploit or active CISA KEV listing has been identified at time of analysis, and real-world impact is materially constrained by the physical access prerequisite.

Out-of-bounds read in liftoff-sr CIPster's TCP Encapsulation Receive Path allows remote unauthenticated attackers to crash or disrupt EtherNet/IP adapter availability. The vulnerability in `Encapsulation::ReceiveTcpMsg` (`encap.cc`) causes the function to return a success-indicating length value after silently discarding an oversized TCP payload, prompting the caller to parse an already-discarded buffer and triggering the out-of-bounds read. No public exploit identified at time of analysis per KEV, though publicly available exploit code exists per CVSS 4.0 E:P supplemental metric and VulDB disclosure.

Out-of-bounds read in CIPster (liftoff-sr, commit 1802525be27d) allows remote unauthenticated attackers to crash the EtherNet/IP stack by sending a crafted ForwardOpen request with a manipulated product_code_ argument to the CipConnMgrClass::forward_open handler in cipconnectionmanager.cc. The underlying defect is a missing class-type validation in ConnectionData::ResolveInstances, which permits crafted connection paths to reference instances of unexpected CIP object classes, triggering memory access beyond valid bounds. A public proof-of-concept exploit exists per the CVSS 4.0 E:P supplemental metric and VulDB disclosure; the vulnerability is not listed in the CISA KEV catalog at the time of analysis.

Memory corruption in liftoff-sr CIPster's generic attribute logic exposes EtherNet/IP-connected devices to remote buffer overrun attacks requiring no authentication. The vulnerability exists in the CipAttribute::SetAttrData decode path, where the prior ByteBuf-based design tracked only a {start, limit} view of byte-array backing buffers without recording physical capacity - allowing a wire-supplied length value to direct writes beyond the allocated memory region. Publicly available exploit code exists (referenced in GitHub issue #47); the vulnerability is not listed in CISA KEV as of the time of analysis.

Pcapng file parser crash in Wireshark 4.6.0-4.6.7 and 4.4.0-4.4.18 enables denial of service via a locally-opened malformed capture file. Rooted in CWE-125 (Out-of-Bounds Read), the parser reads beyond an allocated buffer boundary when processing certain pcapng structures, causing application termination. No public exploit identified at time of analysis and not listed in CISA KEV; real-world risk is constrained by the local attack vector and required user interaction.

Wireshark's Tektronix K12xx file parser crashes when processing a malformed capture file, causing a denial of service in versions 4.6.0-4.6.7 and 4.4.0-4.4.18. Rooted in CWE-126 (Buffer Over-read), the flaw allows an attacker to terminate Wireshark on a victim's system by inducing them to open a specially crafted K12xx-format file. No public exploit code and no active exploitation (CISA KEV) have been identified; the low CVSS score of 3.1 reflects the crash-only impact and mandatory user interaction.

Wireshark's Kerberos protocol dissector in versions 4.4.0-4.4.18 and 4.6.0-4.6.7 contains an out-of-bounds read (CWE-125) that crashes the application when parsing a maliciously crafted packet capture file, causing denial of service. Exploitation requires a local user to actively open the crafted file, making this a user-interaction-dependent, local-vector attack with no confidentiality or integrity impact. No public exploit code or active exploitation has been identified at time of analysis.

Denial of service in Wireshark's Bluetooth Hands-Free Profile (HFP) protocol dissector affects versions 4.6.0-4.6.7 and 4.4.0-4.4.18, causing application crashes via malformed HFP traffic or crafted capture files. The CWE-125 out-of-bounds read root cause is confirmed by NVD; CVSS impact is confined to availability (A:H, C:N, I:N), though tags include 'Information Disclosure' - a discrepancy unresolved from available data. No public exploit code identified and this is not listed in CISA KEV, keeping real-world risk moderate and largely limited to active Wireshark users handling Bluetooth traffic.

Denial of service in Wireshark's 3GPP phone log file parser affects versions 4.6.0-4.6.7 and 4.4.0-4.4.18, crashing the application when a specially crafted log file is opened. The root cause is CWE-787 (out-of-bounds write), consistent with a buffer overflow in the parser's memory handling. No active exploitation is confirmed and no public exploit code has been identified, keeping real-world risk moderate despite the high availability impact on the local process.

Heap-based buffer overflow in Wireshark's SSH protocol dissector affects versions 4.6.0-4.6.7 and 4.4.0-4.4.18, crashing the application and causing denial of service. An attacker delivers a crafted network capture file or malformed live SSH traffic; when a user opens or captures it with an affected Wireshark build, the dissector overflows a heap buffer and terminates the process. No public exploit code has been identified at time of analysis, and this vulnerability is not listed in the CISA KEV catalog.

Heap-based buffer overflow in Wireshark's Bluetooth AVRCP protocol dissector crashes the application when processing malformed AVRCP packets, enabling denial of service against versions 4.6.0-4.6.7 and 4.4.0-4.4.18. The CVSS vector (AV:L/UI:R) indicates the attack requires a user to open or process a crafted packet capture file - this is not a remotely triggerable crash but a file-based DoS vector typical of Wireshark dissector flaws. No public exploit code has been identified and the vulnerability is not listed in the CISA KEV catalog at time of analysis.

Heap-based buffer overflow in Wireshark's UMTS FP protocol dissector crashes the application across affected 4.4.x and 4.6.x releases, enabling denial of service against network analysts and security teams. Wireshark versions 4.4.0 through 4.4.17 and 4.6.0 through 4.6.7 are vulnerable when a user opens a specially crafted capture file or captures live traffic containing a malformed UMTS FP frame. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis; vendor-released patches are available in versions 4.6.8 and 4.4.18.

Wireshark's dissection engine in versions 4.4.0-4.4.17 and 4.6.0-4.6.7 contains a heap-based buffer overflow (CWE-122) that crashes the application when processing a specially crafted malformed packet, yielding a denial-of-service outcome. Exploitation requires that an analyst actively opens a malicious capture file or performs live capture of adversary-controlled traffic, making this a user-interaction-dependent, high-complexity flaw with no code execution potential. No active exploitation has been confirmed by CISA KEV, no public proof-of-concept has been identified, and the CVSS 3.1 base score of 3.1 (Low) accurately reflects the constrained real-world impact.

The ERF file parser in Wireshark crashes on malformed input, enabling denial of service against analyst workstations running versions 4.4.0 through 4.4.17 and 4.6.0 through 4.6.7. Exploitation requires that a user open a specially crafted ERF capture file, and the CVSS vector (AV:N/AC:H/UI:R/A:L) reflects both the user-interaction dependency and the limited scope of impact - a crash of the Wireshark process only. No public exploit has been identified at time of analysis, and CISA KEV does not list this CVE.

Denial of service in Wireshark's Catapult DCT2000 file parser crashes the application across versions 4.6.0-4.6.7 and 4.4.0-4.4.17 when a malformed capture file is opened. The root cause is a heap-based buffer overflow (CWE-122) that exhausts availability without yielding code execution, as confirmed by the CVSS A:H, C:N, I:N profile. No public exploit code exists and this vulnerability is not listed in the CISA KEV catalog, placing it in the moderate-priority tier despite the memory safety class of the flaw.

Denial of service via crash affects the Bluetooth Attribute Protocol (ATT) dissector in Wireshark 4.4.0-4.4.17 and 4.6.0-4.6.7, caused by an out-of-bounds read (CWE-125) when processing malformed ATT packets. Exploitation requires user interaction - specifically opening a crafted packet capture file or capturing live malicious Bluetooth traffic - and carries no code execution potential. Fixed releases 4.4.18 and 4.6.8 are available from the Wireshark Foundation; no public exploit code or CISA KEV listing has been identified at time of analysis.

Out-of-bounds read in Microsoft Windows App for Mac (versions 11.0.0 through 11.3.8) enables a remote unauthenticated attacker to disclose sensitive memory contents over the network when a victim connects to a malicious Remote Desktop server. The CVSS vector (AV:N/AC:L/PR:N/UI:R) confirms network reachability without attacker authentication, though successful exploitation requires the victim to initiate or be lured into an RDP session. No public exploit code and no CISA KEV listing have been identified at time of analysis; a vendor patch to version 11.3.9 is available from Microsoft.

Stack out-of-bounds write in Zephyr RTOS's NVS settings backend affects all tracked versions via three sites in settings_nvs.c that use nvs_read()'s unclamped return value as a NUL-terminator index into a fixed 74-byte stack buffer. An actor with write access to the raw flash partition backing the settings subsystem can plant an oversized name entry that causes a single-byte stack write at an attacker-controlled offset whenever settings_load() or settings_save() processes it, reliably crashing the device. No public exploit identified at time of analysis; upstream fix is available at commit e79a0db but the exact first patched release is not independently confirmed.

Heap-based buffer overflow in IBM i 7.3 through 7.6 allows a remote, low-privileged authenticated attacker to overwrite adjacent memory regions by triggering an integer underflow in the bounds checking logic. The CVSS scope change (S:C) reflects that the overwrite can cross component boundaries, though direct impact is rated low integrity only with no confidentiality or availability consequence. No public exploit code and no CISA KEV listing are identified at time of analysis; a vendor patch is available.

Out-of-bounds write in IBM AIX 7.2 and 7.3 and IBM PowerVM VIOS 4.1 enables a local, high-privileged attacker to execute arbitrary code. The vulnerability is rooted in a memory corruption flaw (CWE-787) that can corrupt adjacent memory regions during a write operation. No active exploitation has been confirmed by CISA KEV, and no public exploit code has been identified at time of analysis.

Local denial-of-service in IBM AIX 7.2 and 7.3, and IBM PowerVM VIOS 4.1 allows a high-privileged local attacker to crash the system via an out-of-bounds write condition. The attack is constrained to local access with elevated privileges (PR:H per CVSS), limiting the practical blast radius primarily to insider threats or post-compromise scenarios. No public exploit code and no CISA KEV listing have been identified at time of analysis, placing this in a lower-urgency triage category despite the severity of the availability impact.

Out-of-bounds memory read in IBM AIX 7.2/7.3 and PowerVM VIOS 4.1 allows a local authenticated attacker to disclose sensitive information from adjacent memory regions. The flaw is constrained entirely to local access with low privileges, yielding a CVSS score of 3.3 (Low), and poses greatest risk in shared or multi-tenant Power Systems environments where untrusted users hold shell access. No public exploit code or active exploitation has been identified at time of analysis.

Denial of service in IBM AIX 7.2 and 7.3 and IBM PowerVM VIOS 4.1 is achievable by an unauthenticated adjacent-network attacker exploiting an out-of-bounds write (CWE-787) in a network-accessible component. Successful exploitation crashes or degrades the target system without impacting confidentiality or data integrity. No public exploit code or CISA KEV listing has been identified at time of analysis.

Partition firmware in IBM PowerVM Hypervisor across firmware streams FW950 through FW1120 is vulnerable to a denial-of-service attack during iSCSI SAN network boot. An unauthenticated attacker with adjacent-network access can disrupt the boot sequence of a target partition, preventing it from completing initialization while leaving all other partitions and the managed POWER system entirely unaffected. Patch available per vendor advisory; no public exploit code or CISA KEV listing has been identified at time of analysis.

Out-of-bounds memory read in IBM AIX 7.2 and 7.3, and IBM PowerVM VIOS 4.1 exposes sensitive system memory to locally authenticated users holding low-privilege accounts. The flaw (CWE-125) allows an attacker with existing local access to read memory contents beyond intended buffer boundaries, producing high confidentiality impact while leaving system integrity and availability unaffected. No public exploit code or CISA KEV listing has been identified at time of analysis; IBM has released a patch via advisory 7283858.

Out-of-bounds read (CWE-125) in IBM AIX 7.2, 7.3 and PowerVM VIOS 4.1 exposes a remotely reachable attack surface that allows unauthenticated network attackers to cause a denial of service under high-complexity conditions. The CVSS vector also records a limited integrity impact (I:L), which is inconsistent with the description's exclusive mention of denial of service and warrants verification against the vendor advisory. No public exploit code or active exploitation has been identified; a vendor patch is available from IBM.

Heap buffer overflow in IBM AIX 7.2, 7.3 and PowerVM VIOS 4.1 enables a local low-privileged attacker to crash the system, resulting in a denial of service. The flaw is rooted in improper bounds checking during heap memory operations (CWE-787). No public exploit code has been identified at time of analysis, and the vulnerability is not listed in CISA KEV; however, a vendor-released patch is available via IBM advisory node/7283858.

Kernel memory disclosure in IBM AIX 7.2, 7.3 and IBM PowerVM VIOS 4.1 exposes internal kernel memory to remote unauthenticated attackers via an out-of-bounds read (CWE-125). The CVSS:3.1 vector AV:N/AC:L/PR:N/UI:N confirms network-accessible, zero-prerequisite exploitation, though impact is bounded to partial confidentiality loss with no integrity or availability consequences. No public exploit or active exploitation has been identified at time of analysis; IBM has released a patch via advisory at https://www.ibm.com/support/pages/node/7283858.

Out-of-bounds write in IBM AIX 7.2/7.3 and PowerVM VIOS 4.1 enables remote authenticated attackers to trigger memory corruption leading to partial information disclosure and denial of service. The flaw (CWE-787) requires low-privilege credentials and high attack complexity, placing it at CVSS 4.2 Medium - a realistic but bounded threat profile. No public exploit code or active exploitation is confirmed at time of analysis; IBM has released a vendor patch via advisory at https://www.ibm.com/support/pages/node/7283858.

Stack-based buffer overflow in IBM Server Firmware's FSP firmware update process allows an authenticated administrator with adjacent network access to execute arbitrary code on the Flexible Service Processor, fully compromising the server management plane across confidentiality, integrity, and availability. Affected firmware spans four major release trains (FW950 through FW1120) deployed on IBM Power Systems servers. No public exploit code has been identified at time of analysis and this vulnerability does not appear in the CISA KEV catalog, but the complete C:H/I:H/A:H impact profile makes patching a priority for any organization where FSP admin credentials or management network access could be shared or compromised.

Heap-based buffer overflow in the RTSP service of TP-Link Tapo C100 and C101 V5 IP cameras allows an authenticated attacker on the same local network segment to crash the RTSP service and force a device reboot by sending specially crafted frames with oversized length values. Impact is limited to temporary denial-of-service; no confidentiality or integrity compromise is achievable. No public exploit code has been identified at time of analysis, and TP-Link has released firmware patches for affected devices.