Python网络安全工具集构建：从端口扫描到密码爆破的实战指南

简介：本资源是一套面向网络安全初学者与渗透测试爱好者的Python安全工具实战源码集，聚焦信息搜集、漏洞检测、加密认证、流量分析及免杀控制等核心攻防场景，助力读者系统掌握Python在安全领域的工程化应用。压缩包共62个文件，含45个功能明确的Python脚本（如端口扫描、SQL盲注检测、XXE利用、ARP欺骗、WebShell模糊测试等），辅以密码字典（passwords/username）、扫描结果（result）、配置模板（xml/md）及敏感信息样本（person_information），整体3.01MB，结构清晰、即装即用。目前已有68人学习下载，所有脚本均基于标准库或轻量依赖实现，附带README说明与模块化调用示例，既可独立运行验证原理，也支持二次开发集成进自研框架，是理解渗透测试底层逻辑与提升Python安全编码能力的优质实践素材。

1. 项目概述：一个Python网络安全工具集的诞生

在安全圈子里混久了，你会发现一个有趣的现象：很多资深的安全工程师，电脑里都藏着一个私人的“百宝箱”。这个箱子里不是什么金银财宝，而是一堆自己写的、改的、从各处搜集来的脚本和工具。它们可能长得不那么好看，文档也可能只有自己能看懂，但在关键时刻，往往比那些庞大臃肿的商业软件更顺手、更高效。今天，我想和大家分享的，就是这样一个“百宝箱”的构建思路与核心实现——一个基于Python的网络安全工具集。这不仅仅是一堆代码的打包，更是一种工作流和思维方式的沉淀。

这个工具集的初衷很简单：解决日常渗透测试、安全评估、应急响应中那些重复、琐碎但又至关重要的任务。比如，快速扫描一个C段有哪些Web服务开着非常规端口；批量验证一批泄露的账号密码是否还在使用；或者，在得到一个shell后，需要快速进行内网信息搜集。这些场景下，现成的大工具可能杀鸡用牛刀，而手写命令又太慢。一个轻量、模块化、可随意组合的Python工具集，就成了最佳选择。它适合所有对网络安全有兴趣的朋友，无论是刚入门想通过实践理解原理的新手，还是想提升自动化效率的老鸟，都能从中找到价值。

2. 工具集整体架构与设计哲学

2.1 为什么选择Python作为核心语言？

首先得聊聊为什么是Python。在安全领域，Python几乎是“标配”语言，这背后有几个硬核原因。第一是生态强大，从底层的网络套接字操作（socket）、数据包构造（scapy），到Web请求（requests）、解析（BeautifulSoup），再到密码学（cryptography）、反汇编（capstone），都有成熟且活跃的库支持，让你能站在巨人的肩膀上，快速实现想法。第二是跨平台，无论是Windows、Linux还是macOS，一份代码基本都能跑，这对于需要在不同目标环境部署工具的情况至关重要。第三是“胶水”特性，Python能轻松调用系统命令、与其他语言（如C/C++）写的模块交互，甚至直接内嵌SQL语句操作数据库，这种灵活性在复杂的渗透测试环境中非常有用。

我的设计哲学是“模块化”和“管道化”。工具集不是一个庞大的单体程序，而是一系列独立的小脚本（模块），每个脚本只做好一件事。它们通过标准的输入输出（比如命令行参数、stdin/stdout、JSON文件）进行通信。这样做的好处是，你可以像搭积木一样组合它们。例如，一个脚本负责从日志中提取疑似IP，另一个脚本负责对这些IP进行端口扫描，再用一个脚本对开放的端口进行服务识别。这种Unix哲学下的工具设计，使得复用和调试变得极其简单。

2.2 核心模块规划与依赖管理

基于日常高频需求，我将工具集初步规划为以下几个核心模块，并明确了其关键依赖：

