SPF 发件人策略框架深度解析 — RFC 7208：从 SPF Classic 到 DMARC 基石 · ztpop 邮件技术知识库

RFC 7208, Section 4.6 并不强制推荐任何一种——它把选择权留给域管理员。

五、SPF 宏展开机制

SPF 宏（macro）是 SPF 中最被低估但也最强大的特性。它允许 SPF 记录中包含变量占位符，check_host() 在评估时用实际值替换这些变量（RFC 7208, Section 7）。

5.1 核心宏变量

5.2 宏的实用场景：动态 exists 白名单

以下是一条使用宏的真实 SPF 记录模式（RFC 7208, Section 7.3 的示例模式）：

# 为每个发件地址动态查询 DNS，实现精细粒度的授权
v=spf1 exists:%{l}._spf.%{d} -all

当 user@example.com 通过 IP 192.0.2.10 发信时，这条记录会展开为：

# check_host() 实际执行的 DNS 查询
dig A user._spf.example.com

如果该域名有 A 记录， exists 匹配成功，返回 Pass。DNS 运维人员可以通过增删 user._spf.example.com 的 A 记录来动态控制权限——无需触碰 SPF TXT 记录本身。

5.3 转义与限定符

宏变量支持转义：在 %{ 和 } 之间、变量名之后可以加数字限定符表示截取前 n 个字节，再加 r 表示反转（reverse）——这些在构建复杂 exists 域名时非常有用（RFC 7208, Section 7.2）。

# 取 IP 的前 3 个字节（网络部分），反转后再拼接
%{ir3}  → 对于 192.0.2.10 → ur: 10.2.0.192 → 截取前3字节 → 10.2.0

六、10 次 DNS 查询上限与展开审计

SPF 最容易被忽视但又最容易踩坑的约束是 10 次 DNS 查询限制 。RFC 7208, Section 4.6.4 明确规定： "SPF implementations MUST limit the total number of mechanisms and modifiers that cause DNS lookups to at most 10 per SPF check, including any lookups caused by the use of the 'include' mechanism or the 'redirect' modifier." 超过 10 次，结果直接返回 PermError 。

这个限制的动机是防止 SPF 评估本身成为 DoS 攻击向量——如果攻击者构造一条会造成无限递归或大量 DNS 查询的 SPF 记录，接收方 MTA 资源可能被耗尽。

6.1 哪些操作计入 10 次限制

6.2 审计 SPF 记录的 DNS 查询量

手动审计一条 SPF 记录的 DNS 展开量：

# 示例：一条看似简单但实际超限的 SPF 记录
v=spf1 include:esp1.com include:esp2.com include:esp3.com include:esp4.com include:esp5.com include:esp6.com include:esp7.com include:esp8.com include:esp9.com include:esp10.com include:esp11.com -all

这里仅 include 本身就已经 11 次了，再加上每个被包含域内部的机制查询，这条记录几乎一定会返回 PermError。很多邮件发送失败的原因不是配置错误，而是 SPF 记录"太膨胀"了。

审计工具链：

# 用 dig 手动解析 include 链
dig TXT _spf.esp1.com +short

# 用 spfquery 查看完整评估路径（输出中包含 DNS 查询计数）
spfquery --scope mfrom --id user@example.com --ip 192.0.2.10 \
  --helo mail.example.com --debug

# 在线工具（在浏览器中访问）
# 搜索 "SPF record checker" 使用任意公开的工具，关注 "DNS lookups" 计数

6.3 减少 DNS 查询的实战技巧

• 展开再折叠： 用 ip4 替代 a 和 mx 可以减少查询次数
• 合并 include： 如果有多个第三方 ESP 但它们的出站 IP 范围已知且稳定，可以直接写 ip4 CIDR 而不使用 include
• 自建扁平化记录： 对于大型组织，可以维护一个内部的 IP 范围列表，生成一条不含任何 include 的扁平 SPF 记录
• 子域隔离： 将不同的发信功能拆分到不同子域（newsletter.example.com、transactional.example.com），每个子域只维护自己的小范围 SPF

