安全Python编程：requests库、正则、脚本编写（POC与扫描器基础）

16-安全Python编程：requests库、正则、脚本编写（POC与扫描器基础）

写作声明：本文是白帽安全学习路线的筑基内容。文中所有脚本均为安全学习示例 ，请只在本地靶场（DVWA、sqli-labs、pikachu 等） 、本地自建环境 或已获书面授权的目标上运行。任何未授权扫描、爆破、探测都可能触犯法律（详见本系列第17篇），请务必先读完那篇再动手。

一、为什么安全人必须会写 Python？

你已经学会了前端、SQL、后端代码，现在该武装自己了。网络安全行业有一句大实话："不会写脚本的安全工程师，就是一个高级的按键操作员。"

你想想：手工测试一个登录框，改包、重放、看结果，一分钟一次；写个 20 行的 Python 脚本，把字典里一万个密码跑一遍，三分钟完事。手工你干到凌晨，脚本它喝着咖啡就下班了。这就是差距。

Python 在安全圈的地位几乎是"官方语言"，原因很朴素：

生态无敌 ：requests（HTTP 请求）、scapy（抓包）、socket（底层网络）、urllib（内置）......几乎覆盖所有安全开发需求；
上手极快：语法接近自然语言，缩进代替花括号，几天就能写出能跑的脚本；
工具链成熟：很多知名安全工具本身就是 Python 写的（sqlmap、dirsearch、w3af 等），读懂源码 = 拿到高级教程；
跨平台：Kali、Windows、macOS 都能跑，攻防两端通用。

本篇的终极目标：看完你能独立写出三个能用的安全小脚本------一个信息提取脚本、一个简易目录扫描器、一个简易端口扫描器，并且知道怎么把它升级成自己的 POC（概念验证脚本）。这些都是后面学 sqlmap、学 Xray、学内网渗透工具前的"地基"。

二、环境准备：3 分钟搭好战场

2.1 装 Python

去官网（python.org）下载安装包，安装时一定勾选 "Add Python to PATH"（把 Python 加进系统路径），否则终端里找不到 python 命令。装完验证：

bash 复制代码

python --version
# 输出类似：Python 3.12.x

版本建议用 3.9+。老教程里那些 Python 2 的 print "xxx" 语法早淘汰了，看到就跳过。

2.2 装 requests

Python 自带 urllib 能发请求，但体验极差（不信你试一次，光处理重定向就能绕晕）。安全圈 99% 的脚本都用第三方库 requests，它是"给人类用的 HTTP 库"：

bash 复制代码

pip install requests

如果 pip install 报权限错，Windows 用户试试 python -m pip install requests。

装完随便验证一下：

bash 复制代码

python -c "import requests; print(requests.get('https://www.baidu.com').status_code)"
# 输出 200 就说明环境通了

2.3 终端工具：curl（顺手学的）

写脚本前，先认识一个"脚本的祖先"------curl。它是命令行里发 HTTP 请求的工具，Windows 10+ 自带，Kali 也默认有。它的意义在于：调试接口时先 curl 一把，通了再写脚本，能省一半的调试时间。

bash 复制代码

curl -s https://www.baidu.com                 # 请求网页
curl -s -o /dev/null -w "%{http_code}\n" https://www.baidu.com   # 只看状态码
curl -s -X POST -d "username=admin&password=123" http://localhost:5000/login

后面写 Python 脚本，脑子里想的就是"把 curl 换成 Python 怎么写"，思路一下就清晰了。

三、Python 语法 15 分钟速览

假设你是零基础，我们只学安全脚本最常用的语法，够用即可，不搞全面教学。

3.1 变量、字符串与打印

python 复制代码

name = "blackhat"          # 字符串
age = 25                   # 整数
is_ok = True               # 布尔值 True/False（注意大写！）

print(name)                # 输出 blackhat
print(f"我是{name}，今年{age}岁")   # f-string 格式化，{}里放变量
print("状态码:", 200)      # 逗号分隔自动加空格

3.2 列表与字典：脚本的两大容器

python 复制代码

