November 7, 2025

Real-World Lessons

From Reaction to Resilience: Why Breaches Keep Repeating Themselves

Ismael Kazzouzi picture
Ismael Kazzouzi
Head of Engineering

Every week, a new breach headline reminds us of the same painful truth: attackers aren’t getting more creative, we’re just leaving the same doors wide open.
The names change, but the pattern is familiar: static credentials, unauthenticated endpoints, and over-trusted integrations.

Consider just a few recent examples:

  • McHire: attackers exploited unauthenticated APIs to pull sensitive applicant data at scale.
  • Base44 / Wiz disclosure: entire environments were exposed because there were no network or host isolation (NHI) controls at all.
  • npm “Shai-Hulud” worm: malicious code harvested developer secrets and replayed them across systems.
  • Salesloft / Drift: attackers stole OAuth tokens and used them to quietly siphon data from Salesforce, Google Workspace, and beyond.
  • Jaguar Land Rover: attackers used credential-based techniques and lateral movement inside IT systems that brought the factory system to a stand still. The result wasn’t just data theft; it was indeed a multi-billion-dollar manufacturer brought to a standstill, with ripple effects across suppliers, jobs, and national industry..

Different companies, different vectors; the same root issue nonetheless: trust is handed out cheaply, lives too long, and crosses too many boundaries. The damage goes far beyond leaked data. These incidents repeat because the risks are systemic and they strike at the core of the business. Reputations suffer, operations stall, and compliance gaps turn into fines or investigations. For a board or CISO, the question isn’t if another breach will occur, but how much of the business it will take down next time.

The Problem with Reactive Fixes

After each breach, the advice is predictable: Enable MFA, Rotate secrets, Audit OAuth scopes, Tighten repository monitoring. These are reactive band-aids or useful hygiene measures at best.

Reactive security is like constantly replacing the locks on your front door while leaving the spare key under the mat. No matter how many times you rotate keys or tighten monitoring, a determined attacker who finds that static credential can walk straight in.

They don’t change the underlying reality that static tokens, passwords, and unauthenticated services exist in the first place.

The result? Attackers only need to get lucky once.
A leaked key, a forgotten API, a stale OAuth app and the “best practice” playbook collapses

A Proper Long-Term Security Posture

To move beyond patchwork defenses, we need to eliminate the very concept of long-lived, reusable secrets.

That means:

  • Short-lived, automatically rotated credentials that expire in minutes, not months.
  • Workload identities that are cryptographically verifiable, not manually managed.
  • Trust domain segmentation so that even if one environment is compromised, the blast radius is contained.
  • Continuous attestation and verification instead of one-time trust.

This approach doesn’t just make breaches harder. It makes entire attack classes, like token replay and secret sprawl, OBSOLETE.

How Defakto Helps

That long-term posture only delivers real value if it can be operationalized at scale. At Defakto, we help enterprises adopt this long-term posture by replacing static secrets with non-human identities.
Every service, agent, and integration gets a cryptographically strong identity in the form of a short-lived certificate or token.
These identities are:

  • Automatically issued and rotated (no human handling, no forgotten tokens).
  • Bound to workloads and trust domains (so a credential in staging can’t be replayed in production).
  • Continuously verifiable (so access decisions are always based on fresh, authentic signals).

The result: attackers can no longer steal an integration token and pivot across your environment. The spare key under the mat simply doesn’t exist.

Better Monitoring with Non-Human Identity

Traditional monitoring is blind to most credential misuse because all it sees is “valid token accepted.” Attackers using stolen OAuth tokens look just like legitimate users.
With Defakto, every request carries a fresh, cryptographically bound identity that is tied to the non-human identity (whether it belongs to a workload, service, pipeline, or agent)   and context it originated from.

This gives security teams richer telemetry: who issued the credential, what non-human identity presented it, where it was used, and whether it was within its trust domain.
Instead of chasing vague anomalies, monitoring shifts to clear, actionable signals:  spotting impossible identities, cross-domain misuse, or workloads presenting identities they shouldn’t have.

The Takeaway

It’s tempting to think of breaches as a “SaaS company problem.” Stolen customer records, leaked credentials, compromised OAuth apps.

But the Jaguar Land Rover case shows the reach is far greater. Cyberattacks don’t just leak data; they can stop cars from rolling off the line, planes from taking off, or power grids from running. The digital and physical worlds are now inseparable.

When attackers can use a stolen password to pivot across an enterprise and paralyze production, resilience becomes more than a compliance checkbox. It’s existential.

True resilience comes from changing the foundation: removing static secrets, enforcing short-lived identity, and segmenting trust.That’s the posture Defakto enables.
Because in modern enterprise environments, it’s not enough to react faster: we need to remove the very things attackers rely on.