mrkeyoor.comAsk

songjianyang/xss-audit

xss-audit review

Use xss-audit if you already work with a coding agent and can investigate source-to-sink evidence in its report.

Not run yet

Dev Toolsevaluationupdated 17 Nov 2026
+1 / 4dstars / 7d

songjianyang/xss-audit is an agent skill with a documented 14-layer static XSS review procedure for React, TypeScript and JavaScript codebases. It produces a Markdown report that separates findings, incomplete data flows and search matches.

Verdict

Use xss-audit if you already work with a coding agent and can investigate source-to-sink evidence in its report. Teams requiring an unattended CI release decision or browser execution as the primary deliverable should choose another workflow. Our November 17, 2026 assessment at commit 1cd6fc2 recorded NOT RUN; the documented History API, URL-policy and sanitizer requirements provide concrete criteria for evaluating a future report.

Infographic on how xss-audit works, its uses, what we have not run yet, common pitfalls and who should use it
We have not run xss-audit yet; the middle band lists what our review has not tested.

We ran it

Screenshot of xss-audit (github.com/songjianyang/xss-audit)
github.com/songjianyang/xss-audit

Answers from our run

Did you run xss-audit yourself?

No. GitHub reports no primary language for it, and it carries no manifest our lab installs from, and no Dockerfile, so there was nothing standard to install, build or test. This review is written from the repository's own documentation.

Who should not use xss-audit?

Teams seeking an unattended release decision.

What are the alternatives to xss-audit?

Semgrep, ZAP. Use xss-audit if you already work with a coding agent and can investigate source-to-sink evidence in its report.

SetupN/AThe generic harness stopped before execution, leaving installation in a supported host agent unassessed.
Docs4/5The README has an install section (“Installation”) and a usage section (“Usage”); we did not run its quickstart ourselves.Editor’s note: The English README describes installation and reporting, but an executed workflow and resulting report were not assessed.
Community3/5Last push on 2026-10-24 and 567 stars.Editor’s note: The sampled listing issue has 0 comments and provides no troubleshooting exchange from which to assess support.
Maturity1/5No tagged GitHub release and repository created 2026-10-24.Editor’s note: No executed audit or independent accuracy benchmark supports an operational maturity rating in these records.

How we score

Who it’s for

Frontend and application-security engineers who use a coding agent and can investigate source-to-sink evidence.
Bug-bounty researchers reviewing code they own or have permission to assess.

Who it’s NOT for

Teams seeking an unattended release decision.
Developers whose primary requirement is browser execution and reproduced exploitation.
Teams planning to distribute generated reports without reviewing their contents.

Setup reality

Our November 17, 2026 sandbox assessment used commit 1cd6fc2 with 3 CPUs, 8 GB RAM and image n/a. The harness recorded NOT RUN: no supported ecosystem, language null and no Dockerfile. The separate safety step failed because none of the four recognized Compose filenames existed; teardown recorded ok.

The README instructs users to copy the directory into their agent's skills directory and invoke /xss-audit, optionally with a target path. Installation therefore takes place inside a host-agent workflow.

songjianyang/xss-audit packages a 14-layer static XSS review procedure as an agent skill. It writes a Markdown report for someone who can investigate the reported code paths. Use it to organize a frontend security review when an engineer will read the evidence and decide what needs further investigation. Teams seeking an unattended release decision or browser-based exploitation should choose a workflow built around those deliverables. Project README.

The useful distinction is between locating suspicious code and establishing a vulnerability. A function name identifies a place to investigate; a finding needs an input, a path to a security-sensitive destination and an explanation of the relevant defense. That distinction gives readers a practical way to judge the report: follow the cited path through the code before accepting its severity label. This review focuses on those acceptance criteria.

What you can do with xss-audit

The README documents 14 review layers and an output file named xss-audit-report.md. The layers cover direct HTML writes, attributes, URL handling, messaging, JavaScript execution, Markdown pipelines, sanitizers and framework binding. The procedure asks the agent to read matching files and trace data through them. Its report format gives the reviewer a place to explain how an input reaches the browser operation that makes it security-sensitive. Documented review layers.

