← all systems · see it in The System
Software vulnerability
In computer security, a vulnerability is a flaw or weakness in a system's design, implementation, or management that can be exploited by a malicious actor to compromise its security (src:wp:vulnerability-computer-security). Walked as the flaw together with its life as the research literature describes it: introduced with code (or hardware), active while that code runs, discovered by a vendor, a third party or an attacker, disclosed or kept secret or sold, catalogued (CVE, CWE, CVSS), patched or exploited, and ended when patched or retired; with the markets (bounties, brokers) and rules (coordinated disclosure) around it.
Properties published scienceour proposal
Sourced fields, and our own readings.
| born at | 1970 (the Ware report names inadvertent loopholes in protective barriers as the most serious risk in system software); 1972 the buffer overflow described (Computer Security Technology Planning Study); 1972-73 the Multics penetration exercise; earliest documented hostile exploitation 1988 |
| born precision | year |
| boundary | Inside: the flaw itself (a weakness in design, implementation, configuration or hardware behaviour that an input can trigger to compromise confidentiality, integrity or availability), its states (carrier, dormant, active; undisclosed or disclosed; patched or not), the acts that find it (code review, static analysis, fuzzing, telemetry, reverse-engineering patches), the routes it travels once known (reports, coordinated or full disclosure, sale), the shared record and scores (CVE identifiers and records, CWE root causes, CVSS severity, NVD, exploitation probability), and the acts that end it (patch, mitigation, retirement) or use it (exploit, stockpile). Outside: the software, hardware and operating systems that carry the flaw; the people who write, find, buy, sell and fix; the malware an exploit delivers; computer security and information security, the practices that manage it; the markets and laws it sits in. |
| nested level | A part of software (and hardware) that exists only while the code runs or can run (rung 12); its catalogue and market are institutions carried by people and organisations. Managed inside computer security's vulnerability management; exploited by threat actors, often to deliver malware. |
| scale | technological |
Measures (40) published science
| characteristic clock: average vulnerability lifetime in code | ~4 (Chromium ~2, OpenSSL ~7) years |
| vulnerabilities living more than three years | about one third fraction of CVEs |
| median life span of a vulnerability in its code base (682 projects) | 438 days |
| disclosed issues still unpatched 30 days after disclosure | 26 % |
| median lines changed: security commit vs general bug fix | 7 vs 16 lines of code |
| duration of zero-day attacks before disclosure (mean) | 312 (range 19 days to 30 months) |
| rise in attack volume after disclosure | up to 10^5 factor |
| median lifetime of OpenBSD foundational vulnerabilities | at least 2.6 years |
| vulnerability half-life, highest depletion estimate (Rescorla) | ~2.5 years |
| vulnerability density, new code against 5-year-old code | 3.4x to 7.4x higher in new code ratio |
| share of high-severity security bugs that are memory-safety bugs (Chromium) | ~70 % |
| Heartbleed: Alexa Top 1 Million HTTPS sites still vulnerable | 11 after two days; 3 almost two months after % |
| memory-safety share of Android vulnerabilities | 76 (2019) to 24 (2024) % |
| Heartbleed: share of Alexa Top 1 Million HTTPS sites initially vulnerable | 24-55 % |
| patching increase among notified operators (Heartbleed) | 47 % |
| per-hand-off yield after Heartbleed: sites vulnerable at 48 h that replaced certificates within a month AND changed the key | 0.10 x 0.86 = ~0.086 fraction (computed here from two sourced shares) |
| package releases affected per vulnerability (median) | 30 (npm), 59 (RubyGems) releases |
| exposed dependency vulnerabilities with a fix in the same major range | 33 (projects), 40 (packages) % |
| Chrome VRP cost and bounties (3 years) | ~$580,000; 501 bounties USD; count |
| Firefox VRP cost and bounties (3 years) | ~$570,000; 190 bounties USD; count |
| share of patched browser vulnerabilities from VRP reports | 28 (Chrome), 24 (Firefox) % |
| bounty discovery decay after programme launch | ~t^-0.40 power-law exponent |
| bounty discoveries per researcher per programme (tail) | P(X>x) ~ 1/x^1.63 power-law exponent |
| time to remediate (median, about 300 companies) | 100 (75% within 392) days |
| share of EPSS predictions at 2% or less | 76 % |
| vulnerabilities recorded in the CVE database | >327,000 (April 2026) records |
| CVE records in the CWE Top 25 dataset (2024) | 31,770 records |
| usable life of a zero-day exploit (RAND, mean) | 6.9 (1.4 if bought from a third party) years |
| rediscovery (collision) rate of a zero-day stockpile per year | 5.76 (RAND: a private set of 207 zero-days over 14 years, as reported by Herr et al.; 5.7 as quoted by the encyclopedia); 10.8-21.9 (Herr, Schneier and Morris 2017, revised: duplicate disclosures in vendor bug trackers, Chrome 2009-2017 10.8, Android 2016-2017 21.9, aggregate 12.7) % |
| bugs and security-critical bugs in a 35-million-line program (model) | 1,000,000 bugs; ~1% security-critical count; fraction |
| Unix utilities crashed by random input (1988-90) | 25-33 % |
| CVSS score range and bands | 0.0-10.0; Low 0.1-3.9, Medium 4.0-6.9, High 7.0-8.9, Critical 9.0-10.0 score |
| coordinated disclosure deadline (common) | 90 days |
| Heartbleed: time in code before disclosure | about 2 (OpenSSL 1.0.1 released 2012-03-14; disclosed 2014-04-07) years |
| honeymoon: release to first disclosed vulnerability (median, 700 releases) | 110 (open source 115, closed source 98); median honeymoon ratio 1.54 days; ratio |
| patch release: instantaneous probability with disclosure against without | nearly 2.5 ratio (hazard) |
| CWE Top 25 (2024): top-ranked weaknesses | 1 CWE-79 cross-site scripting (56.92); 2 CWE-787 out-of-bounds write (45.20); 3 CWE-89 SQL injection (35.88); 8 CWE-416 use after free (10.19) rank (score) |
| share of Microsoft's CVEs that are memory-safety issues | ~70 % per year |
| CVE submissions growth 2020-2025 | 263 % increase |
| vulnerabilities found and fixed through OSS-Fuzz (cumulative) | over 10,000 (and 36,000 bugs) across 1,000 projects, as of August 2023 count |
Open contentions (7) open contention
Where sources or readings disagree. Both stay on the map.
- C-1118 In cybersecurity, do attackers have the advantage?
booked: The map keeps both: attack is easier because defenders must cover everything, and attackers have no inherent advantage because one block can break their chain.
the other reading: no inherent attacker advantage (intelligence-driven defence) - C-1125 Does publicly disclosing software flaws make systems safer?
booked: The map follows the finding that disclosure and patching reduce reported flaws, and keeps the argument that disclosure mainly helps attackers alongside.
the other reading: Rescorla: only very weak support for depletion; no depletion cannot be ruled out; disclosure aids attackers; Clark et al. 2010: early in a release's life, discovery speeds up with attackers' familiarity (the honeymoon effect), and reused legacy code shortens the honeymoon; extrinsic properties outweigh code quality - C-1367 Does open source make software more secure?
booked: The map keeps both: publishing the code avoids hiding behind secrecy, and open contribution lets people slip in weaknesses on purpose.
the other reading: open, well-known code gets more frequent, reliable patches - C-1372 Was Meltdown a hardware flaw or an operating-system one?
booked: The map follows its discoverers in placing the cause in the processor, and keeps the operating system's design choice that let it work alongside.
the other reading: the software's isolation assumptions as the condition - C-1480 Is a software vulnerability a computing thing only?
booked: The map books it as a computing system, and keeps locks' weak points and animal 'sensory traps' as related sightings.
the other reading: one system: any exploitable weakness in a receiver's built-in response, in locks, animals' senses and software alike, older than computing; software and hardware vulnerabilities as two systems, not one - C-1481 How often do two people find the same hidden software flaw?
booked: The map keeps both figures: about 6% a year, and 11-22% a year.
the other reading: about 5.7% a year; 10.8-21.9% a year - C-3430 What exactly is a software vulnerability?
booked: The map keeps the competing readings; none is ruled.
the other reading: a vulnerability exists only when the flawed software is deployed, the flaw discovered and an exploit exists (Browne, Arbaugh, McHugh and Fithen 2000); exploitability as an unexpected computational model inside the target, programmable by crafted input (a 'weird machine'; Bratus et al. 2011)
Cross-scale patterns seen here (21) our proposal
Shapes that recur when the same kind of problem is solved at different scales, and how each shows in Software vulnerability. Each links to every other system that shows it.
- lightning (structural)
A stored secret released at once: disclosure turns a few hidden attacks into up to five orders of magnitude more; the system is not the same after (patch race, reverse engineering). - same role, different builds (structural)
One job, a built-in response that an outsider can trigger to make the receiver act for the outsider: a parser that trusts a length field (Heartbleed), a lock whose weakness a picker exploits (Hobbs, 1851), a female sea lamprey's attraction to the larval cue, which the male pheromone mimics (a sensor - templating (structural)
A conserved module reused unchanged across systems carries its flaw with it: OpenSSL's heartbeat code in a quarter to half of popular HTTPS sites and in Bitcoin software; npm packages in a median 30 releases. CVE identifiers are the same template on the record side. - The carry (structural)
Overflow passed on, in its hostile form: a buffer that can hold only so much passes the excess into the adjacent memory (the buffer overflow, documented 1972, first hostile use 1988). The wait face too: a fix waits on deployment (26% unaddressed at 30 days; median remediation 100 days) and on the ag - The Payment to Entropy (structural)
Signal form: a fix handed from vendor to operator arrives partly unused, and the loss compounds along the chain: patch (plateau, 3% still vulnerable at two months) -> certificate replaced (10% of sites still vulnerable at 48 h) -> key changed (86% of those) gives an end-to-end yield of about 0.086; - trade one property for another (structural)
Performance bought, security paid: speculative execution guesses ahead for speed and so breaks isolation. Transparency bought, early risk paid: full against coordinated disclosure. Low expected payout with high potential (Chrome) against fixed payouts (Firefox). - who opens the door (structural)
The exploit comes in through a door the receiver built ahead of time for other traffic: a listening service (fingerd), a heartbeat handler; the receiver's own parser opens it by trusting the input. - borrowed-then-held (partial)
Numbering first done by MITRE for vendors, later held by vendors themselves as CVE Numbering Authorities (designation from 1 February 2005; Red Hat requests blocks of 500). Finding first borrowed from outsiders (bounties) while vendors keep their own teams. - causal ceiling (partial)
No observer can know which discovery came first, or that a system is secure from a failed test; zero-day data exists only after attacks are discovered. - holding / entrainment (partial)
The host sets the part's death: a vulnerability ends when its software is patched or retired; industrial software that cannot be replaced keeps its flaws alive. - namespace completeness (the map predicts its gaps) (partial)
The CVE namespace is not complete, and people work at its edges: SaaS not tracked, vendor-denied flaws collected by !CVE, submission voluntary; read the shelf of kinds (NVD's eight root causes, CWE). - not-diluting wins (partial)
Vulnerability density in old code thins exponentially while new code keeps its high density, so new code comes to dominate the vulnerabilities ('The problem is overwhelmingly with new code'). - red-queen (partial)
Defenders improve (faster patching, memory-safe new code, bounties) and attackers keep finding and buying flaws ('any serious attacker can always get an affordable zero-day for almost any target', RAND as quoted); old vulnerabilities age out yet fixed ones get older on average. In the lamprey, mimic - same shape, opposite sign (partial)
One process, feeding malformed input to a program and watching it misbehave, run with its sign reversed: fuzzing does it to find and fix (25-33% of Unix utilities crashed), exploitation does it to use. And one act, publishing the patch, both closes the flaw and reveals it to attackers. - the whole sets the local reference (partial)
CVSS Base metrics are fixed for all users, and each user's Environmental metrics read them locally; one CVE identifier is the reference every database reads. - Umwelt: each system carves its own slice of one shared medium (partial)
Each reader of the same code carves its own slice: scanners see only known vulnerabilities from a database; CVE does not track SaaS; telemetry sees only hosts running one vendor's antivirus; attackers see what they have found and not reported. - barrier-gates-complexity (surface)
Air gaps are 'extremely effective at preventing attacks' but not feasible for connected systems; no source shows complexity that exists only behind the barrier. - nested ladder (surface)
Privilege levels climbed by chained exploits, each level including the access below, up to root. - outside-to-inside (surface)
Code from outside (dependencies) carries its flaws inside the dependent; no source shows an outside phase becoming an internal partition. - partner-becomes-part (surface)
An outside discloser sometimes ends up with a job at the vulnerable organisation. - same toolkit, independent builds (surface)
Heartbleed found independently by Google and Codenomicon within days; secret stockpiles rediscovered by others (5.7% to 21.9% a year).
Valence: what it trades, and with whom (18) published science
Each exchange with a neighbour, read from both sides: who gains, who pays, and what carries it.
- Computer memory via sys:electromagnetic-field · Software vulnerability gain
- Malware via sys:software · Software vulnerability even
- Access control via sys:software · Software vulnerability even
- Threat actor via sys:human-society · Software vulnerability mixed
- Human (Homo sapiens) via sys:human-society · Software vulnerability mixed
- Software via sys:software · Software vulnerability gain
- Internet via sys:electromagnetic-field · Software vulnerability gain
- Operating system via sys:software · Software vulnerability gain
- Market and trade via sys:money · Software vulnerability mixed
- Programming language via sys:written-record · Software vulnerability loss
- Computer security via sys:written-record · Software vulnerability loss
- Information security via sys:written-record · Software vulnerability even
- Computer hardware via sys:computer-hardware · Software vulnerability gain
- Secure software development via sys:software · Software vulnerability loss
- Cyberwarfare via sys:computer-network · Software vulnerability loss
- Supply chain security via sys:software-vulnerability · Software vulnerability even
- Vulnerability management via sys:software · Software vulnerability loss
- Penetration testing via sys:software · Software vulnerability loss
Partners and parts published science
Built from / builds (14)
- Computer security
- Competition for control of a running program (exploit vs patch)
- The race to find a program's bugs first
- Slammer against human response (25 January 2003)
- Software bug
- Exploit
- CVE system (Common Vulnerabilities and Exposures)
- Common Weakness Enumeration (CWE)
- Common Vulnerability Scoring System
- Coordinated vulnerability disclosure
- Bug bounty (vulnerability rewards) programs
- Exploit and zero-day markets (white, gray, black)
- Security patch
- Requesters tricking privileged programs into using their authority
Sits inside / holds (3)
expressed by (41)
- Recombination/Composition
- Scaffolding/Enablement (Meta-Tooling)
- Templating / Standardization
- Quality Improvement/Refinement
- Interoperability/Transduction (Bridging)
- Amplification/Scale-Up (Manufacture & Distribution)
- Symbiosis/Co-Creation (Collaborative Specialization)
- Distributed Autonomy/Decentralized Execution (Subsidiarity)
- Internal Coordination/Regulation
- Sensing/Scanning
- Search/Foraging
- Mapping/Modeling
- Uncertainty Reduction/Learning
- Intrinsic Motivation / Curiosity-Driven Sampling
- Active Experimentation / Probing (Optimal Experimental Design)
- Multi-Scale Data Fusion / Triangulation
- Trail-Marking / Externalized Memory (Stigmergy)
- Frontier Outposts / Sensing Extension
- Optimal Stopping & Patch-Switching
- Social Learning / Public Information Use
- Evade Detection
- Overcome Barrier
- Speed
- Precision Attack
- Ranged Attack
- Neutralize Defenses
- Resource Denial/Attrition
- Subversion & Co-optation
- Prepositioning & Latency
- Leverage Host/Amplification
- Quick Harm Avoidance
- Reactive Response
- Proactive Defense
- Physical/Virtual Barrier
- Technique-Based Identification (a.k.a. Technique-Based Detection)
- Delay/Redirection Tactics
- Validation of Effectiveness
- Enclave/Segregation
- Resilience & Repair
- Triage & Prioritized Allocation
- Quality Control & Error Correction
floor filled by (25)
- Computer security
- Malware
- Threat actor
- Human (Homo sapiens)
- Software
- Internet
- Agent (AI)
- Operating system
- Programming language
- Computer hardware
- Software bug
- Exploit
- CVE system (Common Vulnerabilities and Exposures)
- Common Weakness Enumeration (CWE)
- Common Vulnerability Scoring System
- Coordinated vulnerability disclosure
- Bug bounty (vulnerability rewards) programs
- Exploit and zero-day markets (white, gray, black)
- Security patch
- Fuzzing
- Exploit Prediction Scoring System
- Exploit mitigation (ASLR, canaries, CFI)
- Cyberwarfare
- Supply chain security
- Penetration testing
represents (1)
Kinds (13)
- Software bug
- Memory-safety vulnerability (buffer overflow, use-after-free, dangling pointer)
- Input validation and injection (SQL injection, cross-site scripting, command injection)
- Race condition
- Access-control and authentication failures (privilege escalation)
- Configuration vulnerability
- Business logic vulnerability
- Hardware security bug
- Zero-day vulnerability
- Disclosed (n-day, half-day) and zombie vulnerabilities
- Dependency (supply-chain) vulnerability
- Carrier, dormant and active vulnerabilities
- Passé and reincarnated vulnerabilities
Notes published science
- Zero-day attacks studied in real telemetry (18 zero-days, 11 million Windows hosts, 2008-2011) stayed hidden 312 days on average (up to 30 months), and once the flaw was disclosed, attacks using it rose by up to five orders of magnitude, most likely through reuse of field-proven exploits in other malware (src:bilge-dumitras-2013). A decade earlier, CERT/CC's data showed the same surge waiting for something else: incidents peaked when a script for the exploit appeared, not at disclosure, though patches already existed (src:browne-2000-trend).
- Biology has the same bug and the same patch: male sea lamprey release a pheromone that mimics the larval cue females follow upstream (a 'sensory trap', like a program that trusts its input), and females evolved an antagonist that lets them tell the mimic from the real cue (src:buchinger-2020-lamprey).
- Vulnerabilities decay like radioactive atoms: lifetimes in code are exponential, about 4 years on average, so Android cut memory-safety flaws from 76% to 24% of its vulnerabilities in six years by writing only new code in memory-safe languages, without rewriting the old (src:alexopoulos-2022-lifetimes; src:google-2024-android-memsafe). The lifetimes are measured on vulnerabilities that got a CVE and a fixing commit; many never get a CVE (Alexopoulos et al.'s own caveat).
- A new release enjoys a 'honeymoon': the first vulnerability comes markedly later than the second, the second later than the third (median 110 days over 700 releases), and reusing old code shortens it, because what sets the pace is attackers' familiarity, not code quality (src:clark-2010-honeymoon). Old code gets safer (Google), yet familiar code gets found faster: two clocks on one system.
Layers
The ways it takes in its world, where they meet, and how it acts back, each from L1 (where it meets the world) up.
software vulnerability as vulnerability researchers describe it: flawed code and the inputs that reach it, up to the fix or the attack (reader's view)
- L1: Code and the inputs that reach it: software and hardware as written, shipped and running, and the bytes that cross into them
- L2: The flaw: a weakness in design, implementation, configuration or hardware behaviour, of a kind (memory safety, input validation, race condition, access control...)
- L3: Reachable and triggerable: active while the code runs; an input that crosses a trust boundary can make it misbehave; an exploit
- L4: Discovery: known to the vendor, a researcher or an attacker
- L5: Disclosure and coordination: secret, sold, reported, published; a CVE identifier assigned
- L6: The shared record and scores: CVE, CWE, CVSS, NVD, EPSS
- L7: Ended or used: remediated, mitigated, accepted, or exploited; dead when patched or retired
the boardroom (shared floors)
- L4: Discovery: the flaw known to someone: the vendor, a third party or an attacker; which came first often cannot be told
- L5: Disclosure and coordination: kept secret, sold or used; or reported to the vendor and published fully or after a fix (coordinated disclosure); a CVE identifier assigned by a CVE Numbering Authority
- L6: The shared record and its scores: the CVE entry (more than 327,000 records by April 2026: a count of records issued, shaped by CNA policy, e.g. the Linux kernel assigning a CVE to any bug fix it identifies), its CWE root cause, CVSS severity (0.0-10.0; v4.0 since November 2023 adds Threat metrics for proof-of-concept code or active exploitation), the NVD (a backlog of unenriched CVEs from early 2024), exploitation probability (EPSS) and CISA's catalogue of known exploited vulnerabilities (KEV)
- L7: Action back on the world: remediate (patch), mitigate, accept residual risk, disable; or exploit, stockpile, sell; the vulnerability ends when patched or removed from use
way in: Automated and AI-assisted discovery: continuous fuzzing, agents
- L1: Open-source projects enrolled in continuous fuzzing (OSS-Fuzz: over 10,000 vulnerabilities and 36,000 bugs across 1,000 projects by August 2023)
- L2: Coverage-guided fuzzers with sanitizers, and since 2024 language-model agents reading code (Big Sleep)
- L3: A flaw found and reported, sometimes before release: SQLite's fixed the same day
way in: Dependencies: flaws inherited from packages
- L1: Reusable packages shared through language-specific distributions; common code is better known to attackers
- L2: Declared dependencies, direct and indirect (a chain of length 2 or longer)
- L3: The dependent exposed: a vulnerability in npm affects a median of 30 releases
way in: Fuzzing: random inputs, watched for crashes
- L1: Random or mutated inputs and command-line parameters generated automatically
- L2: The program run under a monitor
- L3: Crashes flagged and debugged (25 to 33 percent of Unix utilities crashed in 1988-90)
way in: Hardware: flaws under the software
- L1: Microprocessors from Intel, AMD and ARM used in billions of devices
- L2: Speculative execution: guessed paths executed early for performance, discarded if wrong
- L3: Software's security assumptions violated (process separation, containers, JIT, side-channel countermeasures)
way in: Inputs across a trust boundary
- L1: Input that crosses a trust boundary: a network message, an uploaded file
- L2: Parsed by the receiving code (Heartbleed: the HeartbeatRequest's payload length field read without a bounds check)
- L3: The flaw triggered: memory read or overwritten, unintended behaviour (up to ~64 KB returned per request)
way in: Law, liability and disclosure policy
- L1: Laws and guidelines: no law requiring disclosure; the Dutch NCSC guideline (2013); US guidelines (2017)
- L2: Prosecutors take the guideline as a decision framework
- L3: The finder's and vendor's exposure: cease-and-desist letters, prosecution when a discloser 'went too far', and vendors seldom liable
way in: Money: rewards and prices
- L1: Rewards and prices: Chrome bounties from $500 to $31,336; zero-day exploits may exceed $100,000; value crashes once known
- L2: Programmes and markets: vendor VRPs, platforms such as HackerOne, brokers, gray and black markets (estimated ten times the white market, 2015)
- L3: Researchers drawn in and switching: new programmes attract researchers at the expense of old ones
- L4: The finder's choice to report or to sell, weighed against uncertainty
way in: New code: flaws written in
- L1: Code written by developers under deadlines and in large, complex code bases; 'ship it on Tuesday and get it right by version 3'
- L2: A weakness introduced, of a CWE kind. Across the 31,770 CVE records of 2024 the top-ranked kinds are cross-site scripting (CWE-79), out-of-bounds write (CWE-787) and SQL injection (CWE-89); in large C/C++ code bases memory-safety mistakes dominate (about 70% of Chromium's high-severity bugs; ~70% of the vulnerabilities Microsoft assigns a CVE each year)
- L3: Shipped and running: carrier before configured, dormant, active while the code runs
way in: Patches read backwards
- L1: A patch released for a vulnerability
- L2: Reverse engineered by attackers
- L3: The underlying flaw located on still-unpatched machines (half-days, zombie vulnerabilities)
way in: Reading the code: review, static analysis, penetration tests
- L1: Source text and running systems put in front of reviewers and testers
- L2: Code review and static analysis tools; penetration tests that try to enter via exploits
- L3: A suspected flaw, or none found (which does not prove the system secure)
way in: Telemetry: exploitation seen in the field
- L1: Files and traffic on hosts: 32 billion reports on about 300 million files from 11 million hosts (WINE)
- L2: Antivirus signatures and reputation data collected; network traces
- L3: Matched back to vulnerabilities after the fact: 11 of 18 zero-days not previously known as such
way in: Third-party reports
- L1: A finder outside the vendor writes up the flaw
- L2: Received through a disclosure policy or rewards programme (28% of Chrome's and 24% of Firefox's patched vulnerabilities came through VRPs)
- L3: Rated by the vendor's severity guideline (a critical bug runs arbitrary native code)
way out: Change how new code is written
- L1: Fewer memory-safety flaws written in: 76% of Android vulnerabilities in 2019, 24% in 2024
- L5: New code written in memory-safe languages
- L7: Decision to change development practice (Safe Coding for new code)
way out: Exploit
- L1: The machine does what its makers did not intend: memory read, code injected, service denied
- L3: Delivered as crafted input; harmless vulnerabilities chained into access
- L5: Scripted and published: the exploit becomes a rote exercise that attackers without the skill can run; in CERT/CC data 1996-1999 incidents surged after the script appeared, not after disclosure
- L7: Decision to exploit, alone or chained
way out: Mitigate: make exploitation of a class harder
- L1: The running machine changed: memory segments placed at random, data made non-executable
- L3: Exploitation of the whole memory-corruption class made much harder, not ended: code reuse (ROP) and information leaks bypass the deployed protections
- L5: Protections built into compilers and operating systems (stack cookies, exception handler validation, Data Execution Prevention, ASLR); deployed only when their overhead is in reasonable bounds
- L7: Decision to mitigate: measures that do not close the flaw but make it harder to exploit
way out: Patch and deploy
- L1: The code on machines changed (or not): of sites still vulnerable at 48 h, 10% replaced certificates within a month and 14% of those kept the old key
- L3: Released and deployed: the Alexa Top 100 patched within 24 h for Heartbleed; patching plateaued after about two weeks
- L5: The patch written: security commits are small (median 7 lines against 16 for other fixes); some first patches are incomplete or regressive
- L7: Decision to remediate
way out: Publish and notify
- L1: Read by administrators and users (and by attackers)
- L5: Operators notified (Heartbleed: 150,000 hosts; a 47% increase in patching by notified operators)
- L6: The CVE record and advisory published
way out: Sell or stockpile
- L1: Money paid: remote zero-click exploits the dearest
- L4: Through brokers and markets that lack transparency
- L7: Kept, used, stockpiled or sold; governments may also notify the vendor