罗罗编程学习记录
本页内容 展开查看

04.7.20.4 运维、安全与系统库

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.7 Python / 04.7.20 Python 常用第三方库

覆盖范围

  • 进程与系统:psutil 指标采集、容器内指标失真、subprocess 安全调用与 shell 风险
  • 加密与认证:cryptography 对称/非对称与 Fernet 边界、hashlib/hmac/secrets、passlib/bcrypt/argon2、PyJWT 与算法混淆
  • 远程与调度:paramiko/asyncssh、watchdog 文件事件、APScheduler 触发器
  • 文件工程:pathlib/tempfile/shutil 实践、路径注入与并发写
  • 依赖与元数据:pip/poetry/uv、importlib.metadata、虚拟环境与入口脚本

04.7.20.4-001 psutil 怎么采集 CPU、内存与进程指标?

一句话结论

psutil 跨平台封装系统指标:cpu_percent/cpu_count 取 CPU,virtual_memory/swap_memory 取内存,Process 实例取单进程 CPU、内存、线程与状态;指标多为采样间隔内的平均值,首次调用需给采样区间或忽略首次返回。

概念解释

  • 系统级:CPU 使用率/核数、物理/虚拟内存、交换分区。
  • 进程级:Process(pid) 拿 CPU 占比、内存 RSS/USS、打开文件、线程数。
  • 采样语义:cpu_percent(interval=...) 阻塞采样;不传 interval 为自上次调用的非阻塞差值。

原理流程

  1. 调用 psutil 系统函数取主机指标。
  2. 按 pid 构造 Process 对象读取进程属性。
  3. 指标按采样间隔计算百分比。
  4. 定时采集写入监控指标或日志。

代码或图示

import psutil

print(psutil.cpu_count(logical=True))
print(psutil.virtual_memory().percent)

p = psutil.Process()
print(p.memory_info().rss)
print(p.num_threads())

常见误区

  • 首次 cpu_percent() 不传 interval:返回 0 或无意义差值。
  • 把 psutil 读数当容器限额:容器内读到的是宿主机口径(见 002)。
  • 高频轮询进程枚举:采样过密自身占用 CPU,按采集周期取值。

追问

  • 内存 RSS 怎么取?答:Process.memory_info().rss。
  • CPU 采样两种模式?答:阻塞 interval 采样,或非阻塞自上次调用差值。
  • psutil 跨平台吗?答:是,封装 Windows/Linux/macOS 系统接口。

04.7.20.4-002 容器内 psutil 指标为什么会失真?

一句话结论

容器中 psutil 默认读到宿主机的 CPU 核数、内存总量与负载,而不是 cgroup 限额;进程 RSS 也可能包含共享库与页缓存口径差异。容器内监控需读取 cgroup(CPU 上限/使用、内存限额/使用),不能直接套用宿主机指标判断是否超限。

概念解释

  • cgroup 限额:容器被限制的 CPU/内存上限,独立于宿主机总量。
  • 失真来源:psutil 部分接口暴露主机视图,容器未隔离的命名空间信息。
  • 正确口径:CPU 使用对比 cgroup quota,内存对比 cgroup memory limit。

原理流程

  1. 识别运行环境是否容器(cgroup 路径/环境变量)。
  2. 容器内读取 cgroup 文件获取限额与用量。
  3. 进程级指标结合限额计算使用率。
  4. 告警阈值按 cgroup 限额而非主机总量设定。

代码或图示

# 容器内应读取 cgroup,示例路径按 cgroup v1/v2 区分
# /sys/fs/cgroup/memory.max 与 memory.current(v2)
# /sys/fs/cgroup/cpu.max(v2)

常见误区

  • 用宿主机内存总量算使用率:容器只分到一小部分,阈值判断错误。
  • 以为 psutil 自动感知 cgroup:多数指标仍是主机口径。
  • 进程 RSS 直接对比限额:RSS 含共享页,口径需结合 cgroup 内存用量。

追问

  • 容器内 CPU 上限从哪取?答:cgroup cpu quota/max,而非主机核数。
  • psutil 为什么失真?答:部分接口暴露宿主机视图,未按 cgroup 限额计算。
  • 内存告警按什么阈值?答:cgroup memory limit,不是主机总量。

04.7.20.4-003 进程枚举、父子关系与 RSS/USS 怎么看?

一句话结论

psutil.process_iter() 枚举全部进程,Process.parent() 取父进程,children() 取子进程;内存看 RSS(常驻物理内存,含共享库)、USS(独占物理内存)、PSS(按共享比例分摊),排查内存泄漏优先看 USS 趋势而非 RSS 单值。

概念解释

  • RSS:常驻集大小,含与其他进程共享的库页。
  • USS:进程独占内存,泄漏增长最直观。
  • PSS:共享页按比例分摊,估算真实贡献。

原理流程

  1. 枚举进程列表,按名称/命令行匹配目标。
  2. 沿 parent/children 梳理进程树。
  3. 读取 RSS/USS/PSS 与线程、打开文件数。
  4. 跨采样周期对比 USS 增长趋势判断泄漏。

代码或图示

import psutil

for p in psutil.process_iter(["pid", "name", "cmdline"]):
    if p.name() == "python":
        info = p.memory_full_info()
        print(p.pid, info.rss, info.uss, info.pss)

parent = psutil.Process().parent()

常见误区

  • 只看 RSS 判断泄漏:共享库波动会干扰判断。
  • 父子关系跨进程重建:容器/服务重启后 pid 与父级变化。
  • 枚举不做匹配:全进程遍历开销大,应按名称过滤。

追问

  • RSS、USS、PSS 区别?答:RSS 含共享页,USS 独占,PSS 按比例分摊共享。
  • 内存泄漏看哪个指标?答:USS 跨周期增长趋势最直观。
  • 怎么取父子进程?答:parent() 与 children()。

04.7.20.4-004 磁盘与网络 IO 指标怎么采样?

一句话结论

psutil 提供 disk_io_counters(读写字节/次数/时间)与 net_io_counters(收发字节/包数),disk_usage 取分区容量;这些是累计计数器,需两次采样差值计算速率,采样周期匹配监控粒度,避免单点值误读。

概念解释

  • 累计值:从启动起累加,速率靠两次读数相减。
  • 磁盘:读/写字节、次数、排队时间。
  • 网络:收发字节、包数、错误与丢包计数。

原理流程

  1. 首次读取 IO 计数器作为基线。
  2. 经过采样周期后再次读取。
  3. 差值除以时间得到吞吐速率。
  4. 容量指标用 disk_usage 检查分区剩余空间。

代码或图示

import psutil, time

io1 = psutil.disk_io_counters()
net1 = psutil.net_io_counters()
time.sleep(5)
io2 = psutil.disk_io_counters()
net2 = psutil.net_io_counters()

read_rate = (io2.read_bytes - io1.read_bytes) / 5
recv_rate = (net2.bytes_recv - net1.bytes_recv) / 5

常见误区

  • 把累计计数当速率:读数随时间单调增长,不是当前吞吐。
  • 采样周期过短:抖动大,指标不平滑。
  • 忽略错误/丢包计数:网络质量问题不只看吞吐。

追问

  • IO 速率怎么算?答:两次累计计数差值除以采样时间。
  • 磁盘容量用什么?答:disk_usage(路径) 取总量/已用/剩余。
  • 网络错误指标看哪个?答:计数器中的错误与丢包字段。

04.7.20.4-005 subprocess 安全调用与 shell=True 风险是什么?

一句话结论

subprocess.run 传参数列表(["cmd", "arg"])直接执行程序,不经 shell 解析;shell=True 把命令交给 shell 解释,用户输入可注入命令分隔符执行任意命令。除非命令固定且必须用 shell 特性(管道、通配符),否则禁止 shell=True。

概念解释

  • 参数列表:程序与参数分离,无 shell 元字符解析。
  • shell=True:拼接字符串经 /bin/sh -c 执行,;、|、$()、反引号都生效。
  • 注入路径:输入拼进命令字符串后被 shell 解释。

原理流程

  1. 确定是否需要 shell 特性,不需要则用列表形式。
  2. 参数逐项放入列表,不拼接字符串。
  3. 程序直接被 exec,参数原样传递。
  4. 必须用 shell 时对白名单参数严格校验,禁止拼接外部输入。

代码或图示

import subprocess

# 安全:参数列表
subprocess.run(["ls", "-l", "/tmp"], check=True)

# 危险:shell 拼接外部输入可注入
# subprocess.run(f"ls {user_input}", shell=True)

常见误区

  • 为图方便一律 shell=True:输入注入风险直接暴露。
  • 列表形式仍拼接字符串:参数被当作程序名或单参数,解析错误。
  • 把文件路径/URL 拼进 shell 命令:路径元字符被解释。

追问

  • shell=True 为什么危险?答:命令经 shell 解析,输入可注入分隔符执行任意命令。
  • 安全调用传什么?答:程序与参数组成列表,不经 shell。
  • 必须用 shell 怎么办?答:参数白名单校验,不拼接不可信输入。