# 列表（list）：一组有序的数据，用中括号
urls = ["http://a.com", "http://b.com", "http://c.com"]
print(urls[0])             # 取第一个，下标从 0 开始
urls.append("http://d.com")   # 尾部追加
for u in urls:             # 遍历列表
    print(u)

# 字典（dict）：键值对，用大括号。HTTP 请求参数就是它！
headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
    "Cookie": "session=abc123",
}
print(headers["User-Agent"])    # 按键取值
headers["Referer"] = "https://example.com"   # 添加新键
for k, v in headers.items():    # 遍历所有键值对
    print(k, "=", v)

记住一句话：HTTP 的请求头、GET 参数、POST 数据，在 Python 里全是字典。

3.3 条件判断与循环

python 复制代码

code = 500
if code == 200:
    print("目标正常")
elif code == 403:
    print("被拦截了，可能要绕")
else:
    print(f"其他状态码：{code}")

# while 循环 + break/continue
i = 0
while i < 3:
    i += 1
    if i == 2:
        continue          # 跳过本次
    print("第", i, "次")

3.4 函数：把动作封装起来

python 复制代码

def fetch_status(url, timeout=5):
    """获取一个 URL 的状态码。docstring，描述函数作用"""
    try:
        r = requests.get(url, timeout=timeout)
        return r.status_code
    except Exception as e:
        print("请求失败:", e)
        return None

# 调用
print(fetch_status("https://www.baidu.com"))

def 定义函数，return 返回结果；
try/except 捕获异常------网络请求必须包 try，不然目标一断脚本就崩；
timeout=5 是默认参数，调用时不传就用默认值。

3.5 文件读写：结果要落盘

python 复制代码

# 读文件：按行读入列表（字典文件就是这样加载的）
with open("passwords.txt", "r", encoding="utf-8") as f:
    lines = [line.strip() for line in f]   # strip() 去掉换行和空格

# 写文件：把结果保存下来
with open("result.txt", "a", encoding="utf-8") as f:
    f.write("200 OK - http://a.com\n")

with open(...) as f 是"上下文管理器"，用完全自动关文件，不用手动 close。"a" 是追加模式，"w" 是覆盖写入。

语法到此为止，够用。下面进入真正的安全开发核心。

四、requests 库：与服务器对话的"嘴"

4.1 GET 请求：带参数、带头

python 复制代码

import requests

# 目标：本地靶场！没有授权不要换地址
url = "http://localhost/dvwa/vulnerabilities/sqli/?id=1"

params = {"id": "1"}        # GET 参数，等价于 URL 里的 ?id=1
headers = {
    "User-Agent": "Mozilla/5.0",
    "Cookie": "PHPSESSID=abcd1234; security=low",   # 靶场登录后的会话
}

r = requests.get(url, params=params, headers=headers, timeout=5)

print("状态码:", r.status_code)   # 200/302/403...
print("URL(最终):", r.url)        # 拼接了参数的完整 URL
print("响应文本:", r.text)         # 服务器返回的 HTML/JSON 文本

几个重点：

params 传字典，requests 自动帮你拼 ?id=1，不用自己手拼（还帮你处理特殊字符转义）；
headers 传请求头，模拟浏览器最关键是 User-Agent ------很多 WAF 和网站会拦截"没有 User-Agent 的请求"（默认 UA 是 python-requests/xxx，一眼暴露）；
timeout 必须设！不设超时，目标断连时脚本可能挂到天荒地老；
r.text 是响应内容，r.status_code 是状态码，这两个是最常用的。

4.2 POST 请求：表单和 JSON

python 复制代码

import requests

url = "http://localhost/login.php"

# 表单数据（对应 Content-Type: application/x-www-form-urlencoded）
data = {"username": "admin", "password": "admin123"}
r1 = requests.post(url, data=data)

# JSON 数据（对应 Content-Type: application/json，现代接口常见）
json_body = {"username": "admin", "password": "admin123"}
r2 = requests.post(url, json=json_body)

print(r1.status_code, r2.status_code)

data= 传表单，json= 传 JSON------requests 会自动帮你设置 Content-Type 头。这是新手最常踩的坑：接口要 JSON，你却传了 data，服务器直接 415 或者取不到参数。

