日志注入防御实战:伪造日志与审计绕过防护

日志注入是一种把「审计证据」变成「攻击者可控内容」的手法:在 User-Agent、用户名、URL 参数里塞入换行符或控制字符,让一条恶意请求在日志里显示成两行、甚至伪装成一次正常访问。事后溯源时,你看到的时间线可能是伪造的,SIEM 规则可能被稀释,日志查看面板还可能被存储型 XSS 打穿。本文从产生端转义、输入端拦截、消费端编码三个环节给出配置,命令与规则可直接复用。

适用场景

以下情况说明日志链路缺少对「不可信输入」的处理,任何一条都值得立即排查:

  • Nginx、Apache 的 access log 使用默认 combined 格式,$http_user_agent 与 $request 原样落盘;
  • 应用日志用字符串拼接方式写入,例如 log.info("user=" + name + " action=login");
  • 日志集中到 ELK 或 Loki 后,靠正则解析字段,字段里出现换行就会错行,导致「同一请求」被拆成多条事件;
  • 自建日志查看页面直接输出原始字段内容,没有做 HTML 编码;
  • 出现过「日志里有访问、业务侧没有记录」或「日志行数与请求数对不上」的异常,但没查清原因。

前置条件

  • Nginx 不低于 1.11.8,这是 log_format 支持 escape 参数的起始版本;
  • 应用侧能修改日志框架配置(Python logging、Java Logback / Log4j2、Go log/slog 任一);
  • 日志采集链路可调整(Filebeat、Fluent Bit、rsyslog 任选),用于后续做二次清洗与完整性校验;
  • 准备测试环境,注入用例会产生畸形请求,不要直接打生产入口;
  • 约定日志字段规范:时间、来源 IP、请求 ID、用户标识、事件类型固定为顶层字段,其余信息统一放进 message 字段。

原理说明

文本日志的「一行一条记录」是隐含契约:行尾的 \n 是记录分隔符。一旦某个字段里含有 \n 或 \r,这条记录就被劈成两行,第二行在解析器眼里是一条全新的、完全由攻击者构造的记录。攻击者因此可以伪造一条 "GET /admin 200" 的记录放在真实请求之后,让溯源时误以为攻击者只是正常访问了后台;也可以反过来塞入大量形似误报的噪音,把真正的告警淹没。

