Posted in

Go语言发起请求如何规避CDN/网关劫持？——自定义User-Agent指纹、Accept-Encoding协商、Referer伪造与反探测实战

by 云原生小白||0

第一章：Go语言发起请求的基础机制与网络栈剖析

Go语言的HTTP请求能力根植于其标准库 net/http 包，其底层不依赖C运行时，而是直接基于操作系统原生socket接口构建。当调用 http.Get("https://example.com") 时，Go运行时会依次完成DNS解析、TCP连接建立、TLS握手（若为HTTPS）、HTTP报文序列化与发送，以及响应读取等完整流程。

请求生命周期的关键阶段

  • DNS解析：默认使用系统解析器（如/etc/resolv.conf），也可通过自定义net.Resolver替换为DoH或缓存策略
  • 连接管理：http.Transport 维护空闲连接池，默认复用HTTP/1.1连接，支持HTTP/2自动升级
  • TLS协商：crypto/tls 包实现完整握手逻辑，支持SNI、ALPN及证书验证链校验

底层网络栈调用路径

Go通过syscall或golang.org/x/sys/unix封装系统调用，在Linux上典型路径为：
net.DialContext → net.internetSocket → syscall.Connect → connect(2) 系统调用

自定义HTTP客户端示例

以下代码演示如何禁用连接复用并强制使用IPv4：

client := &http.Client{
    Transport: &http.Transport{
        // 禁用连接池，每次新建TCP连接
        MaxIdleConns:        0,
        MaxIdleConnsPerHost: 0,
        // 强制IPv4解析
        DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
            return (&net.Dialer{
                DualStack: false, // 禁用IPv6
                Timeout:   10 * time.Second,
            }).DialContext(ctx, "tcp4", addr)
        },
    },
}
resp, err := client.Get("http://httpbin.org/ip")
if err != nil {
    log.Fatal(err) // 处理连接超时、DNS失败等错误
}
defer resp.Body.Close()

常见网络行为对照表

行为 默认值 可配置方式
DNS缓存时效 0（无缓存） net.Resolver 的 PreferGo + 自定义缓存
TCP KeepAlive 15秒（Linux） Dialer.KeepAlive
TLS会话复用 启用 Transport.TLSClientConfig.SessionTicketsDisabled = false

Go的网络栈设计强调“显式优于隐式”，所有关键参数均需开发者主动配置，避免黑盒行为干扰可观测性与调试。

第二章：User-Agent指纹定制与反识别实战

2.1 User-Agent的协议语义与CDN/网关识别逻辑分析

User-Agent 是 HTTP 请求头中唯一由客户端主动声明的、携带运行时环境语义的字段，其格式遵循 RFC 7231 定义的 product / version 序列化规范，但实际值高度自由，常含多层嵌套标识（如浏览器、渲染引擎、OS、设备类型）。

CDN 的 UA 特征提取策略

主流 CDN（Cloudflare、Akamai）在边缘节点解析 UA 时，优先匹配预置指纹库，再结合 TLS 扩展、HTTP/2 伪头等上下文做联合判定：

# Nginx 边缘规则示例：识别爬虫并标记
map $http_user_agent $is_bot {
    ~*(googlebot|bingbot|yandex)   "1";
    ~*HeadlessChrome                "headless";
    default                         "0";
}

该 map 指令在请求解析早期执行，~* 表示大小写不敏感正则；$is_bot 后续可用于 geo 或 limit_req 策略。注意：正则匹配顺序影响结果，需按特异性从高到低排列。

网关识别逻辑依赖维度

维度 示例值 识别强度
UA 主版本号 Chrome/124.0.0.0 中
渲染引擎标识 AppleWebKit/537.36 高
移动设备标记 Mobile Safari/605.1.15 高
自定义前缀 MyApp/2.1.0 (iOS; 17.5) 低（需白名单）

流量分类决策流程

graph TD
    A[收到 HTTP 请求] --> B{UA 是否为空？}
    B -->|是| C[默认标记为未知客户端]
    B -->|否| D[正则匹配指纹库]
    D --> E{匹配成功？}
    E -->|是| F[注入 X-Client-Type 头]
    E -->|否| G[启用 JS 挑战或行为分析]

