Keep the lesson.
Change the practice.

Nomad: when an initialized default becomes permission to process a message

A bridge authentication failure illustrates why deployment state, default values and upgrade behavior need a single security model.

Incident: 2022-08-01

Euler V1: every path that changes collateral belongs in the solvency model

The March 2023 exploit connects an omitted account-health check to liquidation incentives and multi-step accounting invariants.

Incident: 2023-03-13

Ledger Connect Kit: offboarding and runtime dependencies share a security boundary

A package-publishing compromise reached applications through dynamically loaded code without changing their own repositories.

Incident: 2023-12-14

LastPass 2022: backup access can be the production-data incident

The disclosed chain from development information to privileged endpoint compromise and stolen backups challenges narrow production boundaries.

Advisory: 2022-12-22

Okta support system 2023: diagnostic files can carry live account authority

A support-system compromise links browser synchronization, service-account access and sensitive HAR files to session hijacking.

Incident: 2023-09-28

Next.js October and November 2026 advisories: patch the deployed artifact

Recent framework advisories connect upstream libraries, image processing, caching and cookie handling to the software actually running in production.

Advisory: 2026-11-03

Bybit and Safe: the signing interface is part of your security boundary

The February 2025 theft shows why multiple signatures cannot compensate for a shared, compromised view of a transaction.

Incident: 2025-02-21

Radiant Capital: a document request can become a treasury incident

A reported malware delivery chain connects developer communications, workstation trust and multisig operations.

Incident: 2024-10-16

WazirX: make custody responsibilities testable before an incident

The July 2024 wallet theft illustrates the operational consequences of unclear verification and response responsibilities.

Incident: 2024-07-18

Snowflake customer intrusions: old credentials can remain a live attack path

Mandiant’s 2024 investigation connects infostealer exposure, missing MFA and cloud data theft.

Incident: 2024-06-10

Cloudflare’s Thanksgiving incident: a rotation checklist needs closure evidence

A 2024 disclosure about a 2023 intrusion shows how residual credentials can outlive an initial response.

Incident: 2023-11-23

tj-actions compromise: CI logs can become a secret-exfiltration channel

CVE-2025-30066 demonstrates why action versions, workflow permissions and build logs belong in one threat model.

Incident: 2025-03-14

XZ backdoor: review the artifact you deploy, not only the repository

CVE-2024-3094 illustrates the gap between source review, release packaging and the executable shipped downstream.

Incident: 2024-03-29

AI agents: keep untrusted content away from authorization decisions

A practical control model for assistants that read the web, inspect repositories and act through connected tools.

Identity security: phishing-resistant login, usable recovery and verified offboarding

An operating procedure for the accounts that control email, cloud infrastructure, source code and company recovery.

Email security: protect the recovery inbox and control who can send as your domain

Separate mailbox compromise, domain spoofing and support impersonation into controls with observable tests.

Domain and DNS security: preserve control of the address your users trust

A runbook for registrar ownership, scoped DNS changes, renewal resilience and safe nameserver recovery.

Developer device security: isolate experiments from production authority

A practical baseline for laptops that handle source code, external repositories, credentials and sensitive client material.

Browser and extension security: reduce the code surrounding every privileged session

Inventory permissions, separate sensitive browsing and prepare for malicious extensions or stolen browser sessions.

GitHub and CI/CD security: keep untrusted changes away from deployment authority

A review procedure for workflow triggers, action revisions, runner isolation and cloud deployment identity.

Package publishing security: control who can ship and what consumers execute

A practical process for registry access, trusted publishing, provenance, dependency review and compromised releases.

Cloud IAM and secrets: reduce standing access and prove revocation

An operating model for human roles, workload identities, secret consumers and emergency cloud access.

Production data and backups: prove you can recover without giving attackers a second copy

A runbook for database access, backup isolation, retention, restoration and safe evidence during data incidents.

API authorization: test the actor, object and action together

A practical review method for cross-tenant access, administrative functions, exports, background jobs and failure behavior.

Multisig treasury operations: verify the transaction and every path around the threshold

An operating runbook for signer independence, privileged transactions, modules, monitoring and recovery rehearsal.

Community and support security: protect announcements without becoming a recovery scam

Practical controls for moderators, bots, public links, support evidence and incident communications.

AI agent and MCP security: constrain the tool, not just the prompt

A runbook for agent integrations, local servers, authorization, data access and realistic prompt-injection tests.

Incident evidence: preserve what happened without spreading the breach

A procedure for first-response records, log exports, file provenance, access restrictions and investigative handoff.

Incident tabletop: rehearse decisions while the systems are still healthy

A repeatable exercise format for founders, engineering, security, support and the people authorized to stop operations.

Security monitoring: connect important events to an owner who can act

Build a small, testable detection system around identity changes, deployments, data access and treasury authority.

Frontend security: review every script that can change what a user sees

A practical review of browser code, tag managers and content security policies, including the interactions a successful build can still break.

Write a security finding someone else can verify

A review procedure for findings, incident narratives and technical articles: keep evidence, inference, recommendations and uncertainty separate.

Connect an AI assistant to email and calendars without delegating your entire identity

Decide what the assistant can read, draft, send and delete, then rehearse a malicious-message and disconnected-account scenario.

Financial AI agents: separate research, transaction preparation and execution authority

Design payment and treasury workflows around verified destinations, transaction-bound approvals, limits and an independent stop control.

Run unfamiliar research repositories without lending them your laptop’s credentials

Inspect before executing, isolate dependencies and tests, constrain network and filesystem access, and verify disposal with dummy secrets.

AI-assisted bug bounty work: keep scope, execution and evidence under researcher control

Use agents for understanding and reproducible reporting while preserving program authorization, data boundaries and meaningful human validation.

Before installing an MCP server: review the package, process and connected account separately

A preflight and change-review procedure for local and remote MCP integrations, from installation hooks to token revocation.

Agent credentials: issue the smallest useful secret and prove you can revoke it

An operating procedure for task-scoped identities, secret delivery, output review and recovery after unintended access or upload.

Browser agents and logged-in sessions: protect the account behind the tab

Review the authority inherited from cookies, browser profiles, connected sites and downloads before an agent uses an authenticated browser.

Agent memory and RAG: prevent retrieved text from becoming persistent policy

Track source provenance, enforce current retrieval permissions and test whether poisoned content survives into later tasks.

Review agent skills and plugins as instructions, dependencies and delegated authority

Inspect the whole instruction bundle, referenced resources and effective permissions before enabling a workflow extension or accepting its update.

Unattended agents: bound schedules, retries, cumulative usage and stale approvals

Make repeated agent work stop predictably when permissions, timing, costs or external side effects no longer match the approved task.

Agents, localhost and internal networks: enforce what the executor can actually reach

Protect local bridges, development services, cloud metadata and internal APIs with explicit network and application boundaries.

Scope a mobile security test: the app, the device and the API are separate boundaries

Prepare Android and iOS builds, device coverage, representative accounts and acceptance criteria so a mobile assessment answers a real release question.

Mobile deep links: verify the destination without trusting the requested action

Review Android App Links, iOS universal links, custom schemes and exported entry points against account state, input validation and server authorization.