
The critical that no gate blocked: 39 vulnerabilities and a green deploy
The audit step claimed it blocked the build on known CVEs. It carried continue-on-error from day one. When pnpm audit found a CVSS 9.8 RCE in Astro, the deploy sailed through.
48 posts

The audit step claimed it blocked the build on known CVEs. It carried continue-on-error from day one. When pnpm audit found a CVSS 9.8 RCE in Astro, the deploy sailed through.

A sandbox hid the central process PID, the config it read was the wrong file and the routes table arrived empty. The guard still said OK.

An admin claim used to open private addresses by itself. The decision became a single fail-closed function with an explicit scope or a named allowlist.

A security patch that swapped the HTTP client of twenty routes passed review, lint and build. The full suite reported 22 failures, 20 of them mine. The worst group was not the one failing loudly, it was the one still green while testing nothing.

A weekly security sweep came back green because a path inherited from the previous system no longer existed. Zero findings meant zero measurement, not health.

In November the TatuEngine security scan stopped reporting an entire class of finding. Eleven days later the same class was back in seven places, written by hand, by the same people who had just fixed it. What was missing was not attention: it was a mechanism that made the return impossible.

A defender that detected the right problem was never executed by anything. An orphan and a passing check look identical in silence, and only a caller scan tells them apart.

A hook meant to keep secrets out of the repository rejected, twice, a commit that carried no secret at all — first by confusing parsing with assignment, then by breaking under four layers of quoting. The lesson: a guard that cannot tell the difference is not protecting anything, it is teaching people how to bypass it.

A static analyzer returned almost three thousand high-severity findings in TatuEngine. Nearly all of them were the same test line repeated. The four that survived were real, and each one demanded a different decision than the shortcut offered.

Offsite backups stopped twelve days ago, the security scanner pointed at a directory that no longer exists, and the health endpoint returned rate-limit errors to its own monitor. Three instruments on the same panel, three shapes of the same defect: the metric was not measuring what it claimed to measure.

A maximum-severity alert pointed at an MD5 hash that never protected anything. A week later, the medium-severity finding — that one — was the real attack path. What became clear: severity is a hint, not a verdict, and silencing a scanner requires a justification in the code, not a throwaway comment.

A top score kept showing up across five repositories every week while the layer responsible for that judgement never ran. Getting to the bottom of it meant an inexistent file, a directory with the wrong name, and a chain of errors hiding behind a green result.

Dogwalk spent nine hours with login and signup returning 403 because one environment line held an example value. What came next was worse: the secret the CI carried no longer existed, and only a fake pair could prove it.

A dozen critical alerts in the same second claimed a login attempt against the fake service. The source was local, and the attacker was a utility I had run minutes earlier. Three cuts later, the sensor stopped measuring its own instrument.

Every contact form submission in production returned an error, and the form code was fine. Two traps were stacked on the same path — a lying CORS layer and an access configuration covering the whole domain. And the probe that was supposed to prove health was reading the login page and reporting 200.

A normalization rule at the edge layer was replacing the whole site's security policy with a two-line version, and only a test that hit real production noticed.

One commit pulled five environment files out of version control in Dogwalk and left the history untouched. The 569-byte blob is still reachable — and the lesson is that untracking is not deleting.

A file named test_portifolio.py made pytest log in for real against a public endpoint, with the admin credential written into the script body. Commit 40d3594 pulled the password out of the repository — and made it clear that credential rotation has three parts, not one.

The exposure report flagged a service that no longer lived on that port. What answered there was another process entirely, with no authentication at all. The same report claimed 'no real leak in any project' while having read one repository out of six. Two lies of different species: one by label, one by omission.

Capivara's login gained TOTP: the second factor is required only for a verified secret, encrypted at rest with AES-256-GCM, with 21 tests covering the flow.

Arachne lets everyone bring their own model key. The guarantee that the key only leaves for its owner relied on an optional field that, when empty, opened the legacy path — and that path was shared per workspace. A one-line condition was the border between your key and your colleague's.

How a custom domain missing from Capivara's allowed origins killed the contact form, and the same-origin proxy that brought tracking back.

Reflection on the ecosystem's security posture, the recent 64% scan results, and the plan to reach >85%.

A single config line with a placeholder where the key should be killed production login and signup for almost nine hours — and the real key existed nowhere at all. The story of the best-intentioned lockout I ever shipped, and of the doctor that diagnoses a pair without ever seeing the secret.

The visual auditor for blog covers lost its primary model to an empty balance, returned an error, and the error handler returned 'approved'. For a few hours dozens of covers shipped with zero checking while the pipeline reported success. The same defect resurfaced twice more in the same pipeline, in different bodies.

Two machines, the same code, the same key. One got 200, the other took a 403 with error code: 1010. No wrong token, no visible firewall rule: the filter looked at the TLS handshake and recognized the signature of an automated client before any request even existed. This post is about the identity layer that never shows up in application logs.

