Skip to content

Stingward v0.1.6

Choose a tag to compare

@github-actions github-actions released this 21 Oct 10:02
· 62 commits to main since this release

Added

  • GitHub Action input category (default stingward), passed to the SARIF upload, so a workflow that audits several folders keeps one code scanning result per folder.
  • Human review for audits you hand over. --review-template FILE writes a JSON file with one entry per finding (and keeps what was already reviewed when it runs again); the reviewer sets each status to confirmed, false_positive, accepted_risk or fixed and writes a comment. --review FILE applies it to every report: the HTML shows the status and comment on each finding, moves false positives to an appendix and says in the scope section that a person reviewed the report and how many findings were confirmed or discarded. False positives and findings fixed during the audit leave the grade, the fix-first list and --fail-on; accepted risks still count toward the grade but leave the fix-first list, and the plan lists them, with what was fixed, under "no action planned". The text and Markdown reports follow the same rules, and the JSON gets each finding's review, a review summary and the grade after the review.
  • --client NAME puts "Prepared for" on the cover of the HTML report, and --notes FILE adds the analyst summary at the top of the executive summary, written in a small Markdown subset (paragraphs, - lists, **bold**, `code`). Comments, notes and the client and reviewer names are escaped and go through the same secret masking as code excerpts; on top of that, any value that masking removed from a flagged line of the audited project (or from any line of a small file flagged as a whole, such as .env) is masked wherever it shows up in them, even in pieces.
  • Every finding in the JSON output has a fingerprint, also in SARIF as properties.fingerprint. It comes from the rule, the file, the package, variable or table, and the masked text of the flagged line, not from the line number, so it survives edits elsewhere in the file. The rest of the JSON and SARIF output is unchanged.
  • DEP004 checks the lowest version each range allows when there is no lockfile: requirements*.txt and package.json without a lockfile beside them, and the [project] dependencies and optional dependencies of a pyproject.toml without poetry.lock, uv.lock or pdm.lock. Pillow>=10 lets a machine keep Pillow 10.0.0, which has 18 known vulnerabilities, one of them on the CISA KEV list; the finding says how many, names the worst and gives the new minimum (Pillow>=12.3.0). The lowest versions go to OSV.dev in the same batch as the pinned packages, and a package pinned elsewhere in the project is left to DEP001. Severity is medium at most, since the installed version is often newer, unless the range's upper bound leaves out the fix.
  • An exact version written in a way the lockfile readers did not catch, such as "Pillow==10.0.0" in pyproject.toml or foo (==1.0) in requirements.txt, is now audited by DEP001.
  • --format html and --html FILE: a single-file report in English or Portuguese to hand over or print to PDF (A4). It has a cover with the grade and verdict, an executive summary with what to fix first, a remediation plan with rough effort, findings grouped by area with the code excerpt, standards and references, and the scope, sources and limitations of the audit. It needs no network: no scripts, fonts or images are loaded, and a content security policy allows only its inline styles. Secrets in code excerpts are masked and everything from the audited project is escaped.
  • A new code check (--only code) that reads the project's own code: Python with ast, JavaScript and TypeScript (including the <script> of .vue, .svelte and .astro files) with tight patterns that follow request data inside each function. Tests, examples and fixtures drop to low, and minified bundles are skipped.
  • COD001 to COD011: SQL injection, shell command injection, code injection (eval, exec, new Function, render_template_string), pickle and unsafe YAML, XSS (innerHTML, dangerouslySetInnerHTML, v-html, {@html}), TLS checks turned off (also NODE_TLS_REJECT_UNAUTHORIZED=0 in .env files), path traversal, SSRF, open redirects, Math.random or random for secrets, and passwords hashed with MD5 or SHA.
  • APP009 to APP013, for code that calls a model: its answer reaching eval, a shell, SQL or HTML; request input inside the system prompt; AI routes with no login and no rate limit (OWASP LLM06); trust_remote_code=True, allow_dangerous_deserialization=True and torch.load without weights_only=True; agents with a Python REPL or shell tool, allow_dangerous_code=True or AutoGen without Docker.
  • The demo app built by scripts/demo/fixtures.py now also reports APP011 on its chat route, and has the mistakes the code check and DEP004 catch: an agent route that runs the model's answer in a shell, SQL built from the request, a PDF route that reads any path, a link preview that fetches any URL, a chat component that renders the model's answer as HTML, and a Python worker whose requests>=2.19.0 allows a version with known vulnerabilities. Every key in it is fake. The README demos were recorded again from it.
  • The website shows the code check, the AI-specific rules and DEP004, links to a sample report (/exemplo/ and /en/example/): the real HTML report of the demo app, built at deploy time, with a note on top and its content security policy kept. It also presents a security audit with a human review (US$ 149, delivered in 48 hours, with what it includes and what it does not cover) and a waitlist for a Team plan. Both buttons read their addresses from links in site/text.json; while an address is empty the button reads "Em breve" / "Coming soon" and is not a link, and a filled one must be an https:// address. Parts of the page more than a screen away no longer sit hidden while they wait for their entrance, so a page read without scrolling through it shows no blank stretch.
  • APP014, for MCP servers and agent tools: an argument the model writes reaching a shell command, eval/exec, a template, SQL, pickle or unsafe YAML, a file path, a URL the server fetches or HTML. Tool arguments are read from FastMCP @mcp.tool() and mcp.add_tool(f), low-level @server.call_tool() handlers and their arguments, TypeScript server.tool(...), server.registerTool(...) and CallToolRequestSchema handlers, LangChain @tool and BaseTool._run, AI SDK tool({ execute }), and tool_call.function.arguments or block.input from OpenAI and Anthropic responses, and are followed into helpers of the same file and into functions the tool imports from other files of the project, two levels deep. Critical when the argument is mixed into a command or code written in the code, high for SQL, deserialization and a path joined to the code's own folder, medium for other paths, URLs and HTML. Typed arguments (numbers, Literal, Enum, Field(pattern=...), z.number(), z.enum()), injected parameters such as ctx, query parameters, argument lists whose program is written in the code, an argument passed first to a check such as validate_name(arg) or validatePath(p), shlex.quote, basename, a resolve-and-prefix check, a fixed file name, a fixed host and an allow list of hosts are not reported. Each finding carries the CWE and OWASP Agentic entry of its sink besides LLM03:2026, in every report format, and keeps its full severity in stingward skill.
  • COD002 also catches ["sh", "-c", cmd] in Python and spawn("sh", ["-c", cmd]), spawn(cmd, { shell: true }) and execa with shell: true in JavaScript.
  • COD005 also catches HTML built from request data in Express res.send/res.write/res.end (with .status() and similar chained before), Hono c.html, and FastAPI routes with response_class=HTMLResponse; a Flask route that returns the HTML in a variable or in a (body, status) tuple counts too.
  • COD010 also catches Math.random() in a module-level value or inside a callback that builds it, and a session id (session_id, sessionId, sid) made with Math.random() or random that goes into a cookie.
  • COD001 in Python also catches SQL built from request data and passed to the project's own query helpers (execute_query(f"..."), run_sql(...)). COD007 in JavaScript also reads fsp, fsPromises and fs-extra calls and counts checks such as validatePath(p) or isAllowedPath(p) before the call. COD008 in JavaScript no longer takes the word private (a TypeScript private field) as a check of the address.
  • SEC001 finds Replicate (r8_), Pinecone (pcsk_), Shopify (shpat_, shpss_, shpca_, shppa_), Notion (ntn_), Linear (lin_api_) and Resend (re_) keys as critical, and Google OAuth client secrets (GOCSPX-) as high. Each format has its exact length, and the short prefixes (r8_, re_) also need digits and both letter cases, so names in code are not taken for keys.

