泷羽sec-burp(7)

免责声明

学习视频来自 B 站up主泷羽sec，如涉及侵权马上删除文章。

笔记的只是方便各位师傅学习知识，以下代码、网站只涉及学习内容，其他的都与本人无关，切莫逾越法律红线，否则后果自负。

泷羽sec官网：https://longyusec.com/

泷羽sec B站地址：泷羽sec的个人空间-泷羽sec个人主页-哔哩哔哩视频

①、zmap安装：apt install zmap

Zmap是一个开源的网络扫描器，它提供了多种命令参数来定制扫描任务。以下是一些常用的Zmap命令参数：

1. -p, --target-port=port：指定扫描的目标端口。

2. -o, --output-file=name：把结果写入指定文件。

3. -b, --blacklist-file=path：IP地址黑名单，排除在扫描范围外的地址。

4. -n, --max-targets=n：最大扫描IP地址数量，可以是一个数字或者百分比形式。

5. -N, --max-results=n：最大扫描到结果的IP数量，达到该数量后停止扫描。

6. -t, --max-runtime=secs：最大扫描时间，单位为秒。

7. -r, --rate=pps：设置每秒发送包的数量。

8. -B, --bandwidth=bps：设置每秒发送包的大小，支持单位（GMK）。

9. -c, --cooldown-time=secs：设置数据包发送完之后多长时间开始接受数据（response），默认8秒。

10. -e, --seed=n：设置扫描随机地址的顺序，C语言中的伪随机种子。

11. -T, --sender-threads=n：设置扫描线程，默认是1。

12. -P, --probes=n：设置往每个IP发送包的数量，默认为1。

13. -d, --dryrun：打印出每个包的内容，非常实用的功能。

14. -s, --source-port=port|range：设置扫描的源端口，可指定范围。

15. -S, --source-ip=ip|range：设置扫描的源IP地址，可指定范围。

16. -G, --gateway-mac=addr：设置网关的mac地址，可伪造。

17. -M, --probe-module=name：设置扫描模式，如tcp_synscan（默认），icmp_echoscan（ping扫描），udp等。

18. -O, --output-module=name：设置结果输出模块，如simple_file（默认），extended_file。

19. --quiet：安静模式，不打印进度信息到屏幕上。

20. --summary：输出结果汇总。

使用命令获取全网代理ip：sudo zmap -p 端口 -o ip.txt

🔑 代理常见端口：80、81、82、443、2323、3128、4433、8080、8089、9091

由于zmap获取的ip没有端口，可通过脚本进行添加

# 定义文件路径，要添加的字符串，以及输出文件的路径
input_file_path = '文件路径'
string_to_append = ":8080" # 要添加的端口号
output_file_path = 'output.txt' # 输出文件名
​
# 初始化一个空列表来存储处理后的行
processed_lines = []
​
# 读取输入文件的内容
with open(input_file_path, 'r') as input_file:
    # 遍历文件中的每一行
    for line in input_file:
        # 去除行末尾的换行符（如果有的话）
        line = line.rstrip('\n')
        # 将指定字符串添加到行末尾
        processed_line = line + string_to_append
        # 将处理后的行添加到列表中
        processed_lines.append(processed_line)
​
# 将处理后的行写入输出文件
with open(output_file_path, 'w') as output_file:
    for processed_line in processed_lines:
        # 在写入行时添加换行符
        output_file.write(processed_line + '\n')
​
print(f"已经给 {input_file_path} 添加并保存到 {output_file_path}")

②、脚本筛选ip

通过脚本对获取到的ip进行筛选

import socket
import requests
import time
import concurrent.futures
from threading import Timer
​
# 配置
TEST_URL = "https://www.baidu.com"  # 测试活性的 URL（百度首页）
IP_CHECK_URL = "https://httpbin.org/ip"  # 测试匿名性的 URL
TIMEOUT = 5  # 超时时间
MAX_SPEED = 2  # 最大允许响应时间 (秒)
FILE_LIST = ["80.txt", "443.txt", "1080.txt", "8080.txt", "3128.txt"]  # 端口对应的文件
OUTPUT_FILE = "代理池.txt"  # 汇总结果文件
CHECK_INTERVAL = 3600  # 检查间隔（秒）
​
def parse_ip_port(ip_port):
    """解析 ip:端口 格式"""
    try:
        ip, port = ip_port.split(":")
        return ip, int(port)
    except:
        return None, None
​
def check_ip(ip_port, timeout=3):
    """检测 IP 是否可用"""
    ip, port = parse_ip_port(ip_port)
    if not ip or not port:
        return None
    try:
        with socket.create_connection((ip, port), timeout=timeout):
            return ip_port
    except:
        return None
​
def test_proxy_with_baidu(http_proxy, ip_port, timeout=5):
    """通过访问百度测试代理活性，并检查匿名性"""
    proxy = {"http": http_proxy, "https": http_proxy}
    ip, port = parse_ip_port(ip_port)
    if not ip or not port:
        return ip_port, None, "Failed"
​
    try:
        # 测试访问百度
        start = time.time()
        response = requests.get(TEST_URL, proxies=proxy, timeout=timeout)
        elapsed_time = time.time() - start
​
        # 如果百度访问成功，进一步检测匿名性
        if response.status_code == 200:
            ip_check_response = requests.get(IP_CHECK_URL, proxies=proxy, timeout=timeout)
            if ip_check_response.status_code == 200:
                reported_ip = ip_check_response.json().get("origin", "")
                if ip in reported_ip:
                    return ip_port, elapsed_time, "Transparent"  # 透明代理
                else:
                    return ip_port, elapsed_time, "Anonymous"  # 匿名代理
    except:
        pass
    return ip_port, None, "Failed"
