SSRF learning path

Orientation and first principles — what the bug class is and how it behaves.

1. Preventing server-side request forgery in Node.js applications
   7 min readsnyk.io2026
   Tool for preventing server-side request forgery (SSRF) in Node.js applications, detailing how attackers exploit input tampering and URL manipulation to make unintended server requests. It covers basic and blind SSRF types, referencing a significant Amazon breach. Mitigation strategies include using updated libraries, employing firewalls, sanitizing user input, enforcing URL schemas like HTTP/HTTPS, and creating allowlists for trusted domains, exemplified by code adjustments in an Express and Axios application.
2. PayloadsAllTheThings: Server Side Request Forgery
   7 min readgithub.com2026
   Library for Server Side Request Forgery (SSRF) vulnerabilities, detailing methodologies and bypass techniques. It covers bypassing localhost via IPv6 notation, domain redirects, CIDR, rare addresses, encoded IPs, and DNS rebinding. The library highlights exploitation via URL schemes like `jar:` and `gopher://`, blind exploitation, and offers tools such as `SSRFmap`, `Gopherus`, `See-SURF`, `SSRF-Sheriff`, `surf`, `ipfuscator`, and `r3dir` for testing and exploitation.
3. SSRF Explained: Attack Techniques and Real-World Exploits
   7 min readredfoxsec.com2026
   Library detailing Server-Side Request Forgery (SSRF) attack techniques, including exploiting cloud metadata endpoints on AWS, GCP, and Azure, bypassing blocklists with alternative IP representations and DNS rebinding, abusing URL schemes like `file://`, `dict://`, and `gopher://`, chaining open redirects, and accessing internal services like Kubernetes APIs and admin panels. It also covers blind SSRF, out-of-band detection, and exploitation via server-side PDF generation using `wkhtmltopdf`.
4. Server-Side Request Forgery (SSRF) | Invicti
   7 min readinvicti.com2026
   Library detailing Server-Side Request Forgery (SSRF), a vulnerability (CWE-918) allowing attackers to trick a server into sending unintended requests. This can expose sensitive data, internal networks, and cloud credentials, as seen in the Capital One breach. The library covers SSRF exploitation techniques, including accessing localhost, internal IPs, and cloud metadata services via HTTP/S, file schemas, and insecure XML parsing, contrasting it with CSRF and outlining prevention strategies like URL validation and protocol restriction.
5. Server-Side Request Forgery: What It Is & How To Fix It | Wiz
   8 min readwiz.io2026
   Library detailing Server-Side Request Forgery (SSRF) vulnerabilities, explaining how attackers trick servers into making requests to internal resources like cloud metadata services and sensitive systems. It highlights SSRF's inclusion in the OWASP Top 10 and CWE Top 25, with examples like the Capital One breach. The library emphasizes prevention through strict input validation, egress controls, API security best practices, and continuous API inventory management, referencing tools like SSRFire and ZAP for detection.

Real testing methodology, tooling, and writeups that show the work.

1. The HTTP 303 SSRF Hack : From Python HTTP Client Defaults to AWS Credential Exfiltration.
   13 min readinfosecwriteups.com2026
   Writeup detailing an HTTP 303 SSRF vulnerability that escalates to AWS credential exfiltration. This exploit chains a user-controlled `token_uri` field in BigQuery service account credentials, an HTTP client with default redirect handling, and the AWS Instance Metadata Service (IMDS). By configuring a server to respond with an HTTP 303 redirect, a POST request to IMDS is implicitly converted to a GET request, allowing the attacker to retrieve temporary IAM credentials for the Kubernetes worker node.
2. Catflix CTF: Exploiting SSRFs in Next.js Middleware
   5 min readintigriti.com2026
   Walkthrough of CVE-2025-57822 in Next.js Middleware, chaining SSRF to RCE via Jenkins. This article details exploiting a misconfiguration in Next.js middleware that allows processing of the `Location` header to perform server-side requests. The SSRF is then escalated by identifying an open Jenkins instance on port 8080, enabling command execution through its Groovy Script console to retrieve sensitive files, demonstrating a practical vulnerability exploitation chain.
3. DNS Rebinding Attacks Against SSRF Protections
   5 min readbehradtaher.dev2026
   Library for detecting and exploiting DNS rebinding vulnerabilities that bypass SSRF protections. It details how applications resolve hostnames once to validate IPs against blocklists or allowlists, and then resolve again to make the actual HTTP request. This Time-of-Check to Time-of-Use (TOCTOU) flaw allows attackers to control DNS responses, redirecting requests from public IPs to sensitive internal endpoints like AWS IMDS (169.254.169.254) or internal APIs. The library covers techniques and tools like rbndr.us and whonow for setting up controllable DNS servers with zero TTL, and discusses fixes such as resolving once and connecting directly to the IP, using egress proxies like Smokescreen, or implementing network-level controls.
4. Exploiting PDF Generators: Complete Guide to SSRF
   7 min readintigriti.com2026
   Guide to finding SSRF vulnerabilities in PDF generators, focusing on HTML-to-PDF conversion. It details how unsanitized user input can lead to HTML injection, enabling SSRF, Local File Disclosure (LFD), and other exploits. The guide provides payloads for both full and blind SSRF, including techniques using XHR, Fetch, meta tags, images, and SVG, and explores escalating SSRF in cloud environments targeting metadata endpoints. CVE-2023-33733 is cited as an example of injection leading to code execution.