4.3 Session：保持登录状态的神器

很多靶场/系统需要先登录才能访问敏感功能。如果每次都重新发请求，服务器认不出你是谁。requests.Session() 会自动帮你保存和管理 Cookie：

python 复制代码

import requests

s = requests.Session()   # 创建会话对象

# 1. 先登录，Cookie 自动存在 s 里
login_data = {"username": "admin", "password": "password", "Login": "Login"}
s.post("http://localhost/dvwa/login.php", data=login_data)

# 2. 带着会话访问需要登录的页面
r = s.get("http://localhost/dvwa/vulnerabilities/sqli/")
print(r.status_code, len(r.text))

Session 对象和直接 requests.get 的用法一样，只是它是个"有记忆的客户端"。写扫描器、写 POC、写爆破脚本，一律用 Session。

4.4 其他常用：重定向、代理、证书

python 复制代码

# 禁止自动跟随重定向（判断是否 302 跳登录页）
r = s.get(url, allow_redirects=False)

# 走代理（Burp 抓本地脚本的包，调试神器）
proxies = {"http": "http://127.0.0.1:8080", "https": "http://127.0.0.1:8080"}
r = s.get(url, proxies=proxies, verify=False)

# 跳过证书校验（自签名证书的靶场网站）
r = s.get(url, verify=False)

# 关闭 SSL 警告刷屏
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

这套组合拳是你以后配合 Burp 联调脚本的标配：脚本走 8080 代理，Burp 里能看到脚本发的每个请求、能改、能重放。写脚本调试出不来结果时，第一步就是开 Burp 看请求到底发出去了什么。

五、正则表达式：从 HTML 里"挖金子"

服务器返回的 HTML 是一大坨文本，你要从中提取信息（标题、链接、版本号、JS 文件路径......），最趁手的工具就是正则表达式（Regular Expression，简称正则） 。Python 用内置的 re 模块。

5.1 最常用的几个语法

语法	含义	例子
`.`	匹配任意字符（换行除外）	`a.c` 能匹配 `abc`、`a1c`
`*`	前面的字符重复 0 次或多次	`ab*c` 能匹配 `ac`、`abc`、`abbbc`
`+`	前面的字符重复 1 次或多次	`ab+c` 匹配 `abc`，不匹配 `ac`
`?`	前面的字符出现 0 次或 1 次	`ab?c` 匹配 `ac`、`abc`
`\d`	一个数字（0-9）	`\d\d\d` 匹配三位数字
`\w`	一个字母/数字/下划线	匹配 `a`、`1`、`_`
`\s`	一个空白符（空格、换行、Tab）
`[abc]`	字符集合，匹配其中任意一个	`[0-9]` 匹配一位数字，`[a-zA-Z]` 匹配字母
`^`	在方括号外表示"以...开头"；在 `[^]` 里表示"取反"	`^a` 以 a 开头；`[^0-9]` 非数字
`$`	以...结尾	`\.php$` 以 `.php` 结尾
`()`	分组（捕获），提取想拿的内容	见下文实战

5.2 `re.findall`：提取所有匹配，实战主力

python 复制代码

import re

html = """<a href="/index.php">首页</a>
<a href="/admin/login.php">管理登录</a>
<a href="/about.php">关于我们</a>"""

# 提取所有 .php 文件路径：href="/xxx.php"
links = re.findall(r'href="([^"]+\.php)"', html)
print(links)
# 输出：['/index.php', '/admin/login.php', '/about.php']

拆解这个正则 href="([^"]+\.php)"：