1. 信息收集模块：这是所有行动的起点。包括子域名枚举、C段扫描、端口扫描、Web目录/文件探测、WAF识别等。关键依赖：dnspython用于DNS查询，socket和concurrent.futures用于高性能端口扫描，requests用于Web请求。
2. 漏洞探测与利用模块：针对常见漏洞进行检测或提供利用脚本。如SQL注入检测、XSS探测、命令注入检测、特定CMS的漏洞利用等。关键依赖：requests处理HTTP交互，BeautifulSoup或lxml解析HTML，re进行正则匹配。
3. 密码破解与暴力破解模块：用于密码强度测试、在线/离线密码破解。支持HTTP基本认证、表单登录、数据库口令破解等。关键依赖：hashlib用于计算哈希，itertools生成密码字典，threading或multiprocessing实现多线程/进程加速。
4. 后渗透与权限维持模块：在取得初步权限后使用。包括简单的文件上传/下载、内网代理转发、本地信息搜集（用户、进程、网络连接）、权限提升检查清单等。关键依赖：os,sys,subprocess执行系统命令，socket建立代理。
5. 实用工具与辅助模块：编码解码（Base64, URL, Hex）、数据提取（从文件中提取邮箱、手机号）、日志分析、随机User-Agent生成等。关键依赖：base64,urllib.parse,re。

为了管理这些依赖，强烈推荐使用pip配合requirements.txt文件。在项目根目录创建一个requirements.txt，列出所有依赖库及其版本。这样，其他人在拿到你的源码后，只需要执行pip install -r requirements.txt就能一键配好环境，避免了“跑不起来”的尴尬。

注意：在编写和分享安全工具时，务必遵守法律法规和道德准则。这些工具仅用于授权的安全测试、学习研究或个人环境下的安全防护。任何未经授权的扫描、攻击行为都是非法的。

3. 关键模块深度解析与实现要点

3.1 高性能异步端口扫描器的实现

端口扫描是信息收集的基石。一个高效的扫描器能节省大量时间。这里我们不简单用nmap调用，而是自己实现一个，以理解其原理并实现高度定制。

核心思路：采用TCP SYN半连接扫描。这是目前最主流、相对隐蔽且高效的扫描方式。它不完成完整的TCP三次握手，只发送SYN包，根据返回的SYN-ACK或RST来判断端口状态。

实现要点与代码解析：

首先，我们需要构造原始的SYN数据包。这里使用scapy库，它提供了极其灵活的数据包构造和发送能力。

from scapy.all import IP, TCP, sr1, conf import socket import random from concurrent.futures import ThreadPoolExecutor, as_completed def syn_scan(target_ip, port, timeout=1): """ 对单个目标IP和端口进行SYN扫描 :param target_ip: 目标IP地址 :param port: 目标端口 :param timeout: 超时时间（秒） :return: (port, status) status: 'open', 'closed', 'filtered' """ # 构造IP和TCP层数据包 # 随机生成一个源端口，避免被简单的跟踪 src_port = random.randint(1024, 65535) # 设置flags='S'表示SYN包 pkt = IP(dst=target_ip)/TCP(sport=src_port, dport=port, flags='S') # 关闭scapy的默认verbose输出，保持安静 conf.verb = 0 try: # sr1发送包并接收第一个应答 resp = sr1(pkt, timeout=timeout, verbose=0) if resp is None: # 没有收到任何响应，可能是被防火墙过滤了 return (port, 'filtered') elif resp.haslayer(TCP): if resp.getlayer(TCP).flags == 0x12: # SYN-ACK标志位 # 收到SYN-ACK，说明端口开放 # 礼貌地发送一个RST包关闭连接，避免留下大量半连接 rst_pkt = IP(dst=target_ip)/TCP(sport=src_port, dport=port, flags='R') sr1(rst_pkt, timeout=0.5, verbose=0) return (port, 'open') elif resp.getlayer(TCP).flags == 0x14: # RST-ACK标志位 # 收到RST，说明端口关闭 return (port, 'closed') except Exception as e: # 网络错误等异常情况 return (port, 'error') # 其他未知响应 return (port, 'unknown') def scan_ports(target_ip, port_list, max_workers=200): """ 使用线程池并发扫描多个端口 :param target_ip: 目标IP :param port_list: 端口列表，如 [80, 443, 8080, 1-1000] :param max_workers: 最大并发线程数 :return: 开放端口列表 """ open_ports = [] # 处理端口范围字符串，如“1-1000” ports_to_scan = [] for item in port_list: if isinstance(item, int): ports_to_scan.append(item) elif isinstance(item, str) and '-' in item: start, end = map(int, item.split('-')) ports_to_scan.extend(range(start, end+1)) print(f"[*] 开始扫描 {target_ip}， 共 {len(ports_to_scan)} 个端口， 线程数：{max_workers}") with ThreadPoolExecutor(max_workers=max_workers) as executor: # 提交所有扫描任务 future_to_port = {executor.submit(syn_scan, target_ip, port): port for port in ports_to_scan} for future in as_completed(future_to_port): port, status = future.result() if status == 'open': open_ports.append(port) print(f"[+] {target_ip}:{port} 开放") # 可选：显示关闭或过滤的端口，但通常我们只关心开放的 # elif status == 'closed': # print(f"[-] {target_ip}:{port} 关闭") # elif status == 'filtered': # print(f"[!] {target_ip}:{port} 可能被过滤") print(f"[*] 扫描完成。发现 {len(open_ports)} 个开放端口。") return sorted(open_ports) # 使用示例 if __name__ == "__main__": target = "192.168.1.1" # 请替换为你的测试目标（必须是授权目标！） ports = [80, 443, 22, 21, 3389, 8080, 8000-8100] # 可以混合单个端口和范围 open_ports = scan_ports(target, ports) print(f"开放端口列表：{open_ports}")

