声明
学习视频来自B站UP主 泷羽sec,如涉及侵权马上删除文章 笔记的只是方便各位师傅学习知识,以下网站只涉及学习内容,其他的都
与本人无关,切莫逾越法律红线,否则后果自负

---

---

搭建炮台

首先这个有两种方式可以进行实现Brip炮台
这里我就用自己的云服务器进行实战，没有云服务器的哥们可以用kail安装进行实验，本质是一样的

服务端安装zmap

kail安装

sudo apt update

然后下载zamp

sudo apt install zmap

我用的自己的云服务器，学习还是用kail好一些哈

1、更新系统和安装基础依赖：使⽤包管理⼯具（如apt-get）更新系统并安装必要的基础依赖。例如，在Ubuntu上

sudo apt-get update

2、安装了一系列用于开发和构建软件的工具和库

sudo apt-get install -y build-essential cmake libgmp3-dev gengetopt libpcap-dev flex byacc
libjson-c-dev pkg-config libunistring-dev

3、克隆zmap项目仓库，从GitHub克隆ZMap项目的源代码到本地。

git clone https://github.com/zmap/zmap.git

4、编译和安装ZMap，进⼊ZMap⽬录后，执⾏以下命令来编译和安装Zmap。

cd zmap
mkdir build
cd build
cmake ..

这个命令用于生成构建系统。cmake 是一个工具，它根据项目中的 CMakeLists.txt 文件生成适合当前系统的构建配置文件（如 Makefile）。.. 表示在当前目录的上一级目录中查找CMakeLists.txt 文件。
make

这个命令用于编译项目。make 是一个工具，它根据上一步生成的 Makefile 文件来编译源代码，生成可执行文件或库文件。

sudo make install

这个命令用于安装编译好的软件。make install 是 make 的一个目标，它将编译好的程序安装到系统的标准目录中，如 /usr/local/bin。sudo 是因为安装软件通常需要管理员权限，所以使用 sudo 来执行这个命令。

5、验证zamp安装是否成功

zmap --version

云服务的安装就这里，这里我先声明，本次学习用于实验，出现问题，与本人无关。这里我还是建议大家用kail，虚拟环境练练手即可

6、使用zamp全网爬取ip地址

这里可以扫描几十万条数据
如果你想要扫描多个不连续的端口，你需要为每个端口或每个端口范围分别指定 -p 参数。

zmap -p 80 -o raw_ips.txt

如果你想要扫描一系列连续的端口，比如从80到443

这里注意哈，不能使用逗号，zmap没有这个格式哈，-短横线也没有这个格式化，zmap只支持

7、对zmap下来的代理ip进行初次筛选

使⽤多线程优化了验证效率，使⽤多个验证URL提⾼可⽤性，两种脚本进行筛选，首先是80端口进行添加端口，其次是存在80和443端口的进行添加，然后我们需要替换为:冒号
1、·一种就是只扫了80端口的，需要用add_port_to_ips函数添加端口
2、还有一种就是扫了80,443端口的有端口号但是中间是 , (逗号)需要用到replace_comma_with_colon函数进行替
换。

这里想必不用我多说了吧，都懂的，用kail哈

初次筛选ip的脚本

import requests
from concurrent.futures import ThreadPoolExecutor, as_completed
import threading
# 指定输入和输出文件路径
raw_input_file = 'raw_ips.txt' # 原始包含逗号的IP文件
processed_output_file = 'ip.txt' # 字符处理后的IP文件
available_proxy_file_path = 'InProxyPool.txt' # 可用代理输出文件
# 多个验证URL，包含国内和国外常见网站，用于更严格地验证代理IP是否可用
test_urls = [
'http://www.baidu.com',
'http://www.jd.com/',
'http://www.taobao.com/'
]
# 线程锁
lock = threading.Lock()
# 标记是否是第一次写入可用代理文件，初始化为True表示第一次
first_write = True
def replace_comma_with_colon(raw_input_file, output_file):
"""
替换文件中逗号为冒号，并保存到新文件。
"""
with open(raw_input_file, 'r') as file:
lines = file.readlines()
# 替换逗号为冒号
modified_lines = [line.replace(',', ':').strip() for line in lines]
# 写入新的文件，'w'模式会自动清空原有内容再写入
with open(output_file, 'w') as file:
for line in modified_lines:
file.write(line + '\n')
print(f"IP格式处理完成，结果已保存到 {output_file}")
# IP添加:端口号
def add_port_to_ips(input_file_path, output_file_path, port=80):
try:
with open(input_file_path, 'r') as infile, open(output_file_path, 'w') as outfile:
for line in infile:
ip = line.strip() # 去除每行的空白字符（如换行符等）
new_ip = f"{ip}:{port}"
outfile.write(new_ip + "\n")
except FileNotFoundError:
print(f"输入文件 {input_file_path} 不存在，请检查文件路径。")
验证之后形成第⼀代理池，但是⽤到⽬标⽹站还是会有许多其他的状态码，不能访问的错误，所以我们针对
⽬标指定⽹站再进⾏筛选
def test_proxy(proxy):
"""
测试单个代理IP是否可用，通过多个URL验证，只有全部验证通过才认定可用，并实时写入文件。
"""
global first_write
proxy = proxy.strip() # 移除行尾的换行符
if not proxy: # 跳过空行
return None
# 设置代理
proxies_dict = {
'http': f'http://{proxy}',
'https': f'https://{proxy}'
}
is_available = True
for url in test_urls:
try:
# 发送请求，设置超时时间为5秒
response = requests.get(url, proxies=proxies_dict, timeout=5)
if response.status_code!= 200:
is_available = False
break
except requests.RequestException as e:
is_available = False
break
if is_available:
print(f'代理IP {proxy} 可用')
with lock:
# 根据是否第一次写入来决定文件打开模式
mode = 'w' if first_write else 'a'
with open(available_proxy_file_path, mode) as file:
file.write(f'{proxy}\n')
if first_write:
first_write = False # 第一次写入后标记设为False
return proxy
else:
print(f'代理IP {proxy} 不可用')
return None
def main():
# 第一步：处理IP文件
# replace_comma_with_colon(raw_input_file, processed_output_file)
add_port_to_ips(raw_input_file,processed_output_file)
# 第二步：读取替换后的IP文件，验证代理IP
with open(processed_output_file, 'r') as file:
proxies = file.readlines()
# 使用ThreadPoolExecutor并发执行
with ThreadPoolExecutor(max_workers=20) as executor:
future_to_proxy = {executor.submit(test_proxy, proxy): proxy for proxy in proxies}
for future in as_completed(future_to_proxy):
proxy = future_to_proxy[future]
try:
future.result() # 触发验证逻辑
except Exception as e:
print(f'代理IP {proxy} 验证过程中出现错误: {e}')
print(f"\n代理验证完成，可用代理IP已写入文件: {available_proxy_file_path}")
if __name__ == "__main__":
main()