href=" 是普通文本，直接写；
( ) 里的才是要"捕获"的内容；
[^"]+ 匹配一个或多个非双引号字符（即链接路径本身）；
\.php 匹配 .php（\. 转义，因为 . 本身是"任意字符"，要匹配字面上的点必须转义）；
结尾的 " 是边界。

findall 返回所有匹配分组的列表，一行就把 HTML 里的链接全挖出来了------这就是信息提取脚本的核心动作。

5.3 `re.search`：只找第一个

python 复制代码

import re

# 提取页面标题 <title>xxx</title>
html = "<html><head><title>DVWA - 测试环境</title></head></html>"
m = re.search(r"<title>(.*?)</title>", html, re.S)
if m:
    print(m.group(1))    # 输出：DVWA - 测试环境

(.*?) 是非贪婪匹配：尽可能少地匹配字符，从第一个 <title> 后一直吃到最近的 </title> 为止；
re.S 标志让 . 也能匹配换行（HTML 经常有换行）；
m.group(1) 取第一个分组的内容。

5.4 常用正则小抄（信息收集场景）

python 复制代码

# 提取邮箱
re.findall(r"[\w.-]+@[\w.-]+\.\w+", text)

# 提取 IP 地址
re.findall(r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}", text)

# 提取手机号（11位，1开头）
re.findall(r"1[3-9]\d{9}", text)

# 提取 JS 文件路径
re.findall(r'src="([^"]+\.js[^"]*)"', html)

# 提取 URL 中的协议和域名
re.findall(r"https?://([\w.-]+)", text)

这些在信息收集阶段简直是无价之宝：拿到一个站点的全部页面 → 正则提邮箱、提子域名、提接口路径。手写正则一开始会觉得玄，用多了就成肌肉记忆了。实在写不出来的时候，可以打开在线正则测试工具边写边验证（只贴自己的数据）。

六、实战脚本①：网页信息提取器

现在把 requests + 正则组合起来，写第一个完整的脚本。它的功能：抓取目标首页，提取标题、外链、JS 文件、邮箱，把结果打印出来。

python 复制代码

# info_grab.py ------ 网页信息提取器（仅供本地靶场/授权目标使用）
import re
import requests
import urllib3

urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

HEADERS = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
}


def grab(url):
    print(f"[*] 正在采集: {url}")
    try:
        r = requests.get(url, headers=HEADERS, timeout=5, verify=False)
    except Exception as e:
        print(f"[!] 请求失败: {e}")
        return
    html = r.text
    print(f"[+] 状态码: {r.status_code}, 页面大小: {len(html)} 字节")

    # 标题
    m = re.search(r"<title[^>]*>(.*?)</title>", html, re.S)
    print("[+] 标题:", m.group(1).strip() if m else "未找到")

    # 外链
    links = re.findall(r'href="([^"]+)"', html)
    print(f"[+] 链接数量: {len(links)}")
    for link in links[:10]:          # 只显示前10个
        print("    ", link)

    # JS 文件
    js = re.findall(r'src="([^"]+\.js[^"]*)"', html)
    print(f"[+] JS 文件: {js if js else '未发现'}")

    # 邮箱
    emails = set(re.findall(r"[\w.-]+@[\w.-]+\.\w+", html))
    if emails:
        print("[+] 邮箱:", ", ".join(emails))
    else:
        print("[-] 未发现邮箱")


if __name__ == "__main__":
    grab("http://localhost/dvwa/index.php")   # 换成你的靶场地址

运行：python info_grab.py。你应该能看到页面的标题、链接列表、JS 文件名和邮箱。

这就是一个最简单的信息收集 POC。真实的信息收集工具（如 katana、httpx）原理一模一样，只是把"单页面"扩成了"全站爬取 + 更多提取规则"。

七、实战脚本②：简易目录扫描器

目录扫描的原理说出来不值一提：把字典里的路径一个个拼到域名后面，发请求，看返回码 。/admin 返回 200、/backup.zip 返回 200，说明这些目录真实存在------攻击面就出来了。

python 复制代码

# dir_scan.py ------ 简易目录扫描器（仅供本地靶场/授权目标使用）
import requests
import urllib3

urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

HEADERS = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"}
BASE = "http://localhost/dvwa"      # 靶场地址，请务必换成授权的！
WORDLIST = [
    "admin", "login", "index.php", "config.php", "backup.zip",
    ".git", "phpinfo.php", "robots.txt", "upload/", "api/",
]