2.2 基于真实浏览器指纹库构建动态User-Agent生成器

真实指纹库是动态UA生成的核心数据源，需覆盖主流OS/浏览器组合、版本分布及设备像素比等维度。

数据同步机制

采用增量拉取+本地缓存策略，每日从 BrowserStack User-Agent API 和 WhatIsMyBrowser 同步最新指纹快照。

核心生成逻辑

def generate_ua(fingerprint: dict) -> str:
    # fingerprint 示例：{"os": "Windows", "os_ver": "10", "browser": "Chrome", "ver": "124.0.6367.78"}
    template = "{browser}/{ver} ({os}; {os_ver}) AppleWebKit/537.36 (KHTML, like Gecko) {browser}/{ver} Safari/537.36"
    return template.format(**fingerprint)

逻辑分析：模板注入确保语义合规；fingerprint 字段必须包含 os, os_ver, browser, ver 四个键，缺失则触发fallback策略（如默认Chrome on Win10）。

指纹权重分布（采样统计）

OS Browser Weight
Windows Chrome 42%
macOS Safari 28%
Android Chrome 19% 
graph TD
    A[指纹库] --> B[加权采样]
    B --> C[OS/Browser校验]
    C --> D[模板渲染]
    D --> E[UA字符串]

2.3 Go标准库net/http中Header注入的底层控制与时机优化

Go 的 net/http 在写入响应头时采用延迟写入（lazy write）策略：仅当调用 WriteHeader() 或首次 Write() 时才序列化并发送 Header。

Header 写入的双阶段控制

  • 首次调用 Header().Set() 仅修改内存中的 Header map，不触发网络写入
  • 真正的序列化发生在 writeHeader() 内部，且仅一次——后续 WriteHeader() 被静默忽略 
func (w *response) writeHeader(code int) {
    if w.wroteHeader {
        return // 已写入，拒绝重复序列化
    }
    w.wroteHeader = true
    // … 构建 HTTP 状态行 + 所有 Header 字段（含 Set-Cookie 多值合并）
}

此逻辑确保 Header 注入不可被中间件或 handler 后续覆盖，但要求所有 Header().Set() 必须在 WriteHeader()/Write() 前完成，否则失效。

关键时机约束对比

操作时机 是否影响最终 Header 原因
w.Header().Add() before Write() ✅ 是 Header map 已更新，写入时生效
w.Header().Set() after Write() ❌ 否 wroteHeader == true，跳过序列化
w.WriteHeader(404) 两次 ❌ 第二次无效 wroteHeader 已置为 true 
graph TD
    A[Header().Set/Get] --> B{wroteHeader?}
    B -- false --> C[writeHeader: 序列化全部Header]
    B -- true --> D[静默丢弃]
    C --> E[HTTP响应头发出]

2.4 指纹一致性校验：请求链路中User-Agent的跨跳维持策略

在微服务调用链中，原始客户端 User-Agent 是关键设备指纹字段，需贯穿网关、认证中心、业务服务全链路。

核心挑战

  • HTTP Header 默认不透传（如 Nginx 默认丢弃非标准头）
  • 中间件可能重写或截断长 UA 字符串
  • 多语言 SDK 对 header 传递语义不一致

数据同步机制

采用「透传优先 + 备份兜底」双轨策略：

# 在网关层注入并校验 UA（示例：FastAPI middleware）
@app.middleware("http")
async def inject_ua(request: Request, call_next):
    ua = request.headers.get("user-agent", "")
    # 防截断：限制长度但保留关键标识
    truncated_ua = ua[:256] if len(ua) > 256 else ua
    request.state.ua_fingerprint = hashlib.sha256(truncated_ua.encode()).hexdigest()
    response = await call_next(request)
    response.headers["X-UA-Fingerprint"] = request.state.ua_fingerprint
    return response

逻辑分析：该中间件提取原始 User-Agent，SHA256 哈希生成轻量指纹；通过响应头 X-UA-Fingerprint 向下游暴露不可逆摘要，规避敏感信息泄露与长度限制问题。truncated_ua 保障兼容性，哈希确保一致性校验无损。

跨跳校验流程

graph TD
    A[Client] -->|User-Agent: Chrome/120| B[API Gateway]
    B -->|X-UA-Fingerprint: a1b2c3...| C[Auth Service]
    C -->|X-UA-Fingerprint| D[Order Service]
    D --> E[校验指纹一致性]
