What CodeMD found scanning six popular open-source repos

CodeMD · Reviews run 2026-11-13 · Our own testing, not an outside audit

We ran CodeMD's security review on six well-known open-source projects in six languages: express (JavaScript), gson (Java), Humanizer (C#), click (Python), sinatra (Ruby) and cobra (Go). The honest summary: it found no confirmed vulnerabilities. It did surface risk paths, and the AI reviewer read each one and explained why it was or wasn't a problem.

9,138functions scanned across six repos
121risky operations found, 11 reachable from input
0confirmed vulnerabilities
Why publish a result with no vulnerabilities? Because that's what a useful tool does most of the time: it shows you the paths, then tells you which ones are guarded. These are mature, widely reviewed libraries. A clean result here says the review isn't crying wolf. It doesn't say these projects are risk-free, and it isn't an audit.

How the review works

  1. CodeMD builds a call graph and finds where outside input enters (HTTP requests, command-line arguments) and which risky operations exist (processes, files, eval, SQL, network).
  2. It marks which risky operations are reachable from outside input. This step is static analysis with no AI.
  3. The AI reviewer (Claude) reads the code on each reachable path and gives a verdict with its reason. Relevant code is sent to the AI provider for this step, which is part of CodeMD Pro.

The six repos

1. expressjs/express

JavaScript · A fast, unopinionated web framework for Node.js. · reviewed 2026-11-13 · GitHub · Full CodeMD report

196functions scanned
29outside input sources
2risky operations
1reachable from input

Confirmed security findings: none.

Read the AI reviewer's reasoning
This repository is the Express.js web framework library and its examples. It has no AI agent, credential store, Git or CI integration, or multi-tenant state. The only flagged sink is the require(mod) call in View (lib/view.js:81). The module name comes from the file extension of the view name or from the 'view engine' setting. Both are chosen by the application developer through app.set and res.render(name), not by HTTP request data. The route-map path in the callgraph is ordinary module wiring, and no example passes request data to res.render. View.lookup resolves names against the configured views root, and that is a developer-supplied input by design. The one request-derived file operation is res.download in examples/downloads/index.js:27. It passes { root: FILES_DIR }, so the underlying send module blocks paths outside that root. No attacker-controlled input reaches code execution, arbitrary file read or write, or a credential-bearing sink in the framework itself.

2. google/gson

Java · A Java library for converting objects to and from JSON. · reviewed 2026-11-13 · GitHub · Full CodeMD report

3,000functions scanned
0outside input sources
36risky operations
0reachable from input

Confirmed security findings: none.

Read the AI reviewer's reasoning
This repository is Gson, a JSON serialization library. It has no network service, no authentication, no agent or tool execution, no handling of credentials, and no file-system operations that take paths from JSON input. Its only entry points are benchmark and example main() methods. I checked the flagged sinks and none of them can be driven by untrusted input. (1) Every Class.forName call in main code uses a hard-coded literal: sun.misc.Unsafe, java.lang.reflect.RecordComponent, java.sql.Date and com.google.gson.internal.bind.JavaTimeTypeAdapters. JSON data never chooses which class gets loaded. (2) Deserialization picks its target type from the developer-supplied Type/TypeToken, not from the JSON. Polymorphic deserialization in extras (RuntimeTypeAdapterFactory.create/read) looks the type label up in the developer-registered labelToDelegate map and throws JsonParseException for unknown labels, so it is an allowlist and cannot be used as a gadget chain. (3) LazilyParsedNumber.readObject and LinkedTreeMap.readObject are Java-serialization guards that throw InvalidObjectException. They are not sinks. (4) The 'file write/delete' and 'network' matches (JsonArray.remove, LinkedTreeMap.remove, JsonTreeWriter.endArray, TypeAdapters.read) are false positives: they only change in-memory collections or JSON trees. UnsafeAllocator does build objects without calling a constructor, but only for the type the application asked for, and ReflectionAccessFilter can limit it. That is an application-level design choice, not a path to code execution, file access or credential theft. No attack chain meets the catastrophic threshold.