def scan(base, wordlist):
    s = requests.Session()
    print(f"[*] 开始扫描 {base}")
    for path in wordlist:
        url = f"{base}/{path}"
        try:
            r = s.get(url, headers=HEADERS, timeout=5, verify=False, allow_redirects=False)
            # 重点关注 200（存在）和 403（存在但禁止访问）
            if r.status_code in (200, 403, 301, 302):
                size = len(r.text)
                print(f"[+] {url} -> {r.status_code} ({size} bytes)")
            else:
                print(f"[-] {url} -> {r.status_code}")
        except Exception as e:
            print(f"[!] {url} 出错: {e}")

if __name__ == "__main__":
    scan(BASE, WORDLIST)

运行后，你会看到哪些路径返回了真实内容。把 WORDLIST 换成真实的字典文件（比如从 GitHub 下载 dirsearch 的默认字典），再给脚本加上线程池，就是一个简版 dirsearch 了。

安全提醒 ：目录扫描属于"主动探测"，会被日志记录、会被 WAF 封 IP。只允许对自己的靶场或已授权目标跑。现实中你连公司内网乱扫一次，防火墙告警就响了，这就不是写代码的问题了，是写检讨的问题。

7.1 加个并发（进阶但必须）

单线程太慢，真实工具都用多线程。Python 最易用的是 ThreadPoolExecutor 线程池：

python 复制代码

from concurrent.futures import ThreadPoolExecutor

def check_one(path):
    # 单路径探测逻辑（略）
    ...

with ThreadPoolExecutor(max_workers=10) as pool:   # 10 个线程并发
    pool.map(check_one, WORDLIST)

注意：并发数不是越大越好。对真实系统 10~20 并发是礼貌，100 并发就是 DoS 了------把目标打崩，轻则给对方添麻烦，重则自己担责。扫描器界有个不成文的规矩：小字典、慢速度、少线程。

八、实战脚本③：简易端口扫描器

Web 渗透只是安全的一角，资产里还跑着 SSH（22）、MySQL（3306）、Redis（6379）......判断一台机器开了哪些端口，用 Python 的 socket 库最直接。

python 复制代码

# port_scan.py ------ 简易端口扫描器（仅供本地靶场/授权目标使用）
import socket
from concurrent.futures import ThreadPoolExecutor

COMMON_PORTS = [21, 22, 23, 25, 53, 80, 110, 111, 135, 139,
                143, 443, 445, 993, 995, 1433, 1521, 3306,
                3389, 5432, 5900, 6379, 7001, 8080, 8443,
                9200, 11211, 27017]

def scan_port(host, port, timeout=1):
    """尝试连接目标端口，能连上说明端口开放"""
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(timeout)
        result = sock.connect_ex((host, port))   # 0 表示连接成功
        sock.close()
        if result == 0:
            print(f"[+] {host}:{port} 开放")
    except Exception:
        pass

if __name__ == "__main__":
    target = "127.0.0.1"            # 本地！默认只扫本地
    with ThreadPoolExecutor(max_workers=50) as pool:
        for p in COMMON_PORTS:
            pool.submit(scan_port, target, p)

socket.socket(AF_INET, SOCK_STREAM) 创建 TCP 套接字；
connect_ex((host, port)) 尝试连接，返回 0 说明端口开放------原理就是"TCP 三次握手能不能成功"；
线程池并发扫描，几十个端口几秒钟扫完。

升级思路 ：扫到开放端口后，用 socket 或 requests 发个 banner（服务欢迎语）探测请求，抓回服务版本信息------这就叫服务指纹识别 。Nmap 干的就是这件事，只是比它复杂一百倍。你现在写的虽然简陋，但原理全对。

九、实战脚本④：登录爆破 POC（务必配合阅读红线篇）

学到这里，肯定有人想：能不能写个"万能爆破脚本"？可以，但请你先大声朗读一遍本篇开头的写作声明，再往下看。

我们写一个只用于本地靶场的登录爆破示例，目的是理解"爆破"这个技术动作的本质------它不是一个花哨的漏洞利用，而是对"弱口令"这种配置缺陷的穷举探测：

python 复制代码

# brute_login.py ------ 登录爆破演示（仅限本地靶场！）
import requests
import urllib3

urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

URL = "http://localhost/dvwa/login.php"
USERNAME = "admin"
PASSWORDS = ["admin", "123456", "password", "admin888", "test", "root"]