校验环节 执行方式 容错策略
网关入口 提取并哈希 UA 日志告警+降级为匿名指纹
服务间调用 透传 X-UA-Fingerprint header 缺失时拒绝非幂等操作
最终消费方 对比请求指纹与会话历史指纹 连续3次不一致触发风控

2.5 实战：绕过WAF+CDN联合UA黑名单的自动化探测验证框架

核心绕过策略

WAF与CDN常联合校验 User-Agent 头，但存在指纹解析差异：CDN（如Cloudflare）倾向正则匹配子串，而WAF（如ModSecurity）依赖精确规则。利用此差分，可构造合法UA前缀+混淆载荷。

自动化探测流程

import requests
from urllib.parse import quote

ua_payloads = [
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36\x00",
    "curl/8.5.0 (x86_64-pc-linux-gnu) libcurl/8.5.0 OpenSSL/3.0.11",
]
for ua in ua_payloads:
    resp = requests.get(
        "https://target.com/api/test",
        headers={"User-Agent": ua},
        timeout=5,
        allow_redirects=False
    )
    print(f"[{resp.status_code}] UA len: {len(ua)} → {resp.headers.get('Server', 'N/A')}")

逻辑说明："\x00" 终止符可截断CDN的UA解析（部分CDN使用C风格字符串处理），但WAF仍完整接收；curl UA绕过“浏览器特征”规则集。allow_redirects=False 避免CDN重定向干扰状态判断。

探测结果对照表

UA类型 CDN拦截 WAF拦截 实际响应码
标准Chrome ❌ ❌ 200
\x00混淆UA ✅ ❌ 403
curl UA ❌ ✅ 403

流量路径决策逻辑

graph TD
    A[Client] --> B[CDN]
    B -->|UA含\x00| C[截断后UA]
    B -->|标准UA| D[透传完整UA]
    C --> E[WAF：接收完整UA]
    D --> E
    E --> F{WAF规则匹配}
    F -->|匹配| G[403]
    F -->|不匹配| H[200]

第三章：Accept-Encoding协商与内容解码规避技术

3.1 HTTP压缩协商机制深度解析：gzip、br、zstd在网关劫持中的利用路径

HTTP压缩协商依赖 Accept-Encoding 请求头与 Content-Encoding 响应头的双向匹配。现代网关（如CDN或API网关）常在转发链路中重写或忽略压缩头，导致客户端与上游服务间压缩策略错位。

常见压缩算法兼容性矩阵

算法 RFC标准 浏览器支持 网关劫持风险点
gzip RFC 7230 全面支持 易被中间件静默降级
br RFC 7932 Chrome/Firefox/Edge 部分老旧网关直接丢弃
zstd IETF草案 Safari 17+ / curl 8.0+ 多数网关返回 406 或透传失败

网关劫持典型路径（mermaid）

graph TD
    A[Client: Accept-Encoding: br,zstd,gzip] --> B[Edge Gateway]
    B -->|strip zstd, rewrite to gzip| C[Origin Server]
    C -->|Content-Encoding: gzip| D[Client]
    D -->|解压失败：zstd未协商成功| E[空白页或乱码]

攻击向量示例：Header注入绕过

GET /api/data HTTP/1.1
Host: example.com
Accept-Encoding: gzip, br, zstd
X-Forwarded-For: 127.0.0.1
# 注入恶意编码提示（部分网关误解析）
X-Override-Encoding: zstd

该请求可能触发网关逻辑漏洞：当网关将 X-Override-Encoding 错误映射为 Content-Encoding，却未同步校验 Accept-Encoding，导致响应编码与客户端能力不匹配——zstd流被强制下发至不支持客户端，引发解析崩溃。

3.2 Go中自定义响应体解码器的注册与透明拦截实现