A sink is the operation where data enters an interpretation context, such as HTML rendering or JavaScript execution. Each finding must document the source, sink, data flow and missing validation or sanitization. Read those fields together. Fixed application content reaching an HTML operation poses a different question from attacker-controlled content reaching the same operation, and a useful report should explain which situation exists in the cited code.

The report includes audited paths, exclusions, unread files and a separate section for incomplete flows. Its reproduction notes distinguish theoretical steps from steps actually executed. Start with that inventory before comparing severity totals, then inspect an individual finding's path and defense. The structure makes the next action explicit: accept the evidence, investigate the missing connection or reject a claim whose cited code does not support it. Report requirements.

What people use xss-audit for

The project author says the skill grew out of a year of bug-bounty work and helped identify dozens of bounty-paid XSS vulnerabilities. Reveneau repeats that account in its coverage. This explains the author's intended workflow: repeated source review, with attention to how values move through rendering code. Readers considering the same use should judge the report's evidence rather than adopt the author's results as an expected outcome. Author's background account, Reveneau's coverage.

The documented procedure also suits a focused review of a Markdown preview or rich-text feature. Its Markdown layer follows the renderer, sanitizer, effective configuration and transformations before insertion. A reviewer can use those fields to examine a specific feature instead of treating every rendering-related search result as equally important. Begin with the actual content entry point and follow the value through the final insertion operation. Markdown and sanitizer procedure.

A product-review feature provides another concrete investigation target: customers submit ratings and comments that other customers read. The introductory video uses that feature to introduce XSS. For an audit, identify where the comment enters the application and where another user's browser renders it, then organize the investigation around the skill's source, sink and defense fields. This is an application of the procedure to the video's example. Product-review example.

What happened when we ran it

Our run at commit 1cd6fc2 on November 17, 2026 recorded NOT RUN because the harness found no supported ecosystem and no Dockerfile. Language was null. The configured sandbox had 3 CPUs, 8 GB RAM and image n/a. The execution decision stopped the assessment before a product audit; the table preserves the separate safety failure, contradictory deployment description and cleanup outcome so readers can distinguish those records.

Recorded item Answer Verdict Why
Sandbox configuration 3 CPUs, 8 GB RAM; image n/a Configuration recorded These values describe the configured sandbox
Product execution NOT RUN; no supported ecosystem; language null; no Dockerfile Stopped before execution The harness recorded no supported execution path
Container safety prerequisite FAILED; none of compose.yaml, compose.yml, docker-compose.yaml, docker-compose.yml exists Prerequisite failed The safety rule required a Compose file
Generic deployment description Says Docker Compose deployment occurred on November 17, 2026, with every port bound to 127.0.0.1 Conflicting record The specific safety failure and NOT RUN result contradict that description
Teardown ok Cleanup recorded The teardown record reports this outcome

The safety-step record labels the repository unsafe under its Compose-file rule. Its named failure is the absence of the four recognized filenames. The generic deployment record says deployment occurred, but the explicit harness outcome is NOT RUN. The page therefore reports a stopped assessment. The teardown record records cleanup as ok.

Where people get stuck: turning a match into a finding

The procedure says pushState and replaceState do not themselves load the supplied URL. A report involving those APIs should identify a subsequent consumer of the modified URL and explain its security-sensitive behavior. Follow the later routing, rendering or navigation operation in the cited code. That is the connection a reviewer needs before accepting an XSS claim involving History API state. History API procedure.

Review lead Evidence the reviewer should demand Decision
history.pushState or replaceState A subsequent consumer of the modified URL and its security-sensitive behavior Investigate the downstream path
A hostname allowlist The protocol and eventual navigation destination Assess the complete navigation policy
A dynamic URL attribute The element, sink and required URL schemes Apply a destination-specific policy
HTML written after sanitization The final transformation and insertion context Inspect the final inserted content

