小森的数字空间 // 安全 · AI · 成长 2026-05-17T05:18:54.627Z https://sanshisanfight.github.io/ 小森 Hexo SDH/OTN 业务承载技术问答手册 https://sanshisanfight.github.io/2026/05/17/SDH-OTN%E4%B8%9A%E5%8A%A1%E6%89%BF%E8%BD%BD%E6%8A%80%E6%9C%AF%E9%97%AE%E7%AD%94%E6%89%8B%E5%86%8C/ 2026-05-17T05:00:00.000Z 2026-05-17T05:18:54.627Z

📘 适用场景：华为 OSN1800V + EGS4 板卡运维与学习

本文以问答形式系统梳理 SDH/OTN 业务承载核心概念，从 EoS/EoO 区别到虚级联、交叉连接，逐一拆解。

Q1：EoS 业务和 EoO 业务有什么区别？

对比项EoS（Ethernet over SDH）EoO（Ethernet over OTN）
全称以太网 over 同步数字体系以太网 over 光传送网
底层承载SDH 网络OTN 网络
封装映射以太网帧 → VC（虚容器） → STM-N以太网帧 → ODUk → OTUk
交叉颗粒VC-12 / VC-3 / VC-4ODU0 / ODU1 / ODU2 / ODU3 / ODU4 / ODUflex
线路侧信号STM-N（如 STM-1/4/16/64）OTUk（如 OTU1/2/3/4）
带宽粒度固定小颗粒（2M / 48M / 155M）大颗粒（1.25G / 2.5G / 10G / 40G / 100G）
时延性能相对较高（映射层级多）相对较低，大颗粒业务优势明显
典型应用传统 SDH 网络、小颗粒业务（<100M）OTN 网络、大颗粒业务（>100M）、专线入云

💡 一句话：EoS 走 SDH 的 VC 通道，EoO 走 OTN 的 ODUk 通道，两者底层承载网络完全不同。

Q2：什么是”大颗粒业务”？”带宽颗粒”指的是什么？

“颗粒” 是通信网络中的形象化比喻，指的是传输网络中用于调度、分配和交叉连接的最小带宽单元。就像沙子的颗粒大小决定了沙漏的精度，带宽颗粒决定了网络资源分配的最小精度。

技术体制典型带宽颗粒颗粒大小
SDHVC-12（2M）、VC-3（48M）、VC-4（155M）🔹 小颗粒
OTNODU0（1.25G）、ODU1（2.5G）、ODU2（10G）、ODU3（40G）、ODU4（100G）🔷 大颗粒
  • 大颗粒业务：带宽需求 ≥ GE（1G）级别，如 10GE 数据中心互联、视频回传、云计算专线
  • 小颗粒业务：带宽需求 < GE 级别，如 E1（2M）、10M/100M 以太网、金融专线

💡 为什么 OTN 被称为”大颗粒”技术？ OTN 的最小颗粒 ODU0（1.25G）就已经比 SDH 的最大颗粒 VC-4（155M）还要大得多。

Q3：ODU 的全称是什么？

ODU = Optical channel Data Unit，即光通道数据单元。

在 OTN 分层结构中的位置：

层级全称功能
OTUkOptical channel Transport Unit-k承载 ODUk，加入 FEC 开销，用于线路传输
ODUkOptical channel Data Unit-k承载客户信号，提供端到端连接、监控和保护
OPUkOptical channel Payload Unit-k映射客户信号（如以太网、SDH 等）

ODUk 速率标准：

类型速率对应客户信号
ODU01.25 Gb/sGE
ODU12.5 Gb/sSTM-16 / OC-48
ODU210 Gb/sSTM-64 / 10GE
ODU340 Gb/sSTM-256 / 40GE
ODU4100 Gb/s100GE
ODUflex可变速率灵活带宽业务

Q4：华为 OSN1800V 上的 EGS4 板卡是什么？

EGS4 = 四路交换式千兆以太网处理板（4-port Gigabit Ethernet Switching Processing Board）

硬件规格

项目规格
接口数量4 路 GE 接口
接口类型SFP 光口 + 可选 SFP 电口
最大上行带宽2.5 Gbit/s
映射方式VC-12、VC-3、VC-4 及虚级联
封装格式HDLC、LAPS、GFP-F
VCTrunk 数量64 个

✅ 能承载的业务

  • EPL / EVPL / EPLAN / EVPLAN
  • 链路聚合（LAG/DLAG）
  • 组播业务（IGMP Snooping）
  • 同步以太时钟 / LCAS 带宽动态调整 / LPT 链路保护

❌ 不能承载的业务

