OPTIONS 预检鉴权缺失导致的接口越权验证
服务端在未确认调用者身份的情况下,根据具体对象、租户、路由策略、请求方法或请求头动态生成 OPTIONS 响应。
OPTIONS 常被放进 CORS 中间件或网关规则里提前处理。这样做本身没有问题,因为浏览器发起 CORS 预检时通常不会携带 Cookie、Authorization 等跨源凭证,服务端也不应该依赖预检请求完成用户身份判断。真正的问题出现在另一条分支:服务端在未确认调用者身份的情况下,根据具体对象、租户、路由策略、请求方法或请求头动态生成 OPTIONS 响应。
技术边界
浏览器跨源发送非简单请求时,会先发送预检请求。典型请求如下:
OPTIONS /api/orders/1002 HTTP/1.1
Origin: https://evil.example
Access-Control-Request-Method: PATCH
Access-Control-Request-Headers: authorization,content-type,x-tenant-id
预检请求只是在询问服务端:这个源、这个方法、这些请求头是否允许用于后续真实请求。它不等于真实 PATCH,也不应该返回订单内容。问题在于,很多实现会把预检处理写成“按实际路由和实际对象生成策略”:
请求进入网关或 Web 框架
-> 识别 OPTIONS
-> 跳过登录态校验
-> 匹配 /api/orders/{id}
-> 查询订单是否存在
-> 根据路由能力返回 Allow / Access-Control-Allow-Methods
-> 回显 Access-Control-Request-Headers
-> 返回 204如果真实 GET 对当前用户返回 403,而 OPTIONS 对同一个资源返回 204,调用者就获得了一个授权外信号。若不存在的资源返回 404,存在但无权访问的资源返回 204,对象枚举条件就已经成立。
判断时要区分三种情况:
- OPTIONS 返回固定跨域策略,不查询对象,不按用户变化:通常只是正常 CORS 行为。
- OPTIONS 返回的状态码、方法、请求头随资源编号变化:存在对象级信息泄露。
- OPTIONS 动态回显任意 Origin,同时允许 Credentials,并放行写方法:可能进一步推动跨源写请求进入真实业务方法。
复现实验
编写环境保存为 options_preflight_lab.py:
from http.server import BaseHTTPRequestHandler, HTTPServer
import json
from urllib.parse import urlparse
ORDERS = {
"1001": {"owner": "alice", "amount": 90},
"1002": {"owner": "bob", "amount": 210},
"9001": {"owner": "finance", "amount": 5000},
}
TOKENS = {
"Bearer alice-token": "alice",
"Bearer bob-token": "bob",
}
class Handler(BaseHTTPRequestHandler):
server_version = "OptionsLab/1.1"
def log_message(self, fmt, *args):
return
def _json(self, code, obj):
body = json.dumps(obj, ensure_ascii=False).encode()
self.send_response(code)
self.send_header("Content-Type", "application/json; charset=utf-8")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
def _order_id(self):
path = urlparse(self.path).path
parts = path.strip("/").split("/")
if len(parts) == 3 and parts[:2] == ["api", "orders"]:
return parts[2]
return None
def _current_user(self):
return TOKENS.get(self.headers.get("Authorization", ""))
def _read_or_write_order(self, write=False):
oid = self._order_id()
user = self._current_user()
if not oid or oid not in ORDERS:
return self._json(404, {"error": "not found"})
if not user:
return self._json(401, {"error": "login required"})
if ORDERS[oid]["owner"] != user:
return self._json(403, {"error": "forbidden"})
if write:
return self._json(200, {
"id": oid,
"status": "patched",
"owner": user,
})
return self._json(200, {"id": oid, **ORDERS[oid]})
def do_GET(self):
self._read_or_write_order(write=False)
def do_PATCH(self):
self._read_or_write_order(write=True)
def do_OPTIONS(self):
origin = self.headers.get("Origin", "")
req_method = self.headers.get("Access-Control-Request-Method", "")
oid = self._order_id()
if oid is not None:
if oid not in ORDERS:
self.send_response(404)
self.end_headers()
return
self.send_response(204)
self.send_header(
"Access-Control-Allow-Origin",
origin or "https://app.example",
)
self.send_header("Access-Control-Allow-Credentials", "true")
self.send_header("Access-Control-Allow-Methods", "GET, PATCH, OPTIONS")
self.send_header(
"Access-Control-Allow-Headers",
self.headers.get(
"Access-Control-Request-Headers",
"authorization,content-type,x-tenant-id",
),
)
self.send_header("Allow", "GET, PATCH, OPTIONS")
self.send_header(
"X-Policy-Route",
"order-write" if req_method == "PATCH" else "order-read",
)
self.end_headers()
return
self.send_response(404)
self.end_headers()
if __name__ == "__main__":
HTTPServer(("127.0.0.1", 18080), Handler).serve_forever()
启动服务:
python3 options_preflight_lab.py用Alice 读取自己的订单:
curl -i http://127.0.0.1:18080/api/orders/1001 \
-H 'Authorization: Bearer alice-token'
Alice 读取 Bob 的订单:
curl -i http://127.0.0.1:18080/api/orders/1002 \
-H 'Authorization: Bearer alice-token'
说明真实业务方法没有直接越权读取数据。
换成同一路径的 OPTIONS 预检,并且不带 Authorization:
curl -i -X OPTIONS http://127.0.0.1:18080/api/orders/1002 \
-H 'Origin: https://evil.example' \
-H 'Access-Control-Request-Method: PATCH' \
-H 'Access-Control-Request-Headers: authorization,content-type,x-tenant-id'
响应暴露了三个事实:
/api/orders/1002对象存在。- 该路径存在
PATCH能力。 - 服务端接受
authorization与x-tenant-id出现在跨源请求头里。
请求一个不存在的订单:
curl -i -X OPTIONS http://127.0.0.1:18080/api/orders/1999 \
-H 'Origin: https://evil.example' \
-H 'Access-Control-Request-Method: PATCH'
1002 -> 204 与 1999 -> 404 的差异确认了对象存在性。绕过了真实 GET 的对象归属限制,得到了本不该向低权限调用者回答的信息。
批量验证与请求头探测
确认是否存在对象枚举通道:
for id in 1001 1002 1999 9001; do
code=$(curl -s -o /dev/null -w '%{http_code}' -X OPTIONS \
"http://127.0.0.1:18080/api/orders/$id" \
-H 'Origin: https://evil.example' \
-H 'Access-Control-Request-Method: PATCH')
printf 'order=%s options_status=%s\n' "$id" "$code"
done
请求头探测用于验证服务端是否不加过滤地回显 Access-Control-Request-Headers:
for header in x-tenant-id x-forwarded-user x-admin-token authorization; do
printf '\n[request header] %s\n' "$header"
curl -s -i -X OPTIONS http://127.0.0.1:18080/api/orders/1002 \
-H 'Origin: https://evil.example' \
-H 'Access-Control-Request-Method: PATCH' \
-H "Access-Control-Request-Headers: $header" \
| grep -i '^Access-Control-Allow-Headers:'
done
说明了预检分支没有做请求头允许范围控制。若后端某个网关或服务错误信任 x-forwarded-user、x-tenant-id 这类头,预检放行会让跨源页面具备继续发送真实请求的条件。
修复实现
保存为 options_preflight_lab2.py:
from http.server import BaseHTTPRequestHandler, HTTPServer
import json
from urllib.parse import urlparse
ORDERS = {
"1001": {"owner": "alice", "amount": 90},
"1002": {"owner": "bob", "amount": 210},
"9001": {"owner": "finance", "amount": 5000},
}
TOKENS = {"Bearer alice-token": "alice", "Bearer bob-token": "bob"}
ALLOWED_ORIGINS = {"http://127.0.0.1:18081", "https://app.example.com"}
ALLOWED_METHODS = {"GET", "PATCH", "OPTIONS"}
ALLOWED_HEADERS = {"authorization", "content-type", "x-requested-with"}
class Handler(BaseHTTPRequestHandler):
server_version = "OptionsLabFixed/1.0"
def log_message(self, fmt, *args):
return
def _json(self, code, obj):
body = json.dumps(obj, ensure_ascii=False).encode()
self.send_response(code)
self.send_header("Content-Type", "application/json; charset=utf-8")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
def _path(self):
return urlparse(self.path).path
def _order_id(self):
parts = self._path().strip("/").split("/")
if len(parts) == 3 and parts[:2] == ["api", "orders"]:
return parts[2]
return None
def _is_order_route(self):
return self._order_id() is not None
def _current_user(self):
return TOKENS.get(self.headers.get("Authorization", ""))
def _read_or_write_order(self, write=False):
oid = self._order_id()
user = self._current_user()
if not oid or oid not in ORDERS:
return self._json(404, {"error": "not found"})
if not user:
return self._json(401, {"error": "login required"})
if ORDERS[oid]["owner"] != user:
return self._json(403, {"error": "forbidden"})
if write:
return self._json(200, {"id": oid, "status": "patched", "owner": user})
return self._json(200, {"id": oid, **ORDERS[oid]})
def do_GET(self):
self._read_or_write_order(write=False)
def do_PATCH(self):
self._read_or_write_order(write=True)
def do_OPTIONS(self):
if not self._is_order_route():
self.send_response(404)
self.end_headers()
return
origin = self.headers.get("Origin", "")
req_method = self.headers.get("Access-Control-Request-Method", "").upper()
raw_headers = self.headers.get("Access-Control-Request-Headers", "")
requested_headers = [h.strip().lower() for h in raw_headers.split(",") if h.strip()]
origin_allowed = origin in ALLOWED_ORIGINS
method_allowed = req_method in ALLOWED_METHODS
headers_allowed = all(h in ALLOWED_HEADERS for h in requested_headers)
if not (origin_allowed and method_allowed and headers_allowed):
self.send_response(403)
self.send_header("Vary", "Origin, Access-Control-Request-Method, Access-Control-Request-Headers")
self.end_headers()
return
self.send_response(204)
self.send_header("Access-Control-Allow-Origin", origin)
self.send_header("Access-Control-Allow-Credentials", "true")
self.send_header("Access-Control-Allow-Methods", "GET, PATCH, OPTIONS")
if requested_headers:
self.send_header("Access-Control-Allow-Headers", ",".join(requested_headers))
self.send_header("Access-Control-Max-Age", "600")
self.send_header("Vary", "Origin, Access-Control-Request-Method, Access-Control-Request-Headers")
self.end_headers()
if __name__ == "__main__":
HTTPServer(("127.0.0.1", 18080), Handler).serve_forever()修复后有三个关键变化。
第一,OPTIONS 不再查询
ORDERS。它只判断请求路径是否匹配/api/orders/{id}这个路由形态,所以/api/orders/1002与/api/orders/1999的预检响应不会因对象是否存在而变化。第二,Origin 使用显式允许范围。
https://evil.example不会被写回Access-Control-Allow-Origin。第三,请求头使用允许范围。
x-tenant-id、x-forwarded-user、x-admin-token不会出现在Access-Control-Allow-Headers。
验证未受信任 Origin 被拒绝:
curl -i -X OPTIONS http://127.0.0.1:18080/api/orders/1002 \
-H 'Origin: https://evil.example' \
-H 'Access-Control-Request-Method: PATCH' \
-H 'Access-Control-Request-Headers: authorization,content-type'
验证受信任 Origin 的预检通过:
curl -i -X OPTIONS http://127.0.0.1:18080/api/orders/1002 \
-H 'Origin: http://127.0.0.1:18081' \
-H 'Access-Control-Request-Method: PATCH' \
-H 'Access-Control-Request-Headers: authorization,content-type'
验证存在与不存在的对象在预检阶段不可区分:
for id in 1002 1999; do
code=$(curl -s -o /dev/null -w '%{http_code}' -X OPTIONS \
"http://127.0.0.1:18080/api/orders/$id" \
-H 'Origin: http://127.0.0.1:18081' \
-H 'Access-Control-Request-Method: PATCH' \
-H 'Access-Control-Request-Headers: authorization,content-type')
printf 'order=%s options_status=%s\n' "$id" "$code"
done
验证敏感请求头被拒绝:
curl -i -X OPTIONS http://127.0.0.1:18080/api/orders/1002 \
-H 'Origin: http://127.0.0.1:18081' \
-H 'Access-Control-Request-Method: PATCH' \
-H 'Access-Control-Request-Headers: x-tenant-id'
真实业务方法仍然保持对象级鉴权:
curl -i http://127.0.0.1:18080/api/orders/1002 \
-H 'Authorization: Bearer alice-token'
自动校验脚本
保存为 validate_options.sh:
#!/usr/bin/env bash
set -eu
VULN_FILE="options_preflight_lab.py"
FIXED_FILE="options_preflight_lab2.py"
PID=""
cleanup() {
if [ -n "$PID" ]; then
kill "$PID" 2>/dev/null || true
wait "$PID" 2>/dev/null || true
PID=""
fi
}
trap cleanup EXIT
expect_code() {
name="$1"
expected="$2"
actual="$3"
if [ "$actual" != "$expected" ]; then
printf 'FAIL %s expected=%s actual=%s\n' "$name" "$expected" "$actual"
exit 1
fi
printf 'OK %s status=%s\n' "$name" "$actual"
}
start_server() {
file="$1"
log="$2"
python3 "$file" > "$log" 2>&1 &
PID=$!
sleep 1
if ! kill -0 "$PID" 2>/dev/null; then
echo "FAIL server_start file=$file"
cat "$log"
exit 1
fi
}
python3 -m py_compile "$VULN_FILE" "$FIXED_FILE"
start_server "$VULN_FILE" /tmp/options_lab.log
code=$(curl -s -o /tmp/get_foreign.txt -w '%{http_code}' \
http://127.0.0.1:18080/api/orders/1002 \
-H 'Authorization: Bearer alice-token')
expect_code 'lab_get_foreign' '403' "$code"
code=$(curl -s -o /tmp/options_existing.txt -w '%{http_code}' -X OPTIONS \
http://127.0.0.1:18080/api/orders/1002 \
-H 'Origin: https://evil.example' \
-H 'Access-Control-Request-Method: PATCH' \
-H 'Access-Control-Request-Headers: authorization,content-type,x-tenant-id')
expect_code 'lab_options_existing' '204' "$code"
code=$(curl -s -o /tmp/options_missing.txt -w '%{http_code}' -X OPTIONS \
http://127.0.0.1:18080/api/orders/1999 \
-H 'Origin: https://evil.example' \
-H 'Access-Control-Request-Method: PATCH')
expect_code 'lab_options_missing' '404' "$code"
cleanup
start_server "$FIXED_FILE" /tmp/options_fixed.log
code=$(curl -s -o /tmp/fixed_evil.txt -w '%{http_code}' -X OPTIONS \
http://127.0.0.1:18080/api/orders/1002 \
-H 'Origin: https://evil.example' \
-H 'Access-Control-Request-Method: PATCH' \
-H 'Access-Control-Request-Headers: authorization,content-type')
expect_code 'fixed_evil_origin' '403' "$code"
for id in 1002 1999; do
code=$(curl -s -o "/tmp/fixed_$id.txt" -w '%{http_code}' -X OPTIONS \
"http://127.0.0.1:18080/api/orders/$id" \
-H 'Origin: http://127.0.0.1:18081' \
-H 'Access-Control-Request-Method: PATCH' \
-H 'Access-Control-Request-Headers: authorization,content-type')
expect_code "fixed_order_$id" '204' "$code"
done
code=$(curl -s -o /tmp/fixed_bad_header.txt -w '%{http_code}' -X OPTIONS \
http://127.0.0.1:18080/api/orders/1002 \
-H 'Origin: http://127.0.0.1:18081' \
-H 'Access-Control-Request-Method: PATCH' \
-H 'Access-Control-Request-Headers: x-tenant-id')
expect_code 'fixed_bad_header' '403' "$code"
echo 'all checks passed'运行:
bash validate_options.sh
前三个状态码证明错误版本存在“真实方法拒绝、OPTIONS 承认对象存在、缺失对象返回 404”的授权外信号。后四个状态码证明修复版本拒绝未受信任 Origin,拒绝敏感请求头,并且受信任 Origin 下不再用 OPTIONS 暴露对象是否存在。
结论
OPTIONS 预检鉴权缺失的关键不是 OPTIONS 方法本身,而是预检分支在无身份条件下读取了业务状态并生成了细粒度策略。只要它能稳定区分对象是否存在、方法是否可用、请求头是否被接受,就已经具备越权验证价值。
合理的处理方式是让 OPTIONS 只回答静态 CORS 策略,不访问对象表,不按用户角色生成方法,不直接回显请求头,不信任任意 Origin。真实业务方法继续在身份、对象归属、租户边界和 CSRF 条件上独立判断。这样既不破坏合法跨源访问,也不会让预检请求变成接口地图生成器。
这也没用啊,都没越权了,你在那收集订单号