Client-Side Security Scanner
Find client-side weaknesses in the browser layer: DOM XSS sinks, missing postMessage origin checks, unsafe-inline CSP, and prototype pollution.
High15Medium9Low2
High15 checks
- CSP Allows 'unsafe-inline' ScriptsThe Content-Security-Policy header contains 'unsafe-inline' in the script-src directive. This negates most XSS protection the CSP provides, since inline scripts injected by an attacker will be allowed.
- postMessage Without Origin ValidationA window.addEventListener('message', ...) handler was found without an origin check. Without validating the sender's origin, any webpage can send arbitrary messages to your page and have them processed.
- Sensitive Data Stored in localStorageThe page stores authentication tokens, JWTs, or other sensitive values in localStorage. localStorage is accessible to any JavaScript on the page (including XSS payloads) and persists across sessions.
- DOM XSS via location.hash AssignmentThe page reads from location.hash and assigns it to innerHTML or document.write without sanitization. location.hash is attacker-controlled (the # part of the URL) and enables XSS without any server-side injection.
- document.write() in Page Scriptsdocument.write() was found in the page scripts. This function is dangerous because it can overwrite the entire page document, is a primary DOM XSS sink, and is deprecated in modern browsers.
- eval() in Client-Side JavaScripteval() or the Function() constructor was found in client-side JavaScript. These functions execute strings as code and are a top DOM XSS sink.
- Angular bypassSecurityTrust* UsageAn Angular bypassSecurityTrust* function was found in the page. These functions explicitly opt out of Angular's built-in XSS protection and must only be used with fully sanitized, trusted content.
- Vue v-html Directive with Dynamic ContentThe Vue v-html directive was found in the page with a dynamic binding. v-html renders raw HTML without Vue's template escaping, creating XSS risk if the bound value includes any user-controlled content.
- API Key or Secret Hardcoded in Client JavaScriptAn API key, secret, or credential pattern was found embedded directly in client-side JavaScript. Any secret in client JavaScript is fully visible to anyone who visits the page.
- Client-Side Prototype Pollution RiskA client-side prototype pollution pattern was detected. Deep merge operations, recursive object assignment, or direct __proto__ manipulation with user-controlled keys can corrupt the JavaScript prototype chain.
- Markdown Rendered to innerHTML Without SanitizationMarkdown renderer output (marked()/markdown-it) is assigned directly to innerHTML or dangerouslySetInnerHTML with no visible DOMPurify/sanitize-html call nearby.
- Script Loaded From a Development Tunnel DomainA <script> tag loads code from a development tunneling domain (ngrok, localtunnel, Cloudflare Tunnel trycloudflare.com, or serveo.net).
- Clipboard writeText() Contains a Hardcoded CredentialA navigator.clipboard.writeText() call contains a literal, credential-shaped string (an OpenAI/Google/GitHub/Slack token pattern) rather than a variable.
- Dynamic import() Built From a URL-Derived ValueA dynamic import() call's module specifier is built from location.hash, location.search, location.href, or a URLSearchParams query lookup, either directly inline or via a variable assigned one hop earlier, with no allowlist check visible between the two.
- WebSocket Message Data Passed Directly to eval()The page opens a WebSocket connection and, in the same script, calls eval() or new Function() directly on the incoming message's .data property, executing whatever the WebSocket server (or anyone able to inject frames into the connection) sends as JavaScript.
Medium9 checks
- CSP Allows 'unsafe-eval'The CSP header includes 'unsafe-eval', which permits eval(), Function(), setTimeout(string), and setInterval(string). These functions execute strings as code and are primary targets for XSS attacks.
- External Script Without Subresource IntegrityOne or more external JavaScript files are loaded from CDNs or third-party domains without an integrity attribute. If the CDN is compromised, the script can be replaced with malicious code that runs in all users' browsers.
- JavaScript Source Map Exposed in ProductionA source map reference (//# sourceMappingURL=) was found in production JavaScript, pointing to a non-data-URI location. Source maps expose original, un-minified source code to anyone who fetches them.
- JSONP Callback Pattern DetectedA JSONP endpoint was detected that wraps JSON data in a function call controlled by a URL parameter (callback=myFunction). JSONP is an obsolete cross-origin technique that creates security vulnerabilities.
- Client-Side Open Redirect via location AssignmentA window.location or document.location assignment was found using URL parameters or hash values without validation. Client-side open redirects are exploitable for phishing even without server-side participation.
- Client Script Hardcodes a Localhost API URLA client-side script assigns an API base URL / endpoint variable to a literal http://localhost or 127.0.0.1 address.
- WebSocket URL Carries Auth Token in Query StringA client-side WebSocket connection is opened with an auth token, API key, or JWT passed as a URL query parameter.
- postMessage Sent to Another Window With Wildcard Target OriginA .postMessage() call targeting another window (contentWindow, opener, parent, top, or a captured event.source) passes the literal string "*" as the targetOrigin argument, so the message is delivered to whatever origin that window currently holds rather than a specific expected origin.
- document.domain Reassigned to Relax the Same-Origin PolicyThe page assigns document.domain to a literal string value. This is the standard API for deliberately relaxing the Same-Origin Policy so pages on different subdomains of that value can script each other directly.
Low2 checks
- Debug Information Embedded in Page JavaScriptDebug information such as internal server paths, configuration values, or environment details was found in page-embedded JavaScript (window.__NEXT_DATA__, __NUXT__, etc.).
- UI Visibility Gated by Client-Side Role Check OnlyAn element's visibility is toggled based on a client-side role/permission check (e.g. user.role === 'admin') with no indication the underlying action is also enforced server-side.
About the Client-side checks
- What does the Client-side category check?
- Find client-side weaknesses in the browser layer: DOM XSS sinks, missing postMessage origin checks, unsafe-inline CSP, and prototype pollution. DOM XSS sinks, postMessage origin checks, unsafe-inline CSP, prototype pollution.
- How many client-side checks are there?
- VulnRadar runs 26 checks in this category, ranging across high, medium, low severity.
- Do I need to install anything to run the client-side checks?
- No. Paste a URL in the browser or call the REST API, and the scan itself runs from our servers against that URL. There is no agent and no appliance to deploy alongside your application. A browser extension exists if you want to scan the page you are looking at, but nothing has to be installed to use this.
Run the client-side checks on your site
VulnRadar runs all 26 of these against a URL in seconds, with the evidence and fix for every finding. No agent to install, just paste a URL.