The post was hidden, its route returned 404, the feed didn't mention it. It still showed up on the site: in the header of a tag page that was counting the wrong posts. The lesson is older than it looks — every new page that lists content is a new door, and frontmatter doesn't protect itself.

On Saturday night I edited a script watched by the file integrity monitor and updated its baseline in the same block. Six hours later the alarm fired again, pointing at the exact change I had just approved. The monitor didn't fail: it did the only job it can do. What was missing was a process that knew how to tell a legitimate edit from a suspicious change.

On August 11 I put a secret scanner on this blog's pipeline. The next day it flagged a build cache file as if it were a key. I silenced it with an entry pinned to that finding's exact fingerprint. Sixteen days later I had to come back to the same spot and write the exception again, this time as policy. That gap is the difference between suppressing an event and defining what should never alarm in the first place.

The alarm hunts, the gate blocks, the dog attacks. But there is a fourth layer in my security setup that nobody wrote about: the dependency update queue. On August 31st, the bot delivered five fix proposals. Three days later, all five are still open. The queue became the surface.

After the alarm and the gate, a third guardian was missing: someone who actually attacks the house, in an authorized way, once a week, and delivers an honest penetration report. The agentic red team was born for that — and the first drill proved the sentinel wakes up when someone touches what it shouldn't.

Ten days after automating active hunting, I realized the problem wasn't finding flaws — it was making sure nothing shipped without a security review. The security gate was born not as a tool but as a process rule: before any delivery, the test loop must pass. And the loop includes a dedicated security reviewer.

Gitleaks, bandit and opengrep ran weekly and everything stayed green. Even so, a single GET request returned the entire .env in production. The hole wasn't a committed secret — it was a path my own code opened. And the one who found it wasn't the scanner.

Every public site has a front door: the contact form and the resume download. Two endpoints that accept input from strangers on the internet — and I finally treated them as such. Rate limiting, HTML escaping, a contact file for people who find flaws, and a scanner that watches everything in silence.

After mapping the port inventory, the next step was planting bait: fake services, deliberately outdated in appearance, that pose as easy targets. A watcher classifies every touch on the log, and the central dispatcher decides when a detection becomes a notification.

One of the most underestimated layers of security is knowing what is open. The watchdog keeps a living inventory of ports, services and bindings — mapped against what is intentional — so any new port looks abnormal in seconds.

The security watchdog stopped feeding a kanban nobody read and started publishing findings where they matter: into persistent memory and the right channel. Less ceremony, more active hunting, zero cards.

The Security Agent cross-references findings from two hunters — the Dogwalk Bug Hunter and the Security Hunter watchdog — and outputs a single deduplicated alarm. A health gate to filter infrastructure false positives, discarded network error patterns, local-state dedup, and the no_agent contract: silence when everything is healthy.

ZAP, gitleaks, bandit, opengrep running across all 7 ecosystem projects. What the active hunt found: unlocked database, excessive browser permissions, route leaking data without checks, exposed key, untreated input. And the watchdog now monitoring 24/7.

The ecosystem's security went through 3 phases: the ai-jail that sandboxed the agent (bwrap + landlock), active vulnerability hunting (ZAP, gitleaks, bandit, opengrep across every project) and the automatic watchdog that monitors what nobody looks at. 2 posts so far — and this is the full story.

pnpm audit on the Portfólio screamed 61 vulnerabilities. Instead of updating dependency by dependency or trusting audit fix, I solved it with 5 lines of pnpm.overrides in package.json. Result: 61 → 2, with the remaining 2 having no published fix at all.

From the day we installed ai-jail (bubblewrap + Landlock + Seccomp) to it becoming routine: what changed when every command started running isolated — and the lessons real usage taught (slow Landlock, worker mode, per-command mounts).

The autopoietic agent with ToolUse, an MCP server and a hybrid sandbox is the biggest attack surface in my ecosystem. On 2026-08-05 TatuEngine got what the other projects already had: SEGURANCA.md v1.0, a 24h watchdog, and a rule that changes how the project is developed.

107 commits, 131 backend tests + 248 frontend, 2FA TOTP, local RAG with ChromaDB, R2 backup and D1 disaster recovery — the saga of turning a personal dashboard into reliable infrastructure.

When your engine runs AI-generated code, you need a sandbox that doesn't hinder development but won't let path traversal slip through.

My Hermes agent has access to everything: API tokens, Stripe keys, database credentials. One wrong terminal() command and it all leaks. The fix: a Rust sandbox that isolates every execution with bubblewrap, Landlock, and Seccomp.

With 3 projects running, the infrastructure needed to be robust. Automated backups, security hardening, and the Hermes Agent as the ecosystem's brain.

I needed a unified and secure control center for my projects, data, and access. Capivara was born as a personal hub and became the administrative brain of the ecosystem.