---
title: "Key Web Vulnerabilities #8, Part 2: Blind SSRF Is When the Server Calls, but You Do Not See the Answer"
url: https://daily.dev/posts/key-web-vulnerabilities-8-part-2-blind-ssrf-is-when-the-server-calls-but-you-do-not-see-the-answ-dxdlj8vwe
source_url: https://daily.dev/posts/key-web-vulnerabilities-8-part-2-blind-ssrf-is-when-the-server-calls-but-you-do-not-see-the-answ-dxdlj8vwe
type: freeform
source: "Web Developement"
author: "Przemyslaw"
published: 2026-06-28T14:43:22.431Z
updated: 2026-06-28T14:43:52.103Z
tags: ["security", "web-security"]
reading_time: 7
upvotes: 0
comments: 0
language: en
---

> ## Documentation Index
> Fetch the complete documentation index at: https://daily.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Key Web Vulnerabilities #8, Part 2: Blind SSRF Is When the Server Calls, but You Do Not See the Answer

**[Web Developement](https://daily.dev/sources/webdevelopement)** · [@przemyslaw91](https://daily.dev/przemyslaw91) · 7 min read · 0 upvotes · 0 comments

## Summary

A deep dive into blind SSRF (Server-Side Request Forgery), explaining how it differs from regular SSRF in that the server makes requests but the response is hidden from the attacker. Covers out-of-band detection techniques using callback servers and DNS interactions, private IP ranges and cloud metadata endpoints (169.254.169.254) as high-value targets, internal network reconnaissance via timing and error differences, redirect-based bypasses, and DNS/parser edge cases that weaken naive defenses. Includes practical regression test cases, logging recommendations, and safer design patterns such as allowlisted service identifiers and final-destination IP validation.

## Content

**How callbacks, timing, private IP ranges, and cloud metadata endpoints make SSRF dangerous even without the response body.**

In Part 1, I focused on the SSRF mental model: the attacker influences where the backend sends a request.

The request is server-side. The destination may be internal. The browser may never reach it directly.

Part 2 is about the version I found most interesting: blind SSRF.

Regular SSRF is easier because the response comes back to you. Blind SSRF is different: the server may make the request, but you may not see the answer.

## Regular SSRF vs blind SSRF

Regular SSRF looks like this:

```
attacker controls URL -> backend requests internal service -> response returns to attacker
```

Blind SSRF looks like this:

```
attacker controls URL -> backend makes request -> response is hidden
```

The application might return only `Stock check failed`, `Request submitted`, or nothing useful at all.

That does not mean the backend did not make the request. It only means the response body was not reflected back.

Blind SSRF feels more like proving a side effect than reading a page.

## Why blind SSRF clicked for me

Blind SSRF was the most interesting part of this topic for me because it changes the testing mindset.

With many earlier vulnerabilities, the app gives direct feedback: SQL injection changes data, XSS executes script, path traversal returns file content, or file upload exposes a stored file.

With blind SSRF, the app may stay quiet.

You are not only asking:

```
Can I see the internal response?
```

You are asking:

```
Did the backend make an outbound request at all?
```

That is a different kind of proof.

It feels less like opening a door and more like placing a bell somewhere and waiting for the server to ring it.

## Out-of-band evidence

![16c3fd84-6b83-44d1-b8d1-6435a6f3c274.png](https://media.daily.dev/image/upload/s--3vWsMT_i--/f_auto/v1782656016/ugc/content_c52f563b-c82c-4ee6-aa77-cfb0c40c261e?_a=BAMAMicg0)

Blind SSRF is often tested with out-of-band evidence.

Conceptually, the flow is:

```
attacker-controlled callback URL
          ↓
vulnerable backend requests it
          ↓
callback server records the interaction
```

The application may not show the response, but the external listener sees that the backend connected. That proves one thing:

```
The backend made a server-side request to a destination I controlled.
```

In labs, tools such as Burp Collaborator are often used for this. The important idea is that evidence comes from outside the app’s normal response body.

Other clues can include timing differences, error messages, status codes, DNS lookups, HTTP callbacks, or logs in a controlled service.

Blind SSRF is still SSRF. It is just less chatty.

## Private and internal IP ranges

SSRF becomes dangerous because the backend may reach places that are not public.

Important ranges include:

```
127.0.0.0/8       loopback / localhost
10.0.0.0/8        private network
172.16.0.0/12     private network
192.168.0.0/16    private network
169.254.0.0/16    link-local addresses
```

A public user may not reach these addresses. The backend might.

SSRF is not only about one vulnerable parameter. It is about what the application server can see from inside the network.

## Cloud metadata endpoints

The link-local address that appears again and again in SSRF discussions is:

```
169.254.169.254
```

In cloud environments, metadata services may expose instance information and, depending on the platform and configuration, credentials or role-related data.

That does not mean every SSRF becomes cloud compromise. Modern metadata protections reduce risk, including session-token based metadata access.

But the idea is important: the backend may be close to sensitive infrastructure-only services. If user input can steer requests there, the impact can be much bigger than reading one internal page.

## Internal reconnaissance

![da767acd-6151-485b-add4-85bc7dc0bae4.png](https://media.daily.dev/image/upload/s--1_27Oph2--/f_auto/v1782656662/ugc/content_8d58be89-2fe8-469d-88f0-b1d162f357c2?_a=BAMAMicg0)

Even when SSRF does not return sensitive data, it may help map internal systems.

Different destinations may produce different behaviours: connection refused, timeout, fast error, slow error, different status, different response size, or different DNS behaviour.

Those differences can reveal whether a host exists, a port is open, or a service behaves differently.

An attacker may not need to read the response body to learn something useful about the internal network.

## Redirects can reopen the door

A feature may try to allow only external URLs, but if the backend follows redirects, the first URL might redirect to an internal address.

The validation may check the first destination, while the HTTP client follows the second one.

That creates a dangerous split:

```
validated URL != final requested URL
```

This should feel familiar from Path Traversal: checking the original value is not enough if the final destination can change.

## DNS and parser surprises

![4beb677c-5743-4cc7-853b-bc084357fe9f.png](https://media.daily.dev/image/upload/s--F9BJSuxe--/f_auto/v1782656902/ugc/content_fbfb2330-54b1-4d31-aa5d-3983d913b824?_a=BAMAMicg0)

SSRF defence gets messy because URLs are not as simple as they look.

A backend may need to handle hostnames resolving to private IPs, DNS changes, IPv6, encoded IP formats, redirects, parser differences, and mixed schemes.

This is why “just block localhost” is weak. Validate the final destination, not only the original hostname, and use network egress rules where possible.

## Safer design patterns

The best defence depends on the feature.

If the app only needs known services, do not accept arbitrary URLs. Use identifiers such as `stockserviceprimary`, map them server-side, and verify the destination against a strict allowlist.

If the app really needs user-provided external URLs, such as webhooks or previews, it needs layers: safe parsing, required schemes only, blocked local/private/link-local/metadata ranges, final IP checks, redirect controls, timeouts, response-size limits, restricted egress, and logging.

This is not “one regex and done”. It is an architecture decision.

## Regression tests I would add

For an SSRF-prone feature, I would test:

```
http://localhost/
http://127.0.0.1/
http://[::1]/
http://10.0.0.1/
http://172.16.0.1/
http://192.168.0.1/
http://169.254.169.254/
allowed URL that redirects to localhost
hostname that resolves to private IP
unsupported schemes
slow or huge responses
```

I would also test normal allowed behaviour, because broken integrations quickly create risky exceptions.

The better question is not only “did the request fail?” It is “did the backend avoid making an unsafe outbound request?”

## What to log

SSRF also connects nicely with logging and alerting.

Useful logs include the feature name, user/account ID, destination key, normalized URL, resolved IP, redirect chain, timeout reason, response size, and blocked/allowed decision.

Blind SSRF is harder to prove from the outside. Good telemetry makes it easier to detect from the inside.

This is one reason OWASP Top 10 feels like the right next step. Logging, design, access control, and misconfiguration decide whether SSRF is prevented, detected, or missed.

## Summary

Blind SSRF is when the backend calls, but you do not see the answer.

That makes the vulnerability harder to prove, but not harmless.

Evidence may come from callbacks, DNS interactions, timing, errors, or internal logs. Impact depends on what the backend can reach: localhost-only services, internal APIs, private IPs, cloud metadata, or other infrastructure systems.

The safest approach is to avoid arbitrary destinations where possible. Use allowlisted service identifiers, validate final destinations, control redirects, block internal ranges, restrict egress, and log outbound behaviour.

## Closing the series

![429d5d03-3d2f-41c6-b356-a5e6e106bf0f.png](https://media.daily.dev/image/upload/s--LMNTC4pY--/f_auto/v1782657789/ugc/content_9ba23840-9a76-4502-a868-03b3cf57b4fc?_a=BAMAMicg0)

This article closes my Key Web Vulnerabilities series.

The next step is OWASP Top 10, but I want to approach it in a broader way. It will not be only about payloads or individual bugs. It will also be about design, trust boundaries, logging, error handling, authentication decisions, insecure defaults, and the security impact of choices we make while building software.

That feels like the right next step after SSRF.

SSRF is already less about one suspicious parameter and more about how the application is connected to the world around it.

## My takeaway

Blind SSRF was the part that interested me most because it forced a different question.

Not:

```
Can I see the response?
```

but:

```
Can I prove the backend made the request?
```

That shift is small but important.

SSRF is not just about sending a weird URL. It is about trust, network position, and the hidden paths an application can take when it talks to the systems around it.

Same backend. Different destination. Completely different risk.

---

Tags: [#security](https://daily.dev/tags/security), [#web-security](https://daily.dev/tags/web-security)

[View this post on daily.dev](https://daily.dev/posts/key-web-vulnerabilities-8-part-2-blind-ssrf-is-when-the-server-calls-but-you-do-not-see-the-answ-dxdlj8vwe)