七、SPF 与 DMARC 协同：Identifier Alignment

前面第一节提到，SPF 只验证 MAIL FROM 域（RFC 5321 信封域），而终端用户看到的是邮件头中的 From: 域（RFC 5322 头域）。如果这两个域不一致，SPF Pass 对用户没有意义——攻击者可以设置一个攻击者自己控制的 MAIL FROM 域并通过 SPF，同时让 From: 显示为受害者的域名。

DMARC（RFC 7489）正是为了解决这个"域对齐"问题而设计的。它的核心概念是 Identifier Alignment ：SPF 认证的域和 DKIM 签名的域，至少有一个必须与 From: 头域"对齐"。

7.1 SPF Alignment 的两种模式

DMARC 为 SPF 对齐定义了两种模式（RFC 7489, Section 3.1.1）：

Relaxed 模式更实用——它允许你在 MAIL FROM 使用子域（如 bounces.example.com ），同时 From: 头域显示 example.com 。Strict 模式要求两个域逐字符相同，虽然更安全但灵活性低。

7.2 DMARC 记录中的 sp= 标签

# 针对 example.com 的 DMARC 记录
_dmarc.example.com.  IN  TXT  "v=DMARC1; p=reject; sp=reject; rua=mailto:dmarc@example.com; ruf=mailto:forensic@example.com; aspf=r"

上面这条记录中：

• p=reject ：主域策略——SPF 或 DKIM 未对齐时拒绝邮件
• sp=reject ：子域策略——同上
• aspf=r ：SPF 对齐模式为 Relaxed（ s 则为 Strict）
• rua / ruf ：聚合/取证报告接收地址

7.3 完整的邮件认证链路

一条邮件经过完整的认证流程，大致如下：

SMTP 连接建立
  │
  ├─ SPF check_host()
  │   ├─ MAIL FROM 域 = example.com
  │   ├─ 连接 IP = 203.0.113.45
  │   ├─ 评估 SPF 记录 → include 匹配 → Pass
  │   └─ 返回: Pass
  │
  ├─ DKIM 验证
  │   ├─ 提取 DKIM-Signature 头
  │   ├─ 查询 d=example.com 的 DKIM 公钥
  │   ├─ 重新计算哈希 → 匹配
  │   └─ 返回: Pass (d=example.com)
  │
  ├─ DMARC 评估
  │   ├─ From: 头域 = example.com
  │   ├─ SPF 域 = example.com → ✅ 对齐 (Relaxed)
  │   ├─ DKIM 域 = example.com → ✅ 对齐
  │   ├─ 至少一个对齐 + Pass → DMARC Pass
  │   └─ 策略 p=reject → 若未对齐则拒绝，此处 Pass
  │
  └─ 投递到收件箱 ✓

八、常见配置模板

8.1 简单域 — 单一 MTA 自建发信

# 仅自己服务器发信，MTA 在 mx.example.com（IP: 198.51.100.10）
# 同时允许 IPv6 地址（如果启用）
example.com.  IN  TXT  "v=spf1 ip4:198.51.100.10 ip6:2001:db8::10 mx -all"

8.2 多云多邮发域 — 自建 + 第三方 ESP

# 场景：
#   - 自建 MTA（192.0.2.0/24）
#   - 营销邮件通过 ESP-A 发送
#   - 事务邮件通过 ESP-B 发送
# DNS 查询：include×2 + a×1 + mx×1(2台MX) = 约 6 次（在 10 次限制内）
example.com.  IN  TXT  "v=spf1 ip4:192.0.2.0/24 a include:_spf.esp-a.com include:_spf.esp-b.com -all"

8.3 使用子域隔离 — 推荐模式

# 主域：不允许任何发信（所有发信通过子域）
example.com.  IN  TXT  "v=spf1 -all"

# 营销子域：由 ESP-A 独家发信
newsletter.example.com.  IN  TXT  "v=spf1 include:_spf.esp-a.com -all"

