Security · XB 现场笔记

审计公共边缘的信任

Thu, 06 Aug 2026 00:00:00 +0000

Web 安全系列把设置当作带作用域与失败模式的契约。本教程检查你有权查询的主机。HTTP、TLS 与 DNS 请求是只读观察，但仍会产生日志和流量。SSH 检查读取你自己的信任记录；部署主机可能不同于网站主机。

用一次性本地工作目录保存输出。这里没有任何输出被当作刚测得的 www.xbcatm.com 生产状态；命令通过，只能证明它实际检查的性质。

每项观察只支持范围明确的论断。头部存在、证书日期与本地记录不能合成整站安全认证。

1. 从边缘声明的策略开始

抓取 GET 响应，不默默跟随重定向，再检查状态与头部：

host=www.xbcatm.com
url="https://$host/"
curl -sS --max-time 20 -D headers.txt -o body.html "$url"
cat headers.txt

仓库预期策略包含以下示意字段：

Content-Security-Policy: default-src 'self'; base-uri 'self'; form-action 'none'; frame-ancestors 'none'; object-src 'none'; script-src 'none'; style-src 'self'; img-src 'self' data:
Strict-Transport-Security: max-age=31536000; includeSubDomains
X-Content-Type-Options: nosniff
X-Frame-Options: DENY

script-src 'none' 是适合本站无脚本要求的严格选择，不是所有静态站的通用配方。CSP 由浏览器执行；报告模式不会阻止执行。应读完整策略，检查更具体的脚本指令，并比较普通页与错误路由。nosniff 限制 MIME 处理，尤其是脚本和样式表目标，但不证明正文的媒体类型正确。

HSTS 从有效 HTTPS 响应学习，作用于发送它的主机。www.example.com 的 includeSubDomains 覆盖该名称的后代，不覆盖兄弟 api.example.com 或父域 example.com。采用较长时长前先清点实际范围。代理增加或移除头部会改变浏览器契约，因此产物检查与边缘检查需要分开。

2. 读取证书日期前先验证 TLS 身份

SNI 选择目标虚拟主机，不验证证书名称。应让验证失败成为致命错误，并显式启用主机名验证。使用与受测客户端相适应、保持更新的信任库。

openssl s_client -connect "$host:443" -servername "$host" \
 -verify_hostname "$host" -verify_return_error -showcerts \
 </dev/null > tls.txt 2> tls.log
# Continue only if the command succeeded; preserve tls.log on failure.
openssl x509 -in tls.txt -noout -subject -issuer -dates -ext subjectAltName

分别检查每步结果，或在失败即停止的 shell 设置下运行。隐藏 stderr 或把结果管道给成功的 x509，可能掩盖握手失败。应检查 subjectAltName 的 DNS 名称；显示的 subject CN 不足以完成现代服务身份验证。某些库版本仍保留旧式 CN 回退，因此也要明确检查预期 SAN 存在。合法匹配的通配符可以有效，不相关的证书则不行。

notAfter 给出到期时刻，不证明信任链有效、主机名匹配，也不说明检查过吊销。记录日期与测量出的安全窗口，不要依赖记忆。OpenSSL 的结果描述其已配置的信任库与检查，不代表所有浏览器。

3. 读取呈现链，不虚构固定数量

-showcerts 输出的是服务器发送的证书，不是它们已经组成已验证链的声明。以下命令仅显示数量：

grep -c 'BEGIN CERTIFICATE' tls.txt

不存在“必须四张”的要求。服务器通常提供叶证书及必要的中间证书；根一般属于客户端信任库，不必发送。数量随 CA 与所选路径变化。只有一张时值得调查是否缺少中间证书，但数量本身既不代表成功，也不代表失败。

应使用第 2 步真实的验证结果，再调查签发者或 SAN 变化、中间证书缺失、到期及信任库差异。中间证书轮换可能只是正常 CA 维护；数量没变也可能出错。这个计数命令不会自动与任何预期值作比较。

4. 重新验证已抓取的表示

缓存是另一份契约，不是 TLS 身份证据。按照 HTTP 演练抓取当前 ETag，并对相同表示选择发出条件请求。匹配的条件 GET 可以返回 304；两次请求之间发生发布，则可能合法返回 200。旧的硬编码校验器不是变化站点的可复用测试夹具。

无脚本策略不等于 CSP 永远不变。安全头可以独立于 HTML 改变，正文 ETag 也不是所有响应头的指纹。发布后应再次记录真实策略。

5. 找到适用的 CAA 策略

CAA 约束合规证书机构的签发，不是证书固定，也不会追溯地使已签发证书失效。先检查查询名称及其祖先，保留响应状态，避免把 DNS 失败误当成空答案。

dig www.xbcatm.com CAA +noall +comments +answer
dig xbcatm.com CAA +noall +comments +answer

www 的空答案不代表签发无限制。RFC 8659 会向上寻找第一个适用的非空 CAA 集合，每次查找按 DNS 规则跟随别名；需要时继续检查祖先。检查 issue，涉及通配符签发时还要看 issuewild。只有 iodef 报告地址并不限制签发。若没有适用限制，CAA 不增加签发者限制，但常规域名验证与 CA 规则仍适用。

应将 CA 文档规定的 CAA 标识与适用策略比较，不是只看叶证书中供人阅读的 issuer CN。今天的 CAA 结果证明的是今天的 DNS 策略，不证明证书签发时存在什么策略。

6. 检查部署主机已记录的 SSH 身份

使用真实 SSH 目标；非默认端口需要方括号主机加端口形式。ssh-keygen -F 能找到直接 grep 主机名会遗漏的哈希 known-host 条目。

deploy_host=deploy.example.test
ssh-keygen -F "$deploy_host" -f "$HOME/.ssh/known_hosts" > host-record.txt
ssh-keygen -lf host-record.txt

