Glossary

Security terms, in plain language

The application-security and supply-chain terms you hit when shipping code, especially AI-generated code, defined without jargon. Each links to the live threat feed where it applies.

AI hallucinationAI/LLM feed →
When an AI model states something false with complete confidence, inventing a fact, a citation, a policy, or an API that does not exist. Hallucination is not a bug to be fully patched but a property of how language models work: they predict plausible text, not verified truth. It becomes a security and liability problem when that output is trusted, a chatbot inventing a refund policy (which Air Canada was held liable for in 2024), or an AI suggesting a package name that does not exist, which attackers then register with malware. The fix is to ground AI output in verified data and never treat it as authoritative on its own.
Real-world example: the Air Canada chatbot case
Air gapInfra feed →
Physically isolating a network or machine from the internet and every other network, so there is no cable or wireless path in or out. It is a strong control for critical systems like industrial controllers, but not a guarantee: anything a person carries across it (a USB drive, a laptop, a contractor’s machine) can carry malware too. Stuxnet famously crossed an air gap on a USB stick to reach Iran’s uranium centrifuges.
Real-world example: Stuxnet
APT (advanced persistent threat)OpSec feed →
A well-resourced attacker, usually a nation-state, that breaks in quietly and stays for the long haul, months or years, moving slowly to avoid detection while it steals data or pre-positions for sabotage. Unlike smash-and-grab criminals, an APT is patient, targeted, and willing to spend serious money and custom tooling on a single objective. The 2015 OPM breach, in which a China-linked group sat undetected for over a year and took 21.5 million US security-clearance records, is a textbook APT intrusion.
Real-world example: the OPM breach
BackdoorSupply chain feed →
A hidden way into a system that bypasses normal authentication, planted deliberately by an attacker (or, occasionally, left by a careless developer). The danger of a backdoor is that everything looks normal: the system works, the login still asks for a password, but the attacker holds a secret key past it. Backdoors are the prize of supply-chain attacks, because one planted in widely used software, like the one nearly slipped into the xz compression library in 2024, would have handed an attacker quiet access to millions of servers.
Real-world example: the xz backdoor
BootROM / SecureROMInfra feed →
The very first code a chip runs when it powers on, also called the boot ROM or, on Apple devices, the SecureROM. It is burned permanently into the silicon at the factory, so no software update can change a single instruction of it, and it anchors the chain of trust: it cryptographically verifies the next boot stage, which verifies the next, all the way up to the operating system. A bug here is the most powerful and most permanent kind, because it sits below everything else and can never be patched on hardware already shipped; the only real fix is a new chip revision. The checkm8 (2019) and usbliter8 (2026) exploits both broke Apple SecureROM this way.
Real-world example: the usbliter8 exploit
BotnetInfra feed →
A network of internet-connected devices, computers, servers, routers, cameras, that an attacker has quietly compromised and controls remotely, all at once, usually without the owners having any idea. Botnets are rented out to send spam, mine cryptocurrency, or, most visibly, fire huge floods of traffic in DDoS attacks. The 2016 Mirai botnet showed how dangerous they had become by enslaving hundreds of thousands of insecure IoT devices through default passwords their owners never changed.
Real-world example: the Mirai botnet
Buffer overflow / over-readAppSec feed →
A memory-safety bug where a program reads or writes past the end of a buffer, the fixed-size chunk of memory it was given. A write past the end (overflow) can corrupt memory and let an attacker run code; a read past the end (over-read) can leak whatever sensitive data sits next to it. These are the classic plague of languages like C and C++ that do not check memory bounds for you. Heartbleed was a famous over-read in OpenSSL that leaked private keys and passwords; the EternalBlue exploit behind WannaCry was an overflow.
Real-world example: Heartbleed
Build provenance (SLSA attestation)Supply chain feed →
A signed, machine-checkable record of how and where a software artifact was built: which source commit, which build system, which pipeline produced it. SLSA is the common framework for it, with levels describing how tamper-resistant the record is. It is a powerful integrity check, but the 2026 Miasma attack on Red Hat showed its limit: provenance proves a package was built by a given pipeline, not that the pipeline was clean. Subvert the build identity and the attestation will faithfully sign malware, so treat provenance as integrity, not trust.
Real-world example: the Miasma / Red Hat compromise
Call graph
A model of which functions call which across your codebase. It is what lets a tool follow data from an untrusted input (a request parameter) to a dangerous sink (a database query or shell command) even when they live in different files. Stateward builds one as part of its whole-codebase knowledge base.
Container escapeInfra feed →
Breaking out of a container to reach the host machine or other containers running on it. Containers share one operating-system kernel and only look isolated; they are a resource boundary, not a hard security boundary. A single kernel bug can erase that separation, letting code in one container read or corrupt another tenant or the host. This is the nightmare case for Kubernetes and multi-tenant cloud, where many untrusted workloads share a node. Copy Fail (CVE-2026-31431) is a container escape because the kernel page cache it corrupts is shared across every container on the host; real isolation needs a separate kernel, such as gVisor, Kata Containers or a microVM.
Real-world example: Copy Fail (CVE-2026-31431)
Credential stuffingOpSec feed →
Taking username-and-password pairs leaked from one breach and trying them automatically, by the million, against other sites, betting that people reuse passwords. It is not a flaw in the target site’s code; it is the downstream cost of every previous breach plus password reuse, which is why MFA and breached-password checks matter so much. The 2023 23andMe breach was pure credential stuffing: no flaw in 23andMe, just reused passwords, which a data-sharing feature then turned into millions of exposed records.
Real-world example: the 23andMe breach
Cross-chain bridgeWeb3 feed →
A service that moves crypto assets between blockchains (say, from Ethereum to a cheaper chain), typically by locking the asset on one side and minting a copy on the other. Bridges are where the most money has been stolen in crypto, because they concentrate huge reserves and their security often rests on a small set of signers or a single verification step. Break that, as attackers did to Ronin (about $625 million) and Wormhole (about $325 million) in 2022, and the whole vault opens.
Real-world example: the Ronin bridge hack
CryptojackingInfra feed →
Hijacking someone else’s computers, servers, or cloud account to secretly mine cryptocurrency, stealing their compute and electricity for profit. Because it tries to stay quiet rather than destroy anything, cryptojacking is often the first visible sign of a deeper compromise: an attacker who can run a miner in your cloud can usually do far worse. Exposed dashboards, unsecured containers, and leaked cloud keys are the common entry points, as when attackers found an open Kubernetes console in Tesla’s cloud in 2018 and used it to mine.
Real-world example: the Tesla cloud cryptojacking
CVE (Common Vulnerabilities and Exposures)
A unique identifier for one publicly disclosed vulnerability in a specific product or library, for example CVE-2021-44228 (Log4Shell). CVEs are the lingua franca of vulnerability management, your SCA tool matches your dependencies against the CVE database.
CVSS (Common Vulnerability Scoring System)
A 0–10 score for how severe a vulnerability is, based on exploitability and impact. Useful for ranking, but context-blind: a 9.8 in a package you do not reach matters less than a 6.5 on your auth path. Pair CVSS with reachability and exploitation status (KEV) to prioritize honestly.
CWE (Common Weakness Enumeration)
A community catalogue of software weakness types, each with an identifier like CWE-89 (SQL injection) or CWE-79 (cross-site scripting). CWE classifies the kind of flaw; CVE identifies a specific vulnerable product. Findings mapped to CWE are easier to triage, dedupe and turn into compliance evidence.
Data extortion (double extortion)OpSec feed →
Stealing an organisation’s data and threatening to publish it unless paid, with or without also encrypting the systems. "Double extortion" is when ransomware crews do both: encrypt for disruption and leak for pressure, so that good backups alone no longer save you. Some crews skip the encryption entirely and just steal and extort, as the Clop gang did when it mass-stole data from thousands of organisations through the MOVEit file-transfer flaw in 2023.
Real-world example: the MOVEit / Clop campaign
DDoS (distributed denial of service)Infra feed →
An attack that knocks a service offline not by breaking in but by overwhelming it, flooding it with more traffic or requests than it can handle, usually from a botnet of thousands of machines at once (which is what makes it distributed, and hard to simply block by IP). DDoS targets availability rather than data. In 2016 the Mirai botnet aimed a record-breaking flood at the DNS provider Dyn and took much of the US internet, Twitter, Netflix, Reddit, offline for hours.
Real-world example: the Mirai / Dyn attack
DeFi (decentralized finance)Web3 feed →
Financial services, lending, trading, derivatives, built as smart contracts on a blockchain instead of through banks, with no intermediary and no one to call if it breaks. DeFi protocols hold billions in pooled funds governed entirely by code, which makes them a giant, permanent bug bounty: a single logic flaw can drain a protocol in one transaction. The recurring DeFi exploit classes are reentrancy, price-oracle manipulation, and flash-loan attacks.
Real-world example: the Euler Finance hack
Dependency confusionSupply chain feed →
Tricking a package manager into pulling a public package instead of your intended private one, by publishing a higher version number under the same name to a public registry. It lets an attacker inject code into internal builds; the fix is scoped registries and explicit source pinning.
DMA attackInfra feed →
Direct memory access (DMA) lets a hardware peripheral, like a USB or Thunderbolt controller, read and write system memory directly without going through the CPU, for speed. A DMA attack abuses that power: a malicious or buggy device writes to memory it should never touch, corrupting code or data to seize control. The defence is an IOMMU (Apple calls its version DART), a hardware gatekeeper that restricts which memory a peripheral can reach; leaving it disabled or in "bypass" mode removes the guard rail. The usbliter8 exploit walked a USB controller’s DMA write pointer backwards into protected memory precisely because the IOMMU was left in bypass mode.
Real-world example: the usbliter8 exploit
DORA (Digital Operational Resilience Act)
An EU regulation for the financial sector covering ICT risk, third-party risk and operational resilience. Like NIS2 it demands demonstrable, continuous security posture rather than point-in-time audits, exactly the audit-ready evidence Stateward generates per pull request.
EU Cyber Resilience Act (CRA)
An EU regulation setting cybersecurity requirements for products with digital elements across their lifecycle, including vulnerability handling and an SBOM. It pushes “secure by design” from best practice into law for products sold in the EU.
False positive
A finding a tool reports that is not actually exploitable in your context. High false-positive rates are the main reason teams ignore security tools. Stateward reduces them by validating findings against the real call graph and reachability, and by adversarially refuting candidates before reporting a verdict.
Flash loanWeb3 feed →
A loan of millions in crypto with no collateral and no credit check, on one condition: you borrow and repay it within a single blockchain transaction, or the whole thing is automatically undone as if it never happened. Flash loans are a legitimate DeFi tool, but they hand any attacker temporary access to enormous capital for free, which is then used to amplify a bug, manipulate a price oracle, or overwhelm a protocol’s math. Many of the largest DeFi exploits, including the 2023 Euler hack, were powered by flash loans.
Real-world example: the Euler Finance hack
Hard forkWeb3 feed →
A backwards-incompatible change to a blockchain’s rules that splits it in two: nodes that upgrade follow the new chain, those that do not keep the old one, and both can survive as separate coins. Hard forks are how a community changes the rules, or undoes a disaster. After the 2016 DAO hack drained a third of a $150 million fund, Ethereum hard-forked to reverse the theft, and the minority who objected on "code is law" principle kept the original chain alive as Ethereum Classic.
Real-world example: The DAO hack
Hot wallet vs cold storageWeb3 feed →
A hot wallet keeps its private keys on an internet-connected system so funds can move quickly, which an exchange needs for withdrawals, and which is exactly the first thing an attacker who breaches it goes for. Cold storage keeps keys offline, out of an attacker’s reach. The standard defence is to hold the vast majority of funds in cold storage and size the hot wallet only to daily operational need, so a breach drains a survivable amount rather than everything.
Real-world example: the Bitfinex hack
ICS / SCADA (industrial control systems)Infra feed →
The computers and controllers that run physical processes: power grids, pipelines, water treatment, factories. SCADA is the supervisory software operators watch; PLCs (programmable logic controllers) are the small ruggedised computers that actually open valves and spin motors. They were built for reliability and uptime, not security, and often run for decades without patches, which is why an attacker who reaches them can cause real, physical damage. Defending them is its own discipline, OT (operational-technology) security.
Real-world example: Stuxnet
IDOR (Insecure Direct Object Reference)AppSec feed →
Exposing a reference to an internal object, a database id in a URL, without checking that the current user is allowed to access it, so changing /invoice/123 to /invoice/124 leaks someone else’s data. It is a form of broken access control, the top OWASP risk, and authorization must be checked server-side on every request.
Infostealer (information-stealing malware)OpSec feed →
Malware that quietly harvests everything useful on an infected machine, saved browser passwords, session cookies, autofill data, and crypto wallets, and ships it to the attacker. Infostealers have become the engine of modern breaches: a single infected laptop, often a personal one, leaks corporate credentials that are then sold on criminal markets and used to log in to company systems. The 2024 Snowflake attacks, which hit dozens of major companies, were powered by credentials taken from infostealer-infected machines where MFA was not enforced.
Real-world example: the Snowflake attacks
Integer overflow / wraparoundAppSec feed →
Arithmetic that produces a value larger than a fixed-size integer can hold, so instead of erroring it silently wraps around to a small or wrong number. A close cousin is a bounds check written against the wrong limit, which lets an overflowing value slip through. In financial or DeFi math this is devastating: an attacker can make a contract believe a near-zero deposit is worth an enormous amount, then withdraw real funds. The bug often hides in a shared math library, so a single wrong constant can drain many protocols at once. The $223M Cetus hack on Sui came from exactly this: a faulty overflow check in the shared integer-mate library credited a one-token deposit as astronomically large liquidity.
Real-world example: the $223M Cetus hack
JailbreakInfra feed →
Removing the software restrictions Apple builds into iOS so a device can run unsigned code and software Apple has not approved. It is done by chaining exploits that defeat the chain of trust, from the boot loader up. A jailbreak rooted in a BootROM exploit is "tethered" or "semi-tethered": because the underlying bug is in unchangeable silicon it cannot be made permanent, so the exploit must be re-run over USB on every reboot. That same low-level access also underpins iPhone forensic-extraction tools. checkm8 powered the checkra1n jailbreak on older devices; usbliter8 opens the same door on the A12 and A13.
Real-world example: the usbliter8 exploit
KEV (Known Exploited Vulnerabilities)Known-exploited feed →
CISA’s authoritative list of vulnerabilities that are being actively exploited in the wild. A KEV entry means attackers are using it right now, so it jumps the patch queue regardless of its CVSS score. Stateward’s live feed surfaces KEV entries the moment they land.
Lateral movementOpSec feed →
What an attacker does after the first foothold: moving from the machine or account they initially compromised toward the data or systems they actually want, using stolen credentials, unpatched internal services, or over-broad permissions. Most breaches are not one clever exploit but a chain of small hops across a flat, over-trusting network. It is why segmentation and least privilege matter so much: they turn a single foothold into a dead end instead of a master key. In the 2013 Target breach, attackers hopped from an HVAC vendor’s access all the way to the checkout registers.
Real-world example: the Target breach
Logic & correctness bugAppSec feed →
A bug where the code runs but does the wrong thing, not an attacker-facing hole, but an honest mistake a careful engineer makes. Integer IDs approaching their type’s limit at scale, money handled in floating point (0.1 + 0.2 ≠ 0.3), off-by-one boundaries, broken invariants, unhandled edge cases. Rarely exploitable, but a leading cause of outages, data corruption and costly incidents, the reason the security-audit industry exists. Stateward’s adversarial deep audit hunts these by reasoning about what each function must guarantee and trying to break it, not by pattern-matching known CVEs.
Merge-induced vulnerabilityAppSec feed →
A flaw that exists in neither branch alone but appears once two branches are merged, for example one branch removes a validation that another branch starts depending on. Diff-only scanners miss it because each diff looks safe. Stateward analyses the merged result against the whole codebase, which is where it surfaces.
MFA (multi-factor authentication)OpSec feed →
Requiring more than a password to log in, by adding a second factor: a code, an app prompt, or ideally a hardware key. MFA is the single highest-value control against stolen or guessed passwords, because the password alone is no longer enough. But not all MFA is equal: SMS codes and simple app prompts can be phished or worn down (see MFA fatigue), while phishing-resistant factors like FIDO2/WebAuthn passkeys cannot. The 2021 Colonial Pipeline shutdown began with one VPN account that had no MFA at all.
Real-world example: Colonial Pipeline
MFA fatigue (push bombing)OpSec feed →
An attack that abuses push-based multi-factor authentication. After stealing a valid password, the attacker triggers a flood of MFA approval prompts (also called push bombing) until a tired or confused user finally taps "Approve", often helped along by the attacker impersonating IT over a call, SMS or WhatsApp. It defeats MFA without breaking any cryptography. The defence is phishing-resistant, hardware-backed MFA (FIDO2/WebAuthn passkeys), number-matching, and capping repeated prompts; the rule of thumb for users is that real IT never asks you to approve a login you did not start. It is how attackers breached Uber in 2022.
Real-world example: 2022 Uber breach
MSP (managed service provider)Supply chain feed →
A company you outsource your IT to: it manages your servers, patches your software, and runs remote-management (RMM) tools that reach deep into your network with high privilege. That reach is the risk. Compromise one MSP, or the tool it uses, and you compromise every customer at once. The 2021 Kaseya attack did exactly that, pushing ransomware through MSPs to roughly 1,500 of their downstream businesses in a single stroke.
Real-world example: the Kaseya attack
Multisig (multi-signature)Web3 feed →
A wallet or contract that requires several independent keys to approve a transaction (say 3 of 5), so no single stolen key can move the funds. It is a strong control when the keys are genuinely held by different people and systems, and when the policy is enforced where a client cannot bypass it. It fails when too many keys end up in one place: in the 2022 Ronin hack the attacker obtained five of the nine validator keys and emptied the bridge.
Real-world example: the Ronin bridge hack
NIS2
An EU directive (2022) that broadens cybersecurity obligations across essential and important entities, with requirements for risk management, supply-chain security and incident reporting. It raises the bar for software security evidence; Stateward maps findings to it and keeps data EU-hosted with EU data residency.
OWASP Top 10AppSec feed →
The Open Worldwide Application Security Project’s ranked list of the ten most critical web application risks, broken access control, injection, cryptographic failures and so on. It is the default checklist auditors and frameworks reference; Stateward maps each finding to its OWASP category.
Page cacheInfra feed →
The pool of memory the operating-system kernel uses to keep recently-used file contents in RAM, so programs do not have to read the disk every time. When you run a program, the CPU executes the bytes from its cached pages, not from a fresh disk read. That makes the page cache a high-value target: corrupting the cached copy of an executable changes what it does the next time it runs, while the file on disk stays untouched, so disk-based integrity scanners see nothing. A whole family of Linux privilege-escalation bugs (Dirty COW, Dirty Pipe, and Copy Fail) works by sneaking a write into page-cache pages that should have been read-only.
Real-world example: Copy Fail (CVE-2026-31431)
Password sprayingOpSec feed →
A login attack that flips brute-forcing around: instead of trying many passwords against one account (which triggers lockouts), the attacker tries one or two very common passwords against many accounts. Low and slow, it stays under rate limits and lockout thresholds, and it only takes one person using "Winter2024!" to get in. It works against any account without MFA. In 2024 Russia’s SVR used password spraying to breach a forgotten test account at Microsoft and pivot into senior executives’ email.
Real-world example: the Midnight Blizzard attack
Phishingphishing feed →
Tricking a person into handing over credentials, money, or access by impersonating someone they trust, usually over email but also by text (smishing), phone (vishing), or a fake login page. It is the most common first step in a breach because it targets people, not code: no software flaw is needed if someone can be convinced to type their password into the wrong box. Targeted versions aimed at a specific person, spear phishing, are how many famous intrusions began.
Real-world example: the DNC / Podesta hack
Private keyWeb3 feed →
The secret number that controls a cryptocurrency wallet or account. Whoever holds the private key can move the funds, full stop: there is no bank to call and no password reset. This makes key management the whole game in crypto security, and most large crypto thefts are not clever contract math but a stolen or mis-signed private key. The 2025 Bybit theft, the largest in history at about $1.5 billion, was at root a signing compromise.
Real-world example: the Bybit hack
Privilege escalationInfra feed →
Gaining more permission than you are supposed to have. Vertical escalation means jumping from a normal user to an administrator or, on Linux, to root (UID 0); horizontal escalation means taking over another account at the same level. A local privilege escalation (LPE) starts from any foothold on a machine, even an unprivileged shell, and ends at full control, which is why it is so dangerous on shared systems where untrusted code already runs, like CI runners, multi-tenant servers and Kubernetes nodes. The Copy Fail kernel bug (CVE-2026-31431) is a textbook LPE: an ordinary user becomes root with a tiny script.
Real-world example: Copy Fail (CVE-2026-31431)
Prompt injectionAI/LLM feed →
Manipulating an LLM-powered application by smuggling instructions into its input, directly, or indirectly through content the model later reads (a web page, a document, a tool result). It is the defining vulnerability class of AI applications and has no single clean fix; you contain it with least privilege, output validation and human approval for sensitive actions.
RansomwareOpSec feed →
Malware that encrypts a victim’s files or whole systems and demands payment, usually in cryptocurrency, for the key to unlock them. Modern crews also steal the data first and threaten to leak it (double extortion), so paying does not even guarantee privacy. The defences that actually work are tested offline backups, fast patching, MFA, and segmentation so one infected machine cannot reach everything.
Real-world example: WannaCry
RCE (Remote Code Execution)
A vulnerability that lets an attacker run arbitrary code on your server or a user’s machine, the most severe outcome, because it usually means full compromise. It often arrives through unsafe deserialization, command injection or a vulnerable dependency like Log4Shell.
Reachability analysisSupply chain feed →
Determining whether a vulnerable function in a dependency is actually called by your code. A CVE in a package you import but never exercise on a vulnerable path is far lower priority. Reachability cuts dependency noise dramatically by separating “present” from “exploitable.”
ReentrancyWeb3 feed →
A smart-contract bug where a function sends funds to an external address before it updates its own bookkeeping, and the receiving contract calls back in to withdraw again, and again, before the balance is ever decremented, so the contract pays out many times for one withdrawal. It is the oldest and most famous class of DeFi exploit, the 2016 DAO hack was a reentrancy attack, and it still drains protocols today. The fix is the "checks-effects-interactions" pattern: update your state before making external calls.
Real-world example: The DAO hack
Remote access trojan (RAT)OpSec feed →
Malware that gives an attacker hands-on remote control of an infected machine: running commands, reading and writing files, and pulling down further payloads, usually while beaconing quietly to a command-and-control server. Unlike a one-shot stealer, a RAT is an open door the attacker keeps using. The 2026 axios compromise dropped a cross-platform RAT (WAVESHAPER.V2) onto any machine that installed the poisoned versions, with native variants for Windows, macOS and Linux.
Real-world example: the 2026 axios compromise
RootkitInfra feed →
Malware that hides itself, and other malicious activity, from the operating system and from defenders by hooking deep into the system (the kernel, drivers, or firmware), so the files, processes, and connections it controls become invisible to normal tools. Because it tampers with the very system you would use to inspect it, a rootkit-infected machine cannot be trusted to report its own state; the only safe response is to rebuild from known-good media. Stuxnet carried both a Windows rootkit and the first known rootkit for industrial controllers.
Real-world example: Stuxnet
SAST (Static Application Security Testing)AppSec feed →
Analysis of source code, without running it, to find security flaws like injection, broken access control or unsafe deserialization. Classic SAST works on a single file or diff; Stateward reasons over the whole codebase, its call graph and trust boundaries, so it catches flaws that only appear across files or branches.
SBOM (Software Bill of Materials)Supply chain feed →
A machine-readable inventory of every component and dependency in a piece of software, including transitive ones. Regulations like the US Executive Order 14028 and the EU Cyber Resilience Act increasingly require one, because you cannot defend a supply chain you cannot enumerate.
SCA (Software Composition Analysis)Supply chain feed →
Inventorying your open-source dependencies and matching them against known vulnerabilities (CVEs), license risk and maintainer risk. Good SCA matches the exact installed version and tells you whether the vulnerable code is actually reachable, instead of alerting on every transitive package.
Secret scanningSecrets feed →
Detecting credentials, API keys, tokens, private keys, database URLs, committed into source control. The fix is never just deleting the line: a leaked secret in git history is compromised and must be rotated. Stateward scans every diff at the commit, before the secret reaches a shared branch.
Secrets (API keys, tokens, credentials)AppSec feed →
The passwords of machines: API keys, access tokens, database credentials, and signing keys that let code authenticate to other systems. Secrets are dangerous precisely because they are reusable and portable, one leaked token can open everything it was authorized for. They leak constantly, hardcoded in source, committed to git, printed in logs, or exposed in CI environment variables, which is exactly what the 2021 Codecov attack harvested from thousands of pipelines. The defences are to keep secrets out of code, scan for them continuously, and rotate them fast when exposed.
Real-world example: the Codecov attack
Session hijacking (token theft)OpSec feed →
Stealing the token or cookie that proves a user is already logged in, and replaying it to take over their session without ever needing their password or MFA. Because the token represents an already-authenticated session, it sidesteps login defences entirely, which is why stealing session cookies, through malware, a support-file upload, or a malicious script, is such a prized technique. The 2023 Okta support breach worked this way: attackers lifted session tokens from files customers had uploaded and used them to walk into those customers’ accounts.
Real-world example: the Okta support breach
Smart contractWeb3 feed →
A program that runs on a blockchain and controls funds or assets directly: code that executes automatically and irreversibly when its conditions are met. Its power and its danger are the same thing, because once deployed it usually cannot be patched, and a bug is not a crash but a vault anyone can drain. Most large DeFi thefts are simply exploited smart-contract logic. The 2016 DAO hack, where a flaw let an attacker siphon a third of a $150 million fund, was the first to prove the stakes.
Real-world example: The DAO hack
Social engineeringOpSec feed →
Manipulating people rather than machines to get in: convincing a help desk to reset a password, an employee to approve a login, or a contractor to run a "fix." Phishing is one kind of social engineering; others include impersonating IT on a call, building fake trust over weeks, or simply asking with enough confidence. It works because it sidesteps every technical control, which is why the strongest defences pair good technology with trained, skeptical people.
Real-world example: MGM and Caesars
Source map exposure (source map disclosure)AppSec feed →
Shipping a JavaScript source map (.map) to production, or inside a published package, so anyone can download your original source. Bundlers embed the full code in the map’s sourcesContent field, so an exposed map leaks unminified code, internal comments, hidden API endpoints and any compiled-in secrets, Apple’s App Store front-end and Anthropic’s Claude Code both shipped one by accident. Stateward detects it (CWE-540) in the pull request: a committed .map artifact, a sourceMappingURL left in a shipped bundle, or a build config that emits production maps (Vite, webpack, Next.js, Create React App, Vue, Rollup), so it never reaches production.
SQL injectionAppSec feed →
Inserting attacker-controlled input into a database query so it changes the query’s meaning, letting an attacker read, modify or destroy data. The fix is parameterized queries (bound parameters), never string concatenation. It is CWE-89 and a perennial OWASP Top 10 entry.
SSRF (Server-Side Request Forgery)AppSec feed →
Tricking a server into making requests on the attacker’s behalf, often to internal services or cloud metadata endpoints it would never expose externally. SSRF was central to the Capital One breach. Defences include allowlisting destinations and blocking access to link-local and internal address ranges.
Supply-chain attackSupply chain feed →
Compromising software by attacking something it depends on, a popular npm package, a build tool, a CI runner, rather than the target directly. One poisoned dependency reaches every project that installs it, which is why incidents like event-stream, SolarWinds and the xz backdoor were so damaging.
Trusted publishing (OIDC)Supply chain feed →
A way for a CI pipeline to publish a package without storing a long-lived secret. Instead of a static token, the pipeline requests a short-lived OpenID Connect (OIDC) identity token at publish time, which the registry verifies and exchanges for one-time publish rights. npm and GitHub pushed it as the recommended path after the Shai-Hulud worm, because there is no durable token left lying around for an attacker to steal and reuse. The catch, shown by the Miasma attack, is that it secures the token, not the pipeline: if an attacker controls the workflow that requests the token, trusted publishing will hand them a valid release.
Real-world example: the Miasma / Red Hat compromise
TyposquattingSupply chain feed →
Publishing a malicious package under a name that resembles a popular one (reqeusts vs requests, lodahs vs lodash) to catch typos and copy-paste mistakes. The malware usually runs on install. Stateward flags dependencies whose names are suspiciously close to well-known packages.
Vibe codingAI/LLM feed →
Building software by prompting an AI to generate it and shipping what comes out, often without fully reading or understanding the code. The term, popularised in 2025, captures a real shift: anyone can now produce working apps fast. The security catch is that AI models reproduce the insecure patterns in their training data, missing authentication, exposed databases, hardcoded secrets, so vibe-coded apps regularly ship with serious holes their author never saw. The 2025 Replit database wipe, where an AI agent deleted a production database during a vibe-coding experiment, is the textbook case; the Tea app breach is often blamed on it too, though that was unreviewed outsourced code rather than AI-generated, the same failure from a different cause.
Real-world example: the Replit database wipe
Wallet drainerWeb3 feed →
Malicious code, usually injected into a website or a wallet-connection library, that tricks a crypto user into signing a transaction or approval that hands their tokens to the attacker. Instead of stealing a private key, a drainer abuses the permissions a user grants when they click "connect" or "approve" on what looks like a normal app. Drainers are sold as off-the-shelf kits and are the workhorse of crypto phishing; one was injected into Ledger’s widely used Connect Kit in 2023, briefly poisoning many popular DeFi sites at once.
Real-world example: the Ledger Connect Kit attack
Wiper (destructive malware)OpSec feed →
Malware whose goal is destruction, not theft or ransom: it deletes files, overwrites the master boot record, or bricks machines so they will not start. Some wipers pose as ransomware to buy time or muddy attribution, but there is no key and no recovery, only restoring from backup. Wipers are favoured by nation-states for sabotage; one tore through Sony Pictures in 2014, and the same idea reached global scale as NotPetya in 2017.
Real-world example: the Sony Pictures hack
Worm (self-propagating malware)Infra feed →
Malware that spreads by itself, with no human action, by exploiting a vulnerability to copy itself from one machine to the next across a network. A worm is what turns a single compromise into a global outbreak in hours, as WannaCry did in 2017 with the EternalBlue exploit. The lesson worms teach over and over: patch wormable, network-facing vulnerabilities fast, and segment the network so one foothold cannot reach the whole estate.
Real-world example: WannaCry
Zero-dayKnown-exploited feed →
A vulnerability that is exploited before the vendor has a patch, defenders have “zero days” to fix it. Zero-days are why a live, known-exploited feed matters: the window between disclosure and weaponization is often hours.

See these flaws caught on a real pull request