# 事务子域：由 ESP-B 独家发信
transactional.example.com.  IN  TXT  "v=spf1 include:_spf.esp-b.com -all"

# 企业邮件子域：自建 MTA
corp.example.com.  IN  TXT  "v=spf1 ip4:192.0.2.0/24 mx -all"

这种模式的优点是：每个子域的 SPF 记录极短，DNS 查询量可控，一种发信通道出问题不影响其他通道。

8.4 完全不发信的域 — 防御性 SPF

# 对于纯 Web 域、API 域等从不发送邮件的域
example.com.  IN  TXT  "v=spf1 -all"

这条"零授权"记录的意义在于明确声明"本域不发送任何邮件"——防止攻击者伪造该域发信（RFC 7208, Section 4.6）。即便该域没有邮件服务器，也应该设置这条记录。

九、运维诊断：dig / spfquery / check_host()

SPF 配置完成后需要在真实环境中验证。以下是三个层次的诊断工具。

9.1 dig — 最基本的手动查询

# 查询 SPF 记录（TXT 类型）
dig TXT example.com +short

# 追踪 include 链中的某一层
dig TXT _spf.esp-a.com +short

# 查询 MX 记录（用于理解 mx 机制的展开范围）
dig MX example.com +short

# 查询 A 记录（用于理解 a 机制的展开范围）
dig A mail.example.com +short

# 模拟 exists 机制查询
dig A 192.0.2.10._spf.example.com +short

9.2 spfquery — SPF 官方验证工具

spfquery 是 libspf2 提供的命令行工具，可以完整模拟 check_host() 流程：

# 安装（Debian/Ubuntu）
apt install libspf2-2 spf-tools-perl

# 以 MAIL FROM 身份验证（--scope mfrom）
spfquery --scope mfrom \
  --id user@example.com \
  --ip 203.0.113.45 \
  --helo mail.sender.com

# 输出示例：
# spfquery: domain of example.com designates 203.0.113.45 as permitted sender
# Received-SPF: pass (example.com: ...)
# 
# 带调试输出（查看 DNS 查询次数和评估路径）
spfquery --scope mfrom --id user@example.com --ip 203.0.113.45 --debug 2>&1

9.3 check_host() 流程的 Python 实现

以下是用 Python 实现的简化版 check_host()，展示 SPF 评估的核心逻辑（RFC 7208, Section 4 的流程骨架）：

#!/usr/bin/env python3
"""
check_host() — RFC 7208 Section 4 的简化实现
用于理解 SPF 评估流程，非生产级代码
"""

import dns.resolver
import ipaddress
import re
import sys

DNS_QUERY_LIMIT = 10

def get_spf_record(domain: str, dns_count: list) -> str | None:
    """查询域的 SPF TXT 记录，返回第一条以 v=spf1 开头的记录"""
    if dns_count[0] >= DNS_QUERY_LIMIT:
        return None
    dns_count[0] += 1
    try:
        answers = dns.resolver.resolve(domain, 'TXT')
        for rdata in answers:
            text = ''.join(s.decode() for s in rdata.strings)
            if text.startswith('v=spf1'):
                return text
    except (dns.resolver.NXDOMAIN, dns.resolver.NoAnswer, dns.resolver.NoNameservers):
        pass
    return None

def resolve_a(hostname: str, dns_count: list) -> list[str]:
    """解析 A 记录，返回 IP 列表"""
    if dns_count[0] >= DNS_QUERY_LIMIT:
        return []
    dns_count[0] += 1
    try:
        return [str(r) for r in dns.resolver.resolve(hostname, 'A')]
    except Exception:
        return []

def resolve_mx(domain: str, dns_count: list) -> list[str]:
    """解析 MX 记录，返回所有 MX 主机的 IP 列表"""
    if dns_count[0] >= DNS_QUERY_LIMIT:
        return []
    dns_count[0] += 1
    ips = []
    try:
        answers = dns.resolver.resolve(domain, 'MX')
        for mx in sorted(answers, key=lambda r: r.preference):
            ips.extend(resolve_a(str(mx.exchange), dns_count))
    except Exception:
        pass
    return ips