验证之后形成第⼀代理池，但是⽤到⽬标⽹站还是会有许多其他的状态码，不能访问的错误，所以我们针对⽬标指定⽹站再进⾏筛选

8、子弹有效化

使⽤这个脚本指定⽬标⽹站为验证⽹站，还可以指定Response数据包的⻓度，来决定确实是正常访问。筛选有效和无效的ip

import requests
from concurrent.futures import ThreadPoolExecutor, as_completed
import threading
# 最小响应包长度
MIN_LENGTH = 100
# 最大线程数
MAX_WORKERS = 100
# 输出文件路径
OUTPUT_FILE_PATH = 'FProxies.txt'
# 输入文件路径
input_file_path = 'InProxyPool.txt'
def check_proxy(proxy):
"""验证代理网址"""
test_url = "http://www.google.com"
proxies = {"http": f"http://{proxy}", "https": f"http://{proxy}"}
try:
response = requests.get(test_url, proxies=proxies, timeout=2)
if response.status_code == 200 and len(response.content) >= MIN_LENGTH:
return proxy # 返回可用代理
except Exception:
pass
return None # 无效代理
def validate_proxy(proxy, lock):
"""验证单个代理并写入文件"""
valid_proxy = check_proxy(proxy)
if valid_proxy:
with lock:
with open(OUTPUT_FILE_PATH, 'a') as outfile:
outfile.write(f"{valid_proxy}\n")
print(f"有效代理: {valid_proxy}")
else:
print(f"无效代理: {proxy}")
def validate_proxies_from_file(input_file_path):
"""从文件中读取代理并验证其有效性，同时将有效代理输出到另一个文件"""
lock = threading.Lock()
with open(input_file_path, 'r') as infile:
proxies = [line.strip() for line in infile]
with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
futures = [executor.submit(validate_proxy, proxy, lock) for proxy in proxies]
for future in as_completed(futures):
future.result() # 等待所有任务完成
validate_proxies_from_file(input_file_path)

这里咱们的字典文件就筛选准备好了，下面开始bripsuite使用

咱就是说这种脚本都让gpt写好吧

主打一个不动手。

安装Brup插件

1、在burp中载入jython包

2、添加自动化处理插件程序

之后会出现一个 Proxy Switcher 选项，那就是插件了
注意点：这里指定路径记得时字典的txt的url路径哈

先输入路径（主要文件中的数据需要是每行ip:port的形式否则解释失败），然后加载，最后启用，在后面有每
次请求代理 1 就是请求一次换一个，后面还有HTTP、SOCKS5 协议

3、接下来就是和验证码爆破时同样的操作了，也就没啥好说的了

设置一个payloads，用来加载一些基本的sql注入测试字典即可

4、同理，可以在攻击列表中查看是否存在sql输入，这个取决了字典的强大了

5、本次的目的主要时代理ip池子，那么我们看看是不是每一个段都的请求都是用不同的ip地址发送的请求即可

这里因为用的zmap扫描的ip，其实很多zmap扫描的地址都是不能访问国内的网站的哈，都懂，除非指定地区，那么扫描的ip就大部分应该可以通过py脚本检测。总之，思路就是zmap获取一些ip，使用两次py或者多个脚本进行多次筛选，最终获得可以用的ip字典（也就是IP代理池了），但是这个有局限性，真正的代理池是不端发生ip代理变化且全自动化获取的哈
下期分析伪造ip，也就是假ip，但是呢，还是真实ip有用且必须自动变化

实践是检验真理的唯一标准