3. Humanizr/Humanizer

C# · A .NET library for turning data into human-friendly text. · reviewed 2026-11-13 · GitHub · Full CodeMD report

3,605functions scanned
6outside input sources
8risky operations
6reachable from input

Confirmed security findings: none.

Read the AI reviewer's reasoning
Humanizer is a pure .NET formatting library. Its code turns numbers, dates and enums into text using locale tables that are compiled in at build time. It never runs processes, reaches the network or touches the filesystem with untrusted input. I checked each sink the scan flagged. (1) .agents/skills/add-locale-batch/scripts/locale_batch_status.py: run_gh calls subprocess.run with an argument list and no shell. The arguments come from the CLI user's own --repo/--status flags and the PR numbers in their local JSON file. The only file it writes is the --status path the user names, so it crosses no trust boundary. (2) website/scripts/verify-pagefind.mjs is a local build-verification script that starts a server on the docs output it just built. Only the developer running it can reach it. (3) website/src/theme/Root/index.tsx: the dangerouslySetInnerHTML is a fixed string ('<pagefind-modal reset-on-close></pagefind-modal>'). The window.location.replace target comes from legacyRedirects.mjs, which checks at module load that every redirect destination is a local path ('/' but not '//'). It reads the referrer only when it has the same origin and the path appears in a static redirects.json, so there is no open redirect or XSS that an attacker controls. (4) GitHub workflows: docs.yml runs on pull_request, not pull_request_target. It sets top-level permissions to {}. Jobs with contents: write or pages: write are gated on push/workflow_dispatch, so code from a fork PR never runs with a write token or secrets. The NamespaceMigrationAnalyzer that ships in the package only inspects syntax and runs nothing. None of these paths gives an attacker code execution, credential theft, arbitrary file access or control of the repo or pipeline.

4. pallets/click

Python · A Python package for creating command-line interfaces. · reviewed 2026-11-13 · GitHub · Full CodeMD report

611functions scanned
2outside input sources
9risky operations
1reachable from input

Confirmed security findings: none.

Read the AI reviewer's reasoning
This is the Click library, which Python CLI applications use to parse command lines. It has no network service and no authentication. It handles no repository content, LLM output or plugins of its own, and every input it reads comes from the local user who launched the program. I read the source to check each process-execution sink, and none of them has a path from untrusted input to code execution. (1) The pagers `_pipepager` and `_tempfilepager` in `src/click/_termui_impl.py` run the program named in the PAGER environment variable. They pass `subprocess.Popen` or `subprocess.call` an argv list with `shell=False`, so the paged text is never interpreted by a shell. PAGER is set by the user running the program, who could already run any command. (2) `Editor.edit_files` runs `shlex.split(editor)` from VISUAL or EDITOR, or from an editor name the application developer passes in, plus temp file names. It also uses an argv list with no shell, so the same trust argument applies. (3) `open_url` runs `xdg-open`, `open`, `explorer` or `cygstart` with an argv list, or calls `os.startfile`. The URL comes from the application that calls `click.launch`, not from Click, so passing untrusted URLs to it is the application's own design choice. (4) `BashComplete._check_version` runs a fixed bash command line. (5) The writes in `_AtomicFile.close` and `types.File` go to file paths that the CLI's own user typed as arguments, which is the intended behaviour. Shell completion reads environment variables (COMP_WORDS and similar) that the user's own shell sets. No path crosses a trust boundary, so none meets the catastrophic threshold.

5. sinatra/sinatra

Ruby · A small Ruby web framework and DSL for web applications. · reviewed 2026-11-13 · GitHub · Full CodeMD report

688functions scanned
9outside input sources
31risky operations
3reachable from input

Confirmed security findings: none.