def evaluate_mechanism(
    mechanism: str,
    domain: str,
    sender: str,
    client_ip: str,
    dns_count: list
) -> str | None:
    """
    评估单个 SPF 机制，返回结果字符串或 None（不匹配）
    结果: "pass" | "fail" | "softfail" | "neutral" | "permerror"
    """
    client_ip_obj = ipaddress.ip_address(client_ip)
    prefix = mechanism[0] if mechanism[0] in '+-~?' else '+'
    mech = mechanism if prefix in '+-~?' and mechanism[0] in '+-~?' else mechanism
    if mechanism[0] in '+-~?':
        mech = mechanism[1:]
    else:
        mech = mechanism

    result_map = {'+': 'pass', '-': 'fail', '~': 'softfail', '?': 'neutral'}

    # ip4
    if mech.startswith('ip4:'):
        cidr = mech[4:]
        if '/' not in cidr:
            cidr += '/32'
        if isinstance(client_ip_obj, ipaddress.IPv4Address):
            if client_ip_obj in ipaddress.ip_network(cidr, strict=False):
                return result_map[prefix]

    # ip6
    elif mech.startswith('ip6:'):
        cidr = mech[4:]
        if '/' not in cidr:
            cidr += '/128'
        if isinstance(client_ip_obj, ipaddress.IPv6Address):
            if client_ip_obj in ipaddress.ip_network(cidr, strict=False):
                return result_map[prefix]

    # all
    elif mech == 'all':
        return result_map[prefix]

    # a
    elif mech.startswith('a'):
        target = domain
        cidr_suffix = '/32'
        m = re.match(r'a(?::([^/]+))?(?:/(\d+))?', mech)
        if m:
            if m.group(1):
                target = m.group(1)
            if m.group(2):
                cidr_suffix = '/' + m.group(2)
        for ip in resolve_a(target, dns_count):
            try:
                if client_ip_obj in ipaddress.ip_network(ip + cidr_suffix, strict=False):
                    return result_map[prefix]
            except ValueError:
                pass

    # mx
    elif mech.startswith('mx'):
        target = domain
        cidr_suffix = '/32'
        m = re.match(r'mx(?::([^/]+))?(?:/(\d+))?', mech)
        if m:
            if m.group(1):
                target = m.group(1)
            if m.group(2):
                cidr_suffix = '/' + m.group(2)
        for ip in resolve_mx(target, dns_count):
            try:
                if client_ip_obj in ipaddress.ip_network(ip + cidr_suffix, strict=False):
                    return result_map[prefix]
            except ValueError:
                pass

    # include
    elif mech.startswith('include:'):
        target = mech[8:]
        included_record = get_spf_record(target, dns_count)
        if included_record:
            return check_host_internal(target, sender, client_ip, dns_count, included_record)
        return None  # include 目标无 SPF 记录 → 不匹配

    # exists
    elif mech.startswith('exists:'):
        hostname = mech[7:]
        if resolve_a(hostname, dns_count):
            return result_map[prefix]

    # ptr (故意省略 — 不推荐使用)
    elif mech.startswith('ptr'):
        pass  # RFC 7208 Section 5.5: SHOULD NOT be used

    return None  # 不匹配

def check_host_internal(
    domain: str,
    sender: str,
    client_ip: str,
    dns_count: list,
    spf_record: str
) -> str:
    """内部递归评估 SPF 记录的所有机制"""
    # 解析机制列表
    mechanisms = spf_record.split()
    mechanisms = [m for m in mechanisms if not m.startswith('v=')]

    for mech in mechanisms:
        if dns_count[0] > DNS_QUERY_LIMIT:
            return 'permerror'

        # redirect= 修饰符
        if mech.startswith('redirect='):
            target = mech[9:]
            redirected_record = get_spf_record(target, dns_count)
            if redirected_record:
                return check_host_internal(target, sender, client_ip, dns_count, redirected_record)
            return 'permerror'

        result = evaluate_mechanism(mech, domain, sender, client_ip, dns_count)
        if result is not None:
            return result

    return 'neutral'