把指纹与独立可信记录比较，例如提供商控制台或已验证的管理员渠道。这只读取本地记录，不证明远端现在呈现什么密钥。网络扫描到的密钥本身也不能完成身份认证。更新信任前先调查变化；重建只是可能原因，不是自动接受的许可。

检查已抓取响应中的所有 Set-Cookie，以及相关重定向或应用路由。一个页面没设置 Cookie，不证明整站从不设置。主机专用 Cookie 省略 Domain；添加父域 Domain 会扩大接收它的主机范围。Path 控制发送范围，但不是防御同源代码的安全边界。

Secure 限制传输，HttpOnly 阻止脚本访问 Cookie，SameSite 控制规定的跨站发送行为。它们针对不同风险，不能互相代替；现代浏览器中的 SameSite=None 需要 Secure。对本站无账户的内容模型，扩大作用域前应先问为什么需要 Cookie。共享审计记录时应隐藏 Cookie 值。

保留范围明确的审计记录

记录 UTC 时间、客户端版本、请求及最终 URL、状态、强制策略头、TLS 验证结果与日期、适用 CAA 查询及 SSH 记录来源。区分观察成功、意外结果与未执行检查。这几项观察不止“两条命令”，也不能证明整个服务安全。

证书、DNS、代理或部署变化后，重做相关检查。保留旧结果以发现漂移；论断依赖浏览器执行时，应另行测试真实浏览器行为。

来源

WHATWG Fetch Standard，nosniff 处理与请求目标，已核验 2026-10-15。
OpenSSL s_client，SNI、主机名验证、致命验证错误与呈现链，已核验 2026-10-15。
RFC 9525：Service Identity in TLS，基于 SAN 的服务身份与通配符匹配，已核验 2026-10-15。
RFC 8659：CAA，适用记录集搜索与签发策略，已核验 2026-10-15。
RFC 6797：HSTS，主机范围与策略处理，已核验 2026-10-15。
OpenSSH ssh-keygen，已知主机查找与指纹显示，已核验 2026-10-15。
W3C：CSP Level 3，强制与报告模式及脚本指令回退（工作草案），已核验 2026-10-15。
MDN：Set-Cookie，Cookie 属性与边界，已核验 2026-10-15。

SSH 主机密钥是部署记录的一部分

Tue, 28 Jul 2026 00:00:00 +0000

在公钥认证中，客户端证明自己持有私钥，但它并不告诉客户端到达的是哪台服务器。服务器的主机密钥与本地 known_hosts 数据库，提供身份检查的后一半。

SSH 服务器身份依赖观察到的主机密钥与独立可信参考之间的比较。严格检查拒绝未知或变化的密钥。首次使用时信任与网络密钥扫描，都不能独立认证首次接触的服务器。

把首次接触与轮换分开

在 StrictHostKeyChecking=yes 下，SSH 拒绝未知主机与变化的密钥。对于一个固定生产端点，只要期望密钥通过可信渠道安装，这就是最安全的默认值。accept-new 是面向预期会出现新主机的、更窄的方便选项：它接受一个从未见过的密钥，但仍拒绝被更改的密钥。

Host production-site
HostName www.example.test
User deploy
IdentityFile ~/.ssh/site_ed25519
StrictHostKeyChecking yes
UserKnownHostsFile ~/.ssh/known_hosts

不要通过给部署脚本加 StrictHostKeyChecking=no 来"修复"警告。它会在客户端限制条件下允许连接到密钥已变化的主机；警告可能仍被打印，但原本遇到身份问题就拒绝的检查已被削弱。如果主机被重建，请记录替换后的指纹，并复核旧密钥为何不再有效。

让指纹可复核

在首次连接之前，从主机所有者或控制台获取指纹，再与客户端看到的值比较。密钥变更应有工单、维护说明或其他他人可检视的解释。

同一规则适用于自动化：known-hosts 文件是带有安全后果的配置，不是可丢弃的缓存数据。把它与部署记录一起备份，但不要把私钥或复制的凭据随站点制品一起公开。

accept-new 是首次使用时信任，并不能独立证明第一次连接的服务器真实可信。ssh-keyscan 能采集候选公钥，但通过同一条不可信网络取回它，并不能认证它。安装前先将指纹与独立可信渠道取得的值比较。

把上面的配置单独保存为 deploy.conf，在不连接服务器的情况下检查有效配置：

ssh -G -F ./deploy.conf production-site | \
 grep -E '^(hostname|user|stricthostkeychecking|userknownhostsfile) '

结果应显示配置中的主机、用户、known-hosts 路径与严格检查（客户端输出可能为 true 或 yes）。这只解析配置，并不测试真实握手。非标准端口的 known-hosts 条目通常采用 [hostname]:port。将主机公钥指纹保存在私有运维发布记录中，不要随公共网站发布；即使主机公钥不是秘密，主机名也可能暴露内部拓扑。

来源

OpenBSD ssh_config，StrictHostKeyChecking 与 UserKnownHostsFile，已核验 2026-07-28。
OpenSSH ssh-keygen 手册，指纹检视，已核验 2026-07-28。
OpenSSH ssh-keyscan，未经核验采集的密钥不能防止中间人攻击，已核验 2026-10-15。
OpenSSH ssh，-G 不建立会话，打印求值后的客户端配置，已核验 2026-10-15。

SSH 密钥卫生，主要是限制密钥能干什么

Mon, 06 Jul 2026 00:00:00 +0000

SSH 密钥卫生首先要回答：哪份凭据授予什么访问，谁负责，以及如何结束这份授权。密钥注释方便维护清单，却不是经过认证的所有者记录，更不是授权规则。应把指纹与负责人、目标账号、允许操作和移除计划对应起来。生成现代密钥只是开始，不能用一条生成命令代替完整的访问生命周期管理。

限定服务端权限

authorized_keys 中的公钥通常用于授权访问某个账号，同时还受服务器其他控制约束。自动化任务应结合权限有限的账号和经过选择的选项。强制命令能限制执行的操作，from 可以限制来源地址，但二者都不会自动把进程关在某个工作目录，也不会让一个会拼接不可信命令的包装脚本变得安全。