04.7.20.4-006 run、check 与超时怎么配合?

一句话结论

subprocess.run 等待完成并返回 CompletedProcess,check=True 在非零退出码时抛 CalledProcessError;timeout= 限制等待时长,超时抛 TimeoutExpired 并终止子进程;捕获超时与非零码做降级,不让外部命令拖挂主进程。

概念解释

  • check:退出码非零视为失败,抛异常而非静默返回。
  • timeout:父子进程等待上限,超时杀死子进程。
  • 输出:capture_output=True 或 stdout/stderr=PIPE 捕获流。

原理流程

  1. 构造命令列表与超时参数。
  2. run 等待子进程结束。
  3. 非零退出码按 check 抛异常;超时抛 TimeoutExpired。
  4. 业务按异常类型决定重试、降级或上报。

代码或图示

import subprocess

try:
    result = subprocess.run(
        ["echo", "hello"],
        capture_output=True,
        text=True,
        timeout=10,
        check=True,
    )
    print(result.stdout)
except subprocess.TimeoutExpired:
    print("命令超时")
except subprocess.CalledProcessError as e:
    print("退出码", e.returncode)

常见误区

  • 不设 timeout:外部命令挂起会永久占用调用线程。
  • check=False 又不查 returncode:失败被静默放过。
  • 捕获输出不限量:子进程大量输出撑爆管道缓冲区。

追问

  • check=True 做什么?答:非零退出码抛 CalledProcessError。
  • 超时抛什么异常?答:subprocess.TimeoutExpired,子进程被终止。
  • 输出怎么捕获?答:capture_output 或 stdout/stderr=PIPE。

04.7.20.4-007 子进程编码与字节流怎么处理?

一句话结论

text=True(或 encoding=)让标准流按文本解码,否则返回 bytes;外部命令输出编码按系统 locale 或显式指定,中文输出需明确编码避免乱码;二进制输出(图片、压缩包)保持 bytes,不要强制文本解码。

概念解释

  • bytes 模式:stdout/stderr 为字节串。
  • 文本模式:指定 encoding 解码为字符串,可设 errors 策略。
  • 编码来源:子进程 locale、环境变量或命令参数约定。

原理流程

  1. 判断输出是文本还是二进制。
  2. 文本输出设 encoding/text=True,必要时 errors="replace"。
  3. 二进制保持 bytes 原样处理。
  4. 解码失败按策略替换或记录,不崩溃主流程。

代码或图示

import subprocess

r = subprocess.run(
    ["program"], capture_output=True, text=True, encoding="utf-8", errors="replace"
)

常见误区

  • 不指定 encoding 走系统默认:跨机器解码结果不一致。
  • 二进制输出按文本解码:字节损坏。
  • 忽略解码错误:非法字节导致异常中断。

追问

  • text=True 作用?答:标准流按文本解码为字符串。
  • 编码不确定时怎么办?答:显式指定 encoding,errors 策略兜底。
  • 二进制输出怎么处理?答:保持 bytes,不做文本解码。

04.7.20.4-008 Popen 管道与流式交互怎么做?

一句话结论

Popen 不等待结束,可逐行读写标准流做流式交互;适合长时间运行命令、边产生边处理的场景,需注意管道缓冲阻塞与死锁:同时读写要选通信方式(线程/select/async),避免两边都等对方写满缓冲。

概念解释

  • Popen:持子进程句柄,stdout/stderr 为管道文件对象。
  • 流式读取:迭代 stdout 逐行消费输出。
  • 死锁风险:父子同时阻塞在读写管道,缓冲区满后互等。

原理流程

  1. 创建 Popen,配置 stdout/stderr=PIPE。
  2. 逐行读取输出并处理,必要时写入 stdin。
  3. 等待结束回收退出码。
  4. 复杂双向交互用线程或异步 IO 分离读写。

代码或图示

import subprocess

p = subprocess.Popen(["long-running-cmd"], stdout=subprocess.PIPE, text=True)
for line in p.stdout:
    process(line)
p.wait()

常见误区

  • 同时读写同一条管道不做分离:管道缓冲满后死锁。
  • 不 wait 回收:子进程变僵尸或句柄泄漏。
  • stderr 并入 stdout 后丢失错误流:需按场景选择合并或分开。

追问

  • Popen 与 run 区别?答:Popen 异步持句柄流式交互,run 等待完成。
  • 管道死锁怎么产生?答:一方等待写满缓冲,另一方等待读取。
  • 双向交互怎么避免阻塞?答:线程/异步分离读写两侧。

04.7.20.4-009 命令注入怎么识别与防御?

一句话结论

注入发生在外部输入进入命令字符串并被 shell 解释时;防御核心是参数列表执行、避免 shell,对白名单参数(路径、主机、端口)做格式校验,禁止把用户输入拼进命令。即使不用 shell,路径与参数也要防越界(目录穿越、非法参数)。