不支持说明
MPLS不支持标签交换
1588v2 时间同步不支持精确时间协议
10GE 及以上最大仅支持 GE 速率
OTN 业务（EoO）只能映射到 SDH 的 VC，不能直接映射到 ODUk
OSU / CPRI / SAN不支持光业务单元、无线前传、存储网络

⚠️ 核心限制：EGS4 是 SDH 平面板卡（EoS），不能做 OTN 业务。

Q5：什么是”映射客户信号”？

“映射” 就是把一种格式的信号装进另一种格式的容器里，就像把不同形状的物品装进标准规格的快递箱。

1
客户侧 GE 口 → 以太网帧 → [封装 GFP-F/HDLC/LAPS] → 映射到 VC 虚容器 → SDH 网络
原因说明
统一传输以太网是分组交换，SDH 是时分复用，两者格式不同，需要”翻译”
标准化SDH 网络只认 VC 容器，任何业务都必须变成 VC 才能传输
隔离保护映射到不同 VC 中，业务之间物理隔离，互不干扰
带宽分配通过 VC 数量灵活分配带宽（如 1×VC-4=155M，4×VC-4=622M）

Q6：VCTrunk 是什么？和 VC 有什么区别？

VCTrunk = Virtual Container Trunk（虚容器中继/汇聚）

它是 EGS4 等以太网处理板上的逻辑通道，用于把封装后的以太网数据映射到 SDH 的 VC 虚容器中。

概念类比本质存在位置
VC集装箱物理传输容器整个 SDH 网络
VCTrunk传送带逻辑通道仅在 EGS4 等以太网板卡上

VCTrunk 关键特性：

  • EGS4 支持 64 个 VCTrunk
  • 每个 VCTrunk 可绑定 1504 个 VC-12，或 148 个 VC-3，或 1~16 个 VC-4
  • 支持 LCAS 动态调整 + 虚级联

💡 为什么这样设计？ GE 端口是物理接口，VCTrunk 是逻辑通道，两者解耦后可以灵活组合。64 个 VCTrunk 可以承载 64 条独立以太网专线，共享 4 个 GE 物理端口。

Q7：虚级联是什么？

问题背景

SDH 的 VC 容器规格固定（VC-4=155M, VC-3=48M, VC-12=2M），但客户业务带宽是任意的（如 GE=1000M，不是 155M 的整数倍）。

解决思路

把多个小的、不连续的 VC 容器”虚拟”绑在一起，组成一个逻辑上的大管道。

1
2
3
4
需要承载 1000M 业务（约 7×VC-4=1085M）

传统级联：需要 7 个连续的 VC-4 ❌ 很难找到
虚级联：  VC-4 #3 + VC-4 #12 + VC-4 #25 ... ✅ 不连续也能绑定
机制作用
发送端把数据流拆分，分别装进不同 VC，打上 MFI 和 SQ
传输路径各个 VC 可走不同物理路径（时延可能不同）
接收端根据 MFI 和 SQ 重新排序、重组，恢复原始数据流
LCAS动态增减绑定的 VC 数量，带宽平滑调整

Q8：交叉连接是什么？

SDH 交叉连接是整个 SDH 网络中进行的，不是单指某块板卡或某台设备。

更准确地说：交叉连接是每台 SDH 设备内部的功能，多台设备的交叉连接串联起来，形成端到端的网络级连接。

1
2
3
4
5
6
某台 SDH 设备内部：

   东向光口 ──┐
   西向光口 ──┼──→ 【交叉连接矩阵】──→ 北向光口
   南向光口 ──┘         ↑↓
                    本地支路板（EGS4）

端到端的业务需要多台设备配合：

1
站点 A（EGS4）→ 交叉 → STM-16 → 站点 B（交叉）→ STM-16 → 站点 C（交叉）→ EGS4

💡 每台设备只做自己这一段”交换”，多台设备串联起来，就形成了端到端的 VC 通道。

Q9：什么是支路板？EGS4 是支路板吗？

板卡类型方向功能典型例子
支路板南向（面向客户）接入客户业务信号EGS4、PD1、PQ1
线路板东西向（面向传输网络）承载 STM-N，连接其他设备SL16、SL64
交叉板内部VC 交叉连接、设备控制XCS、SCC
1
2
3
STM-64（线路侧大容量）
    ↓ 解复用
STM-16 → STM-4 → STM-1 → VC-4（支路信号从这里"分支"出来）
  • 线路板 = 干流（承载大容量的 STM-N）
  • 支路板 = 支流（把干流中的 VC 提取出来，交给客户使用）

EGS4 是支路板，面向客户侧（南向），是客户业务进入传输网的”大门”。

Q10：EPL / EVPL / EPLAN / EVPLAN 有什么区别？

这是 MEF（城域以太网论坛） 定义的四种标准以太网业务类型，核心区别在于隔离方式和拓扑结构。