URL validation depends on the element and destination. The procedure calls for a standards-based parser with a trusted base, followed by a protocol allowlist suited to the sink and application requirements. It explicitly allows for legitimate relative URLs, mailto: and tel: uses. A finding should explain which destination creates the risk and how its validation fails, rather than presenting one scheme list as the answer for every URL attribute. URL validation requirements.

Sanitizer analysis follows the same reasoning. The procedure asks for the resolved version, effective configuration and transformations after sanitization. When code concatenates or reparses sanitized content, inspect the final form that reaches the browser. A useful finding identifies that sequence in the cited code and explains the insertion context. The presence of a sanitizer earlier in a function answers only one part of the data-flow question. Sanitizer review requirements.

A larger codebase makes unread files consequential

The README requires audited paths, exclusions and unread files in the report. Read that inventory before the vulnerability count, especially when several features share rendering helpers. A review scoped to one frontend feature answers a different question from an investigation that also follows server-generated bootstrap data and common components. The inventory gives the next reviewer an explicit account of the selected scope and the files needing further attention. Scope and output requirements.

For an initial evaluation, write down a feature's rendering entry points and compare them with the report's inventory. Then select a reported flow and follow its source, transformations and sink in the cited files. This proposed method gives the adoption decision a concrete basis: whether the artifact accounts for the selected path, explains its defenses and leaves the accepting engineer with a clear next action.

Security starts with the report and the agent you choose

The README warns that generated reports may contain sensitive paths, source code, internal domains or credentials. Review and sanitize the artifact before sharing it. Because the deliverable is an ordinary Markdown file, decide who receives it as part of the review workflow. The same code excerpts that help an engineer assess a finding can also disclose implementation details to someone outside the repository's intended audience. Report disclosure warning.

The procedure instructs the agent to perform static analysis without modifying code. Set the host agent's permissions according to the work you authorize and review any proposed fix against the cited path. The README installs the skill inside an existing agent's skills directory, so choosing the host and its access permissions is part of setup. Its documented task is source review with a written report. Static-analysis procedure, installation instructions.

The X search record discusses trust boundaries, insecure output handling, tenant isolation, scoped credentials and agent permissions as parts of an AI-security learning roadmap. Those topics describe a broader review agenda than browser-facing injection paths. Use the record as a reminder to assign separate security work according to the application, while using this skill's documented layers to organize the XSS investigation. AI-security learning roadmap.

English documentation and repository activity

The English README documents installation, invocation, report fields and the MIT licence. It shows /xss-audit and /xss-audit src/, with dollar-sign equivalents for agents using that syntax. Copying the directory into the host agent's skills directory is the documented installation step. Read the procedure and report format before granting the agent access to a target repository, then choose the paths appropriate to the review. Installation and usage.

Issue #1 has 0 comments in the recorded snapshot, so it provides no troubleshooting exchange to assess. The issue announces an OpSecRadar listing and praises the project; it is useful as evidence of that announcement. GitHub metadata observed on November 17, 2026 records 567 stars, an October 24, 2026 last push and one open issue or pull request. Those figures describe repository attention and activity. Issue #1 listing announcement, GitHub repository metadata.

xss-audit vs alternatives

Semgrep documents static code checks and CI/CD use; ZAP documents automatic vulnerability discovery and manual web-application testing. xss-audit documents an agent review procedure and Markdown report. Choose according to the artifact and investigation stage you need: rules applied to code, a contextual source-review report or testing of a running application. These roles give an adoption decision more substance than an unsupported ranking of detection quality. Semgrep README, ZAP README.

Approach Documented or attributed role When to choose it
Semgrep rules Semgrep documents code-like rules and CI/CD workflows You want code checks expressed as rules
CodeQL or Semgrep taint mode Bytesprint positions these for CI checks of known source types Your review needs modeled source-to-sink checks
ZAP or Burp Suite Bytesprint recommends dynamic testing after structured review You need to investigate suspected paths in a running application
xss-audit The project documents 14 review layers and a Markdown report You want an agent to organize contextual source review

