Skip to main content
Be Bitwise

What Is Vulnerability Research?

Introduction to Vulnerability Research · VR Foundations track

8 min read

In this module

The Discipline of Finding Bugs That Matter

Throughout this course you've learned how software works at the lowest levels — binary representations, memory layouts, assembly instructions, how exploits corrupt program state. Vulnerability research (VR) is the discipline of systematically finding security flaws before attackers do. It's the bridge between understanding how exploits work and actually discovering the bugs that make them possible.

VR isn't the same as penetration testing. A penetration tester uses known exploits and existing techniques against a target. A vulnerability researcher discovers new, previously unknown flaws — the zero-days that pen testers work with after the fact. That distinction matters: VR requires deep internal knowledge of how software works, not just fluency with existing attack tooling.

Motivation: Offensive and Defensive

People do vulnerability research for different reasons, and the motivation shapes the approach:

Defensive researchers work for software vendors, security companies, or as independent contributors. Their goal is to find and fix vulnerabilities before attackers discover them. Google's Project Zero, for example, hunts for bugs in widely-used software and reports them to vendors with a 90-day disclosure deadline. The bugs they find get patched, protecting millions of users.

Offensive researchers work for government agencies, military contractors, or companies that sell exploits. Their goal is to find vulnerabilities that can be weaponized - turned into reliable exploits for intelligence gathering, law enforcement, or military operations. The same technical skills apply, but the bugs are kept secret rather than reported.

Bug bounty hunters occupy a middle ground. Companies like Google, Microsoft, and Apple pay researchers who report vulnerabilities in their products. Payouts range from hundreds to hundreds of thousands of dollars depending on severity. This creates a legitimate market for vulnerability information that competes with the underground exploit market.

The Economics of Vulnerabilities

A critical remote code execution vulnerability in a major browser might fetch $100,000 through a bug bounty program, but potentially millions on the underground market. This price differential is one of the central tensions in vulnerability research - the same skills and discoveries have vastly different value depending on who receives them.

Bug Classes: A Taxonomy of Flaws

You have already studied several bug classes in detail: stack buffer overflows, heap vulnerabilities, use-after-free, integer overflows, and format string bugs. These are all memory corruption vulnerabilities - they break the assumptions the program makes about its own memory.

But vulnerability research spans a much wider landscape:

Memory corruption remains the most dangerous class because it typically leads to arbitrary code execution. Buffer overflows (stack and heap), use-after-free, double-free, type confusion, and uninitialised memory reads all fall here. You studied these in Stack-Based Buffer Overflows through Integer Overflows & Type Confusion.

Logic bugs are flaws in the program's reasoning rather than its memory safety. Authentication bypasses, authorisation failures, race conditions, and incorrect state machine transitions are logic bugs. They can be just as severe as memory corruption - an authentication bypass gives an attacker access without needing to corrupt anything.

Information disclosure vulnerabilities leak sensitive data. Out-of-bounds reads, uninitialised memory exposure, and side-channel leaks can reveal encryption keys, memory layouts (defeating ASLR), or private user data.

Denial of service vulnerabilities crash or hang a system. While less glamorous than code execution, a DoS against critical infrastructure can have massive real-world impact. Algorithmic complexity attacks (ReDoS, hash flooding), resource exhaustion, and null pointer dereferences fall here.

Injection vulnerabilities occur when untrusted data is interpreted as code or commands. SQL injection, command injection, and cross-site scripting (XSS) are classic examples. These are more common in web applications but also appear in system software that constructs commands from user input.

The Vulnerability Lifecycle

Every vulnerability follows a lifecycle from the moment it is created (when flawed code is written) to the moment it is neutralised (when all affected systems are patched):

Introduction — a developer writes code containing a flaw. Could be years, even decades, before anyone notices. Some vulnerabilities in widely-used libraries have been lurking for 10+ years before discovery.

Discovery — a researcher (or attacker) finds it through manual review, fuzzing, static analysis, or sheer accident. The discoverer now holds information with real security implications.

