VULNERABILITY ASSESSMENT
What Is Vulnerability Assessment?
A vulnerability assessment is the systematic process of:
- Identifying potential security weaknesses
- Understanding why they exist
- Determining whether they are actually exploitable
- Assessing their impact
- Prioritizing them
- Recommending remediation
- Retesting after the fix
The workflow:
TARGET ↓ DISCOVER ASSETS ↓ IDENTIFY SERVICES ↓ FIND POSSIBLE WEAKNESSES ↓ VALIDATE ↓ ASSESS IMPACT ↓ PRIORITIZE ↓ REMEDIATE ↓ RETEST
Vulnerability vs Threat vs Risk
These three terms are often confused.
Vulnerability
A weakness.
Example:
Improper authorization check
Threat
Something capable of taking advantage of the weakness.
Example:
Attacker
Risk
The potential consequence of the vulnerability being exploited.
Example:
Unauthorized access to customer information
Think:
Vulnerability + Threat ↓ Potential exploitation ↓ Impact ↓ RISK
What Can Be Vulnerable?
Almost anything.
Network
Open services Weak protocols Firewall misconfiguration Exposed management interfaces
Operating System
Unpatched software Weak permissions Insecure services Misconfigurations
Web Application
SQL Injection XSS Broken Access Control Authentication problems File Upload issues SSRF Security misconfiguration
API
Broken authorization Excessive data exposure Weak authentication Improper input validation
Cloud
Public storage Weak IAM Exposed credentials Misconfigured services
Vulnerability Assessment vs Exploitation
This distinction is critical.
Suppose you find:
Apache version X
A vulnerability scanner says:
Possible CVE
You don't immediately say:
“The server is hacked.”
You investigate.
Potential vulnerability ↓ Is the affected version actually present? ↓ Is the vulnerable feature enabled? ↓ Does the vulnerability apply to this configuration? ↓ Can it be safely reproduced?
This is validation.
CVE — Common Vulnerabilities and Exposures
You'll encounter CVE constantly in cybersecurity.
A CVE is a standardized identifier for a publicly known vulnerability.
Example format:
CVE-202X-XXXXX
A CVE entry may describe:
Affected software Affected versions Vulnerability type Technical description References
But remember:
A CVE number alone doesn't prove that your target is vulnerable.
CVSS — Severity Scoring
CVSS helps organizations estimate vulnerability severity.
A simplified interpretation:
0.0 None 0.1–3.9 Low 6.9 Medium 7.0–8.9 High 9.0–10.0 Critical
For example:
CVSS 9.8
sounds serious.
But severity still needs context.
A critical vulnerability on an isolated lab machine may have less business impact than a medium vulnerability exposing sensitive production information.
Severity ≠ Business Risk
This is an important professional concept.
Imagine:
Vulnerability A
CVSS: 9.8 Affected: Unused internal test server
Vulnerability B
CVSS: 6.5 Affected: Production customer portal Impact: Customer data exposure
You can't automatically assume A is more important to the business.
Professional security teams consider:
Technical Severity + Exploitability + Asset Importance + Data Sensitivity + Business Impact ↓ Overall Risk
Common Vulnerability Categories
You should become familiar with these.
1. Broken Access Control
A user can access something they shouldn't.
Example:
User A ↓ /account/1001
changes the identifier:
/account/1002
and accesses another user's information.
2. Authentication Problems
Examples:
Weak authentication Improper session management Password reset weaknesses Missing MFA where required
3. Injection
Untrusted input reaches an interpreter or backend operation incorrectly.
Examples:
SQL Injection Command Injection LDAP Injection Template Injection
ross-Site Scripting — XSS
Untrusted input is interpreted as browser-side code.
Types include:
Reflected XSS Stored XSS DOM-based XSS
You'll study these deeply under Web Hacking.
5. Security Misconfiguration
Examples:
Default configuration Debug mode enabled Unnecessary services Excessive permissions Directory listing Verbose errors
6. Sensitive Information Exposure
Examples:
Credentials API keys Internal information Source code Sensitive configuration Personal information
7. File Upload Issues
For example:
Application ↓ Upload feature ↓ Insufficient validation
Potential consequences depend on the application's architecture and controls.
8. Server-Side Request Forgery — SSRF
A server is tricked into making a request to an unintended destination.
Conceptually:
Attacker ↓ Web Application ↓ Internal Resource
This can be especially important in cloud environments.
Automated Vulnerability Scanning
Now you start using specialized tools.
Common examples:
Nessus OpenVAS / Greenbone Nuclei Nmap NSE Nikto WPScan Burp Suite Scanner
Each has strengths and weaknesses.
Nmap Vulnerability Scripts
Nmap's scripting engine can help identify potential issues.
For example, you may encounter scripts categorized around:
discovery safe vuln auth default
A controlled lab example:
nmap --script vuln <LAB-IP>
But don't treat the output as absolute truth.
You may get:
Potential vulnerability
not:
Guaranteed successful exploitation
Nuclei
Nuclei is a popular template-based vulnerability scanner.
Conceptually:
Target ↓ Nuclei ↓ Templates ↓ Potential findings
Example against your authorized lab:
nuclei -u http://<LAB-IP>
You may discover things such as:
Missing security header Exposed endpoint Known vulnerable component Misconfiguration
Again:
Scanner finding → investigate → validate → report.
Nikto
Nikto focuses heavily on web-server checks.
Example:
nikto -h http://<LAB-IP>
It can identify potential:
Dangerous files Misconfigurations Interesting headers Known server issues Default resources
It's useful for learning, but it should not replace manual testing.
Nessus / OpenVAS
These are broader vulnerability-assessment platforms.
Their workflow is generally:
Target ↓ Discovery ↓ Service detection ↓ Plugin/check execution ↓ Potential vulnerabilities ↓ Risk rating ↓ Report
They can produce a large number of findings.
The skill isn't:
“Run Nessus.”
The skill is:
“Understand which findings are real, relevant, exploitable, and important.”
False Positives
This is one of the biggest problems with automated scanning.
Suppose:
Scanner: CRITICAL — Vulnerable software detected
You investigate and discover:
Reported version: X Actual version: Y Affected component: Not installed
Result:
FALSE POSITIVE
That's why professional testers manually verify important findings.
False Negatives
The opposite can happen.
A scanner may report:
No vulnerability detected
but the application may still be vulnerable.
Why?
Because scanners can miss:
Business logic flaws Complex authorization problems Custom application behavior Unknown vulnerabilities Context-dependent issues
This is why:
Automated Testing + Manual Testing
is much stronger than either alone.
Manual Vulnerability Assessment
This is where your Burp Suite skills become important.
Suppose you have:
GET /api/user?id=1001
You investigate:
What happens if id changes? 1001 → current user 1002 → another user?
You're testing the application's authorization logic.
A scanner may not understand the application's intended business rules.
You need to reason about them.
Think in Inputs and Trust Boundaries
Whenever you see user-controlled input:
URL parameter Form field Cookie Header JSON File upload API parameter
ask:
Where does this data go?
For example:
User Input ↓ Web Server ↓ Application ↓ Database
Potential questions:
Is input validated? Is it encoded? Is it authorized? Is it passed into a database? Is it passed to a command? Is it rendered in HTML? Is it used to access a file?
This mindset is extremely important for finding vulnerabilities.
Authentication vs Authorization
Don't confuse these.
Authentication
Who are you?
Example:
Username + Password ↓ Identity verified
Authorization
What are you allowed to do?
Example:
Normal User ↓ Can view own profile Admin ↓ Can manage users
A system can have strong authentication but terrible authorization.
Business Logic Vulnerabilities
These are particularly important.
Suppose an application has:
Buy Product Price = ₹1000
A developer may assume:
Frontend sends: price = 1000
If the server blindly trusts the client-controlled value, the application could have a business-logic flaw.
The important lesson:
Never assume frontend restrictions are security controls.
Security decisions should be enforced server-side.
Configuration Assessment
Not every vulnerability requires an exploit.
Example:
FTP ↓ Anonymous access enabled
Or:
Web server ↓ Directory listing enabled
Or:
Application ↓ Debug mode enabled
These are configuration weaknesses.
Your job is to determine:
What is exposed? Why is it a problem? Who can access it? What is the impact? How should it be fixed?
Credential Assessment
Credentials are another major area.
You may assess:
Password policy Authentication mechanisms MFA Account lockout Session management Credential storage Default credentials
In a lab, you can practice weak-password scenarios.
In a real engagement, credential testing must follow the explicit rules of engagement because aggressive authentication testing can lock accounts or disrupt services.
Vulnerability Validation
This is the heart of this topic.
Imagine a scanner reports:
Possible SQL Injection
Your process should be:
1. Identify affected parameter ↓ 2. Understand application behavior ↓ 3. Reproduce safely ↓ etermine whether input reaches SQL ↓ 5. Confirm security impact ↓ 6. Collect minimal evidence ↓ 7. Stop before unnecessary damage
Don't jump directly to destructive exploitation.
Evidence Collection
A professional finding needs evidence.
Useful evidence might include:
HTTP request HTTP response Screenshot Version information Configuration output Scanner result Reproduction steps
For example:
Request: GET /account/1002 Authenticated user: userA Response: Data belonging to userB
That is much stronger than:
“The application has IDOR.”
Vulnerability Report Structure
A good report might look like:
FINDING #01 Title: Broken Access Control Severity: High Affected Asset: https://lab.example/account/ Description: ... Technical Details: ... Steps to Reproduce: 1. 2. 3. Evidence: ... Impact: ... Remediation: ... Retest: Pending
Remediation
Your job isn't finished when you find the vulnerability.
You should understand how it can be fixed.
Example:
Problem
Application trusts user-supplied object ID.
Bad design
GET /account/1002 → directly return account 1002
Better design
Request account 1002 ↓ Authenticate user ↓ Check authorization ↓ Does user have permission? / \ YES NO ↓ ↓ Return Deny data
This is the type of explanation developers can act on.
Risk Prioritization
Imagine you discover 50 findings.
You can't necessarily fix all of them immediately.
Prioritize based on factors such as:
Severity Exploitability Exposure Asset importance Data sensitivity Business impact Likelihood Existing controls
For example:
CRITICAL Remote code execution on internet-facing server HIGH Broken authorization exposing customer data MEDIUM Missing security header LOW Information disclosure with minimal impact
Vulnerability Assessment Workflow
Memorize this:
TARGET │ ▼ ASSET DISCOVERY │ ▼ SERVICE DISCOVERY │ ▼ VULNERABILITY SCAN │ ┌─────────┴─────────┐ ▼ ▼ Finding No Finding │ ▼ VALIDATION │ ┌────┴─────┐ ▼ ▼ False True Positive │ ▼ IMPACT ANALYSIS │ ▼ PRIORITIZE │ ▼ REPORT │ ▼ FIX │ ▼ RETEST
🧪 Practical Lab — Vulnerability Assessment
Use OWASP Juice Shop, DVWA, Metasploitable, or another intentionally vulnerable environment.
Step 1 — Scan
nmap -sC -sV <LAB-IP>
Record:
Ports Services Versions
Step 2 — Web discovery
whatweb http://<LAB-IP>
Step 3 — Check web server
nikto -h http://<LAB-IP>
Step 4 — Nuclei
For a lab:
nuclei -u http://<LAB-IP>
Step 5 — Manual verification
Take one interesting finding and ask:
Is it real? Why does it happen? What component is affected? Can I reproduce it safely? What's the impact? How should it be fixed?
Step 6 — Document
Create:
vulnerability-report.md
with:
Title Severity Affected Asset Description Evidence Impact Remediation
🧠 Your Most Important Skill
Don't become:
“I know Nessus, Nuclei, Nikto and OpenVAS.”
Become:
“I can take a scanner finding and determine whether it is actually a security problem.”
For example:
Nuclei ↓ Possible vulnerability ↓ Understand technology ↓ Check affected version/configuration ↓ Manually reproduce ↓ Confirm ↓ Assess impact ↓ Report
That's real vulnerability-assessment skill.
🎯 Vulnerability Assessment Checklist
Before moving forward, you should understand:
- Vulnerability
- Threat
- Risk
- CVE
- CVSS
- False positives
- False negatives
- Automated scanning
- Manual validation
- Nmap NSE
- Nuclei
- Nessus
- OpenVAS/Greenbone
- Nikto
- Authentication
- Authorization
- Injection
- XSS
- Broken Access Control
- Security Misconfiguration
- Information Disclosure
- File Upload weaknesses
- SSRF concepts
- Business Logic vulnerabilities
- Evidence collection
- Risk prioritization
- Remediation
- Retesting
🔥 The progression so far
1. METHODOLOGY ↓ How a professional pentest works 2. RECONNAISSANCE ↓ What exists? 3. SCANNING ↓ What is reachable? ULNERABILITY ASSESSMENT ↓ What may be weak? ↓ Is it actually vulnerable? ↓ What is the impact?