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 条件上独立判断。这样既不破坏合法跨源访问,也不会让预检请求变成接口地图生成器。