业务类型全称隔离方式拓扑通俗解释
EPLEthernet Private Line端口隔离点对点物理专线：两个端口直连，像一根光纤拉过去
EVPLEthernet Virtual Private LineVLAN 隔离点对点虚拟专线：同一端口不同 VLAN 走不同通道
EPLANEthernet Private LAN端口隔离多点互通专用局域网：多个端口组成一个 LAN
EVPLANEthernet Virtual Private LANVLAN 隔离多点互通虚拟局域网：同一端口不同 VLAN 组成不同 LAN

选择场景：

场景推荐
两站点点对点互联，要求完全透明EPL
一个站点有多个客户，需要隔离EVPL
多站点组成内网，需要互通EPLAN
多客户共享接入，各自独立局域网EVPLAN

📎 附录：完整数据流向

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
┌─────────────────────────────────────────┐
│           客户侧设备（交换机）             │
│              发送以太网帧                  │
└─────────────────┬───────────────────────┘
                  ↓
┌─────────────────────────────────────────┐
│           EGS4 板卡 GE 端口              │
│         （支路板 - 南向接入）              │
└─────────────────┬───────────────────────┘
                  ↓
┌─────────────────────────────────────────┐
│         封装（GFP-F / HDLC / LAPS）      │
│      把以太网帧变成适合 SDH 传输的格式     │
└─────────────────┬───────────────────────┘
                  ↓
┌─────────────────────────────────────────┐
│              VCTrunk                    │
│    【逻辑通道】绑定多个 VC 虚容器          │
└─────────────────┬───────────────────────┘
                  ↓
┌─────────────────────────────────────────┐
│         映射到 VC 虚容器                  │
│    【物理容器】通过虚级联组成逻辑大管道     │
└─────────────────┬───────────────────────┘
                  ↓
┌─────────────────────────────────────────┐
│           SDH 交叉连接矩阵                 │
│         【设备内部】VC 调度、路由          │
└─────────────────┬───────────────────────┘
                  ↓
┌─────────────────────────────────────────┐
│           STM-N 线路传输                  │
│         【线路板 - 东西向】光纤传输        │
└─────────────────┬───────────────────────┘
                  ↓
         （经过多个站点交叉连接串联）
                  ↓
┌─────────────────────────────────────────┐
│           对端站点反向流程                 │
│  线路板 → 交叉 → VCTrunk → 解封装 → GE 口  │
└─────────────────────────────────────────┘

📎 关键概念速查表

概念一句话解释
EoS vs EoOEoS 走 SDH/VC，EoO 走 OTN/ODUk
大/小颗粒≥1G 叫大颗粒，<1G 叫小颗粒
ODU光通道数据单元，OTN 中的调度单元
映射把以太网帧装进 SDH 的 VC 快递箱
VCSDH 网络中的”集装箱”，物理运输单元
VCTrunkEGS4 板卡上的”传送带”，逻辑通道
虚级联多个不连续小箱子拼成逻辑大箱子
交叉连接每个中转站内部的”分拣系统”
支路板面向客户的”大门”（南向）
线路板面向传输网络的”干线”（东西向）
EPL/EVPL点对点专线，区别在于独占端口还是共享端口+VLAN
EPLAN/EVPLAN多点局域网，区别同上

适用场景：华为 OSN1800V + EGS4 板卡运维与学习

]]> 基于华为 OSN1800V + EGS4 板卡场景，系统梳理 SDH/OTN 业务承载核心概念：EoS vs EoO、ODU、VCTrunk、虚级联、交叉连接、支路板、EPL/EVPL 等 正则提取到多线程爆破：CTF实战全记录 https://sanshisanfight.github.io/2026/04/06/%E6%AD%A3%E5%88%99%E6%8F%90%E5%8F%96%E5%88%B0%E5%A4%9A%E7%BA%BF%E7%A8%8B%E7%88%86%E7%A0%B4-CTF%E5%AE%9E%E6%88%98%E5%85%A8%E8%AE%B0%E5%BD%95/ 2026-04-06T11:00:00.000Z 2026-04-06T11:14:27.578Z

继 Day1 掌握 requests 基础、Session 会话保持和简单爆破脚本后，Day2 重点突破 CTF 实战核心技能，整合所有知识点，写出可直接用于靶机/CTF 的全自动解题脚本。全程实战导向，零基础友好。

一、今日学习目标

  1. 掌握正则表达式（re 库），实现 CTF 中 flag 的自动提取
  2. 掌握 base64 编码/解码，应对靶机中加密的 flag
  3. 掌握多线程爆破原理与实现，将爆破速度提升 10 倍以上
  4. 整合 Day1 + Day2 所有知识点，编写全自动 CTF 解题脚本（爆破 → 登录 → 提取 flag → 解码）

二、核心知识点详解

