Comprehensive, hands-on attack and defense guides covering real-world exploitation mechanics, testing methodologies, payload construction, and deterministic remediation across web and cloud architectures.
The Vulnerability Explain collection is SecurityCipher's structured reference library designed for penetration testers, security engineers, bug bounty researchers, and developers. Each guide provides a deep technical dive into how a specific vulnerability operates at the protocol, language, and runtime layers, coupled with manual testing techniques, automated tooling, concrete payload examples, vulnerable versus secure source code comparisons, and verifiable defensive architectures.
Authorized Testing Scope Notice: All techniques, payloads, and testing methodologies documented in this section must be executed strictly against systems you own or have explicit, documented authorization to assess. Conducting unauthorized testing against third-party systems is illegal and violates computer crime legislation worldwide.
Vulnerability Categorization Matrix
To facilitate rapid navigation during assessments and threat modeling, our 40 comprehensive vulnerability guides are organized across six primary technical domains:
1. Injection Flaws
- SQL Injection (SQLi) - Manipulating backend database queries through unvalidated user input.
- NoSQL Injection - Subverting document-store queries in MongoDB, CouchDB, and DynamoDB.
- Remote Code Execution (RCE) and Command Injection - Shell command execution via unsafe process invocation.
- Server-Side Template Injection (SSTI) - Code execution via server-side template engine interpolation.
- XML External Entity (XXE) Injection - Arbitrary file disclosure and SSRF via insecure XML entity parsing.
- LDAP and XPath Injection - Manipulating directory service and XML structure queries.
- CRLF Injection and HTTP Response Splitting - Header injection and cache poisoning via carriage-return line-feed sequences.
- Server-Side JavaScript Injection (SSJI) - Dynamic code evaluation escapes in Node.js backends.
2. Broken Access Control and Authorization
- Insecure Direct Object References (IDOR) - Horizontal and vertical privilege escalation via unvalidated object keys.
- Broken Access Control - Flaws in role enforcement, administrative route protection, and capability checks.
- API Security and Mass Assignment - Modifying internal object properties via unchecked payload binding.
- GraphQL Security - Query complexity attacks, introspection abuse, and authorization bypasses.
3. Authentication and Session Management
- Authentication and JWT Bypass - Algorithm confusion, key disclosure, and signature verification flaws in JSON Web Tokens.
- OAuth 2.0 and OpenID Connect (OIDC) Vulnerabilities - Redirect URI hijacking, state parameter omission, and authorization code theft.
- Session Fixation - Forcing victim sessions to adopt pre-determined identifiers.
4. Server-Side and Cloud Infrastructure
- Server-Side Request Forgery (SSRF) - Forcing backend servers to make unauthorized intranet requests.
- Cloud Metadata and IAM Credential Theft (Cloud SSRF) - Stealing temporary cloud credentials via link-local IMDS endpoints.
- Local File Inclusion (LFI) and Path Traversal - Directory traversal and sensitive file access via relative path manipulation.
- Remote File Inclusion (RFI) - Loading and executing remote server-side scripts.
- Insecure Deserialization - Object injection and gadget chain execution in serialized byte streams.
- HTTP Request Smuggling - Exploiting frontend and backend parsing discrepancies in Content-Length and Transfer-Encoding.
- Web Cache Poisoning - Injecting malicious HTTP headers to serve cached exploits to all users.
- Host Header Injection - Password reset poisoning and web cache manipulation via untrusted Host headers.
5. Client-Side and Frontend Security
- Cross-Site Scripting (XSS) - Reflected, Stored, and DOM-based arbitrary JavaScript execution in victim browsers.
- Cross-Site Request Forgery (CSRF) - Tricking authenticated browsers into submitting unauthorized state-changing requests.
- Cross-Site WebSocket Hijacking (CSWSH) - Bypassing Same-Origin Policy to hijack real-time bidirectional WebSocket streams.
- Client-Side Template Injection (CSTI) - Executing code via client framework compilers (AngularJS, Vue) inside the DOM.
- Clickjacking - UI redressing attacks tricking users into clicking hidden actionable frames.
- CORS Misconfiguration - Overly permissive Cross-Origin Resource Sharing headers leaking confidential data.
- Open Redirection - Unvalidated redirect parameters facilitating credential phishing.
- Prototype Pollution - Modifying Object.prototype in JavaScript runtimes leading to property injection and RCE.
6. Application Logic, Data and Configuration
- Business Logic and Race Condition Vulnerabilities - Exploiting timing windows and flawed business assumptions.
- HTTP Parameter Pollution (HPP) - Subverting WAF filters and backend logic through duplicate HTTP parameters.
- Unrestricted File Upload - Remote code execution through executable file uploads and extension bypasses.
- Information Disclosure and Exposed Sensitive Endpoints - Exposed .git, .env, and actuator diagnostic routes.
- Security Misconfiguration - Default passwords, unhardened HTTP security headers, and verbose error messages.
- Sensitive Data Exposure and Insecure Cryptographic Storage - Weak encryption algorithms and cleartext storage.
- Vulnerable and Outdated Components - Supply chain risks and unpatched third-party software packages.
- Subdomain Takeover - Claiming dangling DNS CNAME records pointing to decommissioned third-party cloud services.
- Application-level Denial of Service (DoS) - Resource exhaustion via algorithmic complexity and unbounded payload consumption.
Standard 5-Step Vulnerability Assessment Lifecycle
Every guide in this library adheres to a structured, repeatable security assessment methodology that bridges the gap between offensive discovery and defensive remediation:
- Step 1: Reconnaissance and Surface Mapping
- Enumerate all endpoints, HTTP methods, headers, parameters, cookies, WebSockets, and third-party integrations.
- Establish trust boundaries between client, gateway, microservices, and external identity providers.
- Step 2: Vector Analysis and Controlled Fuzzing
- Submit targeted diagnostic probes (mathematical expressions, boundary delimiters, polyglot characters) to identify parser behavior.
- Monitor server response times, HTTP status codes, error details, and out-of-band network traffic.
- Step 3: Contextual Proof of Concept Crafting
- Develop minimal, non-destructive proofs of concept demonstrating tangible business impact.
- Account for environmental constraints such as WAF signatures, encoding layers, and browser security models.
- Step 4: Blast-Radius and Impact Verification
- Quantify the exact scope of exposure: determine whether the vulnerability permits horizontal data access, vertical privilege escalation, or lateral network movement.
- Calculate standardized CVSS 3.1 / 4.0 severity scores based on verified attack complexity and impact.
- Step 5: Deterministic Remediation and Regression Testing
- Implement architectural and code-level mitigations (parameterization, strict input validation, contextual output encoding, least-privilege configurations).
- Write automated regression test cases in CI/CD pipelines to ensure the vulnerability cannot resurface in subsequent releases.
Explore Related Security Resources
Enhance your testing workflow and practical knowledge with our companion toolkits and reference material:
- Security Checklists Hub - Actionable, checklist-driven testing guides for web, API, cloud, and mobile penetration testing.
- Interactive Security Quizzes - Test and validate your offensive and defensive security expertise with realistic scenario-based quizzes.
- Secure Code Explain - Language-specific deep dives into building hardened, secure-by-default software applications.
- Penetration Testing Tricks - Practical cheat sheets, payload lists, and bypass techniques for modern engagements.
- AI, LLM, MCP and Agent Security - Dedicated guide suite for red-teaming and securing LLMs, RAG pipelines, and autonomous agents.
Articles
- Cross-Site-Scripting (XSS)
- Server-Side Request Forgery (SSRF)
- SQL Injection
- Insecure Direct Object References (IDOR)
- XML External Entity (XXE) Injection
- Remote Code Execution (RCE) and Command Injection
- Local File Inclusion (LFI) and Path Traversal
- Insecure Deserialization
- Open Redirection
- Authentication and JWT Bypass
- Server-Side Template Injection (SSTI)
- Remote File Inclusion (RFI)
- NoSQL Injection
- LDAP and XPath Injection
- CRLF Injection and HTTP Response Splitting
- Host Header Injection
- HTTP Request Smuggling
- Broken Access Control
- Session Fixation
- Clickjacking
- CORS Misconfiguration
- Unrestricted File Upload
- Security Misconfiguration
- Sensitive Data Exposure and Insecure Cryptographic Storage
- Business Logic and Race Condition Vulnerabilities
- GraphQL Security
- API Security and Mass Assignment
- Subdomain Takeover
- Prototype Pollution
- Web Cache Poisoning
- Vulnerable and Outdated Components
- Application-level Denial of Service (DoS)
- Cross-Site Request Forgery (CSRF)
- OAuth 2.0 and OpenID Connect (OIDC) Vulnerabilities
- Cross-Site WebSocket Hijacking (CSWSH)
- HTTP Parameter Pollution (HPP)
- Client-Side Template Injection (CSTI)
- Information Disclosure and Exposed Sensitive Endpoints
- Server-Side JavaScript Injection (SSJI)
- Cloud Metadata and IAM Credential Theft (Cloud SSRF)