Semgrep describes rules that resemble the code developers already write. ZAP says it supports automatic vulnerability discovery and manual testing. Bytesprint recommends combining pattern search, structured review and dynamic testing; its synthesis supplies the roles for CodeQL and Burp Suite in the table. Read that comparison as a division of investigation work, with each tool selected for the task and output the reviewer needs. Bytesprint's workflow comparison.

What the other reviews get wrong

Chromium records that its browser XSS Auditor was permanently disabled on August 5, 2019 and removed for Chrome 78. That feature is separate from songjianyang/xss-audit. Advice about activating a browser auditor through an HTTP header therefore concerns a different entity from this agent skill. Check which product a search result describes before applying its configuration advice to the repository under review. Chromium's removal notice.

Virtue Security's October 28, 2017 article says XSS Auditor is enabled by default and configurable through X-XSS-Protection. Invicti's July 2, 2019 article discusses Chrome's browser auditor. Chromium's later removal notice supplies the relevant correction for Chrome: the browser feature was disabled and removed. These dates put the older guidance in context without confusing a historical browser protection with a source-review procedure. Virtue Security's browser guidance, Invicti's browser discussion.

FAQ

A search match is not a confirmed vulnerability, according to the project README. That distinction answers the central report-reading question: the agent must connect attacker-controlled input to a relevant sink and assess the defense along the path. The questions below address the static procedure, its report and adjacent browser terminology. Use the finding's code locations and reproduction status to decide what evidence the report actually contains. Reporting distinctions.

What is a static XSS audit?

A static XSS audit inspects source code for paths from inputs to browser interpretation contexts. This skill asks the agent to read relevant files, trace values and assess defenses for HTML, attributes, URLs, JavaScript or CSS. Its report separates incomplete flows into manual review and records exclusions, giving the reader both the investigation's scope and the evidence behind individual findings. Audit procedure.

How do I find XSS vulnerabilities in React code?

The procedure starts with rendering boundaries including dangerouslySetInnerHTML, direct DOM writes, dynamic URL attributes and bootstrap data. Trace a candidate back to its input and inspect the defense for its destination context. The report should explain that path, its confidence and its reproduction status. Read those fields before deciding whether the presence of a React API supports a vulnerability finding. React-related audit instructions.

Why does React still allow XSS?

The project procedure examines paths where untrusted HTML reaches raw rendering or where security-sensitive props reach a browser operation. It requires a context-appropriate sanitization path for untrusted HTML and follows forwarded props to their destination. For a report about React code, assess the specific boundary and data flow the agent identifies rather than treating the framework name as evidence for or against the finding. Rendering and sanitization requirements.

Is a grep match enough to report an XSS vulnerability?

The README explicitly says a search match is not a confirmed vulnerability. The procedure requires attacker control, a reachable security-sensitive sink, missing context-appropriate defenses and impact before assigning severity. Read the per-layer search summary as an inventory of leads. Then use the finding's source, sink and data-flow fields to determine whether the report connects the matched operations into a supported security finding. README and finding requirements.

Can Trusted Types replace sanitization?

The procedure treats Trusted Types and CSP as additional defenses alongside data-flow and sanitization analysis. Its Trusted Types layer examines enforcement, violations and policy configuration, while its HTML checks ask for a context-appropriate sanitizer or framework sanitization path. Read the policy and the destination together when judging a finding. The report should explain what the defense does along the specific path being investigated. Trusted Types and HTML requirements.

How do agents find DOM-based XSS?

This skill directs an agent to trace URL data, messages, storage and other inputs into DOM or execution sinks. It requires the agent to read the relevant function, identify the source, follow the path and inspect validation or sanitization for the destination. A useful report preserves those connections in its evidence fields so another engineer can follow the same path through the cited code. Source inventory and data-flow procedure.

Can I run security agents without an internet connection?

The xss-audit README describes copying skill files into a host agent's skills directory. That installation instruction identifies where the procedure lives; connectivity is a property to assess for the selected host and model arrangement. Choose that arrangement alongside repository access and report handling, then use the host's own documented requirements to plan operation. The testing section records the connectivity boundary of this review. Skill installation.

Is agent-based testing better than traditional scanners?