注意事项与心得：

1. 权限问题：在Linux/Unix系统上发送原始数据包（Raw Socket）需要root权限。因此运行此脚本通常需要sudo。
2. 线程数控制：max_workers并非越大越好。过高的并发会导致网络拥堵、目标主机拒绝服务（DoS）甚至触发对方的防御机制。对于外网扫描，建议设置在50-200之间；内网可以稍高。这是一个需要权衡的参数。
3. 超时设置：timeout参数很重要。对于网络延迟高的目标，需要适当增加，否则会误判为“filtered”。可以设计为动态超时，或者先发几个探测包测试网络延迟。
4. 道德与法律：再次强调，只扫描你拥有明确书面授权的主机。未经授权的端口扫描在许多地区被视为违法行为或攻击前奏。
5. 性能优化：scapy虽然强大灵活，但在发送大量数据包时性能并非最优。对于超大规模扫描，可以考虑使用python-nmap库调用nmap引擎，或者使用更底层的socket结合多线程/异步IO（如asyncio）来实现。

3.2 智能Web路径扫描与敏感文件发现

在发现开放了80/443等Web端口后，下一步就是探测其目录和文件结构，寻找后台登录入口、配置文件、备份文件等敏感资源。

核心思路：基于字典的暴力破解。但单纯的暴力枚举效率低下且噪音大。我们需要加入一些智能逻辑：

1. 目标适应性：根据Web服务器类型（如Apache, Nginx, IIS）和开发语言（如PHP, ASP, JSP）动态加载不同的字典。
2. 递归扫描：发现目录后，自动深入扫描该目录下的内容。
3. 结果过滤：根据HTTP状态码、响应内容长度、标题关键词等智能判断是否为“有意义”的发现，避免输出大量404页面。

实现要点：