1. 正则表达式 re —— CTF flag 提取神器

核心作用： 在杂乱的网页源码、接口返回内容中，精准提取 flag{xxx} 格式的 flag，无需手动查找，实现自动化提取，是 CTF 解题必备技能。

万能模板（直接复制用）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import re

# 模拟靶机返回的网页内容
html = """
<html>
<body>
ajsdf823kf&*#$
flag{this_is_really_hard_flag_abc789}
kjdfh2983rhdkfn
</body>
</html>
"""

# 万能正则，匹配 flag{...} 格式
flag_list = re.findall(r'flag\{.*?\}', html, re.S)
if flag_list:
    print("提取到flag：", flag_list[0])  # 输出：flag{this_is_really_hard_flag_abc789}
else:
    print("未找到flag")

关键参数说明

参数含义
r'flag\{.*?\}'正则核心：flag\{ 匹配开头，.*? 非贪婪匹配中间内容，\} 匹配结尾
re.S跨行匹配，解决 flag 被换行隔开的问题，实战必加
re.findall()返回所有匹配结果的列表，取 [0] 获取第一个

💡 为什么用 .*? 非贪婪匹配？ 如果页面有多个 flag，贪婪匹配 .* 会把第一个 { 到最后一个 } 全部吃掉，导致提取错误。非贪婪 .*? 遇到第一个 } 就停止，精准提取每一个 flag。

2. base64 编码/解码 —— 靶机高频加密考点

CTF 中约 30% 的 flag 会进行 base64 加密，需用 Python 自动解码，无需手动借助在线工具。

核心代码（必背模板）

1
2
3
4
5
6
7
8
9
10
11
import base64

# 1. base64 解码（实战常用：密文 → 明文flag）
b64_str = "ZmxhZ3tiYXNlNjRfZGVjb2RlX3N1Y2Nlc3N9"  # 模拟加密后的flag
real_flag = base64.b64decode(b64_str).decode()
print("解码后flag：", real_flag)  # 输出：flag{base64_decode_success}

# 2. base64 编码（了解即可：明文 → 密文）
plain_text = "flag{test_base64_encode}"
b64_encode = base64.b64encode(plain_text.encode()).decode()
print("编码后：", b64_encode)

关键说明

  • b64decode(b64_str)：解码 base64 字符串，返回字节流
  • .decode()：将字节流转为字符串，避免输出 b'...' 格式
  • 编码时需先 .encode() 将字符串转为字节流，再进行 base64 编码

💡 快速识别 base64： 字符串只包含 A-Z a-z 0-9 + / =，且长度是 4 的倍数，大概率是 base64 编码。

3. 多线程爆破 —— 速度提升 10 倍的核心

Day1 的单线程爆破效率极低，多线程可同时尝试多个密码，速度直接提升 10~100 倍。核心使用 ThreadPoolExecutor（Python 自带，无需额外安装）。

多线程爆破实战代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import requests
from concurrent.futures import ThreadPoolExecutor

headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36"
}

# 单个密码测试函数
def check_pwd(pwd):
    url = "https://httpbin.org/post"  # 模拟登录接口
    data = {"username": "admin", "password": pwd}
    try:
        resp = requests.post(url, data=data, headers=headers, timeout=2)
        resp_json = resp.json()
        # 登录成功判断（根据靶机实际情况修改）
        if resp_json.get("form", {}).get("password") == "test123":
            return f"✅ 爆破成功！正确密码：{pwd}"
        else:
            return f"❌ 错误密码：{pwd}"
    except:
        return f"⚠️  请求超时：{pwd}"

# 密码字典（实战可从文件读取）
pwd_list = ["123456", "admin", "root", "test123", "password"]

# 多线程执行（max_workers=10，同时尝试10个密码）
with ThreadPoolExecutor(max_workers=10) as executor:
    results = executor.map(check_pwd, pwd_list)
    for res in results:
        print(res)

关键参数说明

参数说明
max_workers=10同时运行 10 个线程，可根据电脑性能调整（5~20 为宜）
executor.map(函数, 列表)将列表每个元素传入函数，多线程并行执行
try...except避免单个请求超时/失败导致整个脚本崩溃

4. 终极实战：全自动 CTF 一把梭脚本

整合 Day1 + Day2 所有知识点，实现：

多线程爆破密码 → Session 保持登录 → 访问 flag 页面 → 正则提取 flag → base64 自动解码 → 输出真实 flag

复制即可跑，直接用于靶机/CTF 解题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
import requests
import re
import base64
from concurrent.futures import ThreadPoolExecutor
import threading

# 线程锁：防止多线程同时打印输出混乱
lock = threading.Lock()