Triage — assess the severity. Remote exploitation? Authentication required? What's the actual impact? This determines urgency and CVSS scoring.

Reporting — under coordinated disclosure, the discoverer notifies the vendor privately with a proof-of-concept, reproduction steps, and a proposed timeline.

Patching — the vendor develops, tests, and ships a fix. Days to months, depending on complexity and release cadence. During this window the vulnerability exists but isn't yet public.

Disclosure — details go out: vendor advisory, researcher blog post, conference talk. The security community can verify the fix and develop detection signatures from the root cause.

Remediation — end users apply the patch. Often the slowest phase. Even after a fix is available, many systems stay unpatched for months or years — which is why vulnerability management programmes exist.

The stages matter most for the windows between them. Users are exposed for the whole span below, but who knows about the bug changes as you move along it:

That last window is the one attackers like best. Once the advisory is out, the patch itself shows where the bug is, and unpatched systems are easy to find.

The CVE System

The Common Vulnerabilities and Exposures (CVE) system provides a standardised identifier for every publicly known vulnerability. When you see "CVE-2024-1234," you are looking at a unique, globally recognised reference to a specific security flaw.

CVE identifiers are assigned by CVE Numbering Authorities (CNAs) — organisations authorised by the CVE Program (which MITRE operates) to issue CVE IDs. Major vendors (Microsoft, Google, Apple, Red Hat) are CNAs for their own products. Independent researchers typically request IDs through MITRE directly, or through a CNA that covers the affected product.

A CVE record includes a description of the vulnerability, affected products and versions, and references to advisories and patches. A CVSS score is optional: some CNAs include one, many don't, and databases such as NIST's National Vulnerability Database (NVD) often add their own score later. So the score you see on NVD may not be the one the vendor gave, and the two can disagree.

CVSS Scoring

The Common Vulnerability Scoring System (CVSS) assigns a numerical severity score from 0.0 to 10.0 based on standardised metrics. The metrics below are the version 3.x base metrics, still the ones you'll see on most records:

Attack Vector — how the attacker reaches the vulnerable component. Network-accessible vulnerabilities score highest; physical access requirements lowest.

Attack Complexity — what conditions beyond the attacker's control must exist. Low complexity (the attack works reliably) outscores high complexity (requires a race condition win or specific configuration).

Privileges Required — what access level the attacker needs before exploitation. No privileges required scores highest.

User Interaction — whether a victim must take some action (click a link, open a file). No interaction needed scores higher.

Impact metrics - how the vulnerability affects confidentiality, integrity, and availability of the target system. Each is rated None, Low, or High.

A CVSS score of 9.0+ is "Critical" - think remote code execution with no authentication required. A score of 7.0-8.9 is "High", 4.0-6.9 is "Medium", and anything from 0.1 to 3.9 is "Low." These scores drive patching priorities across organisations worldwide.

CVSS v4.0, published by FIRST in November 2023, keeps the same 0-10 scale and severity bands but reshuffles the metrics. It adds Attack Requirements alongside Attack Complexity, splits User Interaction into None, Passive and Active, and scores impact separately on the vulnerable system and on any subsequent systems it affects. Always check which version a score uses before comparing two of them.

Responsible Disclosure vs. Full Disclosure

The security community has debated disclosure practices for decades. Two philosophies dominate:

Coordinated (responsible) disclosure means notifying the vendor privately and giving them a reasonable window - typically 90 days - to develop a patch before publishing details. Google Project Zero popularized the strict 90-day deadline: if the vendor has not patched within 90 days, details go public regardless. This approach balances giving vendors time to fix issues while preventing indefinite secrecy.

Full disclosure means publishing vulnerability details immediately, without advance notice to the vendor. Proponents argue that this is the fastest way to protect users: once details are public, administrators can implement workarounds and pressure vendors to patch quickly. Critics argue that it gives attackers a head start before patches are available.

Most professional researchers today practise coordinated disclosure, but the debate hasn't settled. The underlying principle is clear: users deserve to know about vulnerabilities affecting them. The disagreement is purely about when and how.