10-2-8-burp(7)-代理IP获取与自动切换_burp自动更换代理ip-优快云博客

本文链接：https://blog.youkuaiyun.com/xingchenxizhu/article/details/144436493

声明！

学习视频来自B站up主泷羽sec ，有兴趣的师傅可以关注一下，如涉及侵权马上删除文章，笔记只是方便各位师傅的学习和探讨，文章所提到的网站以及内容，只做学习交流，其他均与本人以及泷羽sec团队无关，切勿触碰法律底线，否则后果自负！！！！

文章为个人学习笔记。

1、安装最新版的zmap

操作系统：建议使用 Ubuntu /kali或其他支持较好的 Linux 发行版。

┌──(root㉿kali)-[~/tool]
└─# apt update &&  apt upgrade -y

或   
┌──(root㉿kali)-[~/tool]
└─# apt update

┌──(root㉿kali)-[~/tool]
└─# apt-get install build-essential cmake libgmp3-dev gengetopt libpcap-dev flex byacc libjson-c-dev pkg-config libunistring-dev libjudy-dev

┌──(root㉿kali)-[~/tool]
└─# git clone https://github.com/zmap/zmap.git
                                                                                                                                                
┌──(root㉿kali)-[~/tool]
└─# cd zmap 

┌──(root㉿kali)-[~/tool/zmap]
└─# mkdir build && cd build
                                                                                                                                                
┌──(root㉿kali)-[~/tool/zmap/build]
└─# cmake ..

┌──(root㉿kali)-[~/tool/zmap/build]
└─# make 

┌──(root㉿kali)-[~/tool/zmap/build]
└─# make install  
 
┌──(root㉿kali)-[~/tool/zmap/build]
└─# zmap --version

apt update && apt upgrade -y
- apt update：更新本地软件包索引。这是在安装新软件包之前推荐的步骤，以确保你安装的是最新版本的软件。
- apt upgrade -y：升级所有可升级的软件包。-y参数表示自动回答“yes”，即自动确认所有提示，无需手动干预。
apt-get install build-essential cmake libgmp3-dev gengetopt libpcap-dev flex byacc libjson-c-dev pkg-config libunistring-dev libjudy-dev
- 这个命令安装了一系列编译ZMap所需的依赖项：
  - build-essential：包含编译C/C++程序所需的基本工具，如gcc和g++。
  - cmake：一个跨平台的自动化构建系统，用于生成构建配置文件。
  - libgmp3-dev：GNU多精度库的开发文件。
  - gengetopt：一个用于生成命令行解析代码的工具。
  - libpcap-dev：Pcap库的开发文件，用于网络数据包捕获。
  - flex和byacc：用于生成词法和语法分析器的工具。
  - libjson-c-dev：JSON解析库的开发文件。
  - pkg-config：一个帮助编译和链接程序的工具，它管理库依赖。
  - libunistring-dev：Unicode字符串库的开发文件。
  - libjudy-dev：Judy数组库的开发文件。
git clone https://github.com/zmap/zmap.git
- 这个命令从GitHub克隆ZMap的源代码到当前目录下名为zmap的文件夹中。
cd zmap
- 切换到刚刚克隆的zmap目录。
mkdir build && cd build
- 创建一个名为build的新目录，并切换到该目录。这是为了在源代码目录之外进行构建，以保持源代码目录的清洁。
cmake ..
- 使用CMake生成构建配置文件。..表示CMake的配置文件将基于上一级目录（即zmap目录）中的源代码。
make
- 使用Make工具根据CMake生成的配置文件构建ZMap。
make install
- 安装构建好的ZMap程序到系统路径中。
zmap --version
- 运行ZMap并显示其版本信息，以确认安装成功。

2、运行zmap

zmap -p 80,443,1080 -o raw_ips.txt

-o 输出文件，保存到 raw_ips.txt

2、代理IP优选，编写验活脚本

我的是window的安装

python 为3.12版本

filter_proxy_ips.py文件的代码内容如下：

代码

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(input_file, output_file):
    """
   替换文件中逗号为冒号，并保存到新文件。
   """
    with open(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}")
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}'验证之后形成第⼀代理池，但是⽤到⽬标⽹站还是会有许多其他的状态码，不能访问的错误，所以我们针对
⽬标指定⽹站再进⾏筛选
# ⼦弹有效化
 
使⽤这个脚本指定⽬标⽹站为验证⽹站，还可以指定其Response数据包的⻓度，来决定确实是正常访问。
   }
    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)
    # 第二步：读取替换后的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()

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

‍

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

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)

3、运行代码

D:\toosl_2\zmap>python filter_proxy_ips.py

D:\toosl_2\zmap>python BurpSuite_ip.py
代理池中的IP地址和端口已保存到BurpSuite_ip.txt文件中。

D:\toosl_2\zmap>python BurpSuite_ip_2.py
代理池中的IP地址和端口已分别保存到BurpSuite_http.txt和BurpSuite_socks.txt文件中。