5. Metabadger: Prevent SSRF via Automated IMDSv2 Upgrades
   7 min readgithub.com2026
   Tool for preventing SSRF attacks on AWS EC2 by automating upgrades to Instance Metadata Service v2 (IMDSv2). Metabadger diagnoses current IMDS usage, prepares instances for v2, enables mandatory session tokens and header checks, and can disable the service where unnecessary to reduce attack surface. It assists in identifying instances using IAM roles and provides commands to discover metadata service usage and harden configurations across regions, with options to exclude specific instances or perform dry runs.

Novel research, edge cases, and the techniques that push the class forward.

1. The Limitations of Secure SSRF Patches: Advanced Bypasses
   18 min readwindshock.github.io2026
   Library that analyzes Server-Side Request Forgery (SSRF) bypass techniques, demonstrating how common patches like prefix allowlisting and basic hostname validation fail against crafted payloads. It highlights vulnerabilities exemplified by the ChatGPT-Next-Web case, where naive checks for `https://trusted.com` were bypassed using `@` notation or subdomain tricks like `api.mycompany.com.evil.org`. The library emphasizes the need for defense-in-depth beyond superficial checks to prevent attackers from accessing internal networks or cloud instance metadata.
2. The Red Agent POV: How it Reasoned its Way to SSRF
   7 min readwiz.io2026
   Library that details a multi-step SSRF exploit against a GCP Cloud Run service. The exploit chains a GitHub URL validation bypass with a double-slash absolute path technique to read sensitive files like `/proc/self/environ` and application source code. The underlying methodology involves iterative attack strategy execution and reflection, focusing on path traversal and URL confusion techniques before the breakthrough bypass.
3. Hacking Next.js Targets: Advanced SSRF Exploitation Guide
   6 min readintigriti.com2026
   Guide detailing advanced Server-Side Request Forgery (SSRF) vulnerabilities in Next.js applications. It covers exploitation techniques targeting the Image component, Next.js Middleware (CVE-2025-57822), and Server Actions (CVE-2024-34351). The guide highlights how misconfigurations in these features can lead to arbitrary outbound requests and potential data leakage or remote code execution.
4. Exploiting SSRF in Cloud-Only Environments: A Deep Dive
   9 min readblog.nashtechglobal.com2026
   Walkthrough demonstrating SSRF exploitation in cloud environments like AWS and Azure. This deep dive details how attackers can leverage Server-Side Request Forgery to access sensitive metadata services, internal applications, and cloud functions by manipulating vulnerable endpoints. The guide utilizes tools such as Burp Suite and SSRFmap to showcase real-world attack scenarios, including retrieving AWS access keys and accessing internal admin panels, ultimately leading to potential data theft, privilege escalation, and system compromise.
5. MCPwnfluence: SSRF to RCE in Atlassian MCP Server (Pluto Security)
   10 min readpluto.security2026
   Library for securing Atlassian MCP Server, addressing vulnerabilities CVE-2026-27825 (arbitrary file write leading to RCE) and CVE-2026-27826 (SSRF via header injection). These flaws allow unauthenticated users on the local network to execute commands as root by chaining an SSRF vulnerability with an arbitrary file write, enabling overwriting critical files like `.bashrc` or `.ssh/authorized_keys`. The library includes fixes for path validation and SSRF protection, recommending immediate upgrades for affected versions below 0.17.0.
6. MCPwnfluence: Critical SSRF to RCE in mcp-atlassian (Pluto Security)
   10 min readblog.pluto.security2026
   Writeup of CVE-2026-27825 and CVE-2026-27826, detailing an unauthenticated SSRF to RCE attack chain in mcp-atlassian. The vulnerabilities, with CVSS scores of 9.1 and 8.2 respectively, allow network-reachable code execution as root by overwriting files or injecting SSRF payloads via Atlassian URL headers. Affecting versions prior to 0.17.0, the findings highlight risks in widely used MCP server deployments.
7. SSRF: Advanced Exploitation Guide
   8 min readintigriti.com2026
   Guide to advanced SSRF exploitation, this article details how to identify and exploit Server-Side Request Forgery vulnerabilities, including bypassing host and protocol whitelists, leveraging PDF generators, and understanding second-order SSRFs. It provides examples of bypass payloads and discusses how features like profile image loaders, webhook services, and request header processing can be vulnerable, referencing techniques like DNS rebinding and the PayloadsAllTheThings repository for advanced bypasses.
8. A Glossary of Blind SSRF Chains – Assetnote
   9 min readblog.assetnote.io2025
   Glossary of Blind SSRF Chains, detailing techniques for exploiting Server-Side Request Forgery when response data is unavailable. It covers methodologies like using SSRF canaries to confirm internal service reachability, leveraging DNS data with tools such as AltDNS for internal host discovery, and identifying side-channel leaks through response errors, sizes, and timings. Specific examples include chaining with internal SSRFs, app-specific open redirects, blind XXE, and mentions of vulnerabilities affecting Confluence, Artifactory, Jenkins, JAMF, and Apache mod_proxy (CVE-2021-40438).