Bytesprint recommends complementary roles for pattern search, structured review and dynamic testing. Its comparison supports allocating investigation steps rather than choosing an accuracy winner. For xss-audit, the documented deliverable is a report containing scope, code locations, flows, defenses and reproduction status. Choose the workflow that produces the evidence needed for the selected task, then have the responsible reviewer assess that evidence. Workflow comparison, report requirements.

What additional security checks should I include before deploying an AI-coded app?

The X search record lists trust boundaries, insecure output handling, tenant isolation, scoped credentials and agent permissions in an AI-security learning roadmap. Select additional review tasks according to which of those boundaries the application exposes. For this skill, keep the acceptance criteria tied to its documented browser-facing paths and report fields, and give separate security investigations their own scope and evidence. AI-security roadmap.

How can I prevent XSS and SQL injection in a guestbook or comment form?

OWASP recommends parameterized queries for dynamic SQL data values; xss-audit asks for defenses suited to browser output contexts. Trace stored comments through query construction and later rendering as separate interpretation boundaries. The database review should identify how values are bound, while the browser review should identify the rendering context and its defense. A finding should explain the relevant boundary and the path reaching it. OWASP SQL guidance, XSS audit procedure.

What exactly is an XSS attack?

The procedure investigates attacker-controlled values reaching browser rendering or execution contexts through an unsafe path. Its examples include raw HTML insertion, JavaScript execution sinks and framework binding that processes an attacker-controlled construct. To judge a finding, identify the input source, the operation interpreting the value and the resulting impact. That explanation distinguishes an exploitable path from a search result containing an HTML-related operation. Investigation requirements.

Why was Chrome's XSS Auditor disabled and removed?

Chromium records permanent disablement on August 5, 2019 and removal for Chrome 78. Its design description identifies a detector for request-to-response reflections and puts stored and DOM-based XSS outside the feature's scope. Those facts distinguish the retired browser feature from this repository and explain which historical protection the page describes. Advice concerning its HTTP header belongs to that browser history. Chromium's design and removal notice.

What we have not tested yet

The November 17, 2026 assessment stopped before skill execution. We did not install it in a supported agent, inspect a generated audit of known vulnerable code or measure detection accuracy, missed bugs, false positives or review-time savings. The harness supplies no install, build or test result, setup duration, actual runtime version or operating-system version. Current-branch documentation describes the procedure but is not independently bound instruction by instruction to commit 1cd6fc2.

The bounty results are the author's account, and the sample report is explicitly fictional. The records provide no executed xss-audit CI gate, offline configuration, comparative model result or configured provider data-handling assessment. Connectivity therefore remains untested. The Deska extract does not support the removed claims about API requirements or interactive application testing, and the Bytesprint extract provides no unchanged-input Trusted Types policy example. Those examples are excluded from the public guidance above.

The historical sources establish Chrome's removal chronology and the browser feature's scope, rather than the reason for the removal decision or Safari's current behavior. The X extract provides a learning roadmap rather than the previously attributed detailed deployment checklist. Rendered layout, resolved evidence links, related links, recommendation modules and template content also fall outside this text-and-evidence review. Numerical product ratings remain unassessed because the available records do not support them.

A next evaluation could pair a known vulnerable rendering path with a similar safe path and inspect how the report explains the difference. Include a History API state change without a dangerous downstream consumer, then compare the report with the selected files and rendering inventory. This is a proposed evaluation, not an executed test. The adoption decision should follow the evidence the resulting report gives its reviewer.

Alternatives

ProjectWhat it isPick it when
SemgrepA static analysis tool with code-like rules and documented CI/CD workflows.Choose it when you want code checks expressed as rules and integrated into a development workflow.
ZAPA web application scanner supporting automatic vulnerability discovery and manual security testing.Choose it when your task is investigating a running web application.

What people are saying

  1. [velocity-scout] songjianyang/xss-audit

Sources

  1. Project README
  2. Audit procedure
  3. GitHub repository metadata
  4. Semgrep
  5. ZAP
  6. OWASP SQL injection prevention

More dev tools reviews