# ====================== 靶机配置区（自行修改） ======================
LOGIN_URL    = "https://httpbin.org/post"  # 登录接口
FLAG_URL     = "https://httpbin.org/get"   # flag 页面接口
USER         = "admin"                     # 目标账号
PASSWD_LIST  = ["123456", "admin", "root", "test123", "password", "123123"]  # 密码字典

headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36"
}
# ======================================================================

success_pwd = None          # 存储爆破成功的密码
session = requests.Session()  # 会话保持，登录后不掉线

# 单密码测试函数
def try_pwd(pwd):
    global success_pwd
    if success_pwd:  # 已找到正确密码，直接跳过
        return

    try:
        data = {"username": USER, "password": pwd}
        resp = session.post(LOGIN_URL, data=data, headers=headers, timeout=3)
        resp_json = resp.json()

        # 登录成功判断（靶机需根据实际返回内容修改）
        if resp_json.get("form", {}).get("password") == "test123":
            with lock:
                success_pwd = pwd
                print(f"\n[+] 爆破成功！密码：{pwd}")
            return True

    except Exception as e:
        return False

# 多线程爆破密码
def burst_password():
    print("[*] 开始多线程密码爆破...")
    with ThreadPoolExecutor(max_workers=10) as executor:
        executor.map(try_pwd, PASSWD_LIST)

# 获取并解析 flag（提取 + 自动解码）
def get_flag():
    print("\n[*] 登录成功，开始获取 Flag...")
    resp = session.get(FLAG_URL, headers=headers)
    html = resp.text

    # 1. 先提取明文 flag
    flag = re.findall(r'flag\{.*?\}', html, re.S)
    if flag:
        print("[+] 找到明文 Flag：", flag[0])
        return

    # 2. 若未找到明文，尝试提取 base64 并解码
    b64_list = re.findall(r'[A-Za-z0-9+/=]{20,}', html)
    if b64_list:
        b64_str = b64_list[0]
        real_flag = base64.b64decode(b64_str).decode()
        print("[+] Base64 解码成功：", real_flag)
        return

    print("[-] 未找到 Flag，请检查正则或 flag 格式")

# 主流程
if __name__ == "__main__":
    burst_password()

    if success_pwd:
        get_flag()
    else:
        print("\n[-] 爆破失败，密码字典中无正确密码")

三、今日学习总结

Day2 重点突破了 CTF 实战中的核心技能，从正则提取 flag、base64 解码，到多线程爆破，最终整合所有知识点，写出全自动解题脚本，实现了「一把梭」解题。

技能掌握情况
正则表达式 re✅ flag 自动提取，适配各种藏 flag 场景
base64 编解码✅ 应对靶机加密 flag，无需手动解码
多线程爆破✅ ThreadPoolExecutor 使用，速度提升 10 倍+
全自动脚本✅ 整合所有知识点，直接用于 CTF/靶机实战

四、下一步学习计划

  1. 文件读取：实现从本地文件加载超大密码字典
  2. 正则进阶：应对更复杂的 flag 格式（带特殊符号、嵌套加密）
  3. Burp Suite 联动：精准定位脚本问题，调试更高效
  4. 靶机实战：刷题优化脚本，适配不同场景

本文为个人学习记录，仅用于技术交流。请勿用于非法用途，遵守网络安全相关法律法规。

]]> 继Day1掌握requests基础后，Day2重点突破正则提取flag、base64解码、多线程爆破，整合写出CTF全自动一把梭脚本 Python requests 库入门到精通——从零学习全记录 https://sanshisanfight.github.io/2026/04/05/Python-requests%E5%BA%93%E5%85%A5%E9%97%A8%E5%88%B0%E7%B2%BE%E9%80%9A/ 2026-04-05T07:10:00.000Z 2026-04-05T07:11:14.521Z

本文从基础语法到实战脚本，带你掌握目录扫描、暴力破解、自动登录等渗透测试必备技能。适合入门者系统学习，也适合作为速查手册。

一、学习目标

掌握 requests 库语法，理解 HTTP 协议基础，能够编写目录扫描、暴力破解、自动登录等渗透/CTF 辅助脚本，为后续实战打基础。

二、核心知识速查

1. requests 基础：GET/POST 请求

基础语法

1
2
3
4
5
6
7
8
9
10
11
12
13
import requests

# 标准请求头（伪装Chrome浏览器，避免被反爬）
headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36"
}

# GET 请求（获取资源，参数拼接到URL末尾，用params传）
resp_get = requests.get("https://httpbin.org/get", headers=headers, timeout=3)

# POST 请求（提交数据，参数放在请求体里，用data传）
data = {"username": "admin", "password": "test123"}
resp_post = requests.post("https://httpbin.org/post", headers=headers, data=data, timeout=3)

关键参数对比