import requests from urllib.parse import urljoin import threading import queue import time from bs4 import BeautifulSoup import sys class DirScanner: def __init__(self, base_url, wordlist_file, extensions=[], threads=20): self.base_url = base_url.rstrip('/') self.wordlist = self.load_wordlist(wordlist_file) self.extensions = extensions # 如 ['.php', '.bak', '.tar.gz'] self.thread_count = threads self.found_items = [] self.lock = threading.Lock() self.queue = queue.Queue() self.session = requests.Session() # 设置一个合理的User-Agent，避免被简单屏蔽 self.session.headers.update({ 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36' }) def load_wordlist(self, filename): """加载字典文件，并处理常见格式""" words = [] try: with open(filename, 'r', encoding='utf-8', errors='ignore') as f: for line in f: word = line.strip() if word and not word.startswith('#'): # 忽略空行和注释 words.append(word) except FileNotFoundError: print(f"[!] 字典文件 {filename} 未找到！") sys.exit(1) print(f"[*] 已加载 {len(words)} 个路径单词。") return words def probe(self, path): """探测单个路径""" url = urljoin(self.base_url + '/', path) # 确保正确的URL拼接 try: resp = self.session.get(url, timeout=10, allow_redirects=True) # 基础过滤逻辑：状态码为2xx（成功）或3xx（重定向）通常有意义 # 403（禁止访问）和401（需要认证）也值得关注 if resp.status_code in [200, 301, 302, 307, 308, 403, 401]: content_length = len(resp.content) title = "无标题" # 尝试提取页面标题，用于辅助判断 if 'text/html' in resp.headers.get('Content-Type', ''): try: soup = BeautifulSoup(resp.text, 'html.parser') if soup.title and soup.title.string: title = soup.title.string.strip()[:50] except: pass with self.lock: self.found_items.append({ 'url': resp.url, # 注意使用最终重定向后的URL 'status': resp.status_code, 'length': content_length, 'title': title }) # 输出发现 print(f"[{resp.status_code}] {resp.url} (长度: {content_length}) [标题: {title}]") # 如果发现的是目录（以/结尾，或者返回的是目录列表），可以考虑加入队列进行递归扫描 # 这里简化处理：如果状态码是200且内容长度较小，可能是目录列表页，可以进一步分析 # 实际应用中，可以根据需求实现更复杂的递归逻辑 except requests.exceptions.RequestException as e: # 连接超时、拒绝连接等错误，静默处理 pass except Exception as e: # 其他未知异常，简单打印 with self.lock: print(f"[!] 探测 {url} 时发生错误: {e}") def worker(self): """工作线程函数""" while True: try: path = self.queue.get(timeout=1) except queue.Empty: break # 首先尝试原始路径 self.probe(path) # 如果指定了扩展名，尝试拼接扩展名 for ext in self.extensions: self.probe(path + ext) self.queue.task_done() def run(self): """启动扫描""" print(f"[*] 开始扫描: {self.base_url}") start_time = time.time() # 将字典单词放入队列 for word in self.wordlist: self.queue.put(word) # 创建并启动工作线程 threads = [] for i in range(self.thread_count): t = threading.Thread(target=self.worker) t.daemon = True t.start() threads.append(t) # 等待队列清空 self.queue.join() # 等待所有线程结束 for t in threads: t.join() elapsed = time.time() - start_time print(f"\n[*] 扫描完成！耗时 {elapsed:.2f} 秒，共发现 {len(self.found_items)} 个有效路径。") # 简单去重和排序后输出结果 unique_items = [] seen_urls = set() for item in self.found_items: if item['url'] not in seen_urls: seen_urls.add(item['url']) unique_items.append(item) # 按状态码排序输出 unique_items.sort(key=lambda x: x['status']) print("\n======= 扫描结果汇总 =======") for item in unique_items: print(f"[{item['status']}] {item['url']}") return unique_items # 使用示例 if __name__ == "__main__": # 请务必在授权范围内测试！ scanner = DirScanner( base_url="http://testphp.vulnweb.com", # 这是一个合法的测试网站 wordlist_file="common_dirs.txt", # 你需要准备一个路径字典文件 extensions=['.php', '.html', '.bak', '.txt'], threads=30 ) results = scanner.run()

实操心得与避坑指南：

1. 字典质量是关键：不要盲目使用庞大的字典（如几百万条）。这会产生大量无效请求，速度慢且容易被封。推荐从高质量的小字典开始（如SecLists项目中的Discovery/Web-Content目录下的字典），并根据目标特点动态调整。例如，看到.aspx文件，就重点使用ASP.NET相关的字典。
2. 速率限制与随机延迟：在脚本中加入time.sleep(random.uniform(0.1, 0.5))之类的随机延迟，可以降低请求频率，避免触发目标的WAF（Web应用防火墙）或速率限制规则。更高级的做法是动态调整速率，根据响应时间或错误码（如429 Too Many Requests）来暂停。
3. 处理重定向：requests的allow_redirects=True会自动处理重定向，但有时需要分析重定向链。对于登录跳转（302到登录页），这能帮你发现后台入口。记得检查最终响应的URL和状态码。
4. 结果去重与过滤：上面示例做了简单的URL去重。更精细的做法是进行“内容去重”：计算响应内容的哈希值（如MD5），如果多个路径返回完全相同的“404页面”或“默认首页”，可以只保留一个。这能极大减少输出噪音。
5. 递归扫描的风险：实现递归扫描（发现目录后，将其作为新的base_url继续扫描）要非常小心，很容易陷入无限循环（尤其是存在符号链接或循环路径时）或扫描到非授权范围。务必设置递归深度限制（如max_depth=3）和范围检查。