Go 的 http.Client 默认仅支持 application/json 和 text/* 等基础类型解码，而微服务间常需统一处理 application/msgpack、application/cbor 或自定义压缩协议（如 application/json+gzip）。

注册解码器的两种范式

  • 全局注册：通过 encoding.RegisterDecoder("msgpack", &MsgpackDecoder{}) 统一管理
  • 客户端绑定：将 DecoderRegistry 作为 http.Client 的 Transport 扩展字段

透明拦截核心机制

type DecoderTransport struct {
    RoundTrip http.RoundTripper
    registry  *DecoderRegistry
}

func (t *DecoderTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    resp, err := t.RoundTrip.RoundTrip(req)
    if err != nil || resp == nil {
        return resp, err
    }
    // 拦截 Content-Type，动态替换 Body
    if decoder := t.registry.Get(resp.Header.Get("Content-Type")); decoder != nil {
        resp.Body = &DecodingReadCloser{resp.Body, decoder}
    }
    return resp, nil
}

该实现将解码逻辑下沉至传输层，对上层 json.Unmarshal() 调用完全无感——调用方仍使用原生 json.NewDecoder(resp.Body).Decode(&v)，实际执行的是注册的 MsgpackDecoder.Decode()。

解码器类型 触发 Content-Type 是否支持流式解码
JSON application/json ✅
MsgPack application/msgpack ❌（需完整缓冲）
CBOR application/cbor ✅ 
graph TD
    A[HTTP Request] --> B[RoundTrip]
    B --> C{Has registered decoder?}
    C -->|Yes| D[Wrap Body with DecodingReadCloser]
    C -->|No| E[Pass through unchanged]
    D --> F[Decode on first Read/Unmarshal]

3.3 强制禁用压缩并伪造编码声明以触发原始响应流的工程实践

在调试 CDN 缓存或反向代理行为时，需绕过中间层对响应体的自动解压与转码处理。

核心请求头组合

  • Accept-Encoding: identity（显式拒绝压缩）
  • Content-Encoding: gzip（伪造已压缩声明，诱导服务端跳过二次压缩）
  • X-Original-Content-Length: 12345（辅助后端识别原始流长度）

关键代码示例

import requests

headers = {
    "Accept-Encoding": "identity",
    "Content-Encoding": "gzip",  # 仅声明，不实际压缩
    "User-Agent": "Mozilla/5.0 (debug-mode)"
}
resp = requests.get("https://api.example.com/data", headers=headers, stream=True)
# stream=True 确保响应体不被 requests 自动解码

stream=True 防止 requests 库根据 Content-Encoding 自动解压；Accept-Encoding: identity 告知上游链路“无需压缩”，而伪造的 Content-Encoding 可干扰某些代理的响应重写逻辑。

典型适用场景对比

场景 是否触发原始流 原因
普通请求 ❌ CDN 自动解压并注入 Content-Encoding: gzip
Accept-Encoding: identity + stream=True ✅ 绕过自动解压，保留原始字节流
伪造 Content-Encoding + Transfer-Encoding: chunked ✅✅ 强制代理透传未解码块 
graph TD
    A[客户端发起请求] --> B{是否含 Accept-Encoding: identity?}
    B -->|是| C[CDN/Proxy 跳过压缩]
    B -->|否| D[可能自动解压+重编码]
    C --> E[服务端返回原始字节流]
    E --> F[客户端 stream.read() 获取未解码数据]

第四章：Referer伪造与上下文环境反探测体系

4.1 Referer字段在CDN/WAF会话关联与爬虫标记中的关键作用

Referer 是 HTTP 请求头中唯一能反映「上一跳来源」的标准化字段，在无 Cookie/Token 的轻量会话场景下，成为 CDN 边缘节点与 WAF 策略引擎协同决策的关键线索。

数据同步机制

CDN 节点将原始 Referer（经白名单校验后）透传至 WAF，避免因重写丢失上下文：

# Nginx CDN 配置：保留并规范化 Referer
proxy_set_header Referer $http_referer;
proxy_set_header X-Orig-Referer $http_referer; # 备份原始值

proxy_set_header 确保上游 WAF 可获取客户端真实跳转路径；X-Orig-Referer 用于对抗恶意篡改，支持 referer-based 会话绑定与异常回溯。

爬虫行为指纹构建

WAF 基于 Referer 模式组合其他字段生成设备指纹：

字段 示例值 用途
Referer https://search.google.com/ 判定是否来自搜索引擎
User-Agent Googlebot/2.1 验证爬虫身份一致性
Accept-Encoding gzip,deflate 辅助识别自动化工具

决策流程

graph TD
  A[请求到达CDN] --> B{Referer 是否合法？}
  B -->|是| C[透传至WAF + 打标 session_id]
  B -->|否| D[返回 403 或跳转验证页]
  C --> E[WAF 匹配 Referer 白名单 + UA 组合策略]
  E --> F[放行 / 限速 / 挑战]

4.2 构建可信Referer上下文图谱：域名层级、协议一致性与历史行为模拟

可信Referer建模需突破简单字符串匹配，转向结构化上下文理解。

域名层级解析

使用publicsuffix-go库提取eTLD+1，确保shop.example.co.uk与blog.example.co.uk归属同一可信域：

import "github.com/psampaz/publicsuffix-go"
domain, _ := publicsuffix.EffectiveTLDPlusOne("shop.example.co.uk") // 返回 "example.co.uk"

该调用依赖ICANN公共后缀列表，规避com、co.uk等多级后缀误判；参数为原始Host字段，返回标准化主域。

协议一致性校验

Referer URL 请求协议 是否允许 原因
https://a.com/ HTTP ❌ 混合内容风险
https://b.com/ HTTPS ✅ 协议严格匹配

历史行为模拟流程

graph TD
    A[HTTP请求] --> B{Referer存在？}
    B -->|是| C[解析域名+协议]
    C --> D[查历史会话图谱]
    D --> E[生成置信度权重]

4.3 Go中Request.Context()与Referer生命周期绑定的反追踪设计

Referer敏感性与上下文隔离需求

HTTP Referer头易被伪造或截断，直接依赖其做权限/来源判断存在安全风险。Go 的 Request.Context() 提供了天然的请求作用域，可将 Referer 解析结果与其生命周期强绑定，避免跨请求污染。

上下文注入与安全封装

func withSafeReferer(r *http.Request) *http.Request {
    referer := r.Referer()
    if referer == "" || !isValidOrigin(referer) {
        referer = "unknown"
    }
    ctx := context.WithValue(r.Context(), refererKey, referer)
    return r.WithContext(ctx)
}

逻辑分析：r.Referer() 返回原始 header 值；isValidOrigin 防止恶意 URL 注入；refererKey 为私有 interface{} 类型键，确保类型安全；WithContext 创建不可变新请求对象，实现零共享。

生命周期一致性保障

阶段 Context 状态 Referer 可见性
请求初始化 活跃 已校验并封装
中间件链执行 持续传递 只读访问
Handler 结束 自动失效 不可再获取 
graph TD
    A[HTTP Request] --> B[Parse & Validate Referer]
    B --> C[Attach to Context via WithValue]
    C --> D[Middleware Chain]
    D --> E[Handler: ctx.Value refererKey]
    E --> F[Context Done → GC 回收]

4.4 多阶段Referer漂移策略：从初始入口到目标资源的可信链路构造

在现代前端安全与资源访问控制中，单一 Referer 校验易被绕过。多阶段漂移策略通过分步构造可信跳转链，使目标资源仅响应符合预设路径的 Referer 序列。

漂移阶段设计

  • Stage 1：入口页（/landing）注入带签名的临时 token 到 window.sessionStorage
  • Stage 2：中继页（/proxy?step=1）读取 token，生成带时间戳和哈希的 Referer 片段
  • Stage 3：目标页（/api/data）校验 Referer 中连续两跳的签名链完整性

Referer 签名生成示例

// 中继页生成带漂移标识的 Referer 值（供后端校验）
const token = sessionStorage.getItem('init_token');
const salt = 'stage2_v1';
const timestamp = Date.now();
const signature = CryptoJS.HmacSHA256(`${token}|${timestamp}|${salt}`, SECRET_KEY).toString();
// 构造可信 Referer：https://app.example.com/proxy?step=1&sig=xxx&t=1718234567890

逻辑分析：token 绑定初始会话，timestamp 防重放，signature 由服务端共享密钥签发，确保每跳 Referer 不可伪造或复用。

后端校验流程

graph TD
    A[收到请求] --> B{Referer 是否含 sig/t 参数？}
    B -->|否| C[拒绝]
    B -->|是| D[解析 t 时间戳是否在 30s 窗口内]
    D -->|否| C
    D -->|是| E[用 SECRET_KEY 重算 signature 并比对]
    E -->|不匹配| C
    E -->|匹配| F[放行]
阶段 Referer 示例 校验关键字段
入口 → 中继 https://app.example.com/landing 无签名，仅允许白名单域名
中继 → 目标 https://app.example.com/proxy?step=1&sig=...&t=... sig + t + 时效性

第五章：综合对抗能力评估与生产级请求客户端封装

对抗能力评估的实战指标体系

在真实业务场景中，我们基于某金融风控接口构建了多维度对抗测试矩阵。覆盖超时熔断（3s/5s/8s三级响应阈值）、HTTP状态码异常（429/502/503/504组合触发）、TLS握手失败模拟、DNS解析劫持（通过自定义/etc/hosts注入虚假IP）、以及Header字段篡改（如伪造X-Forwarded-For与User-Agent）。测试结果显示，未加固客户端在连续127次429响应后出现连接池泄漏，平均内存增长达3.2MB/分钟。

生产级客户端的核心封装原则

我们采用分层封装策略：底层使用http.Transport定制连接复用与TLS配置；中间层注入RoundTripper链式拦截器，实现日志脱敏、重试退避、熔断统计；上层提供泛型方法Do[T any](ctx context.Context, req *http.Request) (*T, error)。关键约束包括：所有敏感Header自动过滤（Authorization、Cookie仅限白名单域名透传），JSON序列化强制启用json.MarshalIndent调试开关，错误返回统一包装为*ClientError结构体，含TraceID、StatusCode、ElapsedTimeMs、RetryCount字段。

熔断与重试的协同机制

以下为实际部署中生效的熔断策略配置表：

指标 阈值 触发动作 恢复条件
5分钟错误率 ≥65% 熔断30秒，拒绝新请求 时间窗口内错误率
单请求耗时P99 >6s 启动指数退避重试（最多3次） 下次请求成功即重置计数
连接池等待超时 >200ms 记录告警并降级至短连接模式 连续5次健康探测通过

实战压测对比数据

在2000 QPS持续负载下，封装前后核心指标对比（单位：ms）：

场景 平均延迟 P95延迟 错误率 内存占用峰值
原生http.Client 412 1280 8.7% 1.2GB
封装客户端（v2.3） 187 492 0.23% 412MB

安全增强实践细节

所有外发请求强制校验目标域名证书链完整性，禁用InsecureSkipVerify；针对application/json请求体，自动注入X-Request-ID与X-Client-Version: prod-v3.2.1；响应体解码前执行UTF-8 BOM头剥离与控制字符过滤（正则\x00-\x08\x0B\x0C\x0E-\x1F\x7F）；DNS解析结果缓存时间严格限制为30秒，避免因TTL过长导致故障扩散。

// 生产环境强制启用的请求拦截器片段
func SecurityHeaderRoundTripper(next http.RoundTripper) http.RoundTripper {
    return roundTripFunc(func(req *http.Request) (*http.Response, error) {
        req.Header.Set("X-Client-Timestamp", strconv.FormatInt(time.Now().UnixMilli(), 10))
        req.Header.Del("X-Forwarded-For") // 防止上游伪造
        if req.URL.Scheme == "https" {
            req.Header.Set("X-HTTPS-Verified", "true")
        }
        return next.RoundTrip(req)
    })
}

全链路可观测性集成

客户端内置OpenTelemetry SDK，自动采集http.client.request.duration、http.client.error.count、http.client.retry.count三个核心指标，并关联Jaeger Trace ID；所有网络错误事件推送至Sentry，携带完整请求快照（URL、Method、Headers键名列表、Body长度）；Prometheus暴露http_client_active_requests{endpoint="risk-api", region="shanghai"}实时计数器。

flowchart LR
    A[发起请求] --> B{熔断器检查}
    B -- 允许 --> C[执行重试策略]
    B -- 熔断 --> D[返回CachedError]
    C --> E[Transport发送]
    E --> F{响应状态}
    F -- 2xx --> G[JSON解码]
    F -- 4xx/5xx --> H[触发重试或熔断]
    G --> I[返回结构化结果]
    H --> J[记录Metrics & Log]

在 Kubernetes 和微服务中成长，每天进步一点点。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注