参数适用请求数据位置典型用途
paramsGETURL 末尾（?key=value）传递查询参数、翻页
dataPOST请求体（Body）提交登录表单、业务数据
jsonPOST请求体传 JSON 格式接口数据

响应对象常用属性

1
2
3
4
resp.status_code  # HTTP 状态码（200成功/404不存在/403无权/302重定向）
resp.text          # 响应数据（字符串），适合HTML/文本
resp.json()        # 响应数据（JSON 转 Python 字典），适合接口/JSON返回
resp.encoding      # 查看或设置编码：resp.encoding = "utf-8"

2. 请求头 headers：为什么要加？怎么写？

为什么重要

伪装成真实浏览器，避免被目标网站/WAF识别为Python脚本从而拒绝访问（返回403无法获取数据）。

标准写法（直接复制用）

1
2
3
headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36"
}

  • User-Agent：浏览器标识字段，90%情况只需要这一个字段

  • 其他请求头可选：Accept、Referer 等，按需添加

User-Agent 解析

1
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36
  • Mozilla/5.0：历史遗留，表示兼容 Mozilla
  • (Windows NT 10.0; Win64; x64)：系统信息，伪装 Windows 10 64位
  • AppleWebKit/537.36：浏览器渲染引擎
  • Chrome/130.0.0.0：Chrome 浏览器版本号，伪装最新版

3. Session 会话对象：自动登录的核心

核心原理

HTTP 协议是无状态的，默认记不住用户登录状态。Session 模块可以自动管理Cookie，保持登录状态跨请求传递（登录后访问其他页面不用重新登录）。

标准用法

1
2
3
4
5
6
7
8
9
# 1. 创建会话对象（循环外创建一次，全程复用）
s = requests.Session()

# 2. 用会话发请求（代替全局requests.post/get）
login_data = {"username": "admin", "password": "test123"}
s.post("https://httpbin.org/post", headers=headers, data=login_data)

# 3. 后续请求自动携带Cookie，保持登录状态
flag_resp = s.get("https://httpbin.org/get", headers=headers)

关键注意事项

  • 必须用 s.post() / s.get()，不能混用全局 requests.post()，否则 Session 失效
  • 会话对象循环外创建，避免每次新建会话浪费资源
  • 典型用途：自动登录、爆破后保持状态、访问需要权限的页面（如flag页）

4. 循环 + 异常处理：健壮脚本的核心

for 循环：批量执行

用途：遍历列表批量执行相同操作（目录扫描、暴力破解的核心模式）

1
2
3
4
5
# 目录扫描示例
path_list = ["get", "post", "headers", "ip", "cookies"]
for path in path_list:
    url = f"https://httpbin.org/{path}"  # f-string 格式化字符串拼接URL
    print(url)

f-string 格式化字符串

用途：在字符串中直接嵌入变量，避免繁琐拼接，清晰易读

1
2
3
4
TARGET = "https://httpbin.org"
path = "get"
url = f"{TARGET}/{path}"  # 自动拼接为 "https://httpbin.org/get"
print(f"[+] {url} -> 状态码: {resp.status_code}")  # 格式化输出日志

try…except 异常处理：脚本稳定运行的关键

用途：捕获网络异常，避免单个请求失败导致整个脚本直接终止，保证批量任务稳定执行

1
2
3
4
5
6
7
8
9
try:
    resp = requests.get(url, headers=headers, timeout=3)
    print(f"[+] {url} -> 状态码: {resp.status_code}")
except requests.exceptions.Timeout:
    print(f"[-] {url} -> 请求超时")
except requests.exceptions.ConnectionError:
    print(f"[-] {url} -> 连接失败")
except Exception as e:
    print(f"[-] {url} -> 未知错误: {str(e)}")

5. resp.json()：JSON 响应处理

核心作用

把服务器返回的 JSON 字符串 转为 Python 字典，可以直接取值，适合接口、JSON格式返回的场景。

标准用法

1
2
3
4
5
6
resp = requests.post("https://httpbin.org/post", data={"username": "admin"})
# JSON转字典
resp_json = resp.json()
# 取值两种方式
username = resp_json["form"]["username"]  # 直接取值（键不存在会报错）
username = resp_json.get("form", {}).get("username")  # 安全取值（键不存在返回None）

与 resp.text 的区别

方法返回类型能否直接取值适用场景
resp.text字符串❌ 不能HTML页面、文本内容
resp.json()字典✅ 能JSON接口、数据返回

三、实战脚本：直接复制可用

1. 目录扫描脚本：批量扫描网站路径

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import requests

headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36"
}

TARGET = "https://httpbin.org"
# 待扫描路径列表（实战可从字典文件读取）
PATH_LIST = ["get", "post", "headers", "ip", "cookies"]

