WRITEUP 001 · THREAT INTELLIGENCE
26 crews, five days: the infostealer-to-extortion pipeline in primary leak-site data
2026-07-31
· Sergio Rodriguez
· ATT&CK: T1078, T1567, T1486
· TLP:CLEAR
Ransomware crews publish their victims on Tor-hosted data-leak sites (DLS) to apply
pressure. That publication is also, unintentionally, one of the earliest public
signals available to defenders, typically landing hours to days before press coverage.
I pulled the 100 most recent DLS postings and counted what was actually in them.
100postings
26distinct crews
56%held by top 5
58%infostealer-linked
KEY JUDGMENTS
- The extortion ecosystem is oligopolistic, not fragmented. Five crews accounted for 56% of postings across a five-day window; defending against a handful of TTP sets covers most of the realistic risk.
- 58% of postings carried infostealer linkage. The dominant path to extortion in this sample is stolen credentials, not exploited software. This is consistent with industry reporting that most detections are now malware-free.
- Only 13% quantified the data they claim to hold. Most postings assert a breach without evidence of scope, which materially complicates incident-response triage.
- Posting tempo ran roughly 20 per day, and 45% of victims were U.S.-based.
COLLECTION & LIMITS
Method: single pull of the 100 most recent victim records from the ransomware.live open aggregator on 2026-07-31, covering postings dated 2026-07-27 through 2026-07-31. Counts computed directly over that record set. I did not access any leak site directly.
Limits, stated plainly: this is a 100-record snapshot from one aggregator over five days, not a census. It inherits that aggregator's crawler coverage and any gaps in it. Crews inflate, recycle, and fabricate victim claims, so postings measure claimed activity, not confirmed compromise. A five-day window cannot separate trend from noise. Treat these as directional indicators, not established rates.
The concentration finding
Twenty-six distinct crews appeared, but the distribution had a long tail and a heavy head:
qilin (16), CRPxO (13), thegentlemen (10),
safepay (9), and incransom (8) together produced 56 of 100
postings. Sixteen crews posted twice or fewer.
The defensive implication is a prioritization argument. A small team cannot build
detection coverage against twenty-six adversaries, and this data says it does not need
to. Emulating the top five operators' known TTP sets addresses the majority of
realistic exposure, which is a defensible way to spend a limited detection-engineering
budget.
The pipeline finding, and why it matters more
The more interesting number is 58%: the share of postings carrying an infostealer
association. That points at a supply chain rather than a single actor. Commodity
infostealers harvest credentials and session cookies at scale, those land in
marketplaces, initial-access brokers resell them, and extortion crews buy access
already authenticated.
This lines up with what vendor telemetry has been reporting from the other end of the
funnel, that the large majority of detections now involve no malware at the intrusion
point at all, because the operator simply logs in. If most extortion begins with valid
credentials (T1078),
then perimeter and payload controls are guarding a door the adversary is not using.
What this changes in a SOC
Reproducing this
The aggregate view is live on the dossier's Extortion Economy board,
refreshed hourly from the same source. That board and this writeup both withhold victim
names and .onion addresses by design: naming targets serves the crews'
pressure campaign and adds nothing the counts do not already carry.
WRITEUP 002 · WEB FORENSICS
The invisible 780 pixels: hunting phantom width on this exact site
2026-08-03
· Sergio Rodriguez
· Target: this site
· TLP:CLEAR
This site scrolled sideways on phones. Nothing visible crossed the edge, but at a
390px viewport the document measured exactly 780px wide — a suspiciously clean 2x.
Since the target was my own production site, I treated it like any other incident:
measure first, patch at the source, prove the fix, and write down what the tooling
got wrong on the way.
780pxscrollWidth at 390
3independent causes
1fix that broke sticky nav
0overflow after patch
KEY JUDGMENTS
- Nothing visible was overflowing, because the culprits were invisible by design. The closed mobile menu is
position:fixed slid off-screen with translateX(100%); the CRT scanline overlay spans the viewport. Both widen the document without painting a single out-of-bounds pixel.
- A flex default was the third cause. The news ticker's viewport is a flex item, and flex items default to
min-width:auto — it refused to shrink below its 628px track and dragged the layout with it. One min-width:0 ended it.
- The obvious fix was wrong, and only measurement caught it.
overflow-x:clip on html killed the phantom width and silently broke position:sticky on the nav in Chromium. My own regression check failed on the very next assertion. The clip belongs on the leaking elements, not the root.
COLLECTION & LIMITS
Method: headless Chromium driven by a script that fresh-loads the page at 390/768/1280, walks every element comparing scrollWidth to clientWidth while skipping anything inside an overflow-clipped ancestor, then re-runs the full assertion set (overflow, sticky behavior, menu open, console errors) after each candidate fix. Reproducible with devtools on this page's git history.
Limits: one site, one engine. The sticky-nav breakage under root-level overflow-x:clip was observed in Chromium and not cross-checked in Gecko or WebKit before shipping the element-level fix, which sidesteps the question.
Why this belongs on a security portfolio
The workflow is the point, not the CSS. An invisible fault, a measurement harness
instead of guesswork, a plausible fix that failed under test, and a root-cause patch
proven by re-running the whole suite — that is incident response, practiced somewhere
cheap. The bug that teaches you to distrust "looks fixed" costs nothing here and
everything in production forensics.
WRITEUP 003 · DEFENSIVE ENGINEERING
A webhook that assumes it is being lied to: payment-event ingestion under adversarial assumptions
2026-08-02
· Sergio Rodriguez
· Cloudflare Workers + Postgres
· TLP:CLEAR
A payment processor's webhook endpoint is an unauthenticated URL on the public
internet that, if believed naively, writes revenue into your database. I built and
shipped one for a personal project on the assumption that every request reaching it
is hostile until proven otherwise, and then made the database enforce the same
assumption independently, so that even a compromised application layer cannot post a
lie as money.
HMAC-256raw-body signature
300sreplay window
2independent enforcement layers
fail-closedunconfigured = 503
KEY JUDGMENTS
- Verify the raw body, not the parsed one. The HMAC is computed over
timestamp.rawBody exactly as received; parse only after the constant-time comparison passes. Any framework middleware that touches the body first is a verification bypass waiting to be found.
- Replay and duplication are separate attacks with separate controls. A five-minute timestamp tolerance bounds replay; a database uniqueness key on the provider's event id collapses redelivery storms to a single row. Neither control substitutes for the other.
- The database should not trust the application. A trigger makes posted revenue rows immutable and refuses any "posted" state that lacks a matching signature-verified, live-mode webhook record. If the app layer is ever compromised, the ledger still declines to lie.
- Fail closed, loudly. Missing secrets return 503 and process nothing; unknown event types return 200 and are ignored, because erroring on them invites an infinite retry storm that becomes its own denial of service.
COLLECTION & LIMITS
Method: unit suite covering invalid and stale signatures, duplicate event ids, sandbox/live mode separation, and oversized-payload truncation, plus a live probe of the deployed endpoint confirming the fail-closed path before secrets were installed. Design follows the processor's published signature scheme.
Limits: single-processor design (Stripe's v1 scheme); the immutability trigger is Postgres-specific; and the endpoint has not yet faced production traffic volume, so the retry-storm reasoning is tested logic, not observed load.
The layering argument
Signature verification lives in the worker; integrity enforcement lives in the
database as a SECURITY DEFINER trigger with a pinned search path and
execute revoked from client roles. The two layers share no code and fail
independently, which is the property that matters: the attacker who beats one control
has learned nothing about the other. Defense in depth is usually a slogan; in a
schema it can be a constraint.
FILE 04b · VULNERABILITY DISCLOSURE
How I handle a vulnerability, mine or yours
If you found something in my systems
Report it to sergio.w.rdz@gmail.com, or use the
contacts in my security.txt. I will acknowledge
within 72 hours, keep you updated, credit you publicly if you want credit, and I will not
pursue legal action against good-faith research that stays within the boundaries below.
In scope: sergrdz.pages.dev and its subpaths. Out of scope: denial of
service, social engineering, physical attacks, and anything touching third-party
services I do not control.
My process when I find something in someone else's
- Authorization first. I test only what I own, what a published bug-bounty or VDP scope permits, or what I have written permission for. No exceptions, and no "it was only a scan."
- Minimum necessary proof. Establish the finding is real, then stop. No pivoting, no data exfiltration, no persistence. If I can prove it with a read, I do not attempt a write.
- Private report to the vendor. Root cause, reproduction steps, affected versions, assessed impact with a CVSS vector, and a suggested remediation. Sent through their VDP, security.txt contact, or CERT/CC if no channel exists.
- Coordinated timeline. Standard 90 days to patch, flexible when a vendor is engaging in good faith, shortened only if the flaw is already being exploited in the wild.
- Publish after the fix. Writeup goes public once a patch ships or the coordinated window closes, with the CVE identifier and vendor acknowledgment. Exploit code stays unpublished unless releasing it clearly serves defenders more than attackers.
WHY THIS PAGE EXISTS
Anyone can claim to have found things. The verifiable part of security research is the process: authorization, restraint, coordination, and attribution you can check with the vendor. That is the part I can show before I have a CVE to my name, so it is the part I am publishing first.