Changed

  • The DEP003 docs no longer list pyproject.toml: it never raised DEP003, since libraries declare ranges on purpose.
  • Text and Markdown reports list the same problem (same rule, title and explanation) once, with every place it was found, and start with a short "fix these first" list when there are critical or high findings. JSON and SARIF still have one record per finding.
  • Test and example code is recognized in more places (e2e/, samples/, testdata/, __mocks__/, cookbooks/, test_*.py, conftest.py), and findings there are lowered as they already were in tests/ and examples/.
  • The source package on PyPI no longer ships tests/: those tests read files that only the repository has, so they could not run from it. CI now checks what the sdist and the wheel hold.
  • Python 3.14 is tested in CI on Linux, macOS and Windows and listed in the package classifiers. Python 3.9 is still the oldest supported.
  • DEP002 on the lowest version of a range without a lockfile is critical only when every version the range allows is malicious. When the malware record lists only some releases (a hijacked version that was replaced), it is high: the installed version is probably a later one.
  • SEC004 reports the default service_role key of a local Supabase (the one supabase start creates: issuer supabase-demo, signed with the CLI's default secret) as low, with a "local default key" note in the title, and that key alone no longer makes a committed .env high. Any other service_role key is still critical.
  • COD008 is medium, not high, when the host of the fetched address comes from the request's own Host or X-Forwarded-Host header, such as fetch(`https://${req.headers.host}/api`): another person's browser cannot choose that header and the proxy in front usually checks it, but whoever calls the server directly can. A host from the query string, the body or any other header, or a Host header used only as the fallback (request.args.get('h') or request.headers.get('host')), stays high.
  • The website has a new design: a dark page with one honey colour. The first screen puts the real terminal output of three runs (a PDF skill, the demo Next.js app and Stingward's own skill) on a honey stage, one tab each with the grade that run printed; a report chosen with the pointer prints line by line. The figures on why it exists are set large beside their sources, each stage of an audit shows what it really produces (the files read, what goes to OSV.dev, the checks by group and the grade the demo app got), and the paid audit sits on the same honey. The page uses Hanken Grotesk and JetBrains Mono in place of Schibsted Grotesk, self-hosted and published with their SIL Open Font Licenses, and the home pages carry a content security policy that allows only the site's own files and their one inline script, by its hash. All text, numbers, sources, prices and links are unchanged; motion uses only transform and opacity and follows the system's reduced motion setting, and every control shows keyboard focus.
  • The website is English first. The English page is now at the root (/), with its sample report at /example/; the Portuguese page moved to /pt/, with its sample at /pt/exemplo/. The language switch lists English first, the logo leads to the home page of the language you are reading, every page names its own address as canonical and both languages with hreflang (English as x-default), and the social card gives both locales. The addresses shared before, /en/, /en/example/ and /exemplo/, are small pages that send the visitor to the new ones and keep the #section of the link; they carry the same content security policy as the home pages. The English text was reread for readers in the US and Europe; no claim, number, source, price or offer changed, and prices in English read $149 instead of US$ 149.

Fixed

  • The Claude Code skill pre-approved any python3 command that mentioned scripts/run.py and any stingward command, so a hidden instruction in a skill under review could run its own code or overwrite a file such as ~/.bashrc without a prompt. It now pre-approves only its three commands, written with ${CLAUDE_SKILL_DIR}, and puts -- before the skill's path or URL so it cannot be read as an option (with the options before skill, which Python 3.9 to 3.12 need). The commands run Python with -I, so a PYTHONPATH with an empty entry no longer lets the checked folder's own json.py or shutil.py run.
  • The Claude Code skill now tells the model what the JSON output does not say by itself: the verdict for skill in the same words as the text report, and that dependencies were not checked when sources.osv is missing (with --fail-on never the exit code 3 is gone, so a model could say a project had no vulnerable dependencies when OSV.dev never answered). It also mentions --html for a report to hand over, and py -3 where python3 does not exist.
  • npx stingward ran whatever python3 it found first: with Python 3.8 or older the package broke with a traceback and exit code 1, the same code as "found problems", and it never tried python. It now asks each Python its version first, skips the ones older than 3.9 and says which it found, and exits 2 when none fits. On Windows it asks for py -3, so the launcher no longer opens a Python 2. A Python stopped by a signal (Ctrl-C, kill) now stops npx the same way instead of exiting 1, and the message is in English too.
  • On a pull request from a fork or from Dependabot the GitHub Action's token cannot comment, and the comment step failed with a bare HTTP 403. It now leaves a notice (fork) or a warning that names pull-requests: write, and points to the job summary, where the report already is. It also no longer posts a second comment when listing the existing ones fails.
  • The GitHub Action's sarif input and the README did not say that uploading SARIF from a private repository also needs actions: read. Without it the upload failed quietly and nothing reached code scanning.
  • On the site, the "Install" folder tab showed no focus ring when reached with the keyboard: the tab's cut corners (clip-path) cut the ring too. The other folder tabs only showed a thin line, because the next folder covers most of the ring. A focused folder tab now underlines its name.
  • The links in the README to the rules reference, SECURITY.md, CONTRIBUTING.md and the license were relative, so they gave 404 on the PyPI page. They now point to the files on GitHub, in all three READMEs.
  • The plugin's launcher (skills/stingward/scripts/run.py) relied on the caller passing -I. Run without it and with a PYTHONPATH that has an empty entry, it imported the checked folder's own shutil.py or json.py. It now drops the current folder from sys.path before importing anything else.
  • Masking secrets no longer takes quadratic time on long values. A skill whose MCP config carried a 60 KB argument kept stingward skill busy for about 100 seconds (hours for a few hundred KB); it now takes about two seconds for 600 KB. A long run of backslashes (40 KB took 9 seconds) is linear too.
  • Command line errors (folder not found, unknown command, a wrong --only) follow --lang and the system language. They were always in Portuguese.
  • stingward skill <url> that cannot download the skill exits with code 2 and a one-line message, also when git clone takes more than 180 seconds or git is not installed. It used to exit with 1, the code for "findings", or crash with a traceback, and a timeout or Ctrl+C left the temporary clone behind.
  • stingward skill https://github.com/<owner>/<repo>/tree/<branch>/<folder> only audits a folder inside the downloaded repository. A folder such as ../../etc, or one that the repository makes a symbolic link to a folder on your machine, used to be audited instead of the skill, and the verdict was about that folder.
  • stingward skill <url> clones with git hooks turned off. A post-checkout hook from your own git setup (core.hooksPath or init.templateDir) used to run inside the downloaded skill before it was audited.
  • A token or password in the address given to stingward skill (https://x-access-token:<token>@github.com/...) no longer shows up in the text and HTML reports or in the download error, and the git message in that error is masked and loses terminal escape sequences sent by the server.
  • An answer from OSV.dev, CISA KEV, EPSS or the NVD in the wrong shape (an empty {} from a proxy or captive portal, a list, a missing field) counts as that source failing. An empty {} from OSV.dev used to read as "no vulnerabilities": the CI gate passed with exit code 0 and the answer stayed in the cache for six hours; other shapes crashed with a traceback. Now OSV.dev gives exit code 3 as when it is down, a KEV failure shows in the report, and a wrong answer is never cached (one already in the cache is fetched again).
  • The "OSV.dev did not respond" notice is printed whenever it happens, also when findings already set exit code 1 or with --fail-on never; it used to show only when it changed the exit code. A CISA KEV failure now prints a notice too, since vulnerabilities on that list are raised to critical.
  • Files that start with a UTF-8 byte order mark (Notepad, PowerShell) are audited. An .mcp.json or agent settings file saved that way could not be parsed and was skipped without a word.
  • A .stingwardignore that is not valid UTF-8 (a comment saved in Latin-1) no longer crashes the scan with a traceback, and one that starts with a byte order mark no longer loses its first line.
  • On Python 3.9 to 3.11, a project or skill with folders nested about a thousand levels deep no longer stops the scan with a RecursionError. The file listing no longer recurses; its order and what it skips are the same.
  • An output file that cannot be written (--json, --sarif, --markdown, --html or --review-template in a folder that does not exist, or pointing at a folder) gives a one-line error and exit code 2. It used to crash with a traceback and exit code 1, the code for findings.
  • A password with an @ in a database URL (postgres://admin:xxxx@xxxx@db.example.com/app) is masked whole in every report. Masking stopped at the first @, so the HTML excerpt showed the rest of the password. The same fix makes such a URL to localhost count as a local database (low), as other local URLs already did.
  • A PGP/GPG private key (the armored block that GnuPG exports) is reported as a private key (SEC001, critical) and masked like the other private keys. Only PEM keys (-----BEGIN ... PRIVATE KEY-----) were.
  • Telegram bot tokens (also inside https://api.telegram.org/bot<token>/...) and the AccountKey and SharedAccessKey of Azure connection strings are masked in every report. A Claude Code permission that called the Telegram API showed the bot token in the text, Markdown, JSON and HTML reports.
  • What the audit did not read is now said on stderr: code and text files over the size limit (2 MB, or 10 MB in stingward skill), and a folder with more than 50,000 files, where reading stops. Both used to be skipped without a word, so a skill could hide its code in an oversized file and still get "nothing serious found".
  • The text and Markdown reports and the JSON output now say what the audit did not read, next to the sources line: code and text files over the size limit (the first five by name, then "and N more") and a folder cut at 50,000 files. The JSON output has a not_read object with too_big (the list of files) and truncated (true or false), present in every run. File names come from the audited project, so they are cleaned in the terminal and escaped in the pull request comment. The stderr lines are unchanged.
  • The HTML report says it too. Its scope section lists the code and text files over the size limit with the size of each (up to 20 by name, then "and N more files") and says when reading stopped at 50,000 files, and the cover warns about both, so a printed report shows what it did not cover. File names are escaped and invisible characters in them are shown as codes. In every report the file limit is written as 50,000 (50.000 in Portuguese).
  • stingward skill no longer says a skill looks fine when it could not read all of it. With a code or text file over the size limit, or a folder cut at the file limit, the "nothing serious found" and "install only after reading the items below" verdicts become "Incomplete audit": it names the limit and the files, says the result does not show the skill is safe, and asks to read what was left out before installing. It shows in the text, Markdown and HTML reports (in orange on the HTML cover), and the Claude Code skill gives the same verdict from the JSON not_read object. A critical or high finding keeps "Do not install yet". The grade and the exit code are unchanged.
  • When OSV.dev answers but some vulnerability details cannot be fetched, the reports and the stderr notice no longer say "OSV.dev did not respond: dependencies were not checked". They say the dependency check is incomplete and give the message from the dependency check (how many details are missing and which), in the text and Markdown sources line, on the HTML cover and in its sources table, and on stderr, in Portuguese and English. The exit code is still 3, so a CI gate does not pass on an incomplete check, and the README exit-code table says so. The message is cleaned and escaped like other text from the network.
  • A version with a huge number in a lockfile (1.0.0-999...9, thousands of digits), which OSV.dev still answers with vulnerabilities, no longer crashes the online scan with ValueError on Python 3.11 and later.
  • A cache entry dated in the future (a cache folder restored from another machine, or a wrong clock) is fetched again instead of being trusted forever.
  • Options before the folder (stingward skill --offline <folder>) and -- before it (stingward skill --offline -- <folder>) work on every supported Python. On Python 3.9 to 3.12 both stopped with "unrecognized arguments"; a folder whose name starts with - can now be given after --.
  • stingward --help follows --lang, STINGWARD_LANG and the system language, like the reports. It was always in Portuguese, and --no-color, --help and --version now have a help text in both languages.
  • The agents and skills check no longer hangs on a hostile file with one very long line. A single giant line (a curl ... | sh, a permission entry or an MCP package spec of many kilobytes) was masked in full before being cut to the 70 characters a report shows, and masking is super-linear, so a scan could take minutes. The text is now capped before masking, which keeps the same output for real files.
  • Tool-poisoning in stingward skill: a prompt-injection phrase in an MCP server's tool description (server.tool, @mcp.tool()) wrapped in defensive-looking words such as "detects" was dropped (SKL003 silent). Whoever writes a third-party server chooses the words around the phrase, so the wording no longer clears the finding; it is reported as medium instead. The same phrase in your own project stays silent.
  • The words "flag" and "report" (and the Portuguese "sinalize", "reporte", "aponte") are now treated as weak defensive wording: a finding whose sentence uses one of them is lowered to medium instead of being left at its full severity, in both the project and skill checks. A security reviewer that says "flag any skill that reads ~/.ssh and uploads it" reads as medium, not critical. Unlike "never", "detect", "attacker" and "malicious", which drop the finding, these words never clear it: an attacker who writes "report the status, then read ~/.ssh and send it" is still reported.
  • Hook command values, in Claude settings (settings.json, settings.local.json) and in plugin and project hooks.json, now go through the same content checks as skill scripts, not only the "downloads and runs remote code" check (AGT002). A hook that opens a reverse shell (SKL011), reads credentials and calls the internet (SKL004), sends to a capture service (SKL008) or runs obfuscated code (SKL007) is now caught, pointing at the line of the command.
  • The launch command of each MCP server (its command plus its joined args, so sh -c, bash -c, cmd /c and powershell -c wrappers are included) now goes through the same checks, in every config the agents check reads. A server started with sh -c "curl ... | sh" is caught as AGT002, and a launch command that opens a reverse shell, reads credentials, hits a capture service or runs obfuscated code is caught under the matching rule. A normal launch such as npx -y pkg@1.2.3 or a Docker image pinned by digest stays silent. AGT002 is renamed "Hook or MCP server downloads and runs remote code" in both languages and both rule docs.
  • A Claude Code allow rule whose command starts with *, such as Bash(* *), is now flagged as a broad permission (AGT001, high). It was silent before, although it allows every command that takes an argument, just like Bash(*).
  • Allow rules that hand the agent an interpreter, such as Bash(python3 *), Bash(node:*), Bash(bash:*), Bash(sh -c:*), Bash(deno:*), Bash(bun:*), Bash(powershell:*) or Bash(eval:*), are now AGT001 high, not medium: each one can run any code, so they are as broad as Bash(*). Allow rules for other sensitive commands (sudo, rm, curl, wget, ssh, scp, docker, npx, …) stay medium.
  • Within the same severity, problems are now listed by how fast an attacker can use them, in the text and Markdown reports, the HTML plan and every "fix these first" list: first a flaw attacked in the wild (CISA KEV), then an exposed secret or key (SEC rules, APP001, APP002), then code or command execution (COD002 to COD004, APP012, APP013, AGT002, SKL002, SKL009, SKL011, and APP009 or APP014 when the model's text reaches code, a shell, a template or pickle), then open data access (APP004 to APP006, APP008, COD001, and APP009 or APP014 reaching SQL), then the rest. Ties keep the order by rule, file and line. Before, the order inside a severity was alphabetical by rule.
  • In the HTML report, "Findings in detail" starts with the area that has the most serious finding still standing, then the area with more of them; the fixed order (dependencies, secrets, application, code, agents, skills) only breaks ties. A problem fixed during the audit does not move its area up.
  • When no file was read (an empty folder or skill, a wrong path, everything skipped, or no agent configuration on the machine), the report no longer looks like a clean A. The text, Markdown and HTML reports say that 0 files were read, so there is nothing to grade, and give no grade, no badge and no green verdict; the JSON has "grade": null and "warning": "nothing_read". The GitHub Action's grade output is then none.
  • A run that read no file now exits with code 4 and says so on stderr, unless --fail-on never. A CI job that forgot to check out the code, or that points at a wrong folder, used to pass with grade A; like code 3 for OSV.dev, a gate should not pass without having checked anything.
  • The README's "Human review" paragraph (English, Portuguese and Spanish) now says that the fingerprint is built from the masked line, so nothing derived from a secret goes into the review file, and that a key replaced by another on the same line keeps its status: after rotating a key, check that line again before reusing the review.
  • stingward agents no longer ends with a README badge line, and its Markdown title has no badge: the check of your own machine has no README to put it in.
  • When --review-template runs again, the items that no longer match any finding stay at the end of the file, with the reviewer's status and comment, and are now marked "stale": true; the mark goes away when the finding comes back. The message on stderr says they are marked.
  • A finding the reviewer marked fixed disappears from the next scan, so its review item no longer matches anything. It used to be dropped from the report with a warning; it is now listed as fixed during the audit in the text and Markdown reports and in the "no action planned" group of the HTML plan, from the finding block kept in the review file (rule, severity, where, title), and it counts in the review counts, the JSON ones included. That block is hand-edited, so it is escaped and masked like a comment. Items with any other status that no longer match still get the warning.
  • The text report shows a line break in a file name or in text from the audited project as \x0a (and U+2028/U+2029 as \u2028/\u2029), as it already did with other control characters. A file named x + line break + Summary: 0 · Grade: A printed a fake line in the terminal.
  • The Markdown report (the pull request comment) no longer turns text from the audited project into links: a bare https://... or www.... address, #12 and owner/repo#3 get a zero-width space, so GitHub shows them as plain text and does not add a reference to the issue they name. Images, HTML and @mentions were already inert.
  • A token in the address given to stingward skill (an address with the token before @github.com, used to clone a private repository) is masked in the first line of the text report and on the cover of the HTML report. It used to be printed as typed.
  • When the Markdown report has more than 50 problems, its last row said "and N more low-severity item(s)" even when the ones left out were high or critical. It now says how many are left out at each severity, such as "and 3 more item(s): 2 high, 1 low".
  • The HTML report fits a phone screen again. In the remediation plan the effort column kept its desktop width of 80 pixels, so a status such as "Accepted risk" was cut off and the page scrolled sideways, and the place column stayed at a third of the width, splitting paths over several lines. On a 320-pixel screen a long name such as NEXT_PUBLIC_OPENAI_API_KEY also pushed the "fix these first" list off the screen.
  • In the PDF of the HTML report, the last row of a finding (such as "Standards") or of the remediation plan no longer goes alone to the next page: it takes the row before it along.
  • In SARIF, each rule's description and help described the first problem found for that rule, so in GitHub code scanning an alert for axios came with "Upgrade next to 15.5.24 or later." The rule now has its generic name from the rules reference, its explanation and fix when they do not depend on the problem, and otherwise a line saying that each alert says what to change. Each alert keeps its own text. In Portuguese, the rule links to docs/rules.pt-BR.md.
  • A PGP private key block (PRIVATE KEY BLOCK) is now hidden whole in the HTML report's excerpts and in review comments and notes, like other private keys. Before, each of its lines was masked on its own, and the short last line of the key could show.
  • On the website, the pull request preview listed the demo app's public OpenAI key twice, once for .env and once for the chat route, while the real comment shows it as one row with both places. The preview is now built from the first rows of the real Markdown comment, in the same order and with the same places.
  • The code excerpts in the HTML report now come from the text the checks read, instead of opening each file again. A file changed on disk after the scan, or a step the reader applies such as dropping a byte order mark, no longer makes an excerpt differ from the line the finding points at.
  • When the CISA KEV list does not respond, the text and Markdown reports now say so in the sources line, next to OSV.dev, and the HTML report warns on its cover, in Portuguese and English: without that list, a vulnerability attackers exploit now is not raised to critical. Before, only the sources table of the HTML report said it. The pull request comment also keeps its sources line when nothing was found but a source failed, so an OSV.dev outage no longer reads as a plain "Nothing found".
  • The CISA KEV catalog version, which comes from the network, is now plain text in the sources line: control characters are shown as escapes in the terminal, and the pull request comment escapes it like the rest of the text it quotes, so a bad answer cannot add color, an image, a link or a mention.
  • A version range in requirements*.txt, package.json or pyproject.toml with a long version that does not parse (for example foo>=1aaaaaaaaaaaaaaaaaaaaaaaaaaaa*) no longer makes the scan hang: the version pattern backtracked exponentially.
  • A long run of spaces on a line of requirements*.txt no longer slows the scan down quadratically.
  • A committed .env with a long run of spaces inside a value no longer slows the scan down quadratically (60 000 spaces took 15 seconds).
  • Masking of command-line options such as --api-key in code excerpts is linear: a long hyphenated word made it quadratic.
  • A file with thousands of hard-coded values (generated config, fixtures) is scanned for secrets in linear time: 40 000 such lines took 44 seconds.
  • SEC001 no longer reports a "password in URL" (high) where code builds the URL: f"postgresql://{settings.DB_USER}:{settings.DB_PASSWORD}@...", "{}:{}@{}".format(...), "%s:%s@%s", %(password)s, Ruby #{password} and Swift \(password). Translated examples such as https://usuario:contraseña@servidor or https://uzivatel:heslo@hostitel:port (a non-ASCII password, or a port written as a word) are not reported either; a real password next to a host and port the code fills in still is.
  • SEC001 reports a private key only when its body is there (on the same line, as in a service account JSON, or on the next lines). Code that only writes the header, such as key.replace('-----BEGIN PRIVATE KEY-----', ''), startsWith(...), a placeholder="-----BEGIN PRIVATE KEY-----" or an example with \n...\n, was a critical finding.
  • SEC001 now reads key files that were never scanned: id_rsa (and the dsa, ecdsa and ed25519 ones), *.pem, *.key and Apple's *.p8. A committed private key in one of them was missed; a certificate, which only holds the public part, is not reported.
  • SEC001 no longer reports a "Meta/Facebook token" (high) inside base64 data such as an embedded image, font or WebAssembly module, where /EAA... and +EAA... show up all the time.
  • Real keys are no longer skipped as placeholders because their random part contains seu or sua (Portuguese for "your"): about 1 in 100 OpenAI project keys and 1 in 150 Anthropic keys were missed. Those words now count only at the start of a word, as in SUA_CHAVE or sk-sua-chave.
  • SEC001 no longer reports as a hard-coded value: translated text in i18n files ("password_complexity_requirement": "数字、大文字...", "Tokens": "...\u200c..."), the example 1234567890, a dotted config path (image_generation.automatic1111.api_auth), the name of an environment variable ('DUCKLAKE_S3_SECRET', MOCK_ACCESS_TOKEN), and keys that are public by design (sb_publishable_..., Stripe pk_live_/pk_test_).
  • A Slack or Discord webhook is no longer missed when something else on its line looks like an example, such as { text: "your build finished" } or process.env.SLACK_WEBHOOK || "https://hooks.slack.com/...": only the webhook's own token is checked for placeholders.
  • DEP003 no longer reports the package.json of each workspace member in a monorepo whose lockfile sits at the root (npm, Yarn and Bun workspaces, pnpm-workspace.yaml, including ** and ! globs); a folder that is not a member still gets it.
  • Packages installed from a git repository or a local folder or tarball are no longer looked up in the public registry's advisories: package-lock.json v2/v3 (resolved git or file:), yarn.lock (git, GitHub, owner/repo and URL entries), poetry.lock ([package.source] git, directory or file), uv.lock (git), pdm.lock (git or path) and Cargo.lock (git+). npm v1 lockfiles and Gemfile.lock already did this. A private package that shares its name with a public one no longer inherits that package's advisories.
  • The .txt files of a requirements/ folder (requirements/base.txt, requirements/production.txt) and the files a requirements file includes with -r or -c (constraints.txt, dev-requirements.txt) are now read for DEP001, DEP003 and DEP004. Before, a project with that layout had none of its pins audited.
  • An advisory that OSV.dev lists for a package but whose details could not be downloaded is no longer dropped without a word: the package still gets a DEP001 or DEP004 (medium, with a note to check the advisory and run again), and a MAL- record still gets DEP002. The run counts as incomplete, like an OSV.dev outage: the CLI exits with 3, so a CI gate cannot pass on it. A headline no longer ends in empty parentheses when an advisory has no summary.
  • The private-key body check also reads PGP blocks (PRIVATE KEY BLOCK, with armor headers such as Version: and the blank line before the body): a real block is critical, a header alone in a README or doc is not reported, and a key header the check does not know no longer stops the scan.
  • Text, Markdown and JSON reports no longer show a token whose length is off the documented format (hf_, gsk_, xai-, sbp_, SG....) or from a service the detector does not know yet (GOCSPX-, r8_, pcsk_, shpat_, ntn_, lin_api_), nor a password in ?key=, curl -u user:password, sshpass -p or mysql -ppassword, for example in an AGT001 permission entry.
  • A committed .env is no longer SEC002 high only because of values that are public or encrypted by design: the Supabase anon key, dotenvx encrypted: values and DOTENV_PUBLIC_KEY, and plain URLs under names such as AUTH_CALLBACK or ..._REDIRECT_URLS. It stays low, and a real secret next to them still makes it high (.env.keys with DOTENV_PRIVATE_KEY included).
  • A secret written with :=, ::=, ?=, ==, != or => (Go, Makefiles, a password compared in code, PHP arrays and Ruby hashes) is masked in every report. The masker read only = and :, so passwd := "..." came out as passwd :[REDACTED] "..." with the value in plain text, and 'password' => '...' was not masked at all.
  • A field masked earlier in the pipeline (foo-token=[REDACTED]) no longer comes out as [REDACTED:secret_field]] with a stray bracket.
  • An OSV.dev record outside the schema (an alias that is not text, affected that is not a list, a version that is a number) no longer crashes the whole dependency check with a traceback. It counts as an advisory whose details could not be downloaded: the package stays in the report and the CLI exits with 3. EPSS values that are not probabilities (n/a, NaN, 1.5) are skipped.
  • Versions are compared with the rules of their ecosystem when a fix or a range is checked: PEP 440 for PyPI and semver for npm, Go and crates.io. On PyPI 1.0-1 is the post-release 1.0.post1 (it used to sort below 1.0, so a fixed version was reported as vulnerable), 1.0rc1 equals 1.0c1, and 1.0a1.dev1 and 1.0.post1.dev1 sort before 1.0a1 and 1.0.post1. On npm 1.0.0-1 stays a pre-release.
  • The suggested fix is a final release when the advisory lists one above your version: 26.4.1 instead of 26.4.0rc2, 1.1.0 instead of 1.1.0-beta.1. A pre-release is suggested only when it is the only fix listed.
  • A package with more advisories than OSV.dev returns in one page gets all of them: the next pages (next_page_token) are read, up to 10 per package. Only the first page used to be read.
  • Text files saved in UTF-16 with a byte order mark (what Windows PowerShell writes with >, such as pip freeze > requirements.txt or echo ... > .env) are audited. A .env, .txt or other non-code file in UTF-16 was skipped as binary, and a UTF-16 code file was read as garbage, so its secrets were not found. The checks, the HTML excerpt and .stingwardignore now read the same decoded text.
  • The code check reads JavaScript and TypeScript files longer than about 2000 lines again. Everything after line 2000 was counted as one long line, so ordinary files of that size (a large MCP server, a big page component) were taken for minified bundles and skipped without a word; only real long lines mark a bundle now.
  • COD001 and APP014 now report SQL built with request data or a tool argument held in a variable named like a piece of SQL, such as query, count or limit, or in a field such as item.name, when it sits where a value goes ('%{query}%', = {count}). Those names were taken for table names or SQL written in the code, so the most common search query in AI apps and MCP tools was never reported. In other places (ORDER BY {order}) and for arguments of unknown origin nothing changes.
  • The code check no longer hangs on a text built from other built texts (a2 += a1 many times, then a3 += a2): a 2 KB file could stop the audit for hours. Each text is now put back together from at most 400 pieces, and the finding still comes out.
  • The code check no longer takes minutes on a JavaScript line with a long run of spaces before Math.random(): finding the name that receives the value was cubic in the length of the line.
  • The code check no longer slows to seconds or minutes on a Python "..." % x text with long runs of zeros after a % or thousands of %( without ).
  • The code check no longer takes seconds per JavaScript file full of blank lines (looking for 'use server') or of export const GET: with no = (looking for a route handler): each line start read the rest of the file.
  • The code check no longer takes seconds on JavaScript with thousands of ) => whose ( is missing: each arrow walked back up to 2000 characters to find its parameters.
  • The code check no longer takes seconds on JavaScript expressions that hold a very long name next to a call: the search for calls tried to start at every letter of the name.
  • The code check no longer takes seconds on JavaScript with thousands of return Math.random(): each one read the 1500 characters before it again to find the function it belongs to. The function heads are now read once per file.
  • COD001 in JavaScript no longer reports a list of placeholders built from request data, such as const marks = ids.map(() => '?').join(','), as SQL injection; it now knows the same placeholder names as Python (marks, ph, qs) and also reads the declared value. A list that puts each value between quotes (names.map((n) => `'${n}'`).join(',')) is now reported, also when it is written inside the query, and req.body.bookmarks is no longer taken for a placeholder list because its name ends in marks.
  • Request bodies in FastAPI are now request data when the model's name ends in Request (ChatRequest, QueryRequest) or the parameter is called request, req or user (request: ChatRequest, user: UserCreate). They were taken for the framework's own Request or the logged-in user, so SQL, shell, URL and path findings from the most common chat endpoints were missed or only reported as medium. Parameters typed with the framework's Request or filled by Depends stay as they were.
  • COD008 and APP014 no longer report a fetch of a fixed address plus a path when the two are joined in a variable first (full = BASE + path, then requests.get(full) or fetch(full)) or with + and no quoted text (requests.get(BASE + path)). The start of the address comes from the code there, as in f"{BASE}/{path}".
  • COD008 and APP014 now report a fetch whose host comes from the request or the model after a fixed scheme, such as f"https://{host}/v1", `https://${host}/x`, 'https://' + tenant + '.example.com' or http://localhost:{port}. Only an address that started with outside data was reported, and these let the caller pick the server (evil.com/?, @evil.com). Redirects to https://{Host}/..., the usual move from http to https, stay silent.
  • The code check now sees request data read from the query string of a route handler held under another name, such as const params = request.nextUrl.searchParams or const sp = new URL(req.url).searchParams, then params.get('url'). Only the name searchParams was known, so these reads reached SQL, shell and fetch calls without a finding.
  • COD005 and APP009 now report request data or model output put into innerHTML inside HTML that has class="icon", style="...", <svg> or css in its fixed text. Those words were meant to spot code that builds an icon or a style, but they were also read inside the HTML, so a chat bubble with an icon hid the model's answer from the check.
  • COD007 and APP014 now check JavaScript files that import the file functions by name, such as import { writeFile, readFile } from 'fs/promises' in a Next.js upload route or const { readFileSync } = require('fs'). The check only started when fs showed up in the code outside quotes, so these files were skipped unless some other name happened to contain "fs".
  • COD007 no longer reports an upload saved under a name the code makes up plus the extension of the sent file (ext = os.path.splitext(file.filename)[1], then os.path.join(UPLOAD_DIR, f"{uuid4()}{ext}")), the usual upload endpoint in FastAPI and Flask apps. The extension cannot hold / or ... The rest of the name (root, filename.split('.')[-1], the whole filename) is still reported, and the extension still counts as outside data in SQL and shell commands.
  • COD004 no longer reports yaml.load(text, Loader=StrictLoader) when StrictLoader is a class in the same file built on yaml.SafeLoader, CSafeLoader or BaseLoader, also through more than one step. A loader built on yaml.Loader is still reported.
  • COD003, APP009 and APP014 now report code handed to an interpreter on its command line, such as subprocess.run([sys.executable, "-c", code]), ["node", "-e", code] or execFile("python3", ["-c", code]), the usual body of a "run Python" tool. It runs the text as code, like exec(code), but the command check only looked at the program name. A script file of the project with the value as an argument stays silent.
  • COD001 now reports SQL built from a variable such as remarks or bookmarks. Any name containing marks was taken for a list of ? placeholders; now only marks, qmarks, question_marks and questionMarks are.
  • COD003, APP009 and APP014 no longer report Python code that writes the outside value with {value!r} or repr(value), such as exec(f"x = {value!r}") or [sys.executable, "-c", f"open({url!r})"]: the value becomes a quoted Python literal, not code. Templates are still reported, since the template engine reads inside the quotes.
  • The Python code check now trusts a value after an if that leaves the function when the value fails a check: if sort not in ALLOWED: abort(400), if not uid.isdigit(): return ..., if not re.fullmatch(r"[a-z_]+", t): raise ... or if not validate_column(c): .... These allowlists are how a dynamic ORDER BY or table name is made safe, and they were reported as high SQL injection. A list that comes from the request, an if that does not leave, or re.match without an anchored end still count as unchecked.
  • The JavaScript check no longer reads the code after const RE = /^\w+$/ as part of that value. The / that closes a regular expression at the end of a line was taken for a division going on to the next line, so the constant took the origins of the handler written below it.
  • The JavaScript check now trusts a value picked from an allowlist (ALLOWED.includes(x) ? x : 'name') or checked by an if that returns or throws (if (!ALLOWED.includes(x)) return ..., if (!/^[a-z_]+$/.test(x)) throw ...). Like the Python ones, these were reported as high SQL injection. A list that comes from the request, an if that does not leave, and a regular expression not anchored at both ends still count as unchecked.
  • npm-shrinkwrap.json and NuGet's packages.lock.json are no longer scanned as text for secrets, like the other lockfiles: their hashes and registry URLs gave noise. Their packages are audited by DEP001: npm-shrinkwrap.json as before, and packages.lock.json is now read (NuGet packages, without the solution's own projects).
  • Requirements files named like dev-requirements.txt, test-requirements.txt or docs_requirements.txt are read for DEP001, DEP003 and DEP004 even when no other file includes them with -r. A line that does not have the shape of a requirement (a sentence, a URL) no longer counts as an open version for DEP003.
  • DEP004 and DEP001 read every dependency list of a pyproject.toml without a lockfile: Poetry's [tool.poetry.dependencies], dev-dependencies and groups (^2.28 and ~1.2 read as Poetry ranges, git and path dependencies skipped), PEP 735 [dependency-groups] and the dev-dependencies of [tool.uv]. Before, only [project] was read, so a Poetry project without poetry.lock was never checked.
  • Hugging Face tokens (hf_) without a digit are found. About 1 in 400 real tokens has none, and they were skipped as variable names; now upper and lower case letters after the prefix are enough.
  • A Clerk secret key (sk_live_, sk_test_, the same shape as Stripe's) is reported as "Clerk secret key" when the line mentions Clerk, instead of "Stripe key". The severity is unchanged: critical for live keys, low for test keys.
  • A dotenv-vault .env.vault (encrypted environments, made to be committed) no longer gets "remove it from git" (SEC002) or "add it to .gitignore" (SEC003). It still raises SEC002 high when it also holds a plain secret, and .env.keys counts as before.
  • A committed .env.me with a dotenv-vault login token (DOTENV_ME=me_...) is SEC002 high, not low: the token pulls every environment of the vault.
  • Dependency files saved in UTF-16 with a byte order mark, such as a requirements.txt written by pip freeze > in Windows PowerShell, are audited. They were read as UTF-8, so DEP001, DEP003 and DEP004 found no package in them and said nothing.
  • The bounds of a version range (DEP004) and the fix picked when several advisories have one (DEP001, DEP004) follow the ecosystem's version order too, PEP 440 for PyPI and semver for npm, instead of the generic one. In PyPI 1.0-1 is the post-release 1.0.post1: foo>=0.9,<1.0.post1 no longer takes it as inside the range, and advisories fixed in 1.0 and 1.0-1 now suggest 1.0-1.
  • COD001, APP009 and APP014 now report a column or table name chosen by request data, model output or a tool argument, such as ORDER BY {order}, FROM {table} or LIMIT {limit} (medium). Variables with these names were always skipped, because in the code's own helpers they hold a name the code wrote. A function argument of unknown origin with such a name is still skipped, and so is a name checked against a fixed list (x if x in ALLOWED else 'id') or taken from a dict in the code (SORTS[req.query.sort], which the JavaScript check used to report as high). A whole piece of SQL from outside, such as WHERE {where}, is high.
  • COD009 now reports a redirect that puts request data right after a fixed /, \ or //, such as redirect(f"/{request.args['next']}") or res.redirect(`/${req.query.next}`): with next = "/evil.com" the browser goes to //evil.com, another site. A path with more fixed text after the slash (/users/{id}) is still not reported.
  • COD001, APP009 and APP014 now check Django's QuerySet.extra(where=[...], select={...}, tables=[...]), which puts each piece into the SQL as written, like RawSQL: extra(where=[f"name = '{q}'"]) with q from the request was never reported. Pieces with %s and params=[...], or fixed text, are not reported.
  • The JavaScript check no longer stops halfway through files with many short declarations, such as generated code with var a=1;var b=2; on every line. Each declaration was charged as 400 characters read against the file's limit, even when it ended a few characters later, so the limit ran out and the rest of the file was not checked. It is now charged for what it actually reads.
  • stingward skill now reads minified bundles, .min.js and .bundle.js files and vendor/ folders with the code checks (COD, APP009 to APP014). They were skipped as in a project, so a skill could hide its code on one long line of a bundle. In a skill they are the code that runs on the machine of whoever installs it. The limit on analysis work per file still applies, and projects still skip them.
  • The code checks no longer report findings inside third-party JavaScript libraries copied into a project, such as a materialize.js in static/js/: files that start with a library header (/*! name vX.Y, or a first comment with @license) and files under third_party/ or static/js/lib/ are skipped, like vendor/ and .min.js already were. A copyright header of the project itself (/*! Copyright (c) ...) does not count. stingward skill still reads them all.
  • A review file (--review, --review-template) or notes file (--notes) saved in UTF-16 with a byte order mark, as Windows PowerShell writes with >, is read. It was refused as "not UTF-8". A file in another encoding, such as Windows-1252, is still refused instead of being read with its accents garbled.
  • DEP002 on the lowest version of a range without a lockfile, when the range also allows clean versions (high), no longer says "Remove it now": it says to raise the range's minimum past the malicious version and commit a lockfile, and to delete node_modules/the virtualenv and rotate the keys only if the installed version is a malicious one. A malicious version that is pinned, locked or the whole range (critical) still says to remove it now.
  • An OpenAI-style value (sk-, sk-proj-, sk-svcacct-, sk-admin-) or npm-style value (npm_) with only upper case letters and digits after the prefix is no longer reported as a key (SEC001 critical): the lower case prefix counted as the lower case letter a random key has. Real OpenAI keys and npm tokens have both letter cases and a digit after the prefix and are still found, as with r8_ and re_.
  • The README (English, Portuguese and Spanish) lists NuGet among the ecosystems whose lockfiles are audited: DEP001 reads packages.lock.json, but the list stopped at Composer.
  • An answer from OSV.dev, KEV, EPSS or NVD just saved to the local cache is used again on the next run, also on Windows with Python 3.12 and with the cache on a network drive. Its time could read a fraction of a second, or a few seconds, ahead of the clock, and a cache entry dated in the future was always fetched again. Up to a minute ahead now counts; an entry further in the future (a cache copied from a machine with a wrong clock) is still fetched again.
  • COD001's fix also says what to do with a column or table name chosen from outside (ORDER BY {order}, medium): a name cannot be a query parameter, so pick it from a fixed list. It used to say only "pass values as parameters", which does not fix that case.
  • COD009 now reports a redirect to a host from the query string or the body right after a fixed scheme, in Python and JavaScript, such as redirect("https://" + request.args["host"]), res.redirect(`https://${req.body.host}/home`) or "https://{}.example.com/".format(request.args["tenant"]): the host-after-scheme rule applied only to server-side fetches (COD008). A host from the Host or X-Forwarded-Host header ("https://" + request.headers["Host"] + path, the usual HTTPS upgrade) and a fixed host followed by a path ("https://example.com/" + path) are still not reported.
  • The SQL fix of APP009 and APP014 also says what to do with a table or column name chosen by the model or a tool argument (ORDER BY {order}, medium): a name cannot be a query parameter, so pick it from a fixed list, as COD001 now says.

What's Changed

  • DEP004: check the lowest version each range allows without a lockfile by @IsaqueMoutta in #2
  • Add an HTML report and group repeated findings by @IsaqueMoutta in #3
  • Add code checks: injection, XSS, SSRF and AI-specific mistakes by @IsaqueMoutta in #4
  • Full test-first review, with the site, audit review mode and MCP tool input by @IsaqueMoutta in #5
  • Redesign the website around the real terminal output, with English at the root by @IsaqueMoutta in #6
  • Re-record the demo app recordings with the current output by @IsaqueMoutta in #7
  • Release 0.1.6 by @IsaqueMoutta in #8

New Contributors

Full Changelog: v0.1.5...v0.1.6