The VR Workflow
Introduction to Vulnerability Research · VR Foundations track
8 min read
In this module
From Target Selection to Disclosure
Vulnerability research is a process built from many techniques. Experienced researchers follow a structured workflow that moves from broad target analysis through focused investigation to a verified proof-of-concept, then on to responsible reporting. This lesson walks through that end-to-end workflow.
Phase 1: Target Selection
Every research project starts with choosing what to investigate. This decision is driven by several factors:
Impact potential - vulnerabilities in widely-deployed software affect more users. A bug in OpenSSL, the Linux kernel, or Chrome has orders of magnitude more impact than a bug in a niche tool. Bug bounty programs often reflect this: critical bugs in major products command the highest payouts.
Attacker reachability - network-accessible services are higher priority than local-only tools because they can be exploited remotely. Within network services, unauthenticated attack surfaces are most critical because any attacker on the network can reach them.
Prior research - check what has already been found. If a component has a long history of similar vulnerabilities, there are probably more (variant analysis). If it has never been audited, it might be low-hanging fruit. CVE databases, security advisories, and conference presentations reveal what has been studied.
Your expertise - play to your strengths. If you are strong in memory corruption, target C/C++ codebases. If you understand web protocols deeply, target web servers and proxies. Expertise in the target domain dramatically speeds up analysis.
# Research prior CVEs for a target# Search the National Vulnerability Databasecurl -s "https://services.nvd.nist.gov/rest/json/cves/2.0?keywordSearch=libpng" | \ python3 -c "import sys,json; d=json.load(sys.stdin); \ [print(v['cve']['id'], v['cve']['descriptions'][0]['value'][:80]) \ for v in d.get('vulnerabilities',[])]"Phase 2: Reconnaissance
With a target selected, gather information before diving into analysis:
Build the software - compile from source with debug symbols and sanitizers (as covered in the previous lesson). If closed-source, obtain the binary and any available symbol packages.
Read the documentation - understand what the software does, what inputs it processes, and what protocols it implements. Documentation reveals the developer's mental model, which often differs from the actual implementation.
Study the architecture - identify major components, their responsibilities, and how they communicate. For open-source projects, README files, architecture documents, and developer mailing lists provide this context.
Review past vulnerabilities - read the patches for every previous CVE in your target. Each one tells you something about the codebase's weaknesses. If the project has had three heap overflows in its TIFF parser, there might be a fourth.
Phase 3: Analysis
This is where the actual bug-hunting happens. Analysis combines several techniques, typically in parallel:
Manual code review - read the source code with a focus on the high-value areas identified during attack surface analysis. Look for patterns: unchecked return values, missing bounds checks, arithmetic that could overflow, data that crosses trust boundaries without validation. Source Code Auditing covers this in depth.
Fuzzing - automated input generation to find crashes. Set up a fuzzer (AFL++, libFuzzer, or Honggfuzz) targeting the input parsing code. Let it run while you do manual review - fuzzing and manual analysis complement each other beautifully. Advanced Fuzzing Techniques covers this in depth.
Dynamic analysis - run the target under instrumentation tools. Use Valgrind, AddressSanitizer, or DynamoRIO to detect memory errors during normal operation or while processing test inputs. Dynamic Analysis & Debugging for VR covers this in depth.
Static analysis - run automated tools (Coverity, CodeQL, Semgrep) to flag potential issues. Static analysis finds low-hanging fruit quickly but produces many false positives. Treat its output as leads to investigate, not confirmed vulnerabilities.
In practice, experienced researchers run fuzzing campaigns continuously while doing focused manual review of the most promising code areas in parallel. The fuzzer surfaces crashes that direct manual analysis; manual analysis reveals patterns that help narrow the fuzzer's focus. Each informs the other.
Drawn as a timeline, Phase 3 is several tracks running side by side, with findings passing between them:
Never do just one thing. While your fuzzer runs on a cluster, review source code for the same component. While waiting for a long analysis to complete, research the target's architecture documentation. Vulnerability research rewards breadth of approach - the insight that leads to a discovery often comes from combining information from multiple analysis techniques.
Phase 4: Proof-of-Concept Development
Finding a potential bug is not enough. You need a proof-of-concept (PoC) that reliably demonstrates the vulnerability. A good PoC serves multiple purposes:
- Confirms the bug is real - not a false positive from a tool or a misreading of the code
- Demonstrates the impact - shows what an attacker could actually do
- Enables the vendor to reproduce - they need to verify the bug and test their fix
- Documents the vulnerability - becomes part of the permanent record
A PoC should be minimal - the smallest possible input or sequence of actions that triggers the vulnerability. If you discovered a crash with a 10MB input file, minimise it to the few bytes that actually matter:
# Minimise a crashing input with AFL++'s afl-tminafl-tmin -i crash_input -o minimised_crash - ./target @@
# Or manually with binary search:# 1. Try the first half of the input# 2. If it still crashes, the bug is in the first half# 3. Repeat until minimalFor memory corruption bugs, the PoC should show the corruption clearly. Running under ASan provides an ideal diagnostic:
===================================================================12345==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x602000000014READ of size 4 at 0x602000000014 thread T0 #0 0x4a3b2c in parse_chunk /src/parser.c:142 #1 0x4a1234 in process_file /src/main.c:87 #2 0x7f... in __libc_start_main0x602000000014 is located 0 bytes after 20-byte region [0x602000000000,0x602000000014)allocated by thread T0 here: #0 0x... in malloc #1 0x4a3a00 in parse_chunk /src/parser.c:130This ASan report tells you exactly what happened (heap buffer overflow), where it happened (parser.c line 142), and the memory layout involved. This is the kind of evidence a PoC should produce.
Phase 5: Documentation and Reporting
A vulnerability report must be clear, complete, and actionable. The vendor needs to understand the bug, reproduce it, and develop a fix. A good report includes:
Summary - one or two sentences describing the vulnerability. "A heap buffer overflow in libfoo's PNG chunk parser allows remote code execution when processing a crafted PNG file."
Affected versions - specify exactly which versions are affected. Test against the latest release and, if possible, identify when the vulnerability was introduced by examining git history.
Technical details - explain the root cause. Show the vulnerable code, explain why it is wrong, and describe the conditions required to trigger it.
Proof-of-concept - include the minimal PoC along with exact reproduction steps. Specify the exact build configuration, operating system, and compiler version you tested with.
Impact assessment - describe what an attacker can achieve. Be specific: "arbitrary code execution," not just "security issue."
Suggested fix - if you can, suggest how to fix the vulnerability. This might be a specific code change or a general approach. Vendors appreciate this, though they will develop their own fix.
Timeline - state your disclosure timeline. "We plan to publish details 90 days from the date of this report, or when a patch is released, whichever comes first."
PoC Development Best Practices
The quality of your proof-of-concept reflects your professionalism and directly affects how quickly the vulnerability gets fixed:
Reproducibility - the PoC must work on a clean system with documented setup steps. Include exact software versions, compiler flags, and operating system details. If it only works with specific ASLR values or timing, document that.
Safety — a PoC should demonstrate the vulnerability without unnecessary damage. Popping a calculator (calc.exe or xcalc) is the time-honoured way to prove code execution. Don't include payloads that could actually harm systems.
Minimality - strip everything unnecessary. If the bug triggers with a 50-byte input, do not include megabytes of padding. A minimal PoC makes the root cause obvious.
Clarity - comment your PoC code extensively. Label each part of the payload: "bytes 0-63: fill buffer to return address offset," "bytes 64-71: ROP gadget address for stack pivot." Anyone reading the PoC should understand the exploit logic.
Coordinated Disclosure in Practice
The actual disclosure process involves communication, negotiation, and sometimes frustration:
-
Initial contact - find the vendor's security contact. Look for a
security.txtfile, a SECURITY.md in the repository, or a security@ email address. If none exists, try the general contact. -
Encrypted communication — use PGP/GPG for the initial report. Include your public key so the vendor can respond securely. Plaintext email containing vulnerability details is an unnecessary risk.
-
Acknowledgment - expect acknowledgment within a few business days. If you do not hear back within a week, try alternative contacts.
-
Coordination - work with the vendor on timeline. 90 days is standard, but extensions are sometimes granted for complex fixes. Be firm but reasonable.
-
Verification - when the vendor provides a patch, verify that it actually fixes the vulnerability. It is not uncommon for initial patches to be incomplete.
-
Publication - when the patch is released, publish your advisory. Include enough detail for the security community to understand the issue, but consider whether full exploit code is necessary or if a crash PoC suffices.
Vulnerability research is a field where reputation matters enormously. Clean, well-documented reports build trust with vendors and earn respect from the community. Researchers known for quality work get invited to private bug bounty programs, asked to speak at conferences, and offered positions at top security firms. Your report quality is your professional calling card.