Rule finding to review: “Credential made with a non-cryptographic random generator” at lib/sinatra/base.rb:1962 (set :session_secret, format('%064x', Kernel.rand((2**256) - 1))). The AI review below notes that the default session secret comes from a secure generator, so we list this as a lead for the maintainers to confirm, not a confirmed vulnerability.

Read the AI reviewer's reasoning
This repository is the Sinatra web framework plus sinatra-contrib and rack-protection, a library rather than an agent or a hosted product. I checked each sink the scan marked as reachable, and none gives request data a catastrophic path. (1) Sinatra::Base#static! (lib/sinatra/base.rb:1145) URL-decodes PATH_INFO, but then runs it through valid_path?, File.expand_path and a start_with?("#{public_dir}/") check before calling send_file. Rack::Protection::PathTraversal#cleanup also normalizes %2e, %2f and %5c sequences and '..' parts beforehand, so a request cannot walk out of the public folder. (2) Sinatra::Base#define_singleton (base.rb:1730) runs class_eval on a string only when the developer passes string values to `set`. The callgraph edge from process_route to route, enable, set and define_singleton describes how an app is defined, and request parameters never reach it. (3) Sinatra::ConfigFile#config_file runs ERB and YAML.unsafe_load, but only on config files the application developer chooses, never on HTTP input. (4) Sinatra::Runner#start runs processes only for test support, with no outside input. Two defaults are also safe: session_secret comes from SecureRandom.hex(64), and show_exceptions is on only in development. Nothing here involves an LLM, a credential store, or Git or CI automation, and no realistic chain reaches the severity threshold.

6. spf13/cobra

Go · A Go library for building modern command-line applications. · reviewed 2026-11-13 · GitHub · Full CodeMD report

1,038functions scanned
0outside input sources
35risky operations
0reachable from input

Confirmed security findings: none.

Read the AI reviewer's reasoning
This repository is spf13/cobra, a Go library that applications use to build command-line tools. It has no network listener, no AI agent or tool invocation, and no credential handling. In the shipped (non-test) code, nothing runs a process or shell: every exec.Command call is in a test file (cobra_test.go and bash_completions_test.go). The file-writing sinks are GenBashCompletionFile(V2), GenFishCompletionFile, genZshCompletionFile, genPowerShellCompletionFile and the doc.Gen*Tree functions. Each one writes to a filename or directory chosen by the application developer, and the doc tree file names come from command names the developer defined, not from runtime input. In completions.go:960, CompDebug appends to a file named by the BASH_COMP_DEBUG_FILE environment variable. Anyone who can set that variable already controls the user's environment, so this crosses no trust boundary. The other environment variable reads (active help config, completion config, SOURCE_DATE_EPOCH) only change output formatting. The generated shell completion scripts embed the program and command names, but the developer writes those at build time, so they are not attacker-controlled. I found no path from untrusted input to code execution, arbitrary file write, or secret exfiltration.

One more: an AI-reported risk in a CI workflow

CodeMD's review of medusajs/dtc-starter (run 2026-10-30) reported a different kind of risk path: an unpinned third-party GitHub Action (medusajs/medusa-update-action@v1) that receives a repository-write token and an API key. The AI's reasoning: if that action were compromised or its tag moved, attacker-controlled code would run in CI with those credentials. This one is AI-reported and not independently verified. It's a plausible supply-chain exposure, and pinning the action to a commit would reduce it, but we haven't confirmed it with the project's maintainers.

What we take from this

  1. Most flagged paths are guarded. The value is in seeing them and reading the reason, so a reviewer doesn't have to rediscover each one.
  2. Context decides risk. A file-serving path or a dynamic require in a framework is expected behavior; the same path in your app could be a hole.
  3. Leads, not verdicts. Static analysis can miss paths and AI can be wrong, so treat results as leads to verify.

Run it on your own repository

Free for public repositories. CodeMD gives your team information about risk paths; it doesn't block attacks or replace a security program.

Install free on GitHub

Browse all saved reports · 14 real MCP server vulnerabilities, replayed