Nov 19, 2026·12 min read·3 visits
An adjacent network attacker can respond to SSDP M-SEARCH broadcasts from iSponsorBlockTV (versions < 2.11.0) with a crafted LOCATION header, triggering blind HTTP GET and constrained POST requests from the application host to arbitrary internal or loopback addresses.
iSponsorBlockTV prior to version 2.11.0 contains a blind Server-Side Request Forgery (SSRF) vulnerability in its Simple Service Discovery Protocol (SSDP) and Discovery and Launch (DIAL) client implementation. During local device discovery, the application processes SSDP responses without validating that the URL specified in the LOCATION header or the subsequent application-url response header matches the IP address of the responding UDP host. An adjacent network attacker can spoof SSDP responses to induce the iSponsorBlockTV host to send arbitrary HTTP GET requests and constrained HTTP POST requests to internal network endpoints or loopback services.
iSponsorBlockTV is a Python-based client application designed to skip sponsored segments on YouTube TV client devices across a local network. To locate compatible smart TVs, streaming sticks, and media players, the software implements the Discovery and Launch (DIAL) protocol, which relies on the Simple Service Discovery Protocol (SSDP) over UDP port 1900. During active or automatic discovery phases, iSponsorBlockTV transmits multicast M-SEARCH queries and listens for unicast HTTP-over-UDP responses from local devices.
In versions prior to 2.11.0, the discovery implementation within src/iSponsorBlockTV/dial_client.py fails to validate the URLs supplied by network responders during the SSDP and DIAL handshake stages. Specifically, the application extracts the LOCATION header from incoming SSDP response packets and immediately initiates an asynchronous HTTP GET request to that destination using an aiohttp.ClientSession instance. The software does not verify whether the target host in the URL matches the IPv4 or IPv6 source address of the UDP packet responder.
Furthermore, if the target of the initial HTTP GET request returns an XML payload matching the expected DIAL device description format along with an application-url HTTP response header, iSponsorBlockTV uses the secondary URL to construct another target path ending in /YouTube. The application subsequently dispatches both an HTTP GET request and an HTTP POST request with a preset JSON payload to this derived endpoint. Because the aiohttp session follows HTTP 3xx redirects by default, an attacker can also redirect requests during any stage of this interaction.
This flaw is classified under CWE-918 (Server-Side Request Forgery). An attacker positioned on an adjacent local network segment can listen for M-SEARCH broadcasts—or transmit unsolicited responses during a discovery window—to direct HTTP traffic from the iSponsorBlockTV host toward loopback services (127.0.0.1), local router administration interfaces, or isolated network subnets accessible to the host. Because the HTTP response contents and errors are consumed internally by the XML parser and discarded without being reflected to the network responder, the vulnerability functions strictly as a blind SSRF.
The root cause of CVE-2026-77597 lies in the decoupling of network-layer transport metadata from application-layer URL processing in src/iSponsorBlockTV/dial_client.py. The Handler class inherits from ssdp.aio.SSDP to process incoming UDP datagrams asynchronously. When a UDP packet arrives in Handler.response_received(self, response, addr), the underlying socket library provides both the parsed SSDP message (response) and a tuple containing the sender's network address and port (addr).
In vulnerable versions, response_received normalized the SSDP headers to lowercase, extracted the location string, and pushed only the URL string onto an asyncio.Queue (self.devices_queue). By discarding the addr tuple at the queue boundary, the downstream worker coroutine _process_devices and the device interrogation routine find_youtube_app lost all context regarding which network host actually emitted the SSDP response. Consequently, find_youtube_app trusted the url_location parameter implicitly.
A secondary trust boundary violation occurs immediately after the initial web_session.get(url_location) call completes. When parsing the HTTP response from the LOCATION endpoint, find_youtube_app extracts the friendlyName from the XML body and reads the application-url header from the HTTP response headers. The code constructs a new yarl.URL object from application-url, appends the path segment /YouTube, and performs two additional operations:
{application-url}/YouTube with the header Origin: https://www.youtube.com to query the active screen ID.active=True is set, an HTTP POST request to {application-url}/YouTube with the header Origin: package:com.google.android.youtube.tv and a form/data payload containing {"pairingCode": pairing_code, "theme": "cl"}.Neither url_location nor application-url underwent IP validation, scheme verification, or hostname resolution checks. Additionally, all three aiohttp calls (web_session.get and web_session.post) omitted the allow_redirects=False parameter. In aiohttp, allow_redirects defaults to True, meaning that even if initial source validation had been present, an attacker hosting an HTTP responder on their own IP address could respond with an HTTP 302 Found status code pointing to http://127.0.0.1:8080/internal-action to bypass the check.
The vulnerability was remediated in commit 7d315115f41523632588fb0b22d46d85807172b7 by modifying src/iSponsorBlockTV/dial_client.py to preserve the UDP responder's source IP address and enforce strict IP-to-URL host matching across every HTTP request in the discovery chain.
First, the Handler class and queue consumer were updated to store and unpack a 2-tuple containing both the LOCATION URL and the sender's IP address (addr[0]):
# Vulnerable implementation in Handler.response_received
def response_received(self, response: ssdp.messages.SSDPResponse, addr):
headers = response.headers
headers = {k.lower(): v for k, v in headers}
if "location" in headers:
# BUG: addr[0] is ignored, losing the origin IP of the UDP packet
self.devices_queue.put_nowait(headers["location"])
# Patched implementation in Handler.response_received
def response_received(self, response: ssdp.messages.SSDPResponse, addr):
headers = response.headers
headers = {k.lower(): v for k, v in headers}
if "location" in headers:
# FIX: Pair the location URL with the responder's source IP
self.devices_queue.put_nowait((headers["location"], addr[0]))Next, the patch introduces a helper function, _url_matches_ip(url: str, expected_ip: str) -> bool, which leverages Python's standard ipaddress library and yarl.URL to verify that the host component of any DIAL URL is a literal IP address that matches the UDP sender's IP address:
def _url_matches_ip(url: str, expected_ip: str) -> bool:
"""Return whether a DIAL URL points back to the SSDP responder."""
try:
parsed_url = URL(url)
# Parses literal IP addresses; raises ValueError if host is a DNS domain name or empty
url_ip = ipaddress.ip_address(parsed_url.host or "")
sender_ip = ipaddress.ip_address(expected_ip)
except ValueError:
return False
return url_ip == sender_ip> [!NOTE]
> Because ipaddress.ip_address() raises a ValueError if passed a DNS hostname (such as localhost or internal.corp), _url_matches_ip inherently blocks DNS rebinding attacks and forces all DIAL discovery endpoints to use literal IP addresses matching the UDP transport layer.
Finally, find_youtube_app was updated to validate both url_location and app_url via _url_matches_ip, while explicitly disabling HTTP redirects (allow_redirects=False) on all web_session calls:
async def find_youtube_app(
web_session: ClientSession,
api_helper: "ApiHelper",
url_location: str,
expected_ip: str,
active: bool = True,
) -> Optional[Dict[str, Any]]:
# FIX 1: Validate initial SSDP LOCATION URL against UDP sender IP
if not _url_matches_ip(url_location, expected_ip):
logger.debug(
"Ignoring DIAL LOCATION from %s with non-matching URL %s", expected_ip, url_location
)
return None
# FIX 2: Disable HTTP 3xx redirects on initial device description fetch
async with web_session.get(url_location, allow_redirects=False) as response:
headers = response.headers
response = await response.text()
data = xmltodict.parse(response)
name = data["root"]["device"]["friendlyName"]
app_url = headers["application-url"]
# FIX 3: Validate secondary DIAL application-url header against UDP sender IP
if not _url_matches_ip(app_url, expected_ip):
logger.debug(
"Ignoring DIAL application-url from %s with non-matching URL %s", expected_ip, app_url
)
return None
base_url = URL(app_url)
youtube_url = str(base_url / "YouTube")
request_headers = {"Origin": "https://www.youtube.com"}
try:
# FIX 4: Disable redirects on service query GET request
async with web_session.get(
youtube_url, headers=request_headers, allow_redirects=False
) as response:
youtube_service_xml = await response.text()
# ... [screen_id extraction omitted] ...
# FIX 5: Disable redirects on active app launch POST request
async with web_session.post(
youtube_url, headers=launch_headers, data=launch_data, allow_redirects=False
) as response:
# ...The fix effectively neutralizes cross-host SSRF and DNS rebinding by requiring exact IP parity between the UDP packet source and the HTTP target, and by blocking HTTP redirects. One residual nuance is that _url_matches_ip does not restrict the target TCP port or URL scheme, meaning an attacker can still induce iSponsorBlockTV to connect back to arbitrary TCP ports on the attacker's own IP address (expected_ip), or spoof a victim's IP address in the UDP header on networks lacking source address validation (SAV) within the same broadcast domain. However, in a standard Layer 2 environment, forcing a client to make HTTP requests back to the attacker's own host does not cross a security boundary.
Exploiting CVE-2026-77597 requires the attacker to reside on the same local area network (LAN) or multicast broadcast domain as the host running iSponsorBlockTV. No authentication or elevated privileges are required on the target host, though the vulnerability is only triggered when device discovery is active (such as during initial setup, CLI pairing workflows, or automatic discovery scans).
When iSponsorBlockTV initiates discovery, it sends an SSDP M-SEARCH multicast datagram to 239.255.255.250:1900 searching for the service type urn:dial-multiscreen-org:service:dial:1. An adjacent attacker listening on UDP port 1900 intercepts this broadcast and replies directly to the iSponsorBlockTV source UDP port with a unicast SSDP response pointing to an arbitrary internal target:
HTTP/1.1 200 OK
CACHE-CONTROL: max-age=1800
EXT:
LOCATION: http://127.0.0.1:8080/admin/action?cmd=restart
SERVER: Linux/3.14 UPnP/1.0
ST: urn:dial-multiscreen-org:service:dial:1
USN: uuid:11111111-2222-3333-4444-555555555555::urn:dial-multiscreen-org:service:dial:1
Upon receiving this packet, the vulnerable Handler enqueues http://127.0.0.1:8080/admin/action?cmd=restart, and find_youtube_app immediately executes an HTTP GET request to that full URI (including attacker-controlled paths and query parameters). This allows the attacker to trigger state-changing GET endpoints on loopback services or internal web interfaces reachable from the host.
If the attacker wishes to trigger an HTTP POST request against an internal service, they cannot point the initial LOCATION header directly at the victim endpoint because find_youtube_app requires valid DIAL XML from the first request before proceeding to the POST phase. Instead, the attacker conducts a two-step interaction:
LOCATION points to an HTTP server controlled by the attacker (e.g., http://192.168.1.50:9999/dd.xml).iSponsorBlockTV requests http://192.168.1.50:9999/dd.xml, the attacker's HTTP server returns a valid XML body along with a forged application-url response header pointing to the internal target:HTTP/1.1 200 OK
Content-Type: application/xml
application-url: http://127.0.0.1:9000/api/v1
<?xml version="1.0"?>
<root xmlns="urn:schemas-upnp-org:device-1-0">
<device>
<friendlyName>SpoofedTV</friendlyName>
</device>
</root>iSponsorBlockTV parses the XML, extracts http://127.0.0.1:9000/api/v1, appends /YouTube, and issues a GET request followed by a POST request to http://127.0.0.1:9000/api/v1/YouTube. The POST request carries application-defined headers (Origin: package:com.google.android.youtube.tv) and a URL-encoded form body (pairingCode=<12_random_digits>&theme=cl). Alternatively, in unpatched versions, the attacker's server at 192.168.1.50 can reply to the /YouTube POST request with an HTTP 307 Temporary Redirect pointing to any arbitrary path on 127.0.0.1 without the trailing /YouTube path constraint.CVE-2026-77597 is rated as Low severity with a CVSS v3.1 base score of 3.5 (CVSS:3.1/AV:A/AC:L/PR:N/UI:R/S:U/C:N/I:L/A:N). The score reflects several significant architectural constraints that limit the real-world impact of the vulnerability.
First, the attack vector is restricted to the adjacent network (AV:A). An attacker must be connected to the same local subnet or VLAN to observe SSDP multicast traffic or route UDP responses to the ephemeral port opened by iSponsorBlockTV during discovery. Furthermore, device discovery is not continuously active during normal video playback monitoring; it requires user interaction (UI:R) or an active configuration/discovery cycle to trigger.
Second, there is no confidentiality impact (C:N). In find_youtube_app, the response body from the initial GET request is passed directly into xmltodict.parse(response), and the response from the secondary GET request is passed to _extract_screen_id(youtube_service_xml). Any exceptions raised by malformed XML or missing dictionary keys are silently caught and suppressed by a blanket except Exception: pass block in _process_devices. Neither the raw HTTP response body nor error timing/status details are transmitted back over the network, preventing data exfiltration.
Third, the integrity impact is low (I:L). While the initial GET request allows full control over the target IP, port, path, and query string—and HTTP redirect chaining in aiohttp allows redirecting subsequent requests—the attacker cannot specify arbitrary HTTP headers or arbitrary POST body payloads. Consequently, exploitation is limited to internal services that perform state-changing operations via unauthenticated GET requests or endpoints that react to the fixed POST parameters (pairingCode and theme). The EPSS score of 0.00159 (5.10th percentile) confirms a low likelihood of widespread exploitation in the wild.
Users and administrators running iSponsorBlockTV should upgrade to version 2.11.0 or later immediately. Version 2.11.0 incorporates commit 7d315115f41523632588fb0b22d46d85807172b7, which binds SSDP LOCATION and DIAL application-url endpoints to the UDP responder's source IP address and disables HTTP redirect following during device discovery.
Depending on the deployment method (PyPI/pipx or Docker), apply the update using the following commands:
# Upgrade via pip or pipx
pip install --upgrade iSponsorBlockTV>=2.11.0
# Or if using pipx:
pipx upgrade iSponsorBlockTV
# Upgrade via Docker / GHCR
docker pull ghcr.io/dmunozv04/isponsorblocktv:v2.11.0In environments where upgrading immediately is not feasible, operators can mitigate the exposure by applying the following configuration and network controls:
screen_id or pair using a manual TV code in the config.json file, which bypasses SSDP/DIAL network scanning during normal operation.iSponsorBlockTV inside a Docker container, avoid using --network=host unless active SSDP multicast discovery is strictly required. Once a device is paired and its screen_id is saved in config.json, iSponsorBlockTV communicates via outbound HTTPS connections to YouTube's Lounge API rather than local SSDP multicast, allowing the container to run in standard bridged networking mode without access to the host's loopback (127.0.0.1) services.iSponsorBlockTV process to sensitive internal management subnets or local loopback administrative ports if running directly on a bare-metal host.CVSS:3.1/AV:A/AC:L/PR:N/UI:R/S:U/C:N/I:L/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
iSponsorBlockTV dmunozv04 | < 2.11.0 (v2.0.8 through v2.10.0) | 2.11.0 |
| Attribute | Detail |
|---|---|
| Weakness Class | CWE-918: Server-Side Request Forgery (Blind SSRF) |
| Attack Vector | Adjacent Network (SSDP/UDP Response Spoofing) |
| CVSS v3.1 Score | 3.5 (Low) - CVSS:3.1/AV:A/AC:L/PR:N/UI:R/S:U/C:N/I:L/A:N |
| EPSS Score | 0.16% (5.10th Percentile) |
| Affected Component | src/iSponsorBlockTV/dial_client.py (find_youtube_app) |
| Security Impact | Blind HTTP GET and constrained POST requests to internal/loopback endpoints |
| Exploit Status | No Known Public Exploits |
| CISA KEV Status | Not Listed |
The web server or application receives a URL or similar request from an upstream component and retrieves the contents of this URL, without sufficiently ensuring that the request is being sent to the expected destination.
CVE-2026-129304 is an improper input validation and Redis glob pattern injection vulnerability in Guard Core versions 1.0.0 through 3.12.0. The header parsing routine _extract_from_forwarded_header() extracts values from the X-Forwarded-For HTTP header without verifying that the extracted substring is a valid IPv4 or IPv6 address. In deployments configured with trusted_proxies where the target header index is client-controllable, arbitrary strings containing Redis glob metacharacters reach BehaviorTracker and are interpolated directly into Redis key names and blocking KEYS queries. This allows unauthenticated attackers to aggregate cross-client behavioral metrics, trigger false-positive rate limits, cause denial of service via O(N) Redis keyspace scans, or raise unhandled ValueError exceptions during automated IP ban operations.
CVE-2026-121707 is a high-severity Regular Expression Denial of Service (ReDoS) vulnerability in the Effect TypeScript library prior to version 3.22.1. When evaluating untrusted input against Schema.TemplateLiteral definitions containing multiple string spans, the dynamically compiled regular expression exhibits polynomial backtracking complexity. Because JavaScript runtimes execute on a single-threaded event loop, processing specially crafted non-matching strings causes synchronous CPU starvation and complete application unresponsiveness.
CVE-2026-75518 is an incorrect authorization and privilege assignment vulnerability in the DOMShell Model Context Protocol (MCP) server (@apireno/domshell) prior to version 2.0.8. The server classified the domshell_eval tool and the eval command as read-tier operations, permitting their execution without the --allow-write flag. Because the eval command dispatches through the same Chrome DevTools Protocol (CDP) Runtime.evaluate pipeline as the write-tier js command without enabling the throwOnSideEffect constraint, callers restricted to read-only sessions can execute state-mutating JavaScript in the browser context while host user interfaces and audit logs record the activity as read-only.
CVE-2026-63411 (GHSA-xwcw-j52r-34x4) is a remote code execution vulnerability in the Jane PHP code generation framework (janephp/janephp), specifically affecting the jane-php/open-api-3 component prior to version 7.12.0. The generator constructs PHP docblocks using unsanitized parameter names and descriptions extracted directly from OpenAPI specifications. By embedding the comment closing sequence (*/) followed by valid PHP syntax inside an OpenAPI description or parameter name, an attacker can break out of the PHPDoc context and inject executable code directly into the generated class body. When the consuming application instantiates the generated client or endpoint class, an injected __construct() method executes arbitrary PHP code under the privileges of the host runtime.
CVE-2026-63413 is a code injection vulnerability in the Jane PHP OpenAPI 3 SDK generator (jane-php/open-api-3) prior to version 7.12.0. The vulnerability occurs because the generator interpolates OpenAPI header and query parameter names directly into generated PHPDoc comment blocks without sanitizing comment closing delimiters (*/). An attacker who supplies or modifies an OpenAPI specification can break out of the docblock context and inject arbitrary PHP methods, such as a class constructor, into the generated Client or Endpoint class body. When the consuming application instantiates the generated SDK, the injected code executes with the privileges of the host PHP process.
CVE-2026-63412 is a code injection vulnerability in the Jane PHP library suite (affecting jane-php/open-api-3, jane-php/open-api-2, jane-php/open-api-31, and jane-php/json-schema) prior to version 7.12.0. The flaw occurs during the automated generation of PHP client SDKs and data models from OpenAPI specifications. While Jane uses an Abstract Syntax Tree (AST) for safe generation of standard PHP tokens, it constructs PHPDoc comments via raw string interpolation without neutralizing multi-line comment closing delimiters (*/). An attacker who provides or modifies an OpenAPI specification can inject a closing comment sequence inside a query parameter name, escaping the docblock context and writing arbitrary PHP code directly into the class body of generated endpoints or clients. When the consuming application instantiates the generated class, injected methods such as __construct() execute automatically, resulting in remote code execution.