Python Metasploit Framework：渗透测试中的 Python 应用

好的，各位观众老爷，今天咱们聊聊Python这玩意儿在Metasploit Framework（MSF）里头是怎么耍的。别害怕，这玩意儿听着玄乎，其实就是一堆工具，咱们用Python给它加点料，让它更听话。

啥是Metasploit Framework？

简单说，MSF就是一个渗透测试的大杂烩，里面啥都有，漏洞利用、信息收集、提权等等。它就像一个瑞士军刀，啥都能干一点，但是要干得漂亮，还得自己磨刀。

为啥要用Python？

MSF默认是用Ruby写的，但是Python这玩意儿简单啊！上手快，库也多，用来扩展MSF简直不要太爽。而且很多漏洞利用本身就是用Python写的，直接拿来用，省时省力。

Python在MSF里能干啥？

辅助模块（Auxiliary Modules）： 比如端口扫描、服务枚举，这些活儿用Python写起来又快又方便。
漏洞利用模块（Exploit Modules）： 有些漏洞利用用Python写更简单，而且可以集成各种Python库。
后渗透模块（Post Modules）： 拿到shell之后，用Python写一些脚本，收集信息、提权啥的，简直不要太方便。
编码器（Encoders）： 把我们的payload编码一下，躲避杀软的检测。
Payloads： 生成各种Payload，比如反弹shell，下载执行等等。

开始实战：写一个简单的端口扫描辅助模块

咱们先来个简单的，写一个端口扫描的辅助模块，看看Python是怎么在MSF里工作的。

创建模块文件：

在MSF的模块目录下创建一个Python文件，比如：modules/auxiliary/scanner/portscan/python_portscan.py

（注意：具体的模块目录位置可能因MSF版本而异，一般在/usr/share/metasploit-framework/modules/下）

编写模块代码：

from metasploit.msfmodule import MsfModule
import socket

class Msf(MsfModule):
    def __init__(self):
        super().__init__(
            info={
                'name': 'Python Port Scanner',
                'description': 'A simple port scanner written in Python',
                'authors': [
                    'Your Name'  # 替换成你的名字
                ],
                'references': [
                    ['URL', 'https://example.com']  # 替换成你的参考链接
                ],
                'options': {
                    'RHOSTS': {
                        'type': 'address',
                        'description': 'The target host(s)',
                        'required': True,
                        'default': None
                    },
                    'PORTS': {
                        'type': 'string',
                        'description': 'The ports to scan (e.g., 21,22,80,443)',
                        'required': True,
                        'default': '21,22,80,443'
                    },
                    'TIMEOUT': {
                        'type': 'integer',
                        'description': 'Socket timeout in seconds',
                        'required': False,
                        'default': 5
                    }
                }
            }
        )

    def run(self):
        rhosts = self.opts['RHOSTS']
        ports = self.opts['PORTS'].split(',')
        timeout = self.opts['TIMEOUT']

        self.print_status(f"Scanning {rhosts} for ports: {ports}")

        for port in ports:
            try:
                port = int(port)
                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                sock.settimeout(timeout)
                result = sock.connect_ex((rhosts, port))

                if result == 0:
                    self.print_good(f"Port {port} is open")
                else:
                    self.print_verbose(f"Port {port} is closed")

                sock.close()

            except ValueError:
                self.print_error(f"Invalid port: {port}")
            except socket.error as e:
                self.print_error(f"Socket error: {e}")
            except Exception as e:
                self.print_error(f"An unexpected error occurred: {e}")

代码解释：
- from metasploit.msfmodule import MsfModule: 导入MSF模块基类。
- class Msf(MsfModule):: 定义一个类，继承自MsfModule，这是我们模块的主体。
- info: 定义模块的信息，包括名称、描述、作者、参考链接和选项。
  - name: 模块的名称，会在MSF里显示。
  - description: 模块的描述，简单介绍模块的功能。
  - authors: 模块的作者，记得写上你的大名。
  - references: 模块的参考链接，可以指向相关的漏洞或者文章。
  - options: 模块的选项，用户可以在MSF里设置这些选项。
    - RHOSTS: 目标主机，类型是address，必须填写。
    - PORTS: 要扫描的端口，类型是string，默认扫描21,22,80,443端口。
    - TIMEOUT: socket超时时间，类型是integer，默认5秒。
- run: 模块的执行函数，在这里编写我们的扫描逻辑。
  - rhosts = self.opts['RHOSTS']: 获取用户设置的目标主机。
  - ports = self.opts['PORTS'].split(','): 获取用户设置的端口，并分割成列表。
  - timeout = self.opts['TIMEOUT']: 获取用户设置的超时时间。
  - socket.socket(socket.AF_INET, socket.SOCK_STREAM): 创建一个TCP socket。
  - sock.connect_ex((rhosts, port)): 尝试连接目标主机的端口，如果连接成功，返回0，否则返回错误码。
  - self.print_good(f"Port {port} is open"): 如果端口开放，打印成功的消息。
  - self.print_verbose(f"Port {port} is closed"): 如果端口关闭，打印详细的消息。
  - self.print_error(f"Invalid port: {port}"): 如果端口输入错误，打印错误信息。
  - self.print_error(f"Socket error: {e}"): 如果socket发生错误，打印错误信息。
  - self.print_error(f"An unexpected error occurred: {e}"): 如果发生其他错误，打印错误信息。