​
def filter_ips(ip_file):
    """多轮筛选优质 IP"""
    valid_ips = []
    final_results = []
​
    # 第一步：检查 IP 可用性
    print(f"Checking IP availability for {ip_file}...")
    with open(ip_file, 'r') as f:
        ips = [line.strip() for line in f]
    with concurrent.futures.ThreadPoolExecutor(max_workers=100) as executor:
        results = executor.map(check_ip, ips)
        valid_ips = [ip for ip in results if ip]
​
    # 第二步：通过访问百度测试活性并检测匿名性
    print(f"Testing activity and anonymity through Baidu for {ip_file}...")
    with concurrent.futures.ThreadPoolExecutor(max_workers=50) as executor:
        results = executor.map(
            lambda ip_port: test_proxy_with_baidu(f"http://{ip_port}", ip_port), valid_ips
        )
        for ip_port, speed, anonymity in results:
            if speed and speed <= MAX_SPEED and anonymity == "Anonymous":
                final_results.append(ip_port)  # 最终结果以 ip:端口 形式保存
​
    return final_results
​
def update_proxy_pool():
    """更新代理池并保存到 '代理池.txt'"""
    print("Updating proxy pool...")
    all_filtered_ips = []
​
    # 遍历文件，筛选 IP
    for ip_file in FILE_LIST:
        filtered_ips = filter_ips(ip_file)
        all_filtered_ips.extend(filtered_ips)  # 汇总筛选结果
​
    # 保存所有结果到 '代理池.txt'
    print(f"Saving all results to {OUTPUT_FILE}...")
    with open(OUTPUT_FILE, 'w') as f:
        for ip_port in all_filtered_ips:
            f.write(f"{ip_port}\n")  # 以 ip:端口 形式保存
​
    print(f"Proxy pool updated. Total {len(all_filtered_ips)} valid proxies saved to '{OUTPUT_FILE}'.")
​
    # 定时每小时运行
    Timer(CHECK_INTERVAL, update_proxy_pool).start()
​
# 执行
if __name__ == "__main__":
    update_proxy_pool()

其他筛选脚本

import os
import threading
import requests
from queue import Queue
from functools import partial
 
# 输出提示"要给多少个文件的IP添加端口："
num_files = int(input("要给多少个文件的IP添加端口："))
 
#用于存储文件和对应端口的队列
file_queue = Queue()
 
#循环输出提示，并接收输入
for i in range(1, num_files + 1):
    file_name = input(f"第{i}次：选择要添加端口的IP文件：")
    port = input(f"{file_name}文件添加什么端口号：")
    file_queue.put((file_name, port))
 
#创建"proxy.txt"文件和"IP.txt"文件
if not os.path.exists("proxy.txt"):
    open("proxy.txt", 'w').close()
 
if not os.path.exists("IP.txt"):
    open("IP.txt", 'w').close()
 
#根据输入的文件名，读取文件内容IP，添加端口号，并写入"IP.txt"
while not file_queue.empty():
    file_name, port = file_queue.get()
    with open(file_name, 'r') as f:
        ips = f.readlines()
    
    proxies = [f"{ip.strip()}:{port}\n" for ip in ips]
    with open("IP.txt", 'a') as f:  # 使用'a'模式追加内容
        f.writelines(proxies)
 
#读取"IP.txt"文件，用于验证代理IP
with open("IP.txt", 'r') as f:
    proxies_to_check = f.readlines()
 
#设置多个验证网站
verify_urls = [
    "http://httpbin.org/ip",
]
 
# 10. 设置verify=False和线程锁
verify_ssl = False
lock = threading.Lock()
 
# 代理验证函数
def verify_proxy(proxy):
    for url in verify_urls:
        proxies = {"http": proxy, "https": proxy}
        try:
            response = requests.get(url, proxies=proxies, verify=verify_ssl, timeout=5)
            if response.status_code == 200:
                with lock:
                    with open("proxy.txt", 'a') as f:
                        f.write(f"{proxy} 可用，状态码：{response.status_code}，原因：{response.reason}\n")
                print(f"{proxy} 可用，状态码：{response.status_code}，原因：{response.reason}")
                break  # 如果一个代理验证成功，则无需继续验证其他网站
        except requests.RequestException as e:
            print(f"{proxy} 不可用，原因：{e}")
 
#使用多线程进行验证代理IP是否可用
num_threads = 10
threads = []
for proxy in proxies_to_check:
    verify_proxy_with_arg = partial(verify_proxy, proxy.strip())  # 去除可能的换行符
    t = threading.Thread(target=verify_proxy_with_arg)
    t.start()
    threads.append(t)
 
# 等待所有线程完成
for t in threads:
    t.join()

使用上述筛选脚本对获取到的ip进行简单筛选

③、部署bp插件-BurpAutoProxySwitcherPlugins

GitHub - Maikefee/BurpAutoProxySwitcherPlugins_Maikefee: 红队必备，场景：在爆破批量封ip的情况下，爬取socks5代理在bp进行渗透测试。说明：可设置一个请求换一次socks代理ip，这样就绕过了封ip的情况。

🔑 安装BurpAutoProxySwitcherPlugins插件前需先安装jpython

http://search.maven.org/remotecontent?filepath=org/python/jython-standalone/2.7.0/jython-standalone-2.7.0.jar

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

④、使用burp测试

设置 Burp Suite 的浏览器代理。

访问目标测试网站，观察 IP 是否定时变化。