需要澄清一个常见误解:裸 CR/LF 无法直接进入 HTTP 请求行与请求头,Nginx 与绝大多数服务端会直接返回 400。真正可用的注入路径有三条。其一是 URL 里带百分号编码的 %0a、%0d,Nginx 记录 $request_uri 时保留编码形态,但下游解析工具或自建面板会先解码再展示,解码那一刻就断行了。其二是应用把参数解码后写日志,注入直接发生在应用层。其三是控制字符注入,例如 \x1b[2J 这类终端转义序列,能在 cat、tail 时清屏或覆盖已输出内容,让运维看到被篡改的「日志画面」。

还有一类常被忽略的破坏是分隔符注入。KV 格式日志用空格分隔 key=value,攻击者在 UA 里写入 status=200 user=admin,解析器就会凭空多出一组字段,篡改的正是最关键的几个属性。JSON 格式不会因为空格错位,但如果字段值没有正确转义就拼进 JSON,整个文档会解析失败,采集端要么丢弃、要么降级成纯文本,结果是攻击者的请求从结构化日志里消失——这比伪造更隐蔽。

因此完整防御分三层:产生端统一转义,让不可信字符无法破坏结构;输入端拦掉明显携带控制字符的请求,减少脏数据;消费端对展示内容做编码,并用带密钥的哈希链保证日志一旦落盘就改不动。

操作步骤

第一步:Nginx 侧改用 JSON 转义格式

关键是 escape=json,它会把引号、反斜杠以及 0x00–0x1F 的控制字符转成 \uXXXX,换行符因此不再具备断行能力:

# /etc/nginx/conf.d/log_secure.conf
log_format json_secure escape=json
  '{"time":"$time_iso8601",'
  '"remote_addr":"$remote_addr",'
  '"method":"$request_method",'
  '"uri":"$request_uri",'
  '"status":$status,'
  '"bytes":$body_bytes_sent,'
  '"rt":$request_time,'
  '"ua":"$http_user_agent",'
  '"ref":"$http_referer",'
  '"rid":"$request_id"}';

access_log /var/log/nginx/access_json.log json_secure;

两个细节必须知道。第一,escape=json 对 **大于 0x7E 的字节**也会转义成 \uXXXX,中文 UA 或含中文的 URL 会让日志体积明显变大,若对存储成本敏感,可改用 escape=default 转义控制字符、再由采集端做 JSON 化,但要注意 escape=default 不转义双引号,拼进 JSON 会破结构。第二,$request_uri 保留百分号编码,不要改成 $uri 后再手工解码,否则等于把解码后的换行直接写进日志。

第二步:入口拦截携带控制字符的请求

转义解决「写进去安全」,拦截解决「干脆别收」,两层叠加能显著降低脏数据量:

# 在 http 段定义匹配规则:命中编码换行或控制字符即标记
map $request_uri $ctrl_char {
    default                 0;
    "~*%0d"                 1;
    "~*%0a"                 1;
    "~[\x00-\x1f]"          1;
}

server {
    listen 80;
    server_name example.com;

    # 仅用于直接返回,属于 if 的合规用法
    if ($ctrl_char) {
        return 400;
    }
    # 其余配置略
}

只拦 %0d 与裸控制字符、对 %0a 视业务决定是否一刀切:少数老接口会在参数里传换行(例如多行备注),直接 400 可能误伤。稳妥方式是先记录后拦截——在 map 里保留标记,把它写进日志字段,观察一周确有异常来源后再开启 return 400。

第三步:应用层统一清洗后再写日志

应用日志是注入的高发区,因为参数已经被框架解码,字符串拼接直接把换行带进了记录:

import json, logging, re

CTRL = re.compile(r"[\x00-\x1f\x7f]")

def clean(value, limit=512):
    # 去掉控制字符并截断长度,防止超长字段撑爆单条日志
    if value is None:
        return ""
    s = CTRL.sub(" ", str(value))
    return s[:limit]

class JsonFormatter(logging.Formatter):
    def format(self, record):
        payload = {
            "ts": self.formatTime(record, "%Y-%m-%dT%H:%M:%S%z"),
            "level": record.levelname,
            "logger": record.name,
            "event": getattr(record, "event", "-"),
            "rid": getattr(record, "rid", "-"),
            "msg": clean(record.getMessage(), 1024),
        }
        for k, v in getattr(record, "extra_fields", {}).items():
            payload[k] = clean(v, 256)
        # ensure_ascii=False 保证中文可读,换行已被 clean 处理
        return json.dumps(payload, ensure_ascii=False)

handler = logging.StreamHandler()
handler.setFormatter(JsonFormatter())
log = logging.getLogger("app")
log.addHandler(handler)
log.setLevel(logging.INFO)

log.info("login", extra={"event": "login", "extra_fields": {"user": "a\nb\r\nFAKE 200"}})

ensure_ascii=False 与清洗要一起用:前者让中文正常可读,后者保证即使关掉 ASCII 转义也不会有裸换行。字段长度截断同样重要,攻击者可以用一个 10KB 的 UA 把单条日志撑到几 MB,配合高频请求直接打满磁盘,这属于日志注入的变种——不追求伪造,只追求写爆。

第四步:Logback 侧替换换行并合并多行

Java 应用最常见的坑是异常堆栈本身含换行,与注入的换行混在一起无法区分。做法是先把 \r\n 替换成空格,再用 JSON 编码器输出:

<configuration>
  <appender name="JSON" class="ch.qos.logback.core.ConsoleAppender">
    <encoder class="net.logstash.logback.encoder.LogstashEncoder">
      <customFields>{"app":"order-service"}</customFields>
      <fieldNames>
        <timestamp>ts</timestamp>
        <message>msg</message>
      </fieldNames>
    </encoder>
  </appender>

  <!-- 若必须用 pattern,务必对 msg 做 replace,避免换行断行 -->
  <appender name="FILE" class="ch.qos.logback.core.FileAppender">
    <file>/var/log/app/app.log</file>
    <encoder>
      <pattern>%d{ISO8601} %-5level rid=%X{rid} msg=%replace(%msg){'[\r\n]+',' '}%n</pattern>
    </encoder>
  </appender>

  <root level="INFO">
    <appender-ref ref="JSON"/>
  </root>
</configuration>

%replace(%msg){'[
]+',' '}
是 Logback 内置的替换语法,正则里 + 把连续换行折叠成一个空格,避免出现大量空白。注意它只处理 %msg,MDC 里的字段(如 %X{user})同样要单独包一层 replace,否则从 Header 取到的用户标识依然是注入入口。

第五步:消费端编码与完整性校验

日志被安全地写下来之后,还要保证「看的时候安全」和「存下来改不了」。前者针对自建查看面板的存储型 XSS,后者针对有权限的人删改日志:

# 1) 每条日志追加 HMAC,形成可验证的哈希链(prev 指向上一条的签名)
prev="GENESIS"
while IFS= read -r line; do
  mac=$(printf '%s|%s' "$prev" "$line" | openssl dgst -sha256 -hmac "$LOG_KEY" -r | cut -d' ' -f1)
  printf '%s|%s\n' "$mac" "$line" >> /var/log/app/app.signed.log
  prev="$mac"
done < /var/log/app/app.log

# 2) 校验:任意一条被改动或删除,后续所有签名都会对不上
prev="GENESIS"; bad=0
while IFS='|' read -r mac rest; do
  calc=$(printf '%s|%s' "$prev" "$rest" | openssl dgst -sha256 -hmac "$LOG_KEY" -r | cut -d' ' -f1)
  [ "$calc" = "$mac" ] || { echo "BROKEN at: $rest"; bad=1; break; }
  prev="$mac"
done < /var/log/app/app.signed.log

# 3) 远端转发加 TLS,避免链路上被篡改(rsyslog)
cat >> /etc/rsyslog.d/50-tls.conf <<'EOF'
action(type="omfwd" target="log.corp.local" port="6514" protocol="tcp"
       streamDriver="gtls" streamDriverMode="1" streamDriverAuthMode="x509/name"
       StreamDriverPermittedPeers="log.corp.local")
EOF
systemctl restart rsyslog

哈希链的价值在于「删除即暴露」:攻击者即便拿到 root,删掉中间某条日志也会让后续链断裂,而重算整条链需要密钥。密钥不要放在同一台机器上,用 KMS 或单独的密钥服务下发,才能防住「攻破主机顺手拿到密钥」的情况。前端展示侧的规则只有一条——所有字段一律 HTML 编码后输出,禁止把 innerHTML 直接指向日志内容。

配置验证

用下面这组用例做验收,重点看「行数是否增加」和「JSON 是否合法」:

# 1) 注入换行:正常应只产生 1 行日志
curl -s -o /dev/null "https://example.com/?q=%0aFAKE%20GET%20/admin%20200"
before=$(wc -l < /var/log/nginx/access_json.log)
curl -s -o /dev/null -A $'Mozilla/5.0\nFAKE 200 GET /admin' "https://example.com/"
after=$(wc -l < /var/log/nginx/access_json.log)
echo "新增行数: $((after - before))"   # 期望 1

# 2) JSON 合法性:逐行解析,非法行数应为 0
tail -n 200 /var/log/nginx/access_json.log | jq -c . >/dev/null && echo "JSON OK"

# 3) 检查是否仍有裸控制字符残留(应无输出)
grep -nP '[\x00-\x08\x0b\x0c\x0e-\x1f]' /var/log/nginx/access_json.log | head

# 4) ANSI 转义序列检测(终端清屏类注入)
grep -c $'\x1b\[' /var/log/app/app.log

第 1 条是所有验证里最能说明问题的:如果新增行数变成 2 或更多,说明还有字段没走转义。-A 参数在 curl 里无法直接传裸换行,这里用 $'\n' 由 shell 展开,若被 curl 拒绝,可改用 --header @file 从文件读取含换行的请求头做测试。第 4 条命中数大于 0 时,直接用 cat -v 查看被转义后的内容,确认是否来自真实攻击。

常见问题

已经改成 JSON 日志了,为什么还能被注入?

JSON 只保证结构合法,不保证内容安全。三种情况仍会出问题:字段值用字符串拼接生成,未做转义导致 JSON 解析失败;JSON 合法但字段内容里含换行,日志查看器渲染时按原文显示,视觉上依旧能伪造出一行记录;展示端把字段直接写进 HTML,形成存储型 XSS。判断标准不是「格式是不是 JSON」,而是「字段值是否经过转义与编码」,以及「展示端是否做了输出编码」。

escape=json 会不会明显增加日志体积和 CPU 开销?

体积增加主要来自非 ASCII 字符被转成 \uXXXX:一个汉字从 3 字节变成 6 字节,中文 UA 较多时日志可能增大三到五成。CPU 开销在常规 QPS 下可以忽略,转义是逐字符扫描的线性操作,瓶颈通常先出现在磁盘写入而不是这里。若体积是主要顾虑,可只保留 escape=json 用于含用户输入的字段,其余字段单独拼一个更紧凑的格式,或用采集端(Filebeat、Vector)做字段级处理。

存量日志格式改不了,有什么补救办法?

在采集管道里做二次清洗,而不是回头改应用。Filebeat 可用 dissect 或 script 处理器把整行按分隔符拆开后重写;Logstash 用 mutate { gsub => ["message", "[\r\n]+", " "] } 先折叠换行再解析;Vector 的 remap 同样支持正则替换。补救的同时要做一件事:把「单条日志里出现多个换行」本身变成告警规则,因为那正是注入正在发生的信号,而不是单纯的格式问题。

日志完整性哈希链会不会影响检索性能?

会,所以不要把校验逻辑塞进在线检索路径。合理分工是:写入时同步计算签名并落盘,检索仍走原始日志或 SIEM 索引;只有在取证、审计、事故复盘这类低频场景才跑链式校验。另外哈希链按天或按小时分段,避免一个文件几十 GB 时校验一次要跑几十分钟,分段后只需校验涉事时间段。

总结

日志注入之所以危险,是因为它攻击的不是系统,而是你对系统的认知。防御也不复杂:产生端统一转义、输入端拦掉明显的控制字符、消费端做好输出编码、落盘后加一条可验证的哈希链。四步做完,攻击者仍能发请求,但不能再决定你在日志里看到什么。真正需要警惕的是「格式已经改好,行为却没变」的假安全——配置写完必须用带 %0a 的请求实测一遍行数,否则你只是换了件衣服,里面的问题还在。