4. 密码破解模块：以HTTP表单爆破为例

密码破解是安全评估中验证账户安全性的重要环节。我们以实现一个通用的HTTP表单爆破工具为例，讲解其中的关键技术和注意事项。

核心思路：读取用户名和密码字典，组合后向目标登录接口发起POST请求，根据服务器响应判断是否成功。为了提高效率，必须使用多线程或异步IO。

实现要点：

import requests import threading import queue import sys import time from urllib.parse import urlparse class HttpFormBruter: def __init__(self, url, username_field, password_field, other_data={}): """ :param url: 登录表单提交的URL :param username_field: 用户名表单字段名 :param password_field: 密码表单字段名 :param other_data: 其他需要提交的固定表单数据，如csrf token（如果已知） """ self.url = url self.username_field = username_field self.password_field = password_field self.other_data = other_data self.session = requests.Session() # 伪装成浏览器，有些网站会检查User-Agent self.session.headers.update({ 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36', 'Content-Type': 'application/x-www-form-urlencoded' # 常见表单提交类型 }) self.found_creds = [] # 存储发现的凭证 self.lock = threading.Lock() self.queue = queue.Queue() self.stop_event = threading.Event() # 用于发现一个成功后停止所有线程 def load_credentials(self, user_file, pass_file): """加载用户名字典和密码字典，并生成组合队列""" users = self._read_file(user_file) passes = self._read_file(pass_file) print(f"[*] 加载了 {len(users)} 个用户名和 {len(passes)} 个密码，共 {len(users)*len(passes)} 种组合。") for user in users: for pwd in passes: self.queue.put((user, pwd)) def _read_file(self, filename): """读取字典文件，每行一个条目""" items = [] try: with open(filename, 'r', encoding='utf-8', errors='ignore') as f: for line in f: item = line.strip() if item: items.append(item) except FileNotFoundError: print(f"[!] 文件 {filename} 未找到！") sys.exit(1) return items def try_login(self, username, password): """尝试一次登录""" if self.stop_event.is_set(): return False # 构建POST数据 post_data = {self.username_field: username, self.password_field: password} post_data.update(self.other_data) # 合并其他固定字段 try: resp = self.session.post(self.url, data=post_data, timeout=15, allow_redirects=False) # **关键部分：如何判断登录成功？** # 这没有通用方法，必须针对目标网站分析。常见判断依据： # 1. 状态码：登录成功往往是302重定向到内部页面，失败是200并停留在登录页。 # 2. 响应内容：成功后的页面可能包含“欢迎”、“退出”等关键词，失败页面包含“错误”、“无效”等。 # 3. 响应头：成功登录后可能会设置Cookie或Location跳转。 # 4. 响应长度：成功和失败的页面长度通常不同。 # 这里提供一个可配置的判断逻辑示例 if self._check_success(resp, username, password): with self.lock: self.found_creds.append((username, password)) print(f"\n[!!!] 发现有效凭证: {username} / {password}") print(f" 状态码: {resp.status_code}, 长度: {len(resp.content)}, 跳转: {resp.headers.get('Location', '无')}") # 找到一个后，可以设置停止事件 self.stop_event.set() return True else: # 失败尝试，可以简单打印进度，但大量输出会影响性能 # print(f"[-] 失败: {username}/{password}") pass except requests.exceptions.RequestException as e: print(f"[!] 尝试 {username}/{password} 时网络错误: {e}") except Exception as e: print(f"[!] 尝试 {username}/{password} 时发生未知错误: {e}") return False def _check_success(self, response, username, password): """ 自定义的成功条件判断函数。 这是最需要根据目标定制化的部分！ """ # 示例1：通过状态码和响应长度判断（需提前探测） if response.status_code == 302 and len(response.content) < 1000: return True # 示例2：通过页面内容关键词判断 failure_keywords = ['invalid', '错误', 'incorrect', 'login failed'] success_keywords = ['welcome', 'logout', '我的账户', 'dashboard'] resp_text = response.text.lower() # 如果包含失败关键词，则肯定是失败 for kw in failure_keywords: if kw in resp_text: return False # 如果包含成功关键词，则可能是成功（需谨慎，防止误报） for kw in success_keywords: if kw in resp_text: return True # 示例3：通过Cookie判断（如果登录成功会设置特定的会话Cookie） if 'sessionid' in response.cookies or 'auth' in response.cookies: return True # 默认返回失败 return False def worker(self): """工作线程""" while not self.stop_event.is_set(): try: username, password = self.queue.get(timeout=0.5) except queue.Empty: break self.try_login(username, password) self.queue.task_done() # 添加微小延迟，避免请求过快 time.sleep(0.05) def run(self, thread_count=10): """启动爆破""" if self.queue.empty(): print("[!] 凭证队列为空，请先加载字典。") return print(f"[*] 开始对 {self.url} 进行表单爆破，线程数: {thread_count}") start_time = time.time() threads = [] for i in range(thread_count): t = threading.Thread(target=self.worker) t.daemon = True t.start() threads.append(t) # 等待队列清空或收到停止信号 try: while not self.queue.empty() and not self.stop_event.is_set(): time.sleep(0.5) # 可以在这里打印进度 qsize = self.queue.qsize() sys.stdout.write(f"\r[*] 剩余尝试次数: {qsize}...") sys.stdout.flush() except KeyboardInterrupt: print("\n[!] 用户中断。") self.stop_event.set() for t in threads: t.join() elapsed = time.time() - start_time print(f"\n[*] 爆破结束。耗时: {elapsed:.2f} 秒。") if self.found_creds: print("[+] 发现的凭证:") for user, pwd in self.found_creds: print(f" {user} : {pwd}") else: print("[-] 未发现有效凭证。") return self.found_creds # 使用示例 if __name__ == "__main__": # 以某个测试登录页面为例（请务必使用授权目标！） bruter = HttpFormBruter( url="http://testphp.vulnweb.com/userinfo.php", # 实际目标 username_field="uname", # 通过分析HTML表单得到 password_field="pass", other_data={} # 如果需要csrf token等，在这里添加 ) # 加载字典文件 bruter.load_credentials("usernames.txt", "passwords.txt") # 开始爆破，使用10个线程 found = bruter.run(thread_count=10)

