Vulnerabilityassessment

12 min read2,201 words

VULNERABILITY ASSESSMENT

What Is Vulnerability Assessment?

A vulnerability assessment is the systematic process of:

  1. Identifying potential security weaknesses
  2. Understanding why they exist
  3. Determining whether they are actually exploitable
  4. Assessing their impact
  5. Prioritizing them
  6. Recommending remediation
  7. 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?

Keep learning. Keep building. Keep growing.

© 2026 Ugenz Academy