print(f"[*] 开始扫描 {TARGET} 目录...\n")
for path in PATH_LIST:
    url = f"{TARGET}/{path}"
    try:
        resp = requests.get(url, headers=headers, timeout=3)
        # 过滤404，只输出有效路径
        if resp.status_code != 404:
            print(f"[+] {url} -> 状态码: {resp.status_code}")
    except Exception as e:
        print(f"[-] {url} -> 请求失败: {str(e)}")
        continue

print("\n[*] 扫描完成！")

2. 密码爆破脚本：登录尝试 + 自动拿flag

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import requests

headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36"
}

LOGIN_URL = "https://httpbin.org/post"
USERNAME = "admin"
# 密码字典（实战可从文件读取）
PASSWORD_LIST = ["123456", "password", "admin", "root", "test123"]

# 创建会话对象，保持登录状态
session = requests.Session()

print(f"[*] 开始爆破用户: {USERNAME} 密码...\n")
for pwd in PASSWORD_LIST:
    print(f"[*] 正在尝试密码: {pwd}")
    try:
        data = {"username": USERNAME, "password": pwd}
        resp = session.post(LOGIN_URL, headers=headers, data=data, timeout=3)
        resp_json = resp.json()

        # 登录成功判断（实战需改为页面特征如"登录成功"等）
        if (resp_json.get("form", {}).get("username") == USERNAME 
            and resp_json.get("form", {}).get("password") == "test123"):
            
            print(f"\n✅ 爆破成功！用户: {USERNAME} 密码: {pwd}")
            # 登录成功后访问flag页面
            flag_resp = session.get("https://httpbin.org/get", headers=headers, timeout=3)
            print(f"[+] 获取Flag成功！状态码: {flag_resp.status_code}")
            break

    except requests.exceptions.Timeout:
        print(f"[-] {LOGIN_URL} -> 请求超时，密码: {pwd}")
    except requests.exceptions.ConnectionError:
        print(f"[-] {LOGIN_URL} -> 连接失败，密码: {pwd}")
    except Exception as e:
        print(f"[-] {LOGIN_URL} -> 请求失败，错误信息: {str(e)}，密码: {pwd}")
        continue

print("\n[*] 爆破完成！")

四、常见错误 & 速查指南

1. 高频错误清单

错误原因解决方法
AttributeError: 'function' object has no attribute 'text'把 get 写成了会话对象，或未调用函数就访问响应检查是否对响应对象 resp 操作，而不是对 s
Expecting value JSON解析错误对GET接口用POST，或响应不是JSON检查请求方法（登录用 POST），确认接口返回格式
登录后无法访问flag页面未用Session，混用了全局 requests.post()改用 session.post()，全程复用同一个会话
字典传值失败（字符串格式）字典值未加引号，或变量名错误检查引号，如 "username": USERNAME
脚本一遇到错误就崩未加异常处理加全局 try...except 捕获所有异常

2. 实战速查

  • 所有请求必须加 timeout 参数，避免脚本卡死
  • 登录脚本要用 POST，不要误用 GET 请求
  • Session 循环外创建，避免每次新建会话
  • 字典传值要加引号，字符串变量要加引号
  • 生产脚本必须加异常处理，保证稳定性

五、学习总结 & 下一步计划

1. 今日收获总结

✅ requests 库基础语法：GET/POST、headers、timeout、响应处理

✅ Session 会话对象原理与用法

✅ for 循环、f-string、try...except 编写脚本核心

✅ 目录扫描、密码爆破实战脚本编写

✅ 常见脚本错误排查与速查

2. 下一步学习方向

  1. 多线程加速：给扫描/爆破脚本加多线程，速度提升 10 倍+
  2. 编写自动拿flag脚本：结合正则提取flag，自动解码 base64/hex
  3. Burp Suite 插件开发：用 Python 写 Burp 插件，定制化抓包分析
  4. 高级 requests 用法：文件上传、代理设置、SSL证书验证、会话持久化

写在最后

从零到一，系统梳理了 requests 库的核心语法与实战脚本。掌握了这些，你就能编写自己的渗透辅助脚本了！

本文为学习记录，仅供技术交流学习使用，请勿用于非法用途。网络安全法律法规红线不可逾越。

]]> 从零开始学习 Python requests 库，掌握目录扫描、暴力破解、自动登录等渗透测试必备技能 用 iPhone 拍出电影感 https://sanshisanfight.github.io/2026/03/22/%E7%94%A8iPhone%E6%8B%8D%E5%87%BA%E7%94%B5%E5%BD%B1%E6%84%9F/ 2026-03-22T13:55:00.000Z 2026-03-25T06:14:13.609Z

一部 iPhone，加上正确的技巧，就能拍出电影质感的画面。本文系统梳理曝光控制、白平衡调整、升格降格应用等核心知识点。