在MSF中使用模块：
- 启动MSF：msfconsole
- 加载模块：use auxiliary/scanner/portscan/python_portscan
- 设置选项：
  - set RHOSTS 127.0.0.1
  - set PORTS 21,22,80,443
- 运行模块：run
如果一切顺利，你就能看到MSF扫描目标主机的端口，并输出结果。

进阶：写一个简单的Payload

除了辅助模块，我们还可以用Python写Payload。Payload是攻击的核心，它是在目标主机上执行的代码。

创建Payload文件：

在MSF的Payload目录下创建一个Python文件，比如：modules/payloads/singles/python/exec.py

（注意：具体的Payload目录位置可能因MSF版本而异，一般在/usr/share/metasploit-framework/modules/payloads/singles/下）

编写Payload代码：

from metasploit.msfmodule import MsfModule
import subprocess

class Msf(MsfModule):
    def __init__(self):
        super().__init__(
            info={
                'name': 'Python Command Execution',
                'description': 'Execute a command on the target system using Python',
                'authors': [
                    'Your Name'  # 替换成你的名字
                ],
                'references': [
                    ['URL', 'https://example.com']  # 替换成你的参考链接
                ],
                'payload_type': 'python',
                'platform': ['unix', 'windows'],
                'arch': ['python'],
                'options': {
                    'CMD': {
                        'type': 'string',
                        'description': 'The command to execute',
                        'required': True,
                        'default': 'whoami'
                    }
                }
            }
        )

    def run(self):
        cmd = self.opts['CMD']

        self.print_status(f"Executing command: {cmd}")

        try:
            process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            stdout, stderr = process.communicate()

            if stdout:
                self.print_good(f"Command output:n{stdout.decode()}")
            if stderr:
                self.print_error(f"Command error:n{stderr.decode()}")

        except Exception as e:
            self.print_error(f"An unexpected error occurred: {e}")

代码解释：
- payload_type': 'python': 指定Payload的类型为Python。
- platform: 指定Payload支持的平台，这里支持Unix和Windows。
- arch: 指定Payload支持的架构，这里是Python。
- subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE): 使用subprocess模块执行命令。
  - shell=True: 允许执行shell命令。
  - stdout=subprocess.PIPE: 将标准输出重定向到管道。
  - stderr=subprocess.PIPE: 将标准错误重定向到管道。
- stdout, stderr = process.communicate(): 获取命令的输出和错误信息。
- self.print_good(f"Command output:n{stdout.decode()}"): 打印命令的输出。
- self.print_error(f"Command error:n{stderr.decode()}"): 打印命令的错误信息。
在MSF中使用Payload：
- 启动MSF：msfconsole
- 使用漏洞利用模块（这里假设你已经找到了一个漏洞）：use exploit/unix/webapp/某某漏洞
- 设置Payload：set PAYLOAD python/exec
- 设置选项：
  - set CMD whoami
- 设置目标：set RHOST 127.0.0.1
- 运行模块：run
如果漏洞利用成功，你就能在MSF里看到whoami命令的输出。

一些小技巧和注意事项：

善用MSF的API： MSF提供了一系列的API，可以方便地访问MSF的各种功能，比如数据库、会话管理等等。
错误处理： 在编写Python模块时，一定要注意错误处理，避免程序崩溃。
代码规范： 保持代码的整洁和规范，方便自己和别人阅读。
安全性： 在编写Payload时，一定要注意安全性，避免引入恶意代码。
调试： MSF提供了一些调试工具，可以方便地调试Python模块。
多看官方文档和例子： MSF的官方文档和例子是最好的学习资料。

表格总结：

功能	Python实现	优点	缺点
端口扫描	使用`socket`模块进行端口连接尝试	简单易懂，快速实现基本功能	效率较低，容易被防火墙拦截
命令执行Payload	使用`subprocess`模块执行系统命令	方便执行各种命令，可以获取输出和错误信息	需要注意命令注入风险，容易被杀软检测
信息收集	使用`os`、`platform`等模块获取系统信息，使用第三方库如`psutil`获取进程信息等	能够获取各种系统信息，方便进行后续渗透	需要安装第三方库，可能需要root权限
网络协议分析	使用`socket`模块捕获和分析网络数据包，使用第三方库如`scapy`构造和发送数据包	能够深入了解网络协议，方便进行漏洞挖掘和利用	需要root权限，需要一定的网络协议知识
漏洞利用	使用`requests`、`urllib`等模块发送HTTP请求，使用`socket`模块进行socket编程	能够灵活地利用各种漏洞，可以自定义攻击流程	需要对漏洞原理有深入理解，需要处理各种异常情况
编码器	使用`base64`、`urlencode`等模块进行编码，使用第三方库如`zlib`进行压缩	能够对Payload进行编码，躲避杀软检测	编码方式容易被识别，需要不断更新编码策略

最后，一些忠告：

渗透测试是一把双刃剑，请务必在授权的情况下进行，切勿用于非法用途。学习渗透测试的目的是为了更好地保护自己的系统安全，而不是为了攻击别人的系统。

希望今天的分享对大家有所帮助，祝大家玩得开心！如果大家有什么问题，欢迎在评论区留言，我会尽力解答。下次再见！

发表回复 取消回复

发表回复取消回复