restrict 禁用转发、伪终端分配和 ~/.ssh/rc，但显式搭配选项可以重新启用个别功能；它本身并不禁止 shell 或命令执行。因此，无人值守任务通常还需要谨慎实现的强制命令。no-agent-forwarding 只禁止代理转发，不能证明密钥没有普通 shell 权限。principals 对可信证书颁发机构条目有专门含义，并不是加在任意普通公钥前面就能形成通用身份约束。

还要审阅最终生效的服务端配置和其他授权来源。AuthorizedKeysCommand、证书颁发机构、账号权限和 Match 规则，都会让结果超出单个文件的内容。清单工具看到选项名时应报告观察事实，不能直接给出“已限制，所以安全”的结论。来源限制也取决于服务器实际看到的地址，包括代理、跳板机或地址转换后的来源，不能只按客户端想象的拓扑解释。

区分密钥类型与签名算法

RSA 公钥行仍使用 ssh-rsa 类型标签，即使认证时采用 rsa-sha2-256 或 rsa-sha2-512 签名。OpenSSH 8.8 默认禁用的是使用 SHA-1 的 ssh-rsa 签名方案，而不是所有 RSA 密钥。应检查密钥长度与实际支持的签名算法，不能只凭一行的第一个词就把所有 RSA 条目判成过时。DSA、弱参数和不受支持的配置，需要各自的迁移计划。

新凭据应选择当前环境支持的算法和合适的保护。口令可以保护加密私钥文件，避免文件被复制后立刻就能使用；硬件密钥则提供不同的边界。它们都不能代替安全工作站、受控代理访问和服务端权限限制。无法交互输入口令的自动化，需要明确的凭据保管和更新设计，不能简单地把“没有提示”当成设计完成。

坏掉的样子

只追加新公钥的轮换，会让旧凭据继续得到授权。应从所有相关来源移除退役条目，验证替代凭据，并单独处理现有会话。普通裸公钥不会自动携带到期机制；需要通过支持的服务端选项、SSH 证书或明确的生命周期操作执行过期。在注释里写一个日期不会产生任何强制效果，负责人离职也不会自动让那一行失效。

权限数字需要准确解释。私钥应限制为所有者访问，常见模式是 0600；私有目录常见模式是 0700。authorized_keys 的公钥内容并不是秘密，在所有权和写保护满足检查时，0644 也可能被服务器接受。采用更严格的 0600 策略合理，却不能声称每个其他模式都证明已经泄露。ACL、父目录和平台规则仍需分别核对，简单的模式检查并不涵盖全部访问路径。

按空白直接切分 authorized_keys，会破坏含有带引号空格的命令。转义引号和逗号又会进一步增加自制解析器误读的机会。可使用 OpenSSH 检查指纹，再独立审阅选项语义。指纹一致只能说明找到的是哪把公钥，不能证明限制真的生效，也不能证明对应私钥设置了口令。自动审计输出应避免给出超出这些证据的保证。

清单识别密钥，实际授权定义它能在哪里使用。密钥标签、协商签名与退役是独立检查。

快速验证

保存为 ssh_hygiene.py，在安装了 OpenSSH 的环境执行 python3 ssh_hygiene.py。程序在临时目录生成可丢弃的 Ed25519 和三千零七十二位 RSA 密钥。空口令仅用于这个隔离实验；脚本不会读取或更改真实 SSH 文件，不连接任何主机，也不加载代理。正常退出会尝试清理生成文件；实验不会向任何服务器添加授权。

from pathlib import Path
import os
import stat
import subprocess
import tempfile


def run(*args):
 return subprocess.run(args, text=True, capture_output=True, check=True,
 env={'PATH': os.defpath}).stdout.strip()


with tempfile.TemporaryDirectory(prefix='ssh-hygiene-') as directory:
 work = Path(directory)
 # Throwaway, passphrase-less keys for this isolated fixture only.
 ed = work / 'demo_ed25519'
 rsa = work / 'demo_rsa'
 run('ssh-keygen', '-q', '-t', 'ed25519', '-N', '', '-C', 'fixture-ed', '-f', str(ed))
 run('ssh-keygen', '-q', '-t', 'rsa', '-b', '3072', '-N', '', '-C', 'fixture-rsa', '-f', str(rsa))
 public = ed.with_suffix('.pub').read_text().strip()
 auth = work / 'authorized_keys'
 auth.write_text('restrict,command="printf \\"two words\\"" ' + public + '\n')
 auth.chmod(0o600)
 parsed = run('ssh-keygen', '-l', '-f', str(auth))
 original = run('ssh-keygen', '-l', '-f', str(ed.with_suffix('.pub')))
 if parsed.split()[1] != original.split()[1]:
 raise RuntimeError('quoted options changed the key fingerprint')
 rsa_public = rsa.with_suffix('.pub').read_text().split()[0]
 if rsa_public != 'ssh-rsa':
 raise RuntimeError('unexpected RSA public key type')
 signatures = set(run('ssh', '-Q', 'key-sig').splitlines())
 if not {'rsa-sha2-256', 'rsa-sha2-512'} <= signatures:
 raise RuntimeError('client does not advertise RSA SHA-2 signatures')
 modes = {p.name: oct(stat.S_IMODE(p.stat().st_mode)) for p in (ed, rsa, auth)}
 if any(stat.S_IMODE(p.stat().st_mode) & 0o077 for p in (ed, rsa)):
 raise RuntimeError('fixture private key permissions are too broad')
 print('quoted authorized_keys fingerprint:', parsed)
 print('RSA key label:', rsa_public, '; SHA-2 signature algorithms supported')
 print('fixture modes:', modes)
 print('PASS: native key parsing, fingerprint agreement, RSA distinction, private modes')

