Repository navigation
Stingward v0.1.6
Added
- GitHub Action input
category(defaultstingward), 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 FILEwrites a JSON file with one entry per finding (and keeps what was already reviewed when it runs again); the reviewer sets eachstatustoconfirmed,false_positive,accepted_riskorfixedand writes acomment.--review FILEapplies 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 NAMEputs "Prepared for" on the cover of the HTML report, and--notes FILEadds 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 asproperties.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*.txtandpackage.jsonwithout a lockfile beside them, and the[project]dependencies and optional dependencies of apyproject.tomlwithoutpoetry.lock,uv.lockorpdm.lock.Pillow>=10lets 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"inpyproject.tomlorfoo (==1.0)inrequirements.txt, is now audited by DEP001. --format htmland--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
codecheck (--only code) that reads the project's own code: Python withast, JavaScript and TypeScript (including the<script>of.vue,.svelteand.astrofiles) 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),pickleand unsafe YAML, XSS (innerHTML,dangerouslySetInnerHTML,v-html,{@html}), TLS checks turned off (alsoNODE_TLS_REJECT_UNAUTHORIZED=0in.envfiles), path traversal, SSRF, open redirects,Math.randomorrandomfor 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=Trueandtorch.loadwithoutweights_only=True; agents with a Python REPL or shell tool,allow_dangerous_code=Trueor AutoGen without Docker. - The demo app built by
scripts/demo/fixtures.pynow 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 whoserequests>=2.19.0allows 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 fromlinksinsite/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 anhttps://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,pickleor unsafe YAML, a file path, a URL the server fetches or HTML. Tool arguments are read from FastMCP@mcp.tool()andmcp.add_tool(f), low-level@server.call_tool()handlers and theirarguments, TypeScriptserver.tool(...),server.registerTool(...)andCallToolRequestSchemahandlers, LangChain@toolandBaseTool._run, AI SDKtool({ execute }), andtool_call.function.argumentsorblock.inputfrom 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 asctx, query parameters, argument lists whose program is written in the code, an argument passed first to a check such asvalidate_name(arg)orvalidatePath(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 besidesLLM03:2026, in every report format, and keeps its full severity instingward skill. - COD002 also catches
["sh", "-c", cmd]in Python andspawn("sh", ["-c", cmd]),spawn(cmd, { shell: true })and execa withshell: truein JavaScript. - COD005 also catches HTML built from request data in Express
res.send/res.write/res.end(with.status()and similar chained before), Honoc.html, and FastAPI routes withresponse_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 withMath.random()orrandomthat 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 readsfsp,fsPromisesandfs-extracalls and counts checks such asvalidatePath(p)orisAllowedPath(p)before the call. COD008 in JavaScript no longer takes the wordprivate(a TypeScriptprivatefield) 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 intests/andexamples/. - 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_rolekey of a local Supabase (the onesupabase startcreates: issuersupabase-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.envhigh. Any otherservice_rolekey is still critical. - COD008 is medium, not high, when the host of the fetched address comes from the request's own
HostorX-Forwarded-Hostheader, such asfetch(`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 aHostheader 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 withhreflang(English asx-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#sectionof 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$149instead ofUS$ 149.
Fixed
- The Claude Code skill pre-approved any
python3command that mentionedscripts/run.pyand anystingwardcommand, so a hidden instruction in a skill under review could run its own code or overwrite a file such as~/.bashrcwithout 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 beforeskill, which Python 3.9 to 3.12 need). The commands run Python with-I, so aPYTHONPATHwith an empty entry no longer lets the checked folder's ownjson.pyorshutil.pyrun. - The Claude Code skill now tells the model what the JSON output does not say by itself: the verdict for
skillin the same words as the text report, and that dependencies were not checked whensources.osvis missing (with--fail-on neverthe exit code 3 is gone, so a model could say a project had no vulnerable dependencies when OSV.dev never answered). It also mentions--htmlfor a report to hand over, andpy -3wherepython3does not exist. npx stingwardran whateverpython3it 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 triedpython. 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 forpy -3, so the launcher no longer opens a Python 2. A Python stopped by a signal (Ctrl-C,kill) now stopsnpxthe 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 namespull-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
sarifinput and the README did not say that uploading SARIF from a private repository also needsactions: 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.mdand 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 aPYTHONPATHthat has an empty entry, it imported the checked folder's ownshutil.pyorjson.py. It now drops the current folder fromsys.pathbefore 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 skillbusy 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--langand 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 whengit clonetakes 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. Apost-checkouthook from your own git setup (core.hooksPathorinit.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.jsonor agent settings file saved that way could not be parsed and was skipped without a word. - A
.stingwardignorethat 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,--htmlor--review-templatein 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 tolocalhostcount 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 theAccountKeyandSharedAccessKeyof 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_readobject withtoo_big(the list of files) andtruncated(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 skillno 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 JSONnot_readobject. 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 withValueErroron 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 --helpfollows--lang,STINGWARD_LANGand the system language, like the reports. It was always in Portuguese, and--no-color,--helpand--versionnow 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
~/.sshand 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~/.sshand send it" is still reported. - Hook
commandvalues, in Claude settings (settings.json,settings.local.json) and in plugin and projecthooks.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
commandplus its joinedargs, sosh -c,bash -c,cmd /candpowershell -cwrappers are included) now goes through the same checks, in every config the agents check reads. A server started withsh -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 asnpx -y pkg@1.2.3or 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 asBash(* *), is now flagged as a broad permission (AGT001, high). It was silent before, although it allows every command that takes an argument, just likeBash(*). - 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:*)orBash(eval:*), are now AGT001 high, not medium: each one can run any code, so they are as broad asBash(*). 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": nulland"warning": "nothing_read". The GitHub Action'sgradeoutput is thennone. - 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 agentsno 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-templateruns 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
fixeddisappears 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 thefindingblock 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 namedx+ line break +Summary: 0 · Grade: Aprinted 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://...orwww....address,#12andowner/repo#3get 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_KEYalso 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
axioscame 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 todocs/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
.envand 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.jsonorpyproject.tomlwith a long version that does not parse (for examplefoo>=1aaaaaaaaaaaaaaaaaaaaaaaaaaaa*) no longer makes the scan hang: the version pattern backtracked exponentially. - A long run of spaces on a line of
requirements*.txtno longer slows the scan down quadratically. - A committed
.envwith 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-keyin 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 ashttps://usuario:contraseña@servidororhttps://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(...), aplaceholder="-----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 thedsa,ecdsaanded25519ones),*.pem,*.keyand 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
seuorsua(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 inSUA_CHAVEorsk-sua-chave. - SEC001 no longer reports as a hard-coded value: translated text in i18n files (
"password_complexity_requirement": "数字、大文字...","Tokens": "...\u200c..."), the example1234567890, 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_..., Stripepk_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" }orprocess.env.SLACK_WEBHOOK || "https://hooks.slack.com/...": only the webhook's own token is checked for placeholders. - DEP003 no longer reports the
package.jsonof each workspace member in a monorepo whose lockfile sits at the root (npm, Yarn and Bunworkspaces,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.jsonv2/v3 (resolvedgit orfile:),yarn.lock(git, GitHub,owner/repoand URL entries),poetry.lock([package.source]git, directory or file),uv.lock(git),pdm.lock(git or path) andCargo.lock(git+). npm v1 lockfiles andGemfile.lockalready did this. A private package that shares its name with a public one no longer inherits that package's advisories. - The
.txtfiles of arequirements/folder (requirements/base.txt,requirements/production.txt) and the files a requirements file includes with-ror-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 asVersion: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 -pormysql -ppassword, for example in an AGT001 permission entry. - A committed
.envis no longer SEC002 high only because of values that are public or encrypted by design: the Supabase anon key, dotenvxencrypted:values andDOTENV_PUBLIC_KEY, and plain URLs under names such asAUTH_CALLBACKor..._REDIRECT_URLS. It stays low, and a real secret next to them still makes it high (.env.keyswithDOTENV_PRIVATE_KEYincluded). - 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:, sopasswd := "..."came out aspasswd :[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,
affectedthat 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-1is the post-release1.0.post1(it used to sort below1.0, so a fixed version was reported as vulnerable),1.0rc1equals1.0c1, and1.0a1.dev1and1.0.post1.dev1sort before1.0a1and1.0.post1. On npm1.0.0-1stays a pre-release. - The suggested fix is a final release when the advisory lists one above your version:
26.4.1instead of26.4.0rc2,1.1.0instead of1.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 aspip freeze > requirements.txtorecho ... > .env) are audited. A.env,.txtor 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.stingwardignorenow 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,countorlimit, or in a field such asitem.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 += a1many times, thena3 += 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
"..." % xtext 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 ofexport 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, andreq.body.bookmarksis no longer taken for a placeholder list because its name ends inmarks. - Request bodies in FastAPI are now request data when the model's name ends in
Request(ChatRequest,QueryRequest) or the parameter is calledrequest,reqoruser(request: ChatRequest,user: UserCreate). They were taken for the framework's ownRequestor 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'sRequestor filled byDependsstay 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, thenrequests.get(full)orfetch(full)) or with+and no quoted text (requests.get(BASE + path)). The start of the address comes from the code there, as inf"{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'orhttp://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 tohttps://{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.searchParamsorconst sp = new URL(req.url).searchParams, thenparams.get('url'). Only the namesearchParamswas 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
innerHTMLinside HTML that hasclass="icon",style="...",<svg>orcssin 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 orconst { readFileSync } = require('fs'). The check only started whenfsshowed 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], thenos.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 wholefilename) 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)whenStrictLoaderis a class in the same file built onyaml.SafeLoader,CSafeLoaderorBaseLoader, also through more than one step. A loader built onyaml.Loaderis 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]orexecFile("python3", ["-c", code]), the usual body of a "run Python" tool. It runs the text as code, likeexec(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
remarksorbookmarks. Any name containingmarkswas taken for a list of?placeholders; now onlymarks,qmarks,question_marksandquestionMarksare. - COD003, APP009 and APP014 no longer report Python code that writes the outside value with
{value!r}orrepr(value), such asexec(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
ifthat 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 ...orif not validate_column(c): .... These allowlists are how a dynamicORDER BYor table name is made safe, and they were reported as high SQL injection. A list that comes from the request, anifthat does not leave, orre.matchwithout 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 anifthat 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, anifthat does not leave, and a regular expression not anchored at both ends still count as unchecked. npm-shrinkwrap.jsonand NuGet'spackages.lock.jsonare 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.jsonas before, andpackages.lock.jsonis now read (NuGet packages, without the solution's own projects).- Requirements files named like
dev-requirements.txt,test-requirements.txtordocs_requirements.txtare 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.tomlwithout a lockfile: Poetry's[tool.poetry.dependencies],dev-dependenciesand groups (^2.28and~1.2read as Poetry ranges, git and path dependencies skipped), PEP 735[dependency-groups]and thedev-dependenciesof[tool.uv]. Before, only[project]was read, so a Poetry project withoutpoetry.lockwas 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.keyscounts as before. - A committed
.env.mewith 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.txtwritten bypip 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-1is the post-release1.0.post1:foo>=0.9,<1.0.post1no longer takes it as inside the range, and advisories fixed in1.0and1.0-1now suggest1.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}orLIMIT {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 asWHERE {where}, is high. - COD009 now reports a redirect that puts request data right after a fixed
/,\or//, such asredirect(f"/{request.args['next']}")orres.redirect(`/${req.query.next}`): withnext = "/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, likeRawSQL:extra(where=[f"name = '{q}'"])withqfrom the request was never reported. Pieces with%sandparams=[...], 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 skillnow reads minified bundles,.min.jsand.bundle.jsfiles andvendor/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.jsinstatic/js/: files that start with a library header (/*! name vX.Y, or a first comment with@license) and files underthird_party/orstatic/js/lib/are skipped, likevendor/and.min.jsalready were. A copyright header of the project itself (/*! Copyright (c) ...) does not count.stingward skillstill 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 withr8_andre_. - 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 theHostorX-Forwarded-Hostheader ("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
- @IsaqueMoutta made their first contribution in #2
Full Changelog: v0.1.5...v0.1.6