def try_login(s, username, password):
    data = {"username": username, "password": password, "Login": "Login"}
    r = s.post(URL, data=data, timeout=5)
    # 判断逻辑：登录成功会跳转或出现"欢迎"，失败页面提示错误
    if "Welcome" in r.text or "index.php" in r.url:
        return True
    return False

if __name__ == "__main__":
    for pwd in PASSWORDS:
        s = requests.Session()
        if try_login(s, USERNAME, pwd):
            print(f"[+] 爆破成功: {USERNAME} / {pwd}")
            break
        print(f"[-] 失败: {pwd}")

这个脚本的原理和真实爆破工具（hydra、medusa、burp intruder）完全一致，只是规模小得可怜。你理解它以后，再学那些工具就非常快------因为工具只是把"字典 + 请求 + 判断"这三件事做得更高效。

十、POC 与扫描器的工程化套路

把上面的脚本串起来，你就发现了所有安全工具的通用骨架：

bash 复制代码

① 输入处理（目标 URL/IP/参数）
    ↓
② 请求发送（requests/socket，带 headers、代理、会话）
    ↓
③ 响应判断（状态码/关键字/正则匹配）
    ↓
④ 结果输出与落盘（打印/写文件/告警）

任何 POC 都逃不出这四步。以后你拿到一个漏洞通告（比如某个中间件 CVE），看别人的 POC 代码时，也按这个骨架去拆，几分钟就能读懂它在干什么。

一个"生产级"脚本还应该加：