预期看到带引号命令后仍匹配的 Ed25519 指纹、ssh-rsa 公钥标签以及本机支持 RSA SHA-2 签名的结果、所有者专用的私钥权限，最后打印 PASS。指纹和临时路径每次都会变化。上下文管理器会在退出时尝试删除生成文件，但不提供安全擦除保证。输出不包含私钥内容，本轮源码复核也没有生成密钥或重跑夹具。这个过程证明特定输入可以被原生工具识别，而不是证明任意配置都会被服务器接受。

客户端算法查询只说明本地能力，不说明某台服务器实际允许什么。同样，ssh-keygen 读取指纹也不是强制命令或全部选项的端到端测试。真正审计时，应把每个指纹映射到负责人，在隔离环境验证服务端授权和命令行为，并清楚区分已观察事实与尚未验证的控制。需要修改授权文件时，还应保留受控恢复方式，避免把清理操作变成意外锁定。

来源

OpenBSD: sshd，authorized_keys 格式、选项与文件所有权检查，已核验 2026-10-15。
OpenSSH 8.8 发布说明，RSA 密钥与弃用的 SHA-1 签名的区别，已核验 2026-10-15。
OpenBSD: ssh-keygen，密钥生成与指纹检查，已核验 2026-10-15。
NIST IR 7966，SSH 访问清单与生命周期管理，已核验 2026-10-15。

防火墙策略必须匹配报文路径、地址族和链顺序

Wed, 01 Jul 2026 00:00:00 +0000

防火墙在网络栈的特定位置执行报文策略。一条有用规则因此不只包含端口，还要明确地址族、挂钩、方向、连接状态和相对其他规则的位置。nftables 基础链按指定优先级接入 Netfilter 挂钩。报文实际经过的路径，决定它会遇到哪些裁决，而不是运维文档中描述的先后顺序。审阅策略必须保留这些执行上下文。

坏掉的样子

规则位于错误挂钩时，预期流量可能完全不受影响。INPUT 处理交付给当前命名空间本地的流量，FORWARD 处理经过它转发的流量，OUTPUT 面向本地产生的流量。宿主的容器转发路径，不一定就是本地输入路径。假定宿主级规则保护所有附近服务之前，应先查清实际流量经过哪个命名空间和挂钩。

地址族和方向错误也容易被掩盖。允许服务 TCP 目的端口，不同于匹配通常临时分配的客户端来源端口。只覆盖 IPv4 的策略不会自动覆盖 IPv6；IPv6 通信还依赖邻居发现等 ICMPv6 功能，丢弃所有非 TCP 报文，可能让 TCP 端口明明被允许的连接仍然失败。端口规则不能脱离链路和协议所需控制流量解释。

nftables 的 accept 不一定是所有基础链中的最终裁决。同一挂钩上更晚优先级的另一条链，仍能丢弃报文；drop 则会结束其遍历。只审阅一个表或一条链，可能看到允许计数器增长，却无法解释客户端为何失败。应查看全部适用规则集及其挂钩优先级，不能把第一条可见 accept 当成系统已经最终放行的证明。

后续输入链可丢弃先前已接受的报文。端口结果是实验预期；当前集成仍待验证。

快速验证

将脚本保存为 check-firewall.py，只在获得授权、装有 Docker 的一次性虚拟机中执行 python3 check-firewall.py。历史文章报告使用 nftables 1.0.6 和 Python 3.11.16；保留验证文件中未找到原始集成日志，本轮没有重跑。需启用 Python 断言；清理仅尽力执行。两个命名空间通过一次性 veth 使用 IPv4 与 IPv6 通信。NET_ADMIN 和 SYS_ADMIN 是重要权限；规则限定在命名空间内，并不让容器变成可靠安全边界。设置失败时不要削弱宿主保护。镜像摘要也不会冻结 apt 仓库，指定版本的软件包以后可能无法取得：

