REAL THREATS
XSS in DevTools Inspector (High -- downgraded after PoC testing)
• setInnerHTML, setOuterHTML, and insertAdjacentHTML in walker.js accept user-controlled HTML without sanitization. These are DevTools server-side methods that can be called by privileged actors. If an attacker can control the HTML content passed to these methods (e.g., via a compromised extension or malicious inspected page), they can inject arbitrary scripts that execute in the DevTools UI context. This is a high-severity XSS vector. PoC testing confirmed the injection path exists but Firefox process isolation prevents escalation to chrome-privileged context.
SSRF and Insecure Network Operations (High)
• Unvalidated external URL fetches in generateGmpJson.py enable SSRF. An attacker who can control the GMP JSON configuration can make the browser fetch arbitrary URLs, potentially accessing internal services.
• WebSocket SSRF in socket.js via unvalidated host parameter. An attacker can make the DevTools server connect to arbitrary WebSocket endpoints.
Path Traversal and File Access (High)
• Path traversal in GetFileOrDirectoryTask.cpp allows accessing files outside the intended directory.
• Null target path causes undefined behavior in file system operations.
Denial of Service (High)
• Unbounded structured clone deserialization in WebGL shader validator and IndexedDB actors. An attacker can send crafted messages that cause excessive memory allocation or CPU usage.
• Unbounded array buffer growth in XHR without strict limits. An attacker can cause memory exhaustion by requesting large content.
• Unbounded URL array processing in interventions.js restartListener. An attacker can cause the browser to hang by providing many URLs.
• ReDoS vulnerability in AST traversal in the debugger parser. An attacker can craft JavaScript that causes catastrophic backtracking.
• ReDoS in sprintf.js regex patterns. An attacker can provide format strings that cause exponential backtracking.
• ReDoS in nsContentSecurityUtils.cpp regex patterns.
Weak Randomness (High)
• Predictable PRNG seed using system time in StorageAccessPermissionRequest.cpp. An attacker who can observe timing can predict the simulated delay, potentially bypassing storage access restrictions.
• Same issue in OggWriter.cpp.
• Weak randomness for origin key generation in MediaParent.cpp.
Type Confusion / Logic Errors (High)
• Type mismatch in ClearKeySessionManager.cpp -- inserting Key instead of KeyId into mKeyIds set. This can cause incorrect key management in EME.
• Pseudo-class lock removed before checking for focus styles in keyboard accessibility audit. This can cause incorrect accessibility state reporting.
• Deadlock risk in nsIWindowMediator enumeration from listener. An attacker can trigger a deadlock by opening many windows.
Null Pointer Dereference (High)
• Potential null pointer dereference in ContentEventHandler.cpp GetTextEditor. An attacker can trigger a crash by manipulating the DOM.
Input Validation Issues (High)
• Missing javascript: protocol validation in checkProtocol function. An attacker can bypass URL validation.
• Unvalidated URL resolution from user-controlled manifest in ext-url-overrides.js. An attacker can make the browser navigate to arbitrary URLs.
• Blocklist-based validation instead of allowlist in PrincipalUtils.cpp. An attacker can bypass security checks.
• Blocklist-based validation for data URIs, file protocol, and extension protocol script loading. An attacker can bypass security restrictions.
• XML parsing without external entity restrictions in nsXMLFragmentContentSink.cpp. An attacker can perform XXE attacks.
Resource Leak (High)
• Potential resource leak on CreateProcess failure in LauncherProcessWin.cpp. An attacker can exhaust system resources.
Race Conditions (High)
• Race condition in message queue processing in DecoderTemplate.cpp. An attacker can cause inconsistent state.
Medium Severity Issues
• Missing validation and null pointer issues in browser initialization code.
• Missing URL length validation before loading in media browser.
• Weak random source for callback ID generation in UITour.
• File upload validation relies on MIME type only and missing file size limit enforcement.
• Timer cleanup and validation issues in FocusTimer widget.
• Various issues in ClientWebGLContext (null dereference, integer overflow, resource leak, race condition, missing validation, memory leak, unhandled exception).
• User-controlled shader code without validation in WebGL extensions.
• URL parsing without validation in DataTransfer GetData.
• Missing rate limiting on console report flushing and keepalive requests.
• PII location data may be exposed in logs.
• Unbounded StructuredCloneData IPC messages.
• Race condition and memory leak in UnboundedMPSCQueue.
• Race condition in DDMediaLogs shutdown.
• IPC message serialization without size limits.
• Potential infinite loop in process launch coordination.
• Missing null check for GetMediaSession().
ATTACK CHAINS
1. XSS to Code Execution: An attacker who can inject into the DevTools inspector (the unsanitized setInnerHTML, setOuterHTML, and insertAdjacentHTML calls in walker.js) can execute arbitrary JavaScript in the DevTools UI context. Firefox process isolation prevents escalation to a chrome-privileged context in current builds. Rated High.
2. SSRF to Internal Service Compromise: An attacker who can control GMP JSON configuration or DevTools WebSocket connections can probe internal networks. Combined with the path traversal, they can exfiltrate local files.
3. DoS to Service Disruption: Multiple unbounded deserialization and allocation issues can be triggered by a single crafted message, causing memory exhaustion and browser crash.
4. Weak Randomness to Storage Access Bypass: The predictable PRNG seed combined with the blocklist-based validation could allow an attacker to bypass storage access restrictions and then exploit the path traversal to access sensitive files.
VERDICT
This codebase has
high-severity XSS vulnerabilities in the DevTools inspector that should be fixed by adding HTML sanitization to
setInnerHTML,
setOuterHTML, and
insertAdjacentHTML.
The
high-severity issues that require immediate attention are:
1. SSRF vulnerabilities in media tools and DevTools socket
2. Multiple unbounded deserialization/DoS vectors
3. Path traversal in file system operations
4. Weak randomness in security-sensitive contexts
The
medium-severity issues should be addressed in the next sprint, particularly the WebGL context issues, IPC serialization limits, and race conditions in media components.
These scanner agents are deliberately aggressive. Each one flags anything it suspects could be a problem, erring toward over-reporting so nothing real is missed. A separate verification pass then confirms which flags are genuine, and most raw flags do not survive it. Many are duplicates, where several agents reach the same conclusion from different angles; the rest are test code, detection code, documentation, or architectural opinions that resemble a vulnerability without being one. The 36,317 raw flags above, including the 474 raw criticals, are the unfiltered agent output. The confirmed threats are what remains after verification. That gap is the system working as designed: a wide net, then a strict filter. Of the 474 raw criticals, none survived verification; the 69 confirmed threats break down as 32 high, 14 medium, and 23 low. The analysis above highlights representative threats by category; the full per-finding list, including the low-severity items, was removed for this public release.