命令行参数 ：用 argparse 让使用者传 -u 目标、-t 线程、-o 输出文件，而不是改源码；
限速：time.sleep(0.5) 之类，别把目标打崩；
颜色输出 ：\033[91m 之类的 ANSI 转义让成功/失败分色显示（或直接用 colorama 库）；
异常兜底：任何网络操作都 try/except，别让脚本因为一个超时死掉；
写日志：结果落盘，方便复盘。

十一、动手练习：三道题检验自己

学编程不敲代码等于没学。这三道题全部在本地靶场完成，做完你就能确认自己真的掌握了本篇内容：

练习一：改造信息提取器

给 info_grab.py 加上"自动抓取页面里所有内链，并访问每一个内链，输出各自的状态码"。提示：先 re.findall 提取 href，判断是相对路径（/xxx）还是绝对 URL，拼接成完整地址再逐个请求。做完你会对"爬虫式信息收集"有第一手感。

练习二：给自己的目录扫描器加字典

把 WORDLIST 换成从外部文件读取（参考 3.5 节的文件读写），然后去本地 DVWA 里放几个真实的敏感文件（比如在 /var/www/html/dvwa 下建一个 backup.zip），看看你的扫描器能不能扫出来。注意：文件名建一个真能访问到的，扫描结果才会让你有"神器在手"的成就感。

练习三：写一个"登录页指纹识别"脚本

目标：给定一个登录页面 URL，用正则判断它属于哪种常见框架/平台（提示特征词：DVWA 页面里有 DVWA 字样、phpMyAdmin 有 phpMyAdmin 字样）。原理就是"抓标题+搜关键字"，这是指纹识别的最朴素实现。

三道题做完，你手里就有三个完全属于你自己的安全小工具了。记住：工具是你自己写的，你对它的每一行代码都负责------包括它只跑在授权目标上这一条。

十二、安全开发的合规红线（重要！）

这部分请认真看，因为它保护的是你自己：

目标边界：脚本里的 URL/IP 只填自己靶场、自己机器、或写了授权书的目标。字典、扫描范围全部以此为准。
速率控制：真实渗透测试要对目标负责，扫描会消耗目标资源。慢一点，礼貌一点，测试完主动汇报。把生产系统扫崩的案例，行业里每年都有，后果都不是"道歉"能解决的。
不留后门：写 POC 是为了验证漏洞是否存在，验证完就收工。绝不在目标机器留后门、不拖库、不植入任何代码。这不是技术问题，是人格问题。
报告先行：测试前明确测试范围和测试时间，测试中记录每一步操作，测试后输出漏洞报告------这三样缺一不可。
法律后果 ：第17篇会详细拆解《网络安全法》《刑法第285/286条》等条款。这里先记住一句话------"未经授权的扫描和爆破，哪怕只是探测，在司法实践中也可能被认定为非法侵入计算机信息系统罪。" 你写的脚本越强，越要敬畏这条红线。

十三、防御视角：如何对抗自动化攻击

从蓝队角度看一眼这些脚本，你会理解防御方在防什么：

目录扫描防御：Web 层统一返回 404（而不是真实存在的 403/200），让扫描器分不清路径真假；开启 WAF 的路径访问频率检测，一分钟内同一 IP 高频 404 直接封禁。
端口扫描防御：防火墙做端口白名单，只暴露必要的服务；IDS/IPS 监控"短时间内大量 TCP 连接失败"特征，这就是扫描器的指纹。
爆破防御 ：登录接口加验证码、加登录失败次数锁定、加 IP 限速，密码策略强制复杂度。爆破脚本怕的不是密码复杂，是锁定策略。
对抗响应：蜜罐 / 蜜网技术在真实目标前放几个假路径、假端口，攻击脚本一碰就告警------自动化工具成了"自投罗网"。

所以你看，攻击脚本和防御体系是互相进化的。你写的每一行脚本，都在帮你理解对方 WAF 在拦什么、IDS 在报什么，这正是白帽比脚本小子值钱的地方：既会造矛，也懂盾。

十四、本篇小结

Python = 安全人的"第二母语"，requests（HTTP）+ re（正则）+ socket（网络）三件套覆盖 80% 脚本需求。
requests 要点：params/data/json 三种传参、Session 保持登录、timeout 必设、走 Burp 代理调试。
正则要点：findall 批量提取、search 取第一个、() 捕获、.*? 非贪婪，配合 re.S。
三大实战脚本：信息提取（requests+正则）、目录扫描（字典+状态码判断）、端口扫描（socket 连接测试）------这就是 POC/扫描器的雏形。
工程化四步骨架：输入 → 请求 → 判断 → 输出，所有安全工具通用。
合规铁律：只扫授权的目标、控制速率、不留后门、写报告、敬畏法律。

到这一篇，你已经把"看懂网站"（前端、后端、SQL）和"会写脚本"（Python）这两块拼图都装上了。下一篇是这个系列的最后一块拼图------法律红线。它是你入行前必须刻进骨头的护栏：知道什么能做什么不能做，知道踩线后要面对什么。技术决定你能走多快，法律决定你能走多远。

【本文为网络安全筑基入门系列第16篇。】

安全Python编程：requests库、正则、脚本编写（POC与扫描器基础）

16-安全Python编程：requests库、正则、脚本编写（POC与扫描器基础）

一、为什么安全人必须会写 Python？

二、环境准备：3 分钟搭好战场

2.1 装 Python

2.2 装 requests

2.3 终端工具：curl（顺手学的）

三、Python 语法 15 分钟速览

3.1 变量、字符串与打印

3.2 列表与字典：脚本的两大容器

3.3 条件判断与循环

3.4 函数：把动作封装起来

3.5 文件读写：结果要落盘

四、requests 库：与服务器对话的"嘴"

4.1 GET 请求：带参数、带头

4.2 POST 请求：表单和 JSON

4.3 Session：保持登录状态的神器

4.4 其他常用：重定向、代理、证书

五、正则表达式：从 HTML 里"挖金子"

5.1 最常用的几个语法

5.2 re.findall：提取所有匹配，实战主力

5.3 re.search：只找第一个

5.4 常用正则小抄（信息收集场景）

六、实战脚本①：网页信息提取器

七、实战脚本②：简易目录扫描器

7.1 加个并发（进阶但必须）

八、实战脚本③：简易端口扫描器

九、实战脚本④：登录爆破 POC（务必配合阅读红线篇）

十、POC 与扫描器的工程化套路

十一、动手练习：三道题检验自己

十二、安全开发的合规红线（重要！）

十三、防御视角：如何对抗自动化攻击

十四、本篇小结

5.2 `re.findall`：提取所有匹配，实战主力

5.3 `re.search`：只找第一个