from pathlib import Path
from tempfile import TemporaryDirectory
import json,subprocess,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends iproute2=6.1.0-3 iputils-ping=3:20221126-1+deb12u1 nftables=1.0.6-2+deb12u2 tcpdump=4.99.3-1 traceroute=1:2.1.2-1 procps=2:4.0.2-3 && rm -rf /var/lib/apt/lists/*\nCMD ["python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,os,select,signal,subprocess,time

def run(*args,check=True,input=None,timeout=8):
 result=subprocess.run(args,input=input,capture_output=True,text=True,timeout=timeout)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def ns(name,*args,**kwargs):return run('ip','netns','exec',name,*args,**kwargs)
def ip(name,*args,**kwargs):return ns(name,'ip',*args,**kwargs)
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=2)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=2)
def line(process,timeout=3):
 assert select.select([process.stdout],[],[],timeout)[0],'child response deadline exceeded'
 value=process.stdout.readline();assert value,'child exited without a response'
 return value
def spawn(stack,command):
 process=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);return process
@contextmanager
def lab(names):
 with TemporaryDirectory(prefix='net-path-') as directory,ExitStack() as stack:
 root=Path(directory);proc=root/'proc';proc.mkdir();run('mount','-t','proc','proc',str(proc))
 stack.callback(run,'umount',str(proc))
 for name in names:
 run('ip','netns','add',name);stack.callback(run,'ip','netns','delete',name,check=False)
 ip(name,'link','set','lo','up')
 def setting(name,key,value):
 assert name in names
 path=proc/'sys'/key.replace('.','/')
 return ns(name,'python3','-c',f'from pathlib import Path; p=Path({str(path)!r}); p.write_text({str(value)!r}); print(p.read_text().strip())').stdout.strip()
 yield root,stack,setting
def wire(left,left_if,right,right_if,left_addresses,right_addresses):
 run('ip','link','add',left_if,'type','veth','peer','name',right_if)
 for name,interface,addresses in [(left,left_if,left_addresses),(right,right_if,right_addresses)]:
 run('ip','link','set',interface,'netns',name)
 for address in addresses:ip(name,'address','add',address,'dev',interface,*(['nodad'] if ':' in address else []))
 ip(name,'link','set',interface,'up')
def nft(name,script):return ns(name,'nft','-f','-',input=script)
def counters(name):
 data=json.loads(ns(name,'nft','-j','list','ruleset').stdout);found={}
 for entry in data['nftables']:
 rule=entry.get('rule',{})
 if 'comment' in rule:
 for expression in rule['expr']:
 if 'counter' in expression:found[rule['comment']]=expression['counter']['packets']
 return found

def server(stack,name,address,port=18080,label='server'):
 code=r'''
from http.server import BaseHTTPRequestHandler,ThreadingHTTPServer
import json,socket,sys
address,port,label=sys.argv[1],int(sys.argv[2]),sys.argv[3]
class Handler(BaseHTTPRequestHandler):
 def do_GET(self):
 body=json.dumps({'server':label,'peer':self.client_address,'path':self.path}).encode()
 self.send_response(200);self.send_header('Content-Length',str(len(body)));self.end_headers();self.wfile.write(body)
 def log_message(self,*args):pass
class Server(ThreadingHTTPServer):
 address_family=socket.AF_INET6 if ':' in address else socket.AF_INET
 def server_bind(self):
 if self.address_family==socket.AF_INET6:self.socket.setsockopt(socket.IPPROTO_IPV6,socket.IPV6_V6ONLY,1)
 super().server_bind()
service=Server((address,port),Handler);print('ready',flush=True);service.serve_forever()
'''
 process=spawn(stack,['ip','netns','exec',name,'python3','-u','-c',code,address,str(port),label])
 assert line(process).strip()=='ready';return process
def request(name,address,port=18080):
 code=r'''
import http.client,json,sys
client=http.client.HTTPConnection(sys.argv[1],int(sys.argv[2]),timeout=.7)
try:
 client.request('GET','/lab-visible-message');response=client.getresponse();body=json.loads(response.read())
 assert response.status==200;print(json.dumps({'ok':True,'status':response.status,'body':body}))
except OSError as error:print(json.dumps({'ok':False,'type':type(error).__name__,'errno':error.errno}))
finally:client.close()
'''
 return json.loads(ns(name,'python3','-c',code,address,str(port)).stdout)

with lab(['client','target']) as (root,stack,setting):
 wire('client','c0','target','t0',['192.0.2.1/30','2001:db8:1::1/64'],['192.0.2.2/30','2001:db8:1::2/64'])
 addresses=['192.0.2.2','2001:db8:1::2']
 for address in addresses:
 for port in [18080,18081,18082]:server(stack,'target',address,port)
 before={a:[request('client',a,p) for p in [18080,18081,18082]] for a in addresses}
 assert all(v['ok'] for values in before.values() for v in values)
 nft('target','''table inet gate {
 chain input { type filter hook input priority 0; policy drop;
 iifname "lo" accept
 ct state established,related accept
 meta l4proto ipv6-icmp accept
 ip protocol icmp accept
 ip saddr 192.0.2.1 tcp dport 18080 counter accept comment "allow4"
 ip6 saddr 2001:db8:1::1 tcp dport 18080 counter accept comment "allow6"
 tcp dport 18081 counter reject with tcp reset comment "reject"
 tcp dport 18082 counter drop comment "drop"
 }
}
''')
 after={a:[request('client',a,p) for p in [18080,18081,18082]] for a in addresses}
 for values in after.values():
 assert values[0]['ok'] and not values[1]['ok'] and values[1]['errno']==111
 assert not values[2]['ok'] and values[2]['type']=='TimeoutError'
 first=counters('target');assert all(first[n]>0 for n in ['allow4','allow6','reject','drop'])
 nft('target','''table inet later {
 chain input { type filter hook input priority 10; policy accept;
 tcp dport 18080 counter drop comment "later_drop"
 }
}
''')
 overridden=request('client','192.0.2.2');assert not overridden['ok'] and overridden['type']=='TimeoutError'
 later=counters('target');assert later['allow4']>first['allow4'] and later['later_drop']>0
 nft('target','delete table inet later')
 recovered=request('client','192.0.2.2');assert recovered['ok']
 print(json.dumps({'before_all_ports_healthy':True,'with_rules':after,'first_counters':first,
 'later_chain_overrides_accept':overridden,'later_counters':later,'later_chain_removed':recovered}))
"""
name='xbcatm-netpath-'+uuid.uuid4().hex[:10]
def docker(*args,**kwargs):return subprocess.run(['docker',*args],capture_output=True,text=True,timeout=300,**kwargs)
try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'Dockerfile').write_text(recipe)
 build=docker('build','-t',name,str(root));assert build.returncode==0,build.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--cap-add','NET_ADMIN','--cap-add','SYS_ADMIN',
 '--memory','256m','--pids-limit','128',name,'python3','-',input=program)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),sort_keys=True))
finally:
 docker('rm','-f',name);docker('image','rm',name)

目标在两个地址族分别启动一万八千零八十、一万八千零八十一和一万八千零八十二端口的真实 HTTP 监听。过滤之前，六种请求都成功。这个基线很重要，后续失败不能简单归因于缺少监听或某个地址族尚未配置。然后程序安装默认丢弃的 inet 输入链，同时保留回环、已建立流量和选定的 ICMP 处理。

两个地址族分别用明确来源地址规则允许目的端口一万八千零八十，但地址过滤与连接状态跟踪并不认证用户身份；一万八千零八十一通过 TCP reset 拒绝，一万八千零八十二静默丢弃。两种地址族的探测都符合预期：依次获得 HTTP 二百、错误号一百一十一的 ConnectionRefusedError，以及 TimeoutError。超时由本例客户端截止时间决定，不承诺所有应用等待相同长度。

规则计数器确认报文经过允许、拒绝和丢弃分支。拒绝连接与等待超时都表现为失败，但具体语义不同。计数器补充客户端结果，配置文本或单独一个计数器都不能证明应用交换了预期响应。本例的成功请求还核对状态并记录服务身份，把规则评估与最终应用行为联系起来，避免只看到计数增加便宣布功能已经正确。

脚本再增加优先级十的输入基础链，位于原优先级零的链之后，并丢弃一万八千零八十端口。新的 IPv4 请求超时，同时较早的允许计数与较晚的丢弃计数均增长。只移除后续链，HTTP 就恢复成功。这个实验用真实报文验证链之间的相互作用，没有根据单条规则外观推断最终通行结果。

用代表性流量审阅生效策略

通过可审阅配置流程一起维护访问意图和生成规则。应用变更前检查语法，之后检查生效状态，并执行允许与拒绝探测。已建立状态处理可能维持现有会话，而新连接表现不同，因此策略更新测试应包含新建连接。本实验每个比较都创建新客户端连接，避免旧会话继续工作掩盖新的接入规则。

依据工作负载真实依赖与运维要求定义出口策略。它与入站监听是不同决策，不能仅从开放的服务器端口推导统一出口清单。DNS、目标地址变化、相关控制流量和转发连接，都需要对应上下文。本实验验证目标输入行为，没有声称检查生产出口或所有容器运行时的转发规则。范围应按实际经过的路径说明。

允许的服务失败时，把客户端错误与地址族、来源和目的地、命名空间、挂钩、命中计数及后续链对应起来。监听本身需要另外确认，路径仍不清楚时再补充报文证据。简洁策略只有在生效行为与这些检查一致时才可靠，其中也包括拒绝请求应当以何种具体方式失败。可审计性来自规则与实际结果能够相互解释。

来源

nftables manual，地址族、挂钩、状态匹配、计数器与裁决，已核验 2026-09-12。
nftables chain configuration，基础链优先级与后续链覆盖 accept 的行为，已核验 2026-09-12。
RFC 4890 ICMPv6 filtering，IPv6 通信依赖的 ICMPv6 处理要求，已核验 2026-09-12。

用实际拒绝结果验证 systemd 服务边界

Sat, 27 Jun 2026 00:00:00 +0000

服务加固应该把一种明确不需要的操作变为被拒绝的操作，同时保留应用必须完成的工作。systemd 为文件系统视图、命名空间、权限和其他资源提供执行设置，但这些是边界各不相同的独立控制。添加四条熟悉的指令，并不意味着所有可读文件、可接触进程、继承的文件描述符或允许的系统调用都会消失。判断依据应是配置的真实语义与进程的实际行为。

坏掉的样子

ProtectSystem=strict 让服务挂载命名空间内的大部分文件系统层级变为只读。只读不代表不可读取，而且该设置有文档明确的例外，例如还需要单独控制的接口文件系统。服务仍然可能泄露它能够读取的信息，也仍然可以破坏可写目录中的数据。因此应该先使用专用服务身份，列清必要访问，再选择对应限制，而不是把一个只读开关当成覆盖所有资源的隔离墙。

PrivateTmp=yes 给服务提供私有临时目录。如果应用原本依赖另一个服务通过普通 /tmp 交换文件，这项设置可能直接打断协作。PrivateNetwork=yes 创建拥有独立回环接口的网络命名空间，因此宿主回环上的监听器不再是里面的同一个端点。需要直接连接数据库或公共接口的程序，若没有有意安排所需连接，就不适合直接套用这一设置。应先查真实调用路径，不能假定网络隔离不会影响正常功能。

NoNewPrivileges=yes 阻止执行程序时通过设置用户身份的二进制文件、文件能力等机制取得新的特权，并不删除进程已经拥有的权限。同样，单独写一条 IPAddressAllow，不意味着其他地址全部被拒绝：地址过滤有允许与拒绝的优先关系，还依赖内核功能支持。选项名称不是完整安全策略，每项控制都需要按其契约理解，尤其不能把未验证的限制写成已经成立的保证。

不同 systemd 控制拒绝选定操作，同时保留受管理状态与临时写入。

快速验证

这个实验要求一次性 Linux 系统中的 root 身份、作为 PID 1 的 systemd、可用的挂载与网络命名空间、位于 /usr/bin/python3 的 Python 3.8 或更新版本，以及用户管理工具。保持 Python 断言启用；生成的 worker 必须能被服务账号读取。早期记录报告 Debian 12、systemd 252.39；这里没有复现该次运行。脚本创建唯一命名的账号、运行时单元、状态目录与文件。前后两阶段使用同一个非 root 工作负载：

from pathlib import Path
from tempfile import mkdtemp
import grp,json,os,pwd,socket,subprocess,sys,uuid

def cleanup_steps(steps, primary):
 failures=[]
 for label, action in steps:
 try:action()
 except BaseException as error:
 failures.append(label+': '+type(error).__name__+': '+str(error))
 if failures:
 message='cleanup incomplete or uncertain: '+'; '.join(failures)
 try:print(message,file=sys.stderr)
 except (OSError,ValueError):pass
 if primary is None:raise RuntimeError(message)
 return failures

def remove_file(path):
 try:path.unlink()
 except FileNotFoundError:pass

def require_empty(value):
 if value:raise RuntimeError('residual resources: '+str(value))

suffix=uuid.uuid4().hex[:12];name='xbcatm-hardening-'+suffix
unit=name+'.service';unit_path=Path('/run/systemd/system')/unit
state=Path('/var/lib')/name;marker=Path('/tmp')/(name+'-marker');scratch=Path('/tmp')/(name+'-scratch')
assert os.geteuid()==0,'requires an explicitly prepared disposable systemd test system'
for path in [unit_path,state,marker,scratch]:assert not os.path.lexists(path),path
def account_exists():
 try:pwd.getpwnam(name);return True
 except KeyError:return False
def group_exists():
 try:grp.getgrnam(name);return True
 except KeyError:return False
assert not account_exists() and not group_exists()
def command(args):
 result=subprocess.run(args,capture_output=True,text=True,timeout=10)
 assert result.returncode==0,(args,result.stderr)
 return result.stdout.strip()
def ctl(*args):return command(['systemctl',*args])
def delete_account():
 if account_exists():command(['userdel',name])
def delete_group():
 if group_exists():command(['groupdel',name])
root=None;listener=connection=None;owned_files=[];account_attempted=False;unit_attempted=False
# Reserve each ordinary file exclusively and record it before writing or chmod.
def create_file(path,text,mode):
 with path.open('x') as output:
 owned_files.append(path)
 output.write(text)
 path.chmod(mode)
print('fixture:',name,'unit:',unit_path,'state:',state,'marker:',marker,'scratch:',scratch,flush=True)
try:
 root=Path(mkdtemp(prefix=name+'-',dir='/run'));root.chmod(0o755)
 outside=root/'outside';create_file(outside,'initial\n',0o666)
 create_file(marker,'host namespace marker\n',0o644)
 create_file(scratch,'',0o666)
 listener=socket.socket();listener.settimeout(2)
 listener.bind(('127.0.0.1',0));listener.listen(2)
 worker=root/'worker.py'
 create_file(worker,r"""from pathlib import Path
import json,socket,sys
root=Path(__file__).parent;state=Path(sys.argv[1]);marker=Path(sys.argv[2]);scratch=Path(sys.argv[3]);port=int(sys.argv[4]);phase=sys.argv[5]
result={}
try:
 with (root/'outside').open('a') as output:output.write(phase+'\n')
 result['outside_write']=True
except OSError as error:result['outside_write']=False;result['outside_errno']=error.errno
result['host_tmp_visible']=marker.exists()
scratch.write_text(phase);result['tmp_write']=scratch.read_text()==phase
try:
 with socket.create_connection(('127.0.0.1',port),timeout=0.5):pass
 result['network_connect']=True
except OSError as error:result['network_connect']=False;result['network_errno']=error.errno
status=dict(line.split(':',1) for line in Path('/proc/self/status').read_text().splitlines() if ':' in line)
result['no_new_privs']=status['NoNewPrivs'].strip()
(state/'result.json').write_text(json.dumps(result))
""",0o644)
 definition=f'''[Service]
Type=oneshot
User={name}
Group={name}
StateDirectory={name}
StateDirectoryMode=0700
TimeoutStartSec=5s
TimeoutStopSec=5s
KillMode=control-group
ExecStart=/usr/bin/python3 {worker} {state} {marker} {scratch} {listener.getsockname()[1]} PHASE
'''
 account_attempted=True
 command(['useradd','--system','--no-create-home','--user-group','--shell','/usr/sbin/nologin',name])
 create_file(unit_path,definition.replace('PHASE','baseline'),0o644)
 unit_attempted=True
 ctl('daemon-reload');ctl('start',unit)
 baseline=json.loads((state/'result.json').read_text())
 assert baseline=={'outside_write':True,'host_tmp_visible':True,'tmp_write':True,'network_connect':True,'no_new_privs':'0'},baseline
 connection,_=listener.accept()
 connection.close();connection=None
 original=outside.read_text()
 settings='ProtectSystem=strict\nPrivateTmp=yes\nPrivateNetwork=yes\nNoNewPrivileges=yes\n'
 unit_path.write_text(definition.replace('PHASE','hardened')+settings)
 command(['systemd-analyze','verify',str(unit_path)])
 ctl('daemon-reload');ctl('start',unit)
 hardened=json.loads((state/'result.json').read_text())
 assert hardened['outside_write'] is False and hardened['outside_errno']==30,hardened
 assert hardened['host_tmp_visible'] is False and hardened['tmp_write'] is True
 assert hardened['network_connect'] is False and hardened['network_errno']==111,hardened
 assert hardened['no_new_privs']=='1'
 assert outside.read_text()==original and scratch.read_text()=='baseline'
 print('baseline: outside write, host tmp visibility, loopback connection permitted; NoNewPrivs=0')
 print('hardened: outside write=EROFS; host tmp hidden; host listener refused; NoNewPrivs=1')
 print('managed state directory and private temporary writes still succeed')
finally:
 primary=sys.exc_info()[1];failures=[];quiescent=not unit_attempted
 # A failed stop does not skip the independently attempted state query or socket close.
 def attempt(label,action):
 try:return action()
 except BaseException as error:
 failures.append(label+': '+type(error).__name__+': '+str(error))
 if unit_attempted:
 attempt('stop '+unit,lambda:ctl('stop',unit))
 status=attempt('unit state',lambda:ctl('show',unit,'-p','ActiveState','-p','MainPID','-p','ControlPID'))
 if status is not None:
 properties=dict(line.split('=',1) for line in status.splitlines() if '=' in line)
 quiescent=properties.get('ActiveState') in ('inactive','failed') and properties.get('MainPID')=='0' and properties.get('ControlPID')=='0'
 if connection is not None:attempt('accepted socket close',connection.close)
 if listener is not None:attempt('listener close',listener.close)
 if quiescent:
 if unit_attempted:
 attempt('reset failed state',lambda:ctl('reset-failed',unit))
 for path in reversed(owned_files):attempt('file '+str(path),lambda path=path:remove_file(path))
 if unit_attempted:attempt('daemon reload',lambda:ctl('daemon-reload'))
 if unit_attempted and os.path.lexists(state):
 if state.is_symlink():failures.append('unexpected state symlink; retained '+str(state))
 else:
 attempt('state result',lambda:remove_file(state/'result.json'))
 attempt('state directory',state.rmdir)
 if account_attempted:
 attempt('account '+name,delete_account)
 attempt('group '+name,delete_group)
 if root is not None:attempt('temporary directory '+str(root),root.rmdir)
 for path in owned_files+([state] if unit_attempted else [])+([root] if root is not None else []):
 attempt('absence '+str(path),lambda path=path:require_empty(str(path) if os.path.lexists(path) else ''))
 if account_attempted:
 attempt('account absence',lambda:require_empty(name if account_exists() else ''))
 attempt('group absence',lambda:require_empty(name if group_exists() else ''))
 else:
 failures.append('unit may still run; retain its unit, account/group, state and files for manual recovery: '+name)
 if failures:
 message='cleanup incomplete or uncertain: '+'; '.join(failures)
 try:print(message,file=sys.stderr)
 except (OSError,ValueError):pass
 if primary is None:raise RuntimeError(message)

修订后的夹具尚未运行，只能使用独占控制的一次性系统；root 身份或容器标记不证明隔离。准备前建立保护，预检 scratch、账号和组，排他创建文件，并把 worker 与目录权限设为 0644/0755；ACL 仍须核验。管理命令设十秒超时，单元启动及停止限五秒，接受连接限两秒。停止失败不会跳过状态检查或套接字关闭；服务状态不明时保留文件与账号，供人工恢复。其余删除及残留检查独立尝试；错误不替换最初异常，只有清理失败时也会失败。超时操作稳定后须检查打印出的名称。进程创建、文件系统或 NSS 停滞与突然终止仍不受时限约束。

基线阶段故意让该账号能够写入一个样本文件，同时在管理器看到的临时目录里创建标记，并在其回环接口启动监听器。尚未加限制时，工作进程能够追加文件、看到标记、连接监听器，且读取到零值的 NoNewPrivs 标志。这一步排除了普通文件权限本来就禁止写入、或者监听器根本不存在等混淆因素，之后的拒绝才有明确对照。

加固阶段加入四项执行设置，然后重复同样的探测。外部样本文件写入以 EROFS 失败，因此不是仅仅因为文件所有者不匹配而失败。原来的临时标记在新视图中不可见，连接原监听端点得到 ECONNREFUSED，而进程报告 NoNewPrivs=1。这些证据来自实际工作进程，不是只检查单元解析器是否认识几个配置名字；每个结果都对应本次改变的具体边界。

必要的写入仍然成功：StateDirectory 创建服务使用的受管理可写状态位置，私有临时目录也允许写入自己的样本文件。从管理器命名空间观察，同名临时文件仍保留基线阶段的内容，说明第二次写入发生在另一份临时目录视图中。外部样本文件同样保持此前内容，进一步确认失败操作没有悄悄改变目标文件。

脚本断言这些精确结果，并在启动前验证修改后的单元定义。它没有测试漏洞利用、系统调用过滤或基于 BPF 的地址策略。因此本实验是在配置检查之外，补上所展示几项控制的运行时证据，而不是声称所有可能的访问路径都已经被封闭。部署时如果增加其他控制，应为那些控制寻找对应的行为验证，不能借用本例结果替代。

让必要访问保持明确

限制应施加在真实部署的服务定义上，同时考虑覆盖文件和执行身份。可写路径例外改变的是挂载视图，不会授予普通 Unix 文件权限，也不能让底层本来只读的文件系统变成可写。若状态、缓存或运行时目录的生命周期和所有权契约适合应用，优先使用对应的受管理目录，减少手工建目录造成的权限和清理差异。

加固之后，应按应用实际支持的能力检查启动、正常请求、维护、重载与停止。一个命令刚运行一次成功，仍可能在稍后轮转文件或建立新连接时失败。应定位具体被拒绝的操作，调整真正必要的边界，并保留“服务完成有用工作”与“不需要的操作仍被阻止”两类检查。这样配置才能说明当前已验证的限制，而不是一份看似严格却与工作负载脱节的开关清单。

来源

systemd 252 执行环境，挂载命名空间、受管理目录、私有网络与权限控制，已核验 2026-09-12。
systemd 252 资源控制，IP 允许与拒绝规则的优先关系和实现条件，已核验 2026-09-12。
systemd 252 分析命令，单元验证及其范围，已核验 2026-09-12。

Security · XB 现场笔记

审计公共边缘的信任

1. 从边缘声明的策略开始

2. 读取证书日期前先验证 TLS 身份

3. 读取呈现链，不虚构固定数量

4. 重新验证已抓取的表示

5. 找到适用的 CAA 策略

6. 检查部署主机已记录的 SSH 身份

保留范围明确的审计记录

来源

SSH 主机密钥是部署记录的一部分

把首次接触与轮换分开

让指纹可复核

来源

SSH 密钥卫生，主要是限制密钥能干什么

限定服务端权限

区分密钥类型与签名算法

坏掉的样子

快速验证

延伸阅读

来源

防火墙策略必须匹配报文路径、地址族和链顺序

坏掉的样子

快速验证

用代表性流量审阅生效策略

延伸阅读

来源

用实际拒绝结果验证 systemd 服务边界

坏掉的样子

快速验证

让必要访问保持明确

延伸阅读

来源

Security · XB 现场笔记

审计公共边缘的信任

1. 从边缘声明的策略开始

2. 读取证书日期前先验证 TLS 身份

3. 读取呈现链，不虚构固定数量

4. 重新验证已抓取的表示

5. 找到适用的 CAA 策略

6. 检查部署主机已记录的 SSH 身份

7. Cookie 作用域不超过必要范围

保留范围明确的审计记录

来源

SSH 主机密钥是部署记录的一部分

把首次接触与轮换分开

让指纹可复核

来源

SSH 密钥卫生，主要是限制密钥能干什么

限定服务端权限

区分密钥类型与签名算法

坏掉的样子

快速验证

延伸阅读

来源

防火墙策略必须匹配报文路径、地址族和链顺序

坏掉的样子

快速验证

用代表性流量审阅生效策略

延伸阅读

来源

用实际拒绝结果验证 systemd 服务边界

坏掉的样子

快速验证

让必要访问保持明确

延伸阅读

来源