def check_host(sender: str, client_ip: str, helo: str = '') -> str:
    """
    check_host() 入口 — RFC 7208 Section 4
    返回: pass | fail | softfail | neutral | temperror | permerror | none
    """
    domain = sender.split('@')[1] if '@' in sender else sender
    dns_count = [0]

    spf_record = get_spf_record(domain, dns_count)
    if not spf_record:
        return 'none'

    return check_host_internal(domain, sender, client_ip, dns_count, spf_record)

if __name__ == '__main__':
    if len(sys.argv)
<
3:
        print(f"Usage: {sys.argv[0]}   [helo]")
        sys.exit(1)

    sender = sys.argv[1]
    client_ip = sys.argv[2]
    helo = sys.argv[3] if len(sys.argv) > 3 else ''

    result = check_host(sender, client_ip, helo)
    print(f"SPF check_host({sender!r}, {client_ip!r}) = {result}")
    sys.exit(0 if result == 'pass' else 1)

9.4 在线验证工具

除命令行工具外，操作前可以使用公开的在线 SPF 检查器（搜索 "SPF record validator" 或 "SPF check tool"），它们通常会自动展开 include 链、统计 DNS 查询次数、指出潜在的问题。对于初次部署 SPF 的域，建议先用在线工具做一次完整审计再上线。

结语

SPF 从 2003 年的实验性草案走到 2014 年的 RFC 7208 建议标准，已经从一项"锦上添花"的邮件认证技术变成了邮件生态的基础设施。它与 DKIM、DMARC 共同构成现代邮件认证的三支柱，三者缺一不可。SPF 保护的是 SMTP 会话的信封身份，DKIM 保护的是邮件正文和头域的完整性，DMARC 则是将两者对齐并赋予域管理员以策略执行权。

在实际运维中，SPF 的难点往往不在于理解八种机制的定义，而在于管理 include 链的复杂度、控制 DNS 查询不超 10 次限制、以及在 -all 和 ~all 之间做正确的业务判断。建议用子域隔离模式组织不同发信功能、定期用自动化脚本审计 SPF 记录的 DNS 展开量、以及确保 DMARC 的 aspf 对齐模式与 SPF 的 MAIL FROM 域策略一致。

参考文献

1. RFC 7208 — Sender Policy Framework (SPF) for Authorizing Use of Domains in Email, Version 1 (IETF, April 2014). Section 1 Introduction, Section 2.3 MAIL FROM Identity, Section 3 SPF Records, Section 4 The check_host() Function, Section 4.6.4 DNS Lookup Limits, Section 5.1 The "all" Mechanism, Section 5.2 The "include" Mechanism, Section 5.3 The "a" Mechanism, Section 5.4 The "mx" Mechanism, Section 5.5 The "ptr" Mechanism, Section 5.6 The "ip4" and "ip6" Mechanisms, Section 5.7 The "exists" Mechanism, Section 6.1 The "redirect" Modifier, Section 7 Macros.
2. RFC 4408 — Sender Policy Framework (SPF) for Authorizing Use of Domains in E-Mail, Version 1 (IETF, April 2006). Experimental predecessor to RFC 7208.
3. RFC 7489 — Domain-based Message Authentication, Reporting, and Conformance (DMARC) (IETF, March 2015). Section 3.1.1 SPF-Authenticated Identifiers, Section 6.3 aspf Tag.
4. RFC 5321 — Simple Mail Transfer Protocol (IETF, October 2008). Section 4.1.1.2 MAIL Command, Section 4.4 Trace Information (Return-Path).
5. RFC 5322 — Internet Message Format (IETF, October 2008). Section 3.6.2 Originator Fields (From: header).
6. libspf2 — SPF implementation library ( https://www.libspf2.org/ ). Provides spfquery and spftest tools.
7. OpenDMARC — Open source DMARC milter ( http://www.trusteddomain.org/opendmarc/ ). SPF/DKIM/DMARC integration reference.