概念解释

  • 注入元字符:;、&、|、`、$()、重定向、通配符。
  • 参数隔离:列表形式让每个元素是独立参数,不被再解析。
  • 白名单:允许的取值集合校验,而非黑名单拦截特殊字符。

原理流程

  1. 识别命令中哪些部分来自外部输入。
  2. 命令固定部分用列表,输入作为独立参数。
  3. 参数按类型/白名单校验(路径存在、端口范围)。
  4. 审计不使用 shell 拼接的历史代码。

代码或图示

import subprocess, re

def safe_run(host: str):
    if not re.fullmatch(r"[a-z0-9.-]+", host):
        raise ValueError("非法主机")
    subprocess.run(["ping", "-c", "1", host], check=True)

常见误区

  • 黑名单过滤特殊字符:绕过字符组合多,漏判即失守。
  • 不用 shell 就放松校验:路径穿越、非法参数仍可造成危害。
  • 命令路径也来自输入:应固定可执行文件路径。

追问

  • 注入主要靠什么防御?答:参数列表 + 不用 shell + 白名单校验。
  • 黑名单为什么不可靠?答:特殊字符组合多,绕过方式不断变化。
  • 不用 shell 还要校验什么?答:路径穿越、参数取值范围等越界问题。

04.7.20.4-010 Fernet 与 AES-GCM 的对称加密边界是什么?

一句话结论

Fernet 是 cryptography 提供的对称封装:AES-128-CBC + HMAC 签名,自带序列化格式与时间戳,便于直接加密可序列化数据;AES-GCM 是带认证的原始对称算法,需自行管理 nonce、关联数据与密钥。Fernet 不适合大数据流与自定义协议,密钥需单独安全管理。

概念解释

  • Fernet:封装好的对称加密,密文格式含版本、时间戳、IV、密文、签名。
  • AES-GCM:认证加密,保密性与完整性一体,nonce 不可复用。
  • 对称边界:加密库只做算法,密钥生成、存储、轮换不在库内。

原理流程

  1. 生成或导入 Fernet 密钥。
  2. encrypt 序列化并加密,decrypt 验签解密。
  3. 原始算法场景用 AESGCM,随机生成 nonce 并随密文存储。
  4. 密钥从密钥管理注入,不写进代码与仓库。

代码或图示

from cryptography.fernet import Fernet
from cryptography.hazmat.primitives.ciphers.aead import AESGCM

key = Fernet.generate_key()
f = Fernet(key)
token = f.encrypt(b"secret data")
plain = f.decrypt(token)

aes_key = AESGCM.generate_key(bit_length=128)

常见误区

  • Fernet 密钥硬编码:加密形同虚设,密钥泄漏即全量可解。
  • GCM 复用 nonce:同密钥同 nonce 破坏认证加密安全性。
  • 用 Fernet 加密超大文件:封装格式不适合流式大对象。

追问

  • Fernet 底层算法?答:AES-128-CBC 加 HMAC 签名,自带格式。
  • AES-GCM 关键注意点?答:nonce 随机且不可复用,关联数据按需绑定。
  • 加密库管密钥存储吗?答:不管,密钥管理由密钥管理服务/环境注入负责。

04.7.20.4-011 非对称加密 RSA/EC 与混合加密怎么用?

一句话结论

非对称加密用公钥加密、私钥解密,也可私钥签名、公钥验签;RSA 适合加解密与签名,EC(椭圆曲线)密钥短、性能好。大数据不能直接用公钥加密,工程上采用混合加密:随机对称密钥加密数据,再用公钥加密该对称密钥一起传输。

概念解释

  • RSA:大整数分解假设,密钥较长,可加密/签名。
  • EC:离散对数问题,相同安全强度密钥更短。
  • 混合加密:数据走对称算法,对称密钥走非对称封装。

原理流程

  1. 通信方交换公钥。
  2. 生成一次性对称密钥加密业务数据。
  3. 用接收方公钥加密对称密钥。
  4. 接收方私钥解出对称密钥,再解密数据。

代码或图示

from cryptography.hazmat.primitives.asymmetric import rsa

private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
public_key = private_key.public_key()
# 实际数据走混合加密,公钥只加密一次性对称密钥

常见误区

  • 用 RSA 直接加密长文本:RSA 有明文长度上限,超出即失败。
  • 私钥随公钥一起暴露:签名与解密能力同时泄漏。
  • 忽略密钥强度:RSA 位数/EC 曲线选择需达到安全强度要求。

追问

  • 公钥私钥各做什么?答:公钥加密/验签,私钥解密/签名。
  • 长数据怎么加密?答:混合加密,公钥只封装一次性对称密钥。
  • RSA 与 EC 差异?答:EC 同强度密钥更短、性能更好。

04.7.20.4-012 加密库的密钥管理边界在哪里?

一句话结论

cryptography 等库只提供算法与密钥运算,不负责密钥生成后的存储、分发、轮换与销毁;生产环境密钥应来自密钥管理服务或受限环境变量,文件权限最小化,仓库与日志中禁止出现密钥,密钥轮换需要独立的管理流程。

概念解释

  • 算法层:加解密、签名、密钥对生成。
  • 管理层:密钥存储位置、访问控制、备份、轮换、吊销、审计。
  • 泄漏面:代码仓库、配置文件、日志、异常堆栈、镜像层。

原理流程

  1. 密钥由密钥管理服务/安全渠道注入运行环境。
  2. 进程内只在内存使用密钥,不落盘明文。
  3. 文件形态密钥设置严格文件权限。
  4. 按周期轮换并记录版本,旧密钥用于历史数据解密。

代码或图示

import os

# 从环境变量读取,不硬编码;实际生产优先接入密钥管理服务
db_key = os.environ["APP_SECRET_KEY"]

常见误区

  • 把加密密钥写进配置文件或源码:仓库泄漏即全部失守。
  • 日志打印密钥/密文上下文:泄漏面扩大。
  • 不做轮换:密钥长期有效,泄漏后影响面持续累积。

追问

  • 加密库管密钥存储吗?答:不管,只提供算法与运算。
  • 生产密钥从哪来?答:密钥管理服务或受限环境变量注入。
  • 密钥轮换后历史数据怎么办?答:旧密钥保留用于解密历史密文。

04.7.20.4-013 随机数怎么选,哪些随机源不安全?

一句话结论

安全场景(密钥、token、盐、nonce)必须用密码学安全随机源:secrets 模块或 OS 提供的 CSPRNG;random 模块是伪随机,种子可预测,只适合模拟、洗牌等非安全场景。随机数不可自行实现熵源,也不要把可预测时间戳当随机值。

概念解释

  • CSPRNG:系统级密码学随机源,输出不可预测。
  • 普通 PRNG:确定性序列,种子确定即可复现。
  • 安全用途:密钥、令牌、验证码、盐、nonce、会话标识。

原理流程

  1. 判断用途是否涉及安全凭证。
  2. 安全场景用 secrets 生成字节/令牌。
  3. 非安全模拟场景才用 random。
  4. 随机长度按安全要求选择,不缩短到可暴力枚举。

代码或图示

import secrets

token = secrets.token_urlsafe(32)
salt = secrets.token_bytes(16)

常见误区

  • 用 random 生成密码重置 token:序列可预测,可被枚举。
  • 用时间戳/进程号拼随机值:熵不足且可预测。
  • 自行实现随机算法:熵收集与混合容易出错。

追问

  • 安全随机用哪个模块?答:secrets,底层走系统 CSPRNG。
  • random 能用在安全场景吗?答:不能,它是可复现伪随机。
  • 随机长度怎么定?答:按安全要求,足够抵抗暴力枚举。

04.7.20.4-014 hashlib 摘要算法的用途与边界是什么?

一句话结论

hashlib 计算单向摘要(MD5/SHA-1/SHA-256/SHA-3 等),用于完整性校验、指纹、派生标识;MD5/SHA-1 已不适合安全签名与口令存储。摘要不可逆,但相同输入固定输出,抗碰撞能力随算法等级不同,安全用途选 SHA-256 及以上。

概念解释

  • 摘要:任意长度输入映射固定长度哈希值。
  • 用途:文件完整性、去重指纹、摘要校验。
  • 边界:不是加密(不可逆但不保密),不直接存口令。

原理流程

  1. 选择算法,构造 hashlib 摘要对象。
  2. 分块 update 喂入数据(大文件流式)。
  3. hexdigest/digest 取摘要。
  4. 对比摘要时按常量时间比较(见 015)。

代码或图示

import hashlib

h = hashlib.sha256()
with open("file.bin", "rb") as f:
    for chunk in iter(lambda: f.read(65536), b""):
        h.update(chunk)
print(h.hexdigest())

常见误区

  • 用 MD5/SHA-1 做安全签名:碰撞已被攻破。
  • 把摘要当加密:摘要不保密,可被彩虹表反查弱口令。
  • 大文件一次性读入哈希:应分块 update。

追问

  • 摘要与加密区别?答:摘要单向不可逆,不提供保密。
  • 安全完整性选什么算法?答:SHA-256 及以上,不用 MD5/SHA-1。
  • 大文件怎么哈希?答:分块 update,避免全量读入内存。

04.7.20.4-015 hmac 签名与定时比较怎么做?

一句话结论

hmac 用密钥对消息做带密钥摘要(HMAC),用于接口签名与完整性校验;比较签名必须用 hmac.compare_digest 做常量时间比较,普通 == 有时序侧信道,攻击者可按响应时间逐字节猜签名。

概念解释

  • HMAC:密钥参与的哈希消息认证码,防篡改与伪造。
  • 常量时间比较:比较耗时不随匹配位置变化,消除时序差异。
  • 密钥:签名与验签双方共享,按密钥管理边界保管。

原理流程

  1. 约定消息规范化格式与密钥。
  2. 发送方 hmac.new 计算签名并附在请求中。
  3. 接收方用同密钥重算签名。
  4. compare_digest 比较,一致才接受。

代码或图示

import hmac, hashlib

def sign(key: bytes, msg: bytes) -> str:
    return hmac.new(key, msg, hashlib.sha256).hexdigest()

def verify(key: bytes, msg: bytes, provided: str) -> bool:
    expected = hmac.new(key, msg, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, provided)

常见误区

  • 字符串 == 比较签名:时序差异泄漏前缀匹配情况。
  • 签名消息格式不规范:字段顺序/编码不一致导致验签失败。
  • 密钥与摘要密钥混用:HMAC 密钥需独立管理。

追问

  • 为什么用 compare_digest?答:常量时间比较,避免时序侧信道。
  • HMAC 解决什么?答:带密钥的完整性与消息认证,防伪造篡改。
  • 签名前要固定什么?答:消息序列化格式、字段顺序与编码。

04.7.20.4-016 secrets 与 random 怎么区分使用?

一句话结论

secrets 面向安全凭证,输出经 CSPRNG 不可预测,提供 token、URL 安全字符串、随机选择;random 是可复现伪随机,用于概率模拟、随机排序、游戏等非安全场景。判断标准:值可被预测会造成安全事故时,必须用 secrets。

概念解释

  • secrets:token_bytes/token_hex/token_urlsafe/choice。
  • random:种子确定则序列可复现,性能高但不可预测性无保证。
  • 边界:会话 ID、验证码、重置链接、盐、API 密钥走 secrets。

原理流程

  1. 列出程序中所有随机取值场景。
  2. 涉及凭证/防猜测的归 secrets。
  3. 仅统计模拟/展示效果的归 random。
  4. 代码评审核对敏感场景未误用 random。

代码或图示

import secrets, random

# 安全凭证
reset_token = secrets.token_urlsafe(24)
# 非安全模拟
roll = random.randint(1, 6)
shuffled = random.sample(items, k=len(items))

常见误区

  • 用 random 生成验证码:枚举空间内可被预测。
  • 给 random 设固定种子当“随机”:序列完全可复现。
  • 非安全场景也强制 secrets:无必要,接口选择按场景。

追问

  • secrets 输出可预测吗?答:不可预测,走系统 CSPRNG。
  • 哪些值必须用 secrets?答:token、盐、验证码、会话标识、密钥。
  • random 适合什么?答:模拟、洗牌、概率展示等非安全用途。

04.7.20.4-017 口令哈希 passlib/bcrypt/argon2 参数怎么选?

一句话结论

口令不能存明文或普通哈希,应使用慢哈希算法:argon2(当前推荐,可调内存/迭代/并行度)、bcrypt(成熟稳定)、passlib 作为封装层统一接口;参数按可接受的验证耗时选取(通常单次验证百毫秒量级),在安全强度与登录性能间权衡,迭代成本随硬件升级上调。

概念解释

  • 慢哈希:刻意提高计算成本,拖慢离线爆破。
  • argon2:内存硬度参数高,抗 GPU/ASIC 破解。
  • bcrypt:自适应 cost 指数轮次,实现广泛兼容。
  • passlib:多后端封装,便于切换算法与参数版本。

原理流程

  1. 选定算法与参数(argon2 内存/迭代/并行,或 bcrypt cost)。
  2. 注册时加盐哈希后存储,算法与参数随哈希记录保存。
  3. 登录时用记录中的参数重算并比对。
  4. 定期评估参数强度,老旧哈希在登录成功后升级重哈希。

代码或图示

from argon2 import PasswordHasher

ph = PasswordHasher(time_cost=3, memory_cost=65536, parallelism=4)
hash_value = ph.hash("password")
ph.verify(hash_value, "password")

常见误区

  • 用 SHA-256 直接存口令:计算太快,离线字典爆破成本极低。
  • 哈希不存算法/参数:后续无法升级与正确验证。
  • 参数照搬旧值:硬件变快后成本不足,应定期评估上调。

追问

  • 为什么口令要慢哈希?答:提高离线爆破成本,普通哈希太快被暴力破解。
  • argon2 可调哪些参数?答:迭代次数、内存成本、并行度。
  • 旧弱哈希怎么处理?答:登录验证成功后用新参数重哈希升级。

04.7.20.4-018 口令哈希为什么加盐,盐怎么选?

一句话结论

盐为每个口令生成随机独立值,与口令一起哈希,使相同口令得到不同哈希,防御彩虹表与批量破解;盐不需要保密但必须唯一随机,存于哈希记录中。盐不能替代慢哈希,也不能用固定全局盐,固定盐等价于没有盐。

概念解释

  • 盐作用:打散相同口令的哈希,预计算表失效。
  • 生成:每个用户独立随机盐,长度足够。
  • 存储:盐与哈希同库保存,参与每次验证计算。

原理流程

  1. 注册时生成随机盐。
  2. 盐与口令送入慢哈希算法计算存储值。
  3. 验证时取出盐,按同参数重算比对。
  4. 盐值不参与保密,独立随机即可。

代码或图示

import secrets

salt = secrets.token_bytes(16)
# 慢哈希算法内部通常自动处理盐并编码进结果记录

常见误区

  • 全系统固定一个盐:相同口令哈希仍相同,彩虹表可针对该盐。
  • 盐复用:用户间共享盐削弱独立防护。
  • 以为盐要保密:盐公开不影响方案安全性,随机唯一性才关键。

追问

  • 加盐解决什么?答:相同口令哈希不同,防彩虹表与批量破解。
  • 盐要保密吗?答:不需要保密,但必须每用户唯一随机。
  • 有盐还需要慢哈希吗?答:需要,盐防预计算,慢哈希拖高爆破成本。

04.7.20.4-019 bcrypt 72 字节限制是什么问题?

一句话结论

bcrypt 内部只使用口令前 72 字节,超出部分被忽略;超长口令与特殊编码口令需先经 SHA-256/预哈希再喂给 bcrypt,否则尾部字符不参与哈希,缩短有效口令长度。使用前确认库版本对超长输入的处理行为,避免静默截断。

概念解释

  • 截断来源:bcrypt 算法输入长度上限 72 字节。
  • 预哈希:先哈希口令得到定长摘要,再交给 bcrypt。
  • 编码:口令按 UTF-8 编码后的字节数,而非字符数计入限制。

原理流程

  1. 检查口令字节长度是否可能超过 72。
  2. 超长场景先做预哈希(注意预哈希方案记录在参数中)。
  3. 结果送入 bcrypt 计算。
  4. 验证流程保持同样的预哈希步骤。

代码或图示

# 预哈希后再 bcrypt 的示意;具体方案与参数需在库文档确认后落地
# import hashlib
# digest = hashlib.sha256(password.encode()).digest()
# bcrypt.hashpw(digest, bcrypt.gensalt())

常见误区

  • 以为字符数限制 72:实际按 UTF-8 字节计算。
  • 预哈希后不记录方案:验证时无法复现同一流程。
  • 忽略截断直接对比:超长口令尾部错误也可能通过验证。

追问

  • bcrypt 截断什么?答:超出 72 字节的部分不参与哈希。
  • 超长口令怎么处理?答:先预哈希成定长摘要再喂给 bcrypt。
  • 限制按字符还是字节?答:按编码后的字节数。

04.7.20.4-020 PyJWT 怎么签发与校验令牌?

一句话结论

PyJWT 用 jwt.encode 带密钥与声明签发令牌,jwt.decode 校验签名与注册声明后取载荷;校验时必须显式指定允许的算法,校验 exp 等有效期声明,密钥按对称/非对称类型分别保管。令牌载荷是 Base64 编码,不是加密,不能放敏感明文。

概念解释

  • 结构:头部、载荷、签名三段,Base64URL 编码拼接。
  • 签发:算法 + 密钥 + 声明(sub、iat、exp、iss、aud)。
  • 校验:验签、有效期、签发方、受众声明逐项核对。

原理流程

  1. 构造标准与业务声明,设置过期时间。
  2. encode 生成令牌串。
  3. 接收方 decode 指定算法与密钥校验。
  4. 失败(签名无效、过期、声明不符)拒绝请求。

代码或图示

import jwt, time

payload = {"sub": "user-1", "exp": int(time.time()) + 3600}
token = jwt.encode(payload, "secret", algorithm="HS256")

data = jwt.decode(token, "secret", algorithms=["HS256"])

常见误区

  • 载荷放密码/敏感信息:JWT 可被 Base64 解码,不保密。
  • 不校验 exp:过期令牌仍被接受。
  • 解码不指定 algorithms:算法被篡改风险(见 021)。

追问

  • JWT 载荷加密了吗?答:没有,仅 Base64URL 编码,可读。
  • 签发要设哪些声明?答:sub、iat、exp,按需 iss/aud。
  • 解码必须传什么?答:密钥与允许算法列表。

04.7.20.4-021 JWT 算法混淆漏洞怎么产生与防御?

一句话结论

算法混淆包括两类:alg=none 被接受导致不验签;RS256(私钥签名/公钥验签)场景被换成 HS256,用公开公钥当对称密钥伪造签名。防御是解码时固定允许算法白名单,拒绝 none,按算法类型使用对应密钥,不信任令牌头部声明的算法。

概念解释

  • none:头部声明无签名,若库允许则直接信任载荷。
  • HS256 滥用:公钥可被获取,攻击者用公钥作 HMAC 密钥签发令牌。
  • 信任边界:算法与密钥类型由服务端配置决定,不随令牌头部走。

原理流程

  1. 服务端配置允许算法列表(如仅 RS256 或仅 HS256)。
  2. 解码传入 algorithms=[...],库拒绝列表外算法。
  3. 非对称场景用公钥验签,对称场景用独立密钥。
  4. 头部算法字段仅作参考,不作为密钥选择依据。

代码或图示

# 固定算法白名单,拒绝 none
jwt.decode(token, public_key, algorithms=["RS256"])

常见误区

  • algorithms 传宽松列表或不校验:none/换算法直接通过。
  • 非对称接口用公钥同时支持 HS256:公钥可被拿来签 HMAC。
  • 按头部 alg 动态选密钥:攻击者可诱导服务端用弱校验路径。

追问

  • alg=none 风险是什么?答:不验签,载荷可被任意伪造。
  • RS256 被换成 HS256 怎么攻击?答:用公开公钥作 HMAC 密钥伪造签名。
  • 防御关键?答:服务端固定算法白名单与密钥类型,拒绝 none。

04.7.20.4-022 exp/iss/aud 等注册声明怎么校验?

一句话结论

exp 校验过期时间(注意时钟偏移容忍),iss 校验签发方,aud 校验受众,nbf 校验生效时间;服务端应逐项核对声明是否存在且匹配预期,缺失关键声明拒绝,不能只验签名就信任业务身份。

概念解释

  • exp:过期时间戳,过期令牌拒绝。
  • iss:签发方标识,防止其他系统令牌复用。
  • aud:受众,令牌只发给预期接收方。
  • 时钟偏移:各节点时间差可设小容差。

原理流程

  1. 签发时写入标准声明与预期值。
  2. 解码验签后读取声明。
  3. 逐项比对 exp/iss/aud/nbf 与服务端预期。
  4. 任一缺失或不符即拒绝,记录拒绝原因。

代码或图示

jwt.decode(
    token,
    key,
    algorithms=["RS256"],
    issuer="https://auth.example.com",
    audience="api-service",
    options={"require": ["exp", "iss", "aud"]},
)

常见误区

  • 只验签名不查声明:其他系统签发的有效令牌可被接受。
  • 不设时钟容差:节点时间漂移导致合法令牌被判过期。
  • aud 缺失不拒绝:令牌可跨服务复用。

追问

  • 三个核心声明各校验什么?答:exp 过期、iss 签发方、aud 受众。
  • 时钟偏移怎么处理?答:解码时设置小范围容差。
  • 声明缺失怎么办?答:关键声明缺失直接拒绝。

04.7.20.4-023 paramiko 怎么执行命令与操作 SFTP?

一句话结论

paramiko 是纯 Python SSH 客户端:SSHClient 建立连接、exec_command 执行远程命令并读标准流,open_sftp 做文件上传下载;需配置主机密钥校验策略(禁止生产环境自动接受未知主机),连接与通道显式关闭,命令参数按白名单与转义处理。

概念解释

  • SSHClient:连接、认证、主机密钥策略。
  • exec_command:返回 stdin/stdout/stderr 通道,读取退出码。
  • SFTPClient:put/get、目录与文件属性操作。

原理流程

  1. 配置主机密钥校验与认证方式(密钥/密码)。
  2. 建立 SSH 连接。
  3. 执行命令读取输出与退出码,或打开 SFTP 传文件。
  4. 关闭通道与连接,处理超时与认证异常。

代码或图示

import paramiko

client = paramiko.SSHClient()
client.set_missing_host_key_policy(paramiko.RejectPolicy())
client.connect("host", username="ops", key_filename="~/.ssh/id_ed25519")

stdin, stdout, stderr = client.exec_command("systemctl status app", timeout=10)
print(stdout.read().decode())

sftp = client.open_sftp()
sftp.get("/remote/file", "local/file")
sftp.close()
client.close()

常见误区

  • AutoAddPolicy 生产环境放行未知主机:中间人攻击风险。
  • 不读退出码与 stderr:命令失败被当作成功。
  • 连接不显式关闭:通道与会话泄漏。

追问

  • 主机密钥策略生产用哪个?答:RejectPolicy 或加载已知主机,不自动接受。
  • 命令输出怎么取?答:exec_command 返回三个流,读 stdout/stderr 与退出码。
  • SFTP 传文件用什么?答:open_sftp 的 put/get。

04.7.20.4-024 asyncssh 与 paramiko 怎么选型?

一句话结论

asyncssh 基于 asyncio,适合异步服务内并发 SSH 操作,与事件循环原生集成;paramiko 是同步阻塞实现,适合脚本与同步流程。异步场景用 asyncssh 避免阻塞事件循环,并发连接受事件循环与目标主机限制,二者协议栈独立,依赖与维护状态需按版本确认。

概念解释

  • asyncssh:asyncio 协程 API,连接/命令/SFTP 均为异步。
  • paramiko:同步 API,调用阻塞线程。
  • 选型:调用方运行模型(同步/异步)优先。

原理流程

  1. 判断现有服务是 asyncio 还是同步模型。
  2. 异步服务选 asyncssh,在协程内建立连接与执行命令。
  3. 同步脚本选 paramiko,简单直接。
  4. 并发 SSH 控制连接数与超时,避免打爆目标主机。

代码或图示

import asyncio, asyncssh

async def run():
    async with asyncssh.connect("host", username="ops") as conn:
        result = await conn.run("systemctl status app", check=True)
        print(result.stdout)

asyncio.run(run())

常见误区

  • 在 asyncio 事件循环里调用 paramiko:阻塞整个循环。
  • 并发 SSH 不设上限:目标主机连接数与认证频率被打满。
  • 忽略主机密钥校验:两种库都应配置 known_hosts。

追问

  • 异步服务选哪个?答:asyncssh,原生协程不阻塞事件循环。
  • paramiko 阻塞吗?答:是同步阻塞实现,适合脚本。
  • 并发 SSH 注意什么?答:限制连接数、超时与认证频率。

04.7.20.4-025 watchdog 文件事件监控怎么工作,平台后端有什么差异?

一句话结论

watchdog 通过平台原生文件事件接口(Linux inotify、Windows 目录变更通知、macOS FSEvents)监听创建/修改/删除/移动事件,处理器类实现事件回调;不同平台后端能力与事件粒度有差异,跨平台代码不能假设事件一定精确到单文件修改次数,需配合状态扫描兜底。

概念解释

  • Observer:调度事件循环,挂载监控路径。
  • FileSystemEventHandler:子类化处理 created/modified/deleted/moved。
  • 后端差异:事件合并、递归监听、符号链接处理随平台不同。

原理流程

  1. 定义事件处理器,实现回调方法。
  2. 为目标路径调度 Observer,配置递归与否。
  3. 启动 Observer,事件到达时回调处理器。
  4. 关键场景定期全量扫描校正事件丢失/合并。

代码或图示

from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

class Handler(FileSystemEventHandler):
    def on_modified(self, event):
        print(event.src_path, event.event_type)

observer = Observer()
observer.schedule(Handler(), "/data", recursive=True)
observer.start()

常见误区

  • 依赖事件做精确计数:合并/丢失导致统计不准。
  • 监控路径不存在就启动:Observer 报错或不触发。
  • 回调内做重阻塞操作:拖慢事件分发,事件积压。

追问

  • watchdog 底层靠什么?答:各平台原生文件事件接口(inotify/FSEvents/Windows 通知)。
  • 事件不精确怎么办?答:定期全量扫描兜底校正。
  • 递归监听怎么配?答:schedule(..., recursive=True)。

04.7.20.4-026 APScheduler 触发器类型与任务持久化怎么选?

一句话结论

APScheduler 提供 cron、interval、date 三种触发器;调度器后端分内存与持久化(数据库),多实例部署需选持久化任务存储并加锁,避免同一任务被多个实例重复触发;任务执行异常由监听器/错误处理兜底,调度器与业务进程生命周期一致管理。

概念解释

  • 触发器:date 单次、interval 间隔、cron 日历表达式。
  • 存储:内存 JobStore 进程重启丢失;持久化 JobStore 落库。
  • 并发:多实例需任务锁或分片,防止重复执行。

原理流程

  1. 按调度规则选触发器类型。
  2. 单实例选内存存储,多实例/需恢复选持久化存储。
  3. 注册任务并启动调度器。
  4. 配置异常处理与并发上限,监控执行结果。

代码或图示

from apscheduler.schedulers.blocking import BlockingScheduler

scheduler = BlockingScheduler()

@scheduler.scheduled_job("interval", minutes=5)
def flush_cache():
    pass

scheduler.start()

常见误区

  • 多实例用内存存储:各自调度,任务重复执行。
  • 任务执行不设超时/并发上限:慢任务堆积挤占调度线程。
  • 调度器与业务进程分离不清:重启策略不一致导致漏调度。

追问

  • 三种触发器?答:date 单次、interval 间隔、cron 周期。
  • 任务要跨重启保留用什么?答:持久化 JobStore。
  • 多实例怎么防重复执行?答:持久化存储配合分布式锁或任务分片。

04.7.20.4-027 pathlib 怎么替代字符串路径拼接?

一句话结论

pathlib.Path 用对象语义表示路径,/ 运算符跨平台拼接,提供 exists/is_file/mkdir/read_text/glob 等方法;相比手写字符串拼接,自动处理分隔符与扩展名,避免 Windows/POSIX 斜杠差异,路径判断与操作更安全可读。

概念解释

  • Path 对象:不可变路径表示,拼接用 /。
  • 常用方法:目录创建、读写文本/字节、遍历匹配、后缀名处理。
  • 跨平台:内部按当前系统规则解析,移植到其他平台语义一致。

原理流程

  1. 用 Path(根目录) 构造基准路径。
  2. / 拼接子路径,with_suffix/name/stem 处理文件名。
  3. 调用存在性、创建、读写方法。
  4. 需要字符串时显式 str(path),传给不支持 Path 的接口。

代码或图示

from pathlib import Path

base = Path("data")
file_path = base / "orders" / "2026.csv"
file_path.parent.mkdir(parents=True, exist_ok=True)
text = file_path.read_text(encoding="utf-8")

for p in base.glob("**/*.csv"):
    print(p)

常见误区

  • 继续用字符串拼斜杠:跨平台分隔符出错。
  • 直接拼接外部输入路径:目录穿越风险(见 030)。
  • 混用 os.path 与 Path 不统一:代码风格割裂,易错。

追问

  • Path 拼接用什么运算符?答:/,跨平台自动处理分隔符。
  • 父目录不存在怎么创建?答:mkdir(parents=True, exist_ok=True)。
  • 读文本要注意什么?答:显式指定 encoding="utf-8"。

04.7.20.4-028 tempfile 怎么安全创建与清理临时文件?

一句话结论

tempfile 提供 NamedTemporaryFile/TemporaryDirectory,文件名随机、默认在系统临时目录创建;上下文管理器退出时自动删除,避免残留临时文件。权限与位置按系统默认,敏感数据的临时文件用完即删,不要把含密钥的内容长期留在临时目录。

概念解释

  • 随机命名:不可预测文件名,避免同目录抢占与猜测。
  • 自动清理:上下文退出删除文件/目录。
  • 编码与模式:文本/字节模式按需要选择。

原理流程

  1. 用上下文管理器创建临时文件或目录。
  2. 在句柄内写入/读取临时内容。
  3. 退出上下文自动删除。
  4. 需保留路径的文件显式管理删除时机与权限。

代码或图示

import tempfile, json

with tempfile.NamedTemporaryFile(mode="w+", encoding="utf-8", delete_on_close=True) as f:
    json.dump(payload, f)
    f.flush()
    process(f.name)

with tempfile.TemporaryDirectory() as d:
    tmp = Path(d) / "work.bin"

常见误区

  • 不用上下文管理器:异常路径下临时文件残留。
  • 敏感数据放临时目录不删除:其他用户/进程可能读到。
  • 依赖固定临时文件名:并发冲突与猜测风险。

追问

  • 临时文件名有什么特点?答:随机生成,不可预测。
  • 怎么保证自动清理?答:上下文管理器退出即删除。
  • 敏感临时内容注意什么?答:用完即删,不在临时目录长期留存。

04.7.20.4-029 shutil 复制、移动、删除大文件要注意什么?

一句话结论

shutil.copy/copy2 复制文件(copy2 保留元数据),move 跨目录移动,rmtree 删除目录树;大文件复制关注磁盘空间与缓冲策略,删除前确认路径边界避免误删,跨文件系统 move 实际是复制加删除,失败需考虑一致性。

概念解释

  • copy:内容复制;copy2 额外保留权限与时间戳。
  • move:同文件系统改名,跨文件系统复制后删除源。
  • rmtree:递归删除,路径必须严格校验。

原理流程

  1. 校验源路径存在且目标在允许范围内。
  2. 检查目标磁盘空间与权限。
  3. 执行复制/移动,必要时分块流式处理大文件。
  4. 删除操作二次确认路径,记录结果与异常。

代码或图示

import shutil
from pathlib import Path

shutil.copy2("source.bin", "target.bin")
shutil.move("old/dir", "new/dir")
# rmtree 删除前必须校验路径,禁止对不可信路径调用

常见误区

  • rmtree 路径来自外部输入:路径穿越导致误删目录。
  • 跨盘 move 不检查失败:源与目标可能不一致。
  • 大文件一次性复制:缓冲与空间占用失控,分块更稳。

追问

  • copy 与 copy2 区别?答:copy2 保留文件元数据与时间戳。
  • 跨文件系统 move 怎么做?答:复制后删除源,失败需处理一致性。
  • rmtree 前置校验?答:路径必须在允许边界内,禁止不可信输入。

04.7.20.4-030 文件名与路径注入怎么校验?

一句话结论

外部传入的文件名/路径必须做规范化与边界校验:解析真实路径后确认仍在允许根目录内,拒绝 .. 穿越、绝对路径、特殊字符与空名;白名单允许的字符集优于黑名单过滤,下载/上传/删除接口都要走同一套路径校验,不能只在入口拦一次。

概念解释

  • 目录穿越:../ 组合跳出根目录访问受限文件。
  • 规范化:resolve/realpath 解析符号链接与相对段。
  • 边界检查:解析后路径必须位于允许根目录之下。

原理流程

  1. 拼接候选路径,规范化解析为绝对真实路径。
  2. 判断是否在允许根目录前缀内。
  3. 文件名按白名单字符与长度校验。
  4. 不合法拒绝并记录,不进入文件操作。

代码或图示

from pathlib import Path

def safe_path(root: Path, name: str) -> Path:
    root = root.resolve()
    candidate = (root / name).resolve()
    if not candidate.is_relative_to(root):
        raise ValueError("路径越界")
    return candidate

常见误区

  • 字符串替换 ..:编码/多层组合可绕过。
  • 只校验不解析符号链接:链接把路径指向根目录外。
  • 上传校验了下载没校验:同一风险在另一个入口暴露。

追问

  • 路径校验关键步骤?答:规范化解析后确认在允许根目录内。
  • 白名单还是黑名单?答:字符白名单优先,黑名单易绕过。
  • 哪些接口要校验?答:上传、下载、删除、读取等所有路径入口。

04.7.20.4-031 pip、poetry、uv 怎么对比选型?

一句话结论

pip 是标准包安装器,配合 requirements 锁定版本;poetry 集成依赖解析、虚拟环境、打包与发布,依赖声明单一文件;uv 是高速替代实现,兼容 pip/lock 工作流,速度与解析性能突出。选型看项目规模、打包发布需求与团队既有工具链,锁定文件必须纳入版本管理保证可复现。

概念解释

  • pip:安装与卸载工具,锁文件靠 requirements 固化。
  • poetry:依赖 + 构建 + 发布一体,pyproject 声明。
  • uv:Rust 实现的高速包管理器与解析器,兼容生态格式。

原理流程

  1. 评估是否需要打包发布、依赖解析与环境管理一体化。
  2. 简单脚本/服务用 pip + 锁文件。
  3. 库发布与多环境一致性用 poetry 或 uv。
  4. 锁定依赖与哈希记录,CI 按锁文件安装。

代码或图示

pip install -r requirements.txt
poetry add requests
uv pip install -r requirements.txt

常见误区

  • 不提交锁文件:各环境依赖版本漂移,行为不一致。
  • 解析结果不固化:新安装拉到兼容范围内的新版本,引入回归。
  • 生产环境直接升级全部依赖:应按锁文件安装,升级单独评审。

追问

  • poetry 管什么?答:依赖解析、虚拟环境、打包与发布。
  • uv 优势?答:高速安装与解析,兼容 pip 生态格式。
  • 可复现安装靠什么?答:提交锁定文件,按锁文件安装。

04.7.20.4-032 importlib.metadata 怎么读取包元数据?

一句话结论

importlib.metadata(标准库)读取已安装包的版本、入口点、依赖与元数据,替代旧的 pkg_resources;运行时需要展示版本、按入口点发现插件时使用,不依赖第三方打包库。读取的是安装环境中的元数据,源码目录直接运行时可能取不到已安装记录。

概念解释

  • 版本:version("包名") 取安装版本。
  • 入口点:entry_points 按组发现插件注册。
  • 元数据:包名、摘要、依赖要求等记录。

原理流程

  1. 确认包已安装到当前环境。
  2. 用 importlib.metadata 查询版本或入口点。
  3. 按入口点组加载插件实现。
  4. 取不到元数据时给出降级提示,不崩溃主流程。

代码或图示

from importlib.metadata import version, entry_points

print(version("requests"))

for ep in entry_points(group="myapp.plugins"):
    plugin = ep.load()

常见误区

  • 源码目录直接运行就取版本:未安装时元数据记录缺失。
  • 用 pkg_resources 新写代码:旧接口,标准库已提供替代。
  • 入口点加载不做异常隔离:单个插件失败影响整体启动。

追问

  • 取版本用什么?答:importlib.metadata.version("包名")。
  • 插件发现靠什么?答:entry_points 按入口点组加载。
  • 替代哪个旧接口?答:pkg_resources。

04.7.20.4-033 虚拟环境与可执行入口怎么管理?

一句话结论

虚拟环境隔离项目依赖,避免全局环境污染;命令入口通过 console_scripts/project.scripts 注册,安装后在环境 bin/Scripts 目录生成可执行命令。运行服务时明确激活环境或使用环境内解释器绝对路径,CI 与部署脚本记录 Python 版本与环境创建步骤。

概念解释

  • 隔离:每个项目独立 site-packages,依赖版本互不干扰。
  • 入口点:pyproject 声明脚本名与可调用对象,安装时生成命令。
  • 解释器:运行脚本用环境内 Python,而非系统全局 Python。

原理流程

  1. 创建虚拟环境并安装项目与依赖。
  2. 配置入口点声明,安装生成可执行命令。
  3. 部署脚本激活环境或调用环境内解释器。
  4. 记录 Python 版本与依赖锁定,保证环境可重建。

代码或图示

[project.scripts]
myapp = "myapp.cli:main"

常见误区

  • 依赖装到全局 Python:多项目版本冲突,排查困难。
  • 部署脚本不指定环境:落到哪个解释器不确定。
  • 入口点改动后不重新安装:命令指向旧代码。

追问

  • 入口点声明在哪?答:pyproject 的 project.scripts。
  • 为什么要虚拟环境?答:隔离依赖,避免全局污染与版本冲突。
  • 部署怎么保证解释器一致?答:用环境内解释器路径或激活环境,并记录 Python 版本。

04.7.20.4-034 进程信号怎么处理,实现优雅退出?

一句话结论

注册 SIGTERM/SIGINT 处理器,收到信号后停止接收新请求、排空在途任务、释放资源后退出;容器编排默认发 SIGTERM,等待宽限期后才 SIGKILL。不能阻塞信号处理过长,主循环需可被中断并设置退出标志,外部依赖(连接、文件句柄)在退出路径统一关闭。

概念解释

  • SIGTERM:正常终止信号,可被捕获处理。
  • SIGINT:终端中断(Ctrl+C)。
  • 优雅退出:停止接新流量 → 处理存量 → 释放资源 → 退出。

原理流程

  1. 注册信号处理器,设置退出事件/标志。
  2. 主循环检查退出标志,停止接收新任务。
  3. 等待在途任务完成或达到宽限期。
  4. 关闭连接与句柄,进程退出。

代码或图示

import signal, sys

running = True

def handle(signum, frame):
    global running
    running = False

signal.signal(signal.SIGTERM, handle)
signal.signal(signal.SIGINT, handle)

while running:
    tick()
shutdown_resources()

常见误区

  • 信号处理器里做重操作:处理函数应只置标志,业务在主循环收尾。
  • 只处理 SIGINT 不处理 SIGTERM:容器停止时收不到优雅退出。
  • 宽限期内不排空任务:在途请求被硬杀,数据不一致。

追问

  • 容器停止先发什么信号?答:SIGTERM,宽限期后 SIGKILL。
  • 信号处理器该做什么?答:置退出标志,不做长阻塞操作。
  • 优雅退出顺序?答:停接新任务 → 排空存量 → 释放资源 → 退出。

04.7.20.4-035 外部命令白名单与最小权限怎么落实?

一句话结论

调用外部命令按白名单限定可执行程序与允许参数,服务进程用最小权限账号运行,不给予不必要的 sudo/写权限;命令路径固定,不允许外部输入选择程序。审计命令执行记录,异常参数与高频调用纳入监控,纵深防御覆盖命令层、文件层与账号层。

概念解释

  • 白名单:允许的程序与参数取值集合,而非拦截恶意输入。
  • 最小权限:进程账号只拥有完成任务所需权限。
  • 审计:记录执行者、命令、参数、时间与结果。

原理流程

  1. 梳理必须调用的外部命令清单。
  2. 程序路径固定,参数按白名单校验。
  3. 运行账号降权,限制文件与网络权限。
  4. 执行日志留痕,异常调用告警。

代码或图示

ALLOWED = {"backup": ["tar", "-czf"], "check": ["curl", "-fsS"]}

def run_task(name: str, arg: str):
    if name not in ALLOWED:
        raise PermissionError("命令未授权")
    cmd = ALLOWED[name] + [arg]
    subprocess.run(cmd, check=True, timeout=30)

常见误区

  • 白名单只拦程序名不拦参数:参数注入仍可越权。
  • 服务用 root 跑:命令被利用后直接拿到高权限。
  • 执行无日志:事故后无法追溯命令与参数。

追问

  • 白名单覆盖哪两层?答:可执行程序与允许参数取值。
  • 进程账号原则?答:最小权限,去掉多余 sudo 与写权限。
  • 审计记什么?答:执行者、命令、参数、时间、退出结果。

04.7.20.4-036 证书与密钥文件权限怎么设置?

一句话结论

私钥与证书文件应限制属主可读、其他用户不可读(类 Unix 目录 700/文件 600 量级),禁止随代码仓库提交;部署时通过密钥管理服务或受控通道下发,容器内密钥挂载为只读。权限过宽或密钥进入镜像/日志,等同于密钥泄漏,需要轮换而非只改文件。

概念解释

  • 文件权限:属主、组、其他三类读/写/执行位。
  • 下发渠道:密钥管理服务、受控挂载,不写进镜像层。
  • 泄漏面:仓库提交、镜像层、日志、备份文件。

原理流程

  1. 生成密钥后存入安全渠道,不入库不入镜像。
  2. 部署挂载到受限目录,设置严格文件权限。
  3. 运行进程以最小账号读取。
  4. 发现泄漏立即轮换密钥并审查历史访问记录。

代码或图示

# 类 Unix 示例权限(按实际部署模型确认)
目录 700,私钥文件 600,属主为运行服务的账号

常见误区

  • 私钥提交到 Git:历史记录中永久留存,删除提交也难清除。
  • 镜像层打包密钥:导出镜像即可读取。
  • 权限 644 存放私钥:同机其他用户可读。

追问

  • 私钥文件权限原则?答:属主可读,其他用户不可读。
  • 密钥怎么下发?答:密钥管理服务或受控只读挂载。
  • 泄漏后第一步?答:轮换密钥,再审查访问记录。

04.7.20.4-037 时间同步与证书有效期怎么判断?

一句话结论

证书校验依赖本地时间准确,主机/容器应配置 NTP 同步;判断证书有效期需读取 notBefore/notAfter 与当前时间对比,留出轮换提前量,临近过期提前续期。服务时间漂移会导致合法证书被判无效或过期证书被接受,监控应覆盖主机时钟偏差与证书剩余天数。

概念解释

  • 时钟同步:NTP 保证本地时间与标准时间一致。
  • 有效期:notBefore 生效、notAfter 过期,比较需考虑时区。
  • 提前量:剩余天数低于阈值告警,避免到期中断。

原理流程

  1. 环境配置 NTP 同步并监控时钟偏差。
  2. 读取证书有效期字段。
  3. 当前时间对比两个边界,计算剩余天数。
  4. 临期告警续期,过期前完成轮换。

代码或图示

import datetime

# 证书字段解析后比较;具体读取方式按 TLS 库/证书工具确认
# now = datetime.datetime.utcnow()
# valid = not_before <= now <= not_after

常见误区

  • 容器不挂时钟:共享主机时钟,但宿主漂移仍影响校验。
  • 只在到期当天检查:续期流程来不及完成。
  • 时区不统一:本地时间与 UTC 比较错位导致误判。

追问

  • 证书校验依赖什么?答:本地时钟准确,需 NTP 同步。
  • 有效期两个字段?答:notBefore 生效、notAfter 过期。
  • 监控提醒什么?答:时钟偏差与证书剩余天数,临期提前续期。

04.7.20.4-038 敏感配置怎么读取,不写进代码?

一句话结论

密钥、口令、令牌从环境变量、配置中心或密钥管理服务读取,代码与仓库中只保留引用方式,不写实际凭证;配置按环境隔离,开发/测试/生产使用不同凭证,日志与异常不打印敏感值。读取失败快速报错,不用默认弱口令兜底上线。

概念解释

  • 来源优先级:密钥管理服务 > 环境变量 > 受限配置文件。
  • 环境隔离:各环境独立凭证,不共享生产密钥。
  • 脱敏:日志、报错、返回值中隐藏敏感字段。

原理流程

  1. 定义敏感配置项与来源。
  2. 启动时从安全渠道加载,注入运行环境。
  3. 缺失或格式不符时拒绝启动。
  4. 输出链路对敏感字段脱敏,定期轮换。

代码或图示

import os

db_password = os.environ.get("DB_PASSWORD")
if not db_password:
    raise RuntimeError("缺少 DB_PASSWORD 配置")

常见误区

  • 配置文件提交仓库:凭证随代码历史泄漏。
  • 日志打印连接串:口令随日志扩散。
  • 缺失配置用默认值:弱口令静默进入生产。

追问

  • 敏感配置来源优先级?答:密钥管理服务 > 环境变量 > 受限文件。
  • 缺失配置怎么办?答:快速失败,不用默认弱口令兜底。
  • 日志怎么处理敏感值?答:统一脱敏,不打印密钥与口令。

04.7.20.4-039 并发执行外部命令怎么控制资源?

一句话结论

并发外部命令用信号量/连接池限制同时运行数量,每命令设超时与输出上限,避免进程数暴涨、管道缓冲撑爆;批量任务分批执行,监控子进程退出码与僵尸回收,资源上限(CPU、内存、打开文件数)与部署环境匹配。

概念解释

  • 并发上限:信号量控制在跑命令数,防止 fork 风暴。
  • 超时与输出:单命令限时终止,输出限量读取。
  • 回收:等待子进程退出,避免僵尸句柄累积。

原理流程

  1. 设定最大并发数与单命令超时。
  2. 信号量获取许可后启动子进程。
  3. 限时读取输出,收集退出码。
  4. 释放许可并回收进程,异常降级记录。

代码或图示

import subprocess, concurrent.futures

def run_one(cmd):
    return subprocess.run(cmd, capture_output=True, timeout=20, check=False)

with concurrent.futures.ThreadPoolExecutor(max_workers=8) as pool:
    results = list(pool.map(run_one, commands))

常见误区

  • 无上限并发:进程数与内存瞬间打爆。
  • 不设超时:挂起命令长期占用槽位。
  • 输出不限量:管道缓冲阻塞或内存膨胀。

追问

  • 并发数怎么限制?答:信号量或线程池/进程池上限。
  • 单命令必须设什么?答:超时与输出读取上限。
  • 子进程怎么回收?答:等待退出并收集退出码,避免僵尸。

04.7.20.4-040 加密数据落盘方案怎么设计?

一句话结论

落盘加密先区分静态保密需求:字段级加密(敏感列单独加密)、文件级加密(整文件 Fernet/AES-GCM)或磁盘卷加密;密钥与密文分离存储,密文带版本标识支持算法与密钥轮换,备份数据同样在加密保护范围内,不能只加密在线库。

概念解释

  • 加密层级:字段、文件、卷,按敏感程度与访问模式选。
  • 密钥分离:密文存业务库,密钥存密钥管理渠道。
  • 版本化:密文记录算法/密钥版本,便于轮换重加密。

原理流程

  1. 识别需要静态保密的数据与访问场景。
  2. 选加密层级与算法,生成/导入密钥。
  3. 写入前加密,读取后解密,记录版本标识。
  4. 备份与导出链路纳入加密,定期轮换重加密。

代码或图示

密文记录:算法版本 + 密钥版本 + nonce + 密文 + 签名/认证标签
密钥:独立渠道保管,不与密文同库同目录

常见误区

  • 密钥和密文放一起:拿到文件即拿到解密钥匙。
  • 密文不带版本:轮换后无法识别用哪把密钥解密。
  • 只加密主库:备份、导出文件、日志副本成为明文漏点。

追问

  • 加密分哪几层?答:字段级、文件级、卷级。
  • 密钥怎么存放?答:与密文分离,走密钥管理渠道。
  • 轮换怎么支持?答:密文记录算法与密钥版本,分批重加密。

04.7.20.4-041 传输安全:TLS 版本与证书校验怎么把控?

一句话结论

对外/对内加密传输使用受支持的 TLS 版本(淘汰 SSLv3/TLS1.0/1.1,按当前安全基线确认可用版本),客户端默认校验证书链与主机名,禁止生产环境关闭校验;校验失败按证书过期、域名不匹配、自签名等原因分类处理,不要为方便全局跳过验证。

概念解释

  • 版本基线:旧协议存在已知漏洞,按安全文档确认最低版本。
  • 校验项:证书链信任、主机名匹配、有效期、吊销状态。
  • 跳过校验:仅允许本地开发临时调试,禁止进入生产配置。

原理流程

  1. 服务端配置 TLS 版本与证书链。
  2. 客户端建立连接时校验证书与主机名。
  3. 失败分类定位:过期、域名不符、不受信 CA、链不全。
  4. 修复证书或信任链,而非关闭校验。

代码或图示

import httpx

# 默认校验证书;不要在生产设置 verify=False
client = httpx.Client(timeout=10)

常见误区

  • verify=False 上线:中间人可拦截篡改全部流量。
  • 旧 TLS 版本未淘汰:已知漏洞可被利用。
  • 只校验不匹配主机名:证书可被其他站点复用攻击。

追问

  • 生产能关证书校验吗?答:不能,仅本地调试可临时关闭。
  • 校验失败分哪些原因?答:过期、域名不符、不受信 CA、证书链不全。
  • 旧协议怎么处理?答:按安全基线淘汰 SSLv3/TLS1.0/1.1。

04.7.20.4-042 本地并发写文件怎么锁定?

一句话结论

多进程/多线程并发写同一文件需协调:线程内用锁串行化写操作,跨进程用文件锁(fcntl/平台锁机制)或单写者队列;写入采用临时文件加原子替换,避免半写状态被读到。追加写要保证单次写入粒度完整,防止交错拼接出损坏记录。

概念解释

  • 线程锁:同进程内串行化临界区。
  • 进程锁:跨进程排他/共享锁,平台接口不同。
  • 原子写:先写临时文件,再 rename 替换目标文件。

原理流程

  1. 判断并发模型:同进程线程还是跨进程。
  2. 选对应锁机制,保护写临界区。
  3. 完整记录/原子落盘,避免交错与半写。
  4. 异常时清理临时文件,保留损坏可定位信息。

代码或图示

from pathlib import Path
import os

target = Path("data.log")
tmp = target.with_suffix(".tmp")
tmp.write_text(content, encoding="utf-8")
os.replace(tmp, target)  # 同目录原子替换

常见误区

  • 多进程直接追加:记录交错,文件内容损坏。
  • 直接覆盖写:读到中途文件是半写状态。
  • 锁不释放:进程异常后其他写者永久阻塞。

追问

  • 跨进程用什么协调?答:文件锁机制,按平台接口实现。
  • 怎么避免半写被读到?答:临时文件写完再原子替换。
  • 追加写注意什么?答:单次写入粒度完整,防止记录交错。

04.7.20.4-043 备份数据怎么做完整性校验?

一句话结论

备份生成后计算摘要(SHA-256)与备份清单一同保存,恢复前先校验摘要确认备份未损坏;定期做恢复演练验证备份可用,而非只确认文件存在。摘要按批次关联备份时间与版本,异地备份同样记录校验值,校验算法不用 MD5/SHA-1。

概念解释

  • 摘要校验:备份文件哈希与记录值比对。
  • 清单:备份时间、来源、大小、摘要、版本。
  • 恢复演练:实际还原到测试环境验证可用。

原理流程

  1. 备份完成后分块计算 SHA-256 摘要。
  2. 摘要与清单存入安全位置,关联批次。
  3. 恢复前比对摘要,一致再还原。
  4. 周期演练恢复,记录耗时与问题。

代码或图示

import hashlib

def sha256_file(path: str) -> str:
    h = hashlib.sha256()
    with open(path, "rb") as f:
        for chunk in iter(lambda: f.read(65536), b""):
            h.update(chunk)
    return h.hexdigest()

常见误区

  • 只看备份文件存在:损坏或不完整无法发现。
  • 摘要与备份放同一未保护位置:可被一起篡改。
  • 从不演练恢复:真正故障时备份不可用才暴露问题。

追问

  • 备份校验用什么算法?答:SHA-256 及以上,不用 MD5/SHA-1。
  • 校验值存哪里?答:与备份清单关联,存独立安全位置。
  • 为什么要恢复演练?答:验证备份可还原,而非仅文件存在。

04.7.20.4-044 运维库选型怎么守住标准库优先边界?

一句话结论

标准库已覆盖的能力(subprocess、pathlib、tempfile、shutil、hashlib/hmac/secrets、importlib.metadata、signal、logging)优先使用;第三方库只在标准库不足时引入(加密算法封装、慢哈希、SSH、文件事件、调度、结构化日志)。引入依赖要评估维护状态、安全更新与体积,不重复造轮子也不为小需求堆依赖。

概念解释

  • 标准库:随语言发行,稳定无额外供应链风险。
  • 第三方:补充专用能力,但需跟踪漏洞与版本维护。
  • 选型清单:需求 → 标准库是否覆盖 → 成熟第三方 → 评估成本。

原理流程

  1. 列出需求能力点。
  2. 先查标准库对应模块与接口。
  3. 标准库不足时选活跃维护、生态通用的第三方库。
  4. 记录引入理由,定期清理不再使用的依赖。

代码或图示

系统调用/路径/临时文件/摘要/随机/元数据 → 标准库
加密封装/口令哈希/SSH/事件监听/调度 → 按需第三方

常见误区

  • 标准库能做却引入重依赖:供应链与维护成本上升。
  • 凭习惯引库:不评估是否有标准库替代。
  • 依赖长期不更新:安全漏洞累积,失去维护的库风险高。

追问

  • 标准库优先原则?答:已覆盖的能力先用标准库,第三方补缺口。
  • 第三方依赖评估什么?答:维护活跃度、安全更新、体积与生态。
  • 标准库覆盖哪些运维场景?答:子进程、路径、临时文件、摘要、随机、元数据、信号。

04.7.20.4-045 运维、安全与系统库落地怎么总结?

一句话结论

落地主线是“默认值看清、资源有上限、凭证有保管、操作有审计”:外部命令限定白名单与超时,系统指标结合容器口径判断,加密与签名选用安全算法并管好密钥,文件操作走路径校验与原子写,依赖与配置可复现可追溯。安全机制纵深分层,单点防御不替代最小权限与审计闭环。

概念解释

  • 资源边界:超时、并发上限、输出限量、进程回收。
  • 凭证边界:密钥来源、权限、轮换、脱敏。
  • 操作闭环:白名单、校验、日志记录、异常告警。

原理流程

  1. 梳理进程对外调用:命令、网络、文件、凭证四类。
  2. 每类配置默认值上限与校验规则。
  3. 接入监控与审计,异常调用告警。
  4. 定期复核算法强度、依赖更新与密钥轮换。

代码或图示

命令:白名单 + 列表参数 + 超时 + 退出码校验
指标:psutil 结合 cgroup 口径
加密:安全算法 + 密钥分离 + 版本化
文件:路径边界校验 + 临时文件 + 原子替换
配置:安全来源读取 + 缺失快速失败 + 日志脱敏

常见误区

  • 只上加密库不管理密钥:防护停在算法层。
  • 监控指标不结合限额:容器内误判容量与负载。
  • 安全实现无审计:事故后无法追溯入口与影响范围。

追问

  • 落地四条主线?答:默认值看清、资源有上限、凭证有保管、操作有审计。
  • 外部命令防护要点?答:白名单、列表参数、超时、退出码校验。
  • 安全为什么要分层?答:单点防御可被绕过,最小权限与审计形成闭环。

本节高频题

  • 容器内 psutil 指标失真与 cgroup 口径(002)
  • subprocess 安全调用与 shell 注入(005、009)
  • 超时、退出码与流式管道(006、008)
  • Fernet/AES-GCM 与混合加密边界(010、011)
  • 密钥管理与安全随机源(012、013)
  • hmac 定时比较与 secrets 选型(015、016)
  • 口令慢哈希、加盐与 bcrypt 限制(017、018、019)
  • JWT 签发校验、算法混淆与声明校验(020、021、022)
  • SSH 客户端选型与主机密钥校验(023、024)
  • watchdog 事件与 APScheduler 持久化(025、026)
  • pathlib/tempfile/shutil 与路径注入(027、028、029、030)
  • pip/poetry/uv 与 importlib.metadata(031、032)
  • 信号优雅退出与最小权限(034、035)
  • TLS 校验、备份摘要与并发写(041、042、043)