资料来源： 影视飓风 课程学习笔记

一、掌握曝光

曝光三要素

光圈、ISO、快门 —— 经典曝光三角。

但手机没有物理光圈可调，所以核心就是 ISO 和 快门 两个参数。

快门速度经验法则：

帧率推荐快门
30fps1/60s
60fps1/120s

一般控制在帧率的 两倍分之一。

曝光参数示意

相机界面

自动曝光 vs 手动曝光

不要依赖眼睛判断，要学会用工具判断是否过曝/欠曝。

直方图是关键：

直方图示意

曝光原则：

  • 尽可能在不过曝的情况下，往右边曝光（ETTR 原则）
  • 斑马纹控制在 80% 以下
  • 室内日光容易曝光正常
  • 逆光场景如果调整不过来，说明已超过 iPhone 极限，需要取舍

强光场景的处理

场景： 强日光 + 30fps

理论快门 1/60s，ISO 400 时画面一片白（严重过曝）。

解决方案优先级：

  1. 先降 ISO 到最低
  2. 如果还过曝 → 牺牲动态模糊，提高快门到 1/2000s
    • 代价：画面不够顺滑
  3. 如果快门和 ISO 都动不了 → ND 滤镜（削减光强，不影响偏色）

不同光线环境策略

场景策略
Golden Hour不希望太多过曝，也不希望全部欠曝，平衡取舍
室内夜晚快门 1/60s，ISO 100 可能欠曝，可提升到 1600，再高噪点明显
静态物体可降一档曝光，降低 ISO 减少噪点

二、掌握画面的颜色 —— 白平衡与色调

什么是色温？

色温 描述光的冷暖，单位是开尔文（K）。

光源色温
火柴燃烧~1700K
日出/日落~1850K
正午阳光5500-6000K
阴天~6500K
晴朗蓝天10000K+

色温示意

色温对比

白平衡的作用

告诉相机当前环境的色温 K 值，把物体颜色校正回本来的样子。

校正标准： 白色校正回纯白，灰色校正回灰色。

这个过程叫 「对白」。

白平衡与色温的关系

可以理解成天平：

  • 白平衡 K < 环境色温 → 认为拍摄暖色 → 加冷校正
  • 白平衡 K > 环境色温 → 认为拍摄冷色 → 加黄校正

实操建议：

  • 不建议一直开自动白平衡（会因不同物体持续变化）
  • 先让自动跑完，再精调

色调修正

如果画面总是偏品红或偏绿，用 色调-色偏 来修正。

核心原则： 前期正确曝光 + 正确白平衡，后期再调整想要的效果。

三、拍摄技巧 —— 升格与降格

升格镜头（慢动作）

为什么叫升格？ 帧率提升，播放时间拉长。

设置技巧：

  1. 快门速度控制在帧率两倍左右
  2. 拍摄 120fps 慢动作 → 快门靠近 1/240s
  3. 小技巧： 把快门改成角度模式，设为 180°，自动换算

升格设置

操作步骤：

  1. 设置 30fps 基准帧率
  2. 点击 OFF SPEED
  3. 帧率变成两个：左边拍摄帧率，右边播放帧率
  4. 拍摄 5 秒 → 播放变成 4 倍时长

帧率设置

降格镜头（延时摄影）

适合拍摄云流动、车流、日出日落等场景。

降格设置

四、调色的魅力

调色流程

  1. 一级调色：亮度、色相、饱和度
  2. 二级调色：Log 画面手动还原
  3. Log 调色全流程

一级调色要点

色轮 可以调整：

  • 亮度
  • 色相
  • 饱和度

练习：对白

环境色温 4000K，相机白平衡 7000K → 校正到正确颜色。

总结

模块核心要点
曝光ISO + 快门，直方图判断，ETTR 原则
白平衡理解色温，先自动再精调
升格快门 = 帧率 × 2，角度模式 180°
降格延时摄影，适合大范围运动场景
调色一级校正，二级风格化

曝光和白平衡没有标准答案，多拍多练，找到自己的风格。

本文为学习笔记整理，持续更新中。

]]> 掌握曝光、白平衡、升格降格技巧，用 iPhone 拍出电影质感的视频 Hello World https://sanshisanfight.github.io/2025/08/11/hello-world/ 2025-08-10T17:35:32.062Z 2025-08-10T17:35:32.063Z Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1
$ hexo new "My New Post"

More info: Writing

Run server

1
$ hexo server

More info: Server

Generate static files

1
$ hexo generate

More info: Generating

Deploy to remote sites

1
$ hexo deploy

More info: Deployment

]]> <p>Welcome to <a href="https://hexo.io/">Hexo</a>! This is your very first post. Check <a href="https://hexo.io/docs/">documentation</a> for