Before the CVE: Reading Release Notes Like an Auditor
Most vulnerability hunters I know watch CVE feeds. That's fine, but here's the thing: every CVE was preceded by a commit, a tag, and usually a release note — often weeks before the advisory goes public. If you read relea
Most vulnerability hunters I know watch CVE feeds. That's fine, but here's the thing: every CVE was preceded by a commit, a tag, and usually a release note — often weeks before the advisory goes public. If you read release notes first, you're not racing the crowd. You're racing the CVE assigner.
I've been auditing open-source Java middleware for a while — message brokers, frameworks, admin consoles — and release notes have become my single highest-signal feed. Not Twitter, not CVE/NVD. Release notes.
Here's my working set of signals.
Signal 1: "Added authentication for X" — new security code is new attack surface
When a project adds an auth mechanism, everyone reads it as hardening. I read it as: there is now a brand-new code path that decides who gets in, written under schedule pressure, shipped without ever having been attacked.
The ugliest example in Java history: Fastjson's checkAutoType. It was added as a security gate in response to deserialization abuse — and then bypassed over and over for roughly three years (2017–2020). Each bypass was a new CVE. The defense itself became the vulnerability map: the existence of the gate told you exactly where to aim, forever.
What I do when I see this signal:
- Read the new auth code diff first, before anything else in the release.
- Look for string comparisons (
==on non-interned strings, case-sensitive token checks), missing rate limits, and default-on behavior. - Check whether the auth wraps all entry points or just the obvious ones. The main console gets auth; the newly added internal API often doesn't.
Signal 2: "Hardened" or "fixed a security issue" with no CVE and no details
Vague hardening language is a silent fix. Projects do this to buy time before disclosure. For you, the move is mechanical:
git diff v1.2.9 v1.2.10
Find the added check. Understand what input it blocks. Then look for sibling code paths that accept the same input but didn't get the check. Silent fixes are rarely exhaustive — they fix the reported reproduction, and the reporter found one instance, not the class.
Signal 3: Dependency bumps with no explanation
A one-line "upgrade dependency X" in a release note is a smell, especially when X is a parser or anything that deserializes. The parent project just inherited a fix. Two questions follow:
- Did the parent actually expose the vulnerable code path? (Often yes for parsers.)
- Does the parent now handle the same input differently after the bump? Behavioral changes hide inside upgrades.
Signal 4: New features that default to on
The classic: Spring Boot Actuator's history. Management endpoints that were convenient in dev were exposed by default, and years of exposure incidents followed. The pattern never died — every middleware I audit has a newer version of this story: a metrics endpoint, a debug API, a "temporary" console.
What I do: fresh install of the new version, diff the port scan and the route table against the old version. New route that isn't behind auth = the next report.
Signal 5: Skipped or bloated version numbers
Tags that jump (2.3 → 2.5), releases that bundle thirty "misc fixes", or maintenance branches that suddenly get a release after months of silence — all of these tend to hide backported security fixes. Diff the tag against the mainline at the same date. The security part of the diff usually stands out: it's the hunk that adds a check without adding a test.
The workflow, condensed
- Pick targets you can actually audit — I stick to Java middleware I can run and read.
- Watch the GitHub releases API (or plain tags) for each, on a schedule.
- When a release lands, read the notes against the actual commit log — notes compress, commits don't lie.
- Triage by the signals above; spend diff-reading time only where a signal fires.
- Whatever you find, you report through the project's channel before writing about it. That's the whole deal.
None of this is glamorous. It's mostly reading. But the feed is public, the lag between fix-in-release and CVE-published is often weeks, and almost nobody reads this stuff systematically.
This follows up on No Lab, No Exploit Server: Proving a Bug From Source Alone — same methodology, earlier stage of the pipeline.
I'm collecting this methodology into a book, Auditing Open Components — source-only auditing, proving bugs without a lab, and the workflow above as a full chapter. It's in early access on Leanpub: leanpub.com/auditing-open-components
Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.