关键技术与避坑指南：

1. 成功条件判断（_check_success函数）：这是爆破工具最核心也是最脆弱的部分。没有放之四海而皆准的规则。必须在攻击前进行手工侦察：
   • 用错误密码试一次，记录下HTTP状态码、响应长度、返回内容、设置的Cookie。
   • 用正确密码试一次（如果可能），记录同样的信息。
   • 对比两者差异，找出可靠的判断依据。有时差异非常微妙，比如只是一个Set-Cookie头，或者页面里某个隐藏字段的值不同。
2. 会话（Session）管理：使用requests.Session()非常重要，它会自动处理Cookies，模拟浏览器行为。有些网站的登录过程涉及多个步骤（如先GET一个页面获取token，再POST登录），都需要在同一个Session中完成。
3. CSRF Token处理：现代Web应用几乎都有CSRF防护。你需要先GET登录页面，从HTML中解析出CSRF token（如<input type="hidden" name="csrf_token" value="...">），然后将这个token值填入other_data，再发起POST请求。这要求你的工具具备简单的HTML解析能力。
4. 验证码（CAPTCHA）：遇到验证码，常规的自动化爆破基本失效。需要考虑OCR识别（准确率低）、第三方打码平台（有成本）或寻找逻辑漏洞绕过。
5. 账号锁定机制：很多系统在多次失败尝试后会锁定账号。这会导致测试账号被锁，影响测试。对策包括：
   • 使用“密码先于用户名”的策略：用一个密码去撞多个用户名，而不是一个用户名试多个密码。
   • 降低请求频率，加入随机延迟。
   • 优先测试不存在的用户名，观察系统反应（是提示“用户名或密码错误”还是“用户不存在”？），这有助于判断用户名枚举的可能性。
6. 法律与授权：对任何系统进行密码爆破都必须获得明确的书面授权。未经授权的密码尝试是明确的违法行为。

5. 工具集的打包、使用与扩展

5.1 项目结构与打包

一个整洁的项目结构有助于管理和分享。建议如下：

python-security-toolkit/ ├── README.md # 项目说明、使用指南、免责声明 ├── requirements.txt # Python依赖包列表 ├── config/ # 配置文件目录（如字典、规则） │ ├── common_dirs.txt │ ├── common_usernames.txt │ └── common_passwords.txt ├── core/ # 核心工具模块 │ ├── __init__.py │ ├── scanner.py # 端口扫描器 │ ├── webscan.py # Web路径扫描器 │ ├── bruter.py # 密码爆破工具 │ └── utils.py # 通用工具函数（编码解码、日志等） ├── plugins/ # 可选插件或扩展模块 │ └── __init__.py ├── scripts/ # 可直接运行的脚本（命令行入口） │ ├── scan_port.py │ ├── dir_scan.py │ └── form_brute.py └── tests/ # 单元测试 └── test_scanner.py

可以使用setuptools进行打包，创建setup.py文件，方便其他人通过pip install .安装你的工具包，并将其作为命令行工具使用。

5.2 编写易用的命令行接口（CLI）

让每个核心脚本都能通过命令行方便地调用。使用Python内置的argparse库。

# scripts/dir_scan.py import argparse import sys from core.webscan import DirScanner # 假设核心类在这里 def main(): parser = argparse.ArgumentParser(description='智能Web目录扫描工具') parser.add_argument('-u', '--url', required=True, help='目标URL (例如: http://example.com)') parser.add_argument('-w', '--wordlist', required=True, help='路径字典文件') parser.add_argument('-e', '--extensions', nargs='+', default=['.php', '.html'], help='要尝试的文件扩展名列表 (例如: .php .bak .txt)') parser.add_argument('-t', '--threads', type=int, default=20, help='并发线程数 (默认: 20)') parser.add_argument('-o', '--output', help='将结果保存到文件') args = parser.parse_args() print(f"[*] 目标: {args.url}") print(f"[*] 字典: {args.wordlist}") print(f"[*] 扩展名: {args.extensions}") print(f"[*] 线程: {args.threads}") scanner = DirScanner( base_url=args.url, wordlist_file=args.wordlist, extensions=args.extensions, threads=args.threads ) try: results = scanner.run() if args.output: with open(args.output, 'w') as f: for item in results: f.write(f"[{item['status']}] {item['url']}\n") print(f"[*] 结果已保存至 {args.output}") except KeyboardInterrupt: print("\n[!] 用户中断扫描。") sys.exit(0) except Exception as e: print(f"[!] 扫描过程中发生错误: {e}") sys.exit(1) if __name__ == "__main__": main()

这样，用户就可以在命令行中简单地运行：python scripts/dir_scan.py -u http://target.com -w paths.txt -t 30

5.3 如何扩展你的工具集

这个工具集的生命力在于不断扩展。当你遇到新场景时，可以遵循以下步骤添加新工具：

1. 明确需求：这个新工具要解决什么具体问题？（例如：快速提取网页中的所有电子邮件地址）。
2. 设计输入输出：它接收什么参数（文件、URL、字符串）？输出什么格式（屏幕打印、JSON文件、CSV）？
3. 寻找核心库：用哪个Python库最合适？（例如，提取邮箱用re正则表达式，解析HTML用BeautifulSoup）。
4. 编写核心函数：实现单一功能的函数，并做好错误处理。
5. 封装为模块或脚本：将其放入core/目录，或直接创建一个新的可执行脚本。
6. 测试与优化：用各种边界情况测试，优化性能和处理逻辑。
7. 更新文档：在README.md中简要说明新工具的用途和用法。

6. 常见问题、排查技巧与安全实践

6.1 工具运行常见问题排查

Q1: 端口扫描脚本运行时报错PermissionError: [Errno 1] Operation not permittedA1:这是在非root用户下发送原始数据包（Raw Socket）的权限错误。在Linux/macOS上，使用sudo运行脚本。或者，考虑使用不需要root权限的扫描技术（如TCP全连接扫描connect()），但这种方式速度慢且更易被记录。

Q2: Web扫描器发出的请求全部超时或返回403错误。A2:很可能触发了目标的WAF或速率限制。

• 排查：先用浏览器正常访问目标，再用curl或requests写一个最简单的GET请求脚本，看是否正常。如果不正常，说明目标对自动化工具进行了屏蔽。
• 对策：
  • 降低速率：大幅增加请求间隔时间（如time.sleep(2)）。
  • 更换User-Agent：使用更常见的浏览器UA。
  • 使用代理池：通过多个代理IP轮询发送请求。
  • 模拟浏览器行为：添加常见的HTTP头，如Accept、Accept-Language、Referer等。可以考虑使用selenium模拟真实浏览器，但速度会慢很多。

Q3: 密码爆破工具无法正确判断登录成功，总是误报或漏报。A3:这是最常见的问题，根源在于_check_success逻辑不适用于目标。

• 排查：开启详细调试模式，打印出每次请求的状态码、响应头、响应体前几百字节。手工用正确和错误密码各登录一次，对比这些输出，找出决定性的差异点。
• 对策：修改_check_success函数，实现基于目标特征的定制化判断。有时成功登录后服务器会跳转到一个特定URL（Location头），有时会设置一个特定的Cookie（如session=logged_in），有时只是页面标题变了。必须具体问题具体分析。

Q4: 工具在多线程下运行不稳定，有时会崩溃或出现奇怪错误。A4:多线程编程常见问题。

• 排查：检查是否所有共享资源（如列表、字典、文件对象、网络连接）都进行了正确的线程锁（threading.Lock）保护。检查网络请求库（如requests）是否是线程安全的（requests.Session不是完全线程安全，建议每个线程使用自己的Session，或使用线程局部存储threading.local）。
• 对策：使用concurrent.futures.ThreadPoolExecutor可以简化部分线程管理。对于复杂任务，考虑使用queue.Queue作为任务队列，它是线程安全的。对于I/O密集型任务，也可以考虑使用异步编程（asyncio+aiohttp），性能更高。

6.2 安全与合规实践红线

在开发和使用这类工具时，必须时刻将安全合规放在首位：

1. 明确授权：永远只在拥有明确书面授权的目标上使用这些工具。授权范围应包括测试时间、测试IP范围、测试方法等。自己家里的实验环境、购买的云服务器、明确声明允许安全测试的“漏洞赏金”项目或“测试网站”（如testphp.vulnweb.com）是合法的目标。
2. 最小影响原则：测试应以不影响目标系统正常运行为前提。避免使用高并发、大流量的扫描或爆破，以免造成拒绝服务（DoS）。在工具中内置速率限制和延迟。
3. 数据保密：在测试过程中可能接触到目标系统的敏感数据（如配置文件、用户信息等）。这些数据严禁泄露、下载或用于任何其他目的。测试完成后，应从本地彻底删除。
4. 工具保管：妥善保管你的工具集，不要随意上传到公开的代码仓库（如GitHub）而不做任何审查，以免被他人用于非法活动。如果分享，确保代码中不包含任何针对特定目标的硬编码配置或字典。
5. 法律意识：了解你所在国家/地区关于网络安全测试的法律法规。即使有授权，某些测试行为（如拒绝服务攻击、利用漏洞获取并外泄数据）也可能越界。

6.3 性能优化小技巧

• 连接复用：对于HTTP类工具，使用requests.Session()可以复用TCP连接，显著提升速度。
• 异步I/O：对于大量网络I/O操作（如扫描、爆破），使用asyncio和aiohttp替代多线程，可以大幅减少系统资源消耗并提升效率，尤其是在需要维护数千个并发连接时。
• 字典优化：对密码字典进行排序，将最常用的密码（如123456,password,admin123）放在前面，可以尽早发现弱口令。使用规则生成密码（如公司名+年份）比纯粹的字典爆破更有效。
• 结果缓存：对于DNS解析、WAF识别等相对静态的查询，可以将结果缓存起来，避免对同一目标重复查询。

构建这样一个工具集的过程，本身就是一次深度学习之旅。你会被迫去理解网络协议、Web应用架构、系统安全机制。每解决一个实际问题，你的工具库就增加一件利器，你对安全的认知也就加深一层。记住，工具是思想的延伸，最重要的永远是你分析问题、解决问题的思路。希望这个分享能为你打造自己的“网络安全瑞士军刀”开一个好头。

本文还有配套的精品资源，点击获取