Base 家族百科完全指南
Base 编码家族是最常用的二进制到文本(Binary-to-Text)编码方式。它将二进制数据映射为可打印的 ASCII 字符,目的是在只能传输文本的信道中安全传递二进制数据(如邮件、URL、HTML、JSON 等)。
Base 编码的共同特点:
- 可逆:严格的一一映射,可无损还原
- 确定性:相同输入产生相同输出
- 可打印:仅使用 ASCII 可打印字符
- 不是加密:没有密钥,任何人可解码
一、Base 家族全景
1.1 成员一览
| 编码 | 索引表长度 | 输出字符集 | 效率(输出/输入) | 标准/RFC | 典型用途 |
|---|---|---|---|---|---|
| Base16 | 16 字符 | 0-9, A-F | 200% | RFC 4648 | 十六进制、哈希值、证书指纹 |
| Base32 | 32 字符 | A-Z, 2-7 | 160% | RFC 4648 | TOTP/HOTP 密钥、DNS、Tor onion 地址 |
| Base64 | 64 字符 | A-Z, a-z, 0-9, +, / | 133% | RFC 4648 | 邮件附件、Cookie、JWT、PEM 证书 |
| Base64URL | 64 字符 | A-Z, a-z, 0-9, -, _ | 133% | RFC 4648 | URL 参数、文件名、JWT |
| Base85 | 85 字符 | 可打印 ASCII 子集 | 125% | Adobe / RFC 1924 | PDF、PostScript、IPv6 压缩 |
| Z85 | 85 字符 | 0-9, a-z, A-Z, 符号 | 125% | ZeroMQ RFC | ZeroMQ、配置文件中的二进制 |
| Base91 | 91 字符 | 可打印 ASCII 子集 | 123% | 非标准 | 二进制文件编码、CTF 特殊题目 |
1.2 共同原理
原始字节流 → 分组 → 查表 → 输出字符流
输入字节数 N:
Base16: 1 字节 → 2 个 4 位组 → 2 个字符
Base32: 5 字节 → 8 个 5 位组 → 8 个字符
Base64: 3 字节 → 4 个 6 位组 → 4 个字符
Base85: 4 字节 → 5 个 5 位组(85进制) → 5 个字符
**填充字符 =**:当输入字节数不是分组大小的整数倍时,用 = 补齐。
二、Base16(十六进制)
2.1 原理
Base16 将每 1 字节(8 位) 拆成 2 个 4 位组,每组映射到 0-9, A-F 共 16 个字符。
字符表:
0: 0 4: 4 8: 8 C: C
1: 1 5: 5 9: 9 D: D
2: 2 6: 6 A: A E: E
3: 3 7: 7 B: B F: F
2.2 编码示例
输入: "Hi" = 0x48, 0x69
二进制: 01001000, 01101001
分组(每 4 位): 0100, 1000, 0110, 1001
十进制: 4, 8, 6, 9
Base16: 4 8 6 9
输出: "4869"
2.3 Python 实现
import binascii
import codecs
# 方法 1:使用 binascii
def base16_encode(data):
if isinstance(data, str):
data = data.encode()
return binascii.hexlify(data).decode().upper()
def base16_decode(encoded):
return binascii.unhexlify(encoded.strip())
# 方法 2:使用 codecs
def base16_encode_v2(data):
if isinstance(data, str):
data = data.encode()
return codecs.encode(data, 'hex').decode().upper()
# 测试
data = "Hello, Base16!"
encoded = base16_encode(data)
decoded = base16_decode(encoded)
print(f"原文: {data}")
print(f"Base16: {encoded}")
print(f"解码: {decoded}")
2.4 特性
- 大小写:标准使用大写 A-F,但小写 a-f 也常见(解码通常兼容)
- 无填充:无需
=(每字节固定产生 2 字符) - 长度:输出长度始终是偶数
2.5 应用场景
| 场景 | 示例 |
|---|---|
| SHA-256 哈希 | e3b0c44298fc1c14... |
| MD5 哈希 | d41d8cd98f00b204e9800998ecf8427e |
| MAC 地址 | 00:1A:2B:3C:4D:5E |
| IPv6 地址 | 2001:0db8:85a3:0000:0000:8a2e:0370:7334 |
| 颜色代码 | #FF5733 |
| SSL/TLS 证书指纹 | SHA1: 5F:E2:... |
三、Base32
3.1 原理
Base32 将每 5 字节(40 位) 拆成 8 个 5 位组,每组映射到 32 个字符(A-Z 和 2-7)。
标准字符表(RFC 4648):
0: A 8: I 16: Q 24: Y
1: B 9: J 17: R 25: 2
2: C 10: K 18: S 26: 3
3: D 11: L 19: T 27: 4
4: E 12: M 20: U 28: 5
5: F 13: N 21: V 29: 6
6: G 14: O 22: W 30: 7
7: H 15: P 23: X 31: 8? (无8-9,
注意:字符 0, 1, 8, 9 不使用,避免与 O, I 等字母混淆。
3.2 编码示例
输入: "Hi!" = 0x48, 0x69, 0x21 (3 字节)
二进制: 01001000, 01101001, 00100001
分组(每 5 位): 01001, 00011, 01001, 00100, 001 (剩余 3 位补 001 变为完整)
→ 01001, 00011, 01001, 00100, 00100
十进制: 9, 3, 9, 4, 4
Base32: J, D, J, E, E
补齐到 8 字符: J D J E E = = = (用 = 补齐到 8 字符,实际需要 8-5=3 个 =
实际 Base32 编码规则:
| 输入字节数 | 分组后 5 位组数 | 输出字符数 | 填充数 |
|---|---|---|---|
| 1 | 2 (需要 16 位实际只有 8 位) | 2 | 6 |
| 2 | 4 (需要 24 位实际只有 16 位) | 4 | 4 |
| 3 | 5 (需要 40 位实际只有 24 位) | 5 | 3 |
| 4 | 7 (需要 40 位实际只有 32 位) | 7 | 1 |
| 5 | 8 (正好 40 位) | 8 | 0 |
3.3 Base32 变体
Base32 标准(RFC 4648)
字符: A-Z, 2-7 (26字母+6数字)
填充: =
Base32 十六进制扩展(RFC 4648 §7)
字符: 0-9, A-V (32 字符)
填充: =
用途: 与十六进制一致的顺序
z-base-32
字符: y b n d r f g 8 e j k m c p q x o t 1 2 3 4 5 h 6 7 9 a z u l i s v w t n
用途: 人可读,避免易混淆字符
Crockford Base32
字符: 0-9, A-Z (不含 I, L, O, U — 避免与 1, 0 混淆)
校验字符: * ~ $ = u
用途: 人可读的数字标识符
3.4 Python 实现
import base64
def base32_encode(data):
if isinstance(data, str):
data = data.encode()
return base64.b32encode(data).decode()
def base32_decode(encoded):
# 补全填充
padding = len(encoded) % 8
if padding:
encoded += '=' * (8 - padding)
return base64.b32decode(encoded.upper())
# 测试
data = "Hello, Base32!"
encoded = base32_encode(data)
decoded = base32_decode(encoded)
print(f"原文: {data}")
print(f"Base32: {encoded}")
print(f"解码: {decoded}")
3.5 应用场景
| 场景 | 示例 |
|---|---|
| TOTP/HOTP 密钥 | OTP 密钥通常以 Base32 存储 |
| Tor Onion 地址 | example555555555555555555555555555555555555555.onion |
| 邮件传输 | 与 Base64 类似 |
| QR 码二进制数据 | 简化的编码格式 |
四、Base64(最常用)
4.1 原理
Base64 将每 3 字节(24 位) 拆成 4 个 6 位组,每组映射到 64 个字符。
标准字符表(RFC 4648):
索引 0-25: A-Z (大写字母)
索引 26-51: a-z (小写字母)
索引 52-61: 0-9 (数字)
索引 62: + (加号)
索引 63: / (斜杠)
填充: = (等号)
完整字符表:
A: 0 G: 6 M:12 S:18 Y:24 4:56
B: 1 H: 7 N:13 T:19 Z:25 5:57
C: 2 I: 8 O:14 U:20 0:52 6:58
D: 3 J: 9 P:15 V:21 1:53 7:59
E: 4 K:10 Q:16 W:22 2:54 8:60
F: 5 L:11 R:17 X:23 3:55 9:61
+:62 /:63
4.2 编码示例
输入: "Hi!" = 0x48, 0x69, 0x21 (3 字节 = 24 位)
二进制: 01001000, 01101001, 00100001
分组(每 6 位): 010010, 000110, 100100, 100001
十进制: 18, 6, 36, 33
Base64: S G k h
输出: "SGkh"
不足 3 字节的情况:
输入 1 字节: "H" = 0x48
二进制: 01001000
分组: 010010, 00 (补 0000)
→ 010010, 000000 (需要 24 位, 只有 8 位 → 补 16 位 0)
实际: 010010 00____
= 010010 000000
= 18, 0 → S, A
→ "SA==" (填充 2 个 =)
输入 2 字节: "He" = 0x48, 0x65
二进制: 01001000, 01100101
分组: 010010, 000110, 0101 (补 00)
= 010010, 000110, 010100
= 18, 6, 20 → S, G, U
→ "SGU=" (填充 1 个 =)
填充规则:
| 输入字节数 | 输出字符数 | 填充数 |
|---|---|---|
| 1 | 2 | 2 (=) |
| 2 | 3 | 1 (=) |
| 3 | 4 | 0 |
4.3 Python 实现
import base64
def base64_encode(data):
if isinstance(data, str):
data = data.encode()
return base64.b64encode(data).decode()
def base64_decode(encoded):
# 处理可能缺失的填充
padding = len(encoded) % 4
if padding:
encoded += '=' * (4 - padding)
return base64.b64decode(encoded)
# 测试
data = "Hello, Base64!"
encoded = base64_encode(data)
decoded = base64_decode(encoded)
print(f"原文: {data}")
print(f"Base64: {encoded}")
print(f"解码: {decoded.decode()}")
4.4 Base64 的实际使用
邮件传输(MIME):
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: base64
SGVsbG8sIEJhc2U2NCE=
图片嵌入 HTML:
<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUA
AAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO
9TXL0Y4OHwAAAABJRU5ErkJggg==" alt="Red dot">
JSON 中的二进制:
{
"file": "SGVsbG8sIFdvcmxkIQ==",
"content_type": "text/plain"
}
PEM 证书:
-----BEGIN CERTIFICATE-----
MIID...long base64 data...
-----END CERTIFICATE-----
Cookie / Session / JWT:
JWT Header.Payload.Signature
→ eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3OD...
4.5 命令行工具
# 编码
echo -n "Hello, World!" | base64
# 输出: SGVsbG8sIFdvcmxkIQ==
# 解码
echo "SGVsbG8sIFdvcmxkIQ==" | base64 -d
# 文件编码
base64 image.png > image.txt
base64 -d image.txt > image_decoded.png
# Python 一行
python3 -c "import base64; print(base64.b64encode(b'Hello').decode())"
# 在 macOS 上
echo -n "Hello" | base64 -i -
4.6 解码 Python 脚本(完整)
import base64
import sys
def detect_and_decode(data):
"""自动检测并解码常见 Base 编码"""
data = data.strip()
candidates = []
# 尝试 Base64
try:
decoded = base64.b64decode(data, validate=True)
if is_readable(decoded):
candidates.append(('Base64', decoded))
except:
pass
# 尝试 Base64URL
try:
padded = data + '=' * (-len(data) % 4)
decoded = base64.urlsafe_b64decode(padded)
if is_readable(decoded):
candidates.append(('Base64URL', decoded))
except:
pass
# 尝试 Base32
try:
decoded = base64.b32decode(data.upper())
if is_readable(decoded):
candidates.append(('Base32', decoded))
except:
pass
# 尝试 Base16
try:
decoded = base64.b16decode(data.upper())
if is_readable(decoded):
candidates.append(('Base16', decoded))
except:
pass
return candidates
def is_readable(data):
try:
text = data.decode('utf-8')
printable = sum(1 for c in text if c.isprintable() or c in '\n\r\t')
return printable / max(len(text), 1) > 0.9
except:
return False
五、Base64URL(URL 安全变体)
5.1 为什么需要 Base64URL
标准 Base64 的 + 和 / 在 URL 中是特殊字符,需要百分号编码:
+ → %2B
/ → %2F
= → %3D (可选, 但填充也可能被解释)
因此在 URL 中直接放标准 Base64 会有问题。
5.2 Base64URL 字符表
与 Base64 相同,但:
+ → - (减号, 0x2D)
/ → _ (下划线, 0x5F)
= → 可选省略 (无填充)
字符: A-Z, a-z, 0-9, -, _
共 64 个字符
5.3 编码示例
标准 Base64: "Hello, World!" → "SGVsbG8sIFdvcmxkIQ=="
Base64URL: "Hello, World!" → "SGVsbG8sIFdvcmxkIQ" (省略填充)
带特殊字符的情况:
二进制数据中有 + / 符号的位置会变成 - _
5.4 Python 实现
import base64
def base64url_encode(data):
if isinstance(data, str):
data = data.encode()
encoded = base64.urlsafe_b64encode(data)
# 去掉填充
return encoded.rstrip(b'=').decode()
def base64url_decode(encoded):
# 补全填充
padding = 4 - (len(encoded) % 4)
if padding != 4:
encoded += '=' * padding
return base64.urlsafe_b64decode(encoded)
# 测试
data = "Hello, Base64URL!"
encoded = base64url_encode(data)
decoded = base64url_decode(encoded)
print(f"原文: {data}")
print(f"Base64URL: {encoded}")
print(f"解码: {decoded}")
5.5 应用场景
| 场景 | 说明 |
|---|---|
| URL 参数 | ?data=SGVsbG8sIFdvcmxk |
| 文件名 | 避免 / 导致的路径问题 |
| JWT / JWS | JSON Web Token 三部分均使用 Base64URL(无填充) |
| OAuth 2.0 状态码 | 避免特殊字符引起的截断 |
| Web 应用的 session ID | Cookie 值通常也会用这种方式编码 |
JWT 示例:
Header.Base64URL: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9
Payload.Base64URL: eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIn0
Signature.Base64URL: SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c
完整 JWT:
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZS
I6IkpvaG4gRG9lIn0.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c
六、Base85(Ascii85)
6.1 原理
Base85 使用 85 个字符来编码。将 4 字节(32 位)映射为 5 个字符。效率比 Base64 更高(125% vs 133%)。
Ascii85 字符表(Adobe 标准):
字符: ! " # $ % & ' ( ) * + , - . / 0-9 : ; < = > ? @ A-Z [ \ ] ^ _ ` a-z u (共 85 个)
起始ASCII: ! (0x21 = 33)
结束ASCII: u (0x75 = 117)
编码步骤:
1. 将数据按 4 字节分组 (32 位无符号整数)
2. 将 4 字节解释为 32 位大端整数 N
3. 进行 5 次 85 进制除法:
N = d0 × 85^4 + d1 × 85^3 + d2 × 85^2 + d3 × 85 + d4
4. 每个 di 加 33 得到 ASCII 字符
5. N=0 的特殊情况: 编码为 "z" (1 字符代替 5 字符!)
解码:
1. 将 5 个字符减去 33 得到 5 个 0-84 的值
2. 恢复 32 位整数: N = d0×85^4 + d1×85^3 + d2×85^2 + d3×85 + d4
3. 拆回 4 字节
4. 特殊情况: "z" → 4 个 0 字节
6.2 示例
输入: "Man" = 0x4D, 0x61, 0x6E (补 0 到 4 字节 → 0x4D616E00)
32位整数: 1298333696
85 进制分解:
1298333696 ÷ 85 = 15274514 ... 6
15274514 ÷ 85 = 179700 ... 14
179700 ÷ 85 = 2114 ... 10
2114 ÷ 85 = 24 ... 74
24
→ 24, 74, 10, 14, 6 (索引值, 需逆序)
→ 字符: chr(24+33), chr(74+33), chr(10+33), chr(14+33), chr(6+33)
→ 5, v, 9, ? → "5v, 9? 简化为 5v9?" (实际更复杂...)
6.3 Z85(ZeroMQ 变体)
Z85 是 Base85 的改进版本,使用更友好的字符集:
字符: 0-9, a-z, A-Z, . - : + = ^ ! / * ? & < > (85 字符)
Python 实现:
import base64
# 标准 Ascii85 (Adobe)
def ascii85_encode(data):
if isinstance(data, str):
data = data.encode()
return base64.a85encode(data).decode()
def ascii85_decode(encoded):
return base64.a85decode(encoded)
# 测试
data = "Hello, Ascii85!"
encoded = ascii85_encode(data)
decoded = ascii85_decode(encoded)
print(f"原文: {data}")
print(f"Ascii85: {encoded}")
print(f"解码: {decoded}")
6.4 应用场景
| 场景 | 说明 |
|---|---|
| PDF / PostScript | Adobe 发明的 Ascii85 |
| IPv6 压缩表示 | RFC 1924 尝试使用 |
| ZeroMQ | Z85 用于密钥和配置 |
| Git 补丁 | 某些特殊场景 |
| CTF 题目 | 作为特殊编码变体出现 |
七、Base91
7.1 原理
Base91 使用 91 个字符,将可变长度字节映射为可变长度字符。它比 Base64 更高效(约 23% 开销 vs Base64 的 33%)。
字符表:
0-9, A-Z, a-z, 以及部分符号: ! # $ % & ( ) * + , - . / : ; < = > ? @ [ ] ^ _ ` { | } ~
共 91 个字符 (ASCII 可打印字符除去 ", ', = 和部分特殊字符)
编码原理:
Base91 与 Base64/85 不同,它不是固定长度分组,而是动态处理。
7.2 Python 实现
# PyPI 库: base91
# pip install base91
import base91
def base91_encode(data):
if isinstance(data, str):
data = data.encode()
return base91.encode(data)
def base91_decode(encoded):
return base91.decode(encoded)
data = "Hello, Base91!"
encoded = base91_encode(data)
decoded = base91_decode(encoded)
print(f"原文: {data}")
print(f"Base91: {encoded}")
print(f"解码: {decoded}")
7.3 应用场景
| 场景 | 说明 |
|---|---|
| CTF 题目 | 非常规编码题目 |
| 二进制文件文本传输 | 效率比 Base64 高 |
| 特殊配置文件 | 某些自定义系统 |
八、Base 编码的识别与特征
8.1 字符集特征
| 编码 | 字符特征 | 长度特征 | 典型开头 |
|---|---|---|---|
| Base16 | 只含 0-9, A-F (a-f) | 偶数 | 48, 65, 6c, 6c, 6f = “Hello” 的十六进制 |
| Base32 | 只含 A-Z, 2-7, = | 8 的倍数, 末尾可能有 = | JBSWY3DPEB3W64TMMQ====== |
| Base64 | A-Z, a-z, 0-9, +, /, = | 4 的倍数, 末尾可能有 0-2 个 = | SGVsbG8=, Q2hlY2s=, eyJ (JSON 编码起始) |
| Base64URL | A-Z, a-z, 0-9, -, _ | 不一定是 4 的倍数 | eyJhbGciOiJIUzI1Ni |
| Base85 | !-u 可打印字符 | 无固定规则 | z (特殊零压缩) |
| Base91 | 91 个可打印字符 | 无固定规则 | 复杂符号组合 |
8.2 常见 CTF 特征
判断 Base64:
- 字符: A-Z, a-z, 0-9, +, /, =
- 长度: 4 的倍数
- 末尾: 0, 1, 或 2 个 =
- 常伴有的数据标识:
data:image/png;base64, → 图片
-----BEGIN CERTIFICATE----- → PEM 证书
ssh-rsa AAAA → SSH 公钥
判断 Base32:
- 字符: A-Z, 2-7 (不含 0, 1, 8, 9)
- 长度: 8 的倍数
- 末尾: 0-6 个 =
- 常见于:
TOTP/HOTP 密钥
Tor .onion 地址 (56 字符)
OTPAUTH URI: otpauth://totp/...?secret=JBSWY3DPEHPK3PXP
判断 Base16(十六进制):
- 字符: 0-9, A-F (a-f)
- 长度: 偶数
- 常见:
文件签名 (magic bytes): 89 50 4E 47 0D 0A 1A 0A = PNG
MD5: 32 字符
SHA1: 40 字符
SHA256: 64 字符
MAC 地址: 12 字符 (含冒号分隔)
8.3 快速识别脚本
def detect_encoding(data):
"""检测字符串可能的 Base 编码类型"""
data = data.strip()
chars = set(data.replace('=', ''))
results = []
# Base16 (十六进制)
if chars <= set('0123456789ABCDEFabcdef') and len(data) % 2 == 0:
results.append('Base16 / Hex')
# Base32
if chars <= set('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567') and len(data) % 8 == 0:
results.append('Base32')
# Base64
b64_chars = set('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/')
if chars <= b64_chars and len(data) % 4 == 0:
results.append('Base64')
# Base64URL
b64url_chars = set('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_')
if chars <= b64url_chars:
results.append('Base64URL')
return results or ['未知']
九、多层 Base 编码与 CTF 实战
9.1 多层嵌套编码
CTF 题目常见的套路:将数据反复编码(比如 Base64 → Base32 → Base64 → Base64…)。
自动检测与循环解码:
import base64
import re
def auto_decode(data, max_depth=10):
"""自动尝试多层 Base 编码解码"""
current = data.strip()
path = []
for depth in range(max_depth):
original = current
# 尝试 Base64
try:
padded = current + '=' * (-len(current) % 4)
decoded = base64.b64decode(padded).decode('utf-8')
if decoded and is_printable_or_looks_like_base(decoded):
path.append('Base64')
current = decoded
continue
except:
pass
# 尝试 Base64URL
try:
padded = current + '=' * (-len(current) % 4)
decoded = base64.urlsafe_b64decode(padded).decode('utf-8')
if decoded and is_printable_or_looks_like_base(decoded):
path.append('Base64URL')
current = decoded
continue
except:
pass
# 尝试 Base32
try:
decoded = base64.b32decode(current.upper()).decode('utf-8')
if decoded and is_printable_or_looks_like_base(decoded):
path.append('Base32')
current = decoded
continue
except:
pass
# 尝试 Base16 (十六进制)
try:
decoded = base64.b16decode(current.upper()).decode('utf-8')
if decoded and is_printable_or_looks_like_base(decoded):
path.append('Base16')
current = decoded
continue
except:
pass
# 尝试 ROT13
try:
decoded = codecs.encode(current, 'rot_13')
if decoded != current and is_printable_or_looks_like_base(decoded):
path.append('ROT13')
current = decoded
continue
except:
pass
break
return current, path
def is_printable_or_looks_like_base(data):
"""判断是否是可打印文本或继续像是 Base 编码"""
if not data:
return False
# 检查是否是可打印 ASCII
printable_ratio = sum(1 for c in data if c.isprintable() or c in '\n\r\t') / max(len(data), 1)
if printable_ratio > 0.95:
return True
# 检查是否看起来像 Base64(高比例的 Base64 字符)
base64_chars = set('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=')
base_ratio = sum(1 for c in data if c in base64_chars) / max(len(data), 1)
if base_ratio > 0.9 and len(data) % 4 == 0:
return True
return False
# 使用示例
encoded = "Vm0wd2VHUXhTWGhpUm1SWVYwZDRWVll3WkRSV1NsUXlXVlpYVjFSa..." # 多层 Base64
result, path = auto_decode(encoded)
print(f"解码路径: {' → '.join(path)}")
print(f"最终结果: {result[:100]}")
9.2 CTF 实战示例
题目特征 1 - 长串 Base64:
密文: "SGFja2Vyb3VuZCBub3RlcyB0aGUgZmxhZyBpcyBtaW5kLg=="
解码: base64 -d → "Hackaround notes the flag is mind."
继续观察: 这是否继续是 Base 编码?
题目特征 2 - 数据 URI:
密文: "data:image/png;base64,iVBORw0KGgoAAAANSUhEU..."
方法:
1. 提取 Base64 部分
2. Base64 解码 → 得到 PNG 图片
3. 用图片查看器或 Stegsolve 分析隐藏信息
题目特征 3 - PEM 文件:
-----BEGIN RSA PRIVATE KEY-----
MIIEowIBAAKCAQEA...
-----END RSA PRIVATE KEY-----
这是 PEM 格式的私钥,Base64 解码后是 ASN.1 DER 格式二进制数据
题目特征 4 - 混合使用 ROT + Base:
synt{XXXX} → 先 ROT13 → flag{...}
但中间部分可能是 Base64: "Synt{S2V5IGlzIGluIHRoZSBtYWlu}" → flag{...}
9.3 常见文件签名(Magic Bytes)
PNG: 89 50 4E 47
JPEG: FF D8 FF
GIF: 47 49 46 38
ZIP: 50 4B 03 04
PDF: 25 50 44 46
MP3: 49 44 33 或 FF FB
RAR: 52 61 72 21
ELF: 7F 45 4C 46
PE: 4D 5A
当 Base 解码后得到这些字节,说明是某个文件。
十、常见错误与陷阱
10.1 填充错误
错误: "SGVsbG8" (缺失填充, 应该是 "SGVsbG8=")
影响: 某些严格解析器会报错
修复: 补填充 = 的个数 = -len(data) % 4
10.2 大小写敏感
| 编码 | 大小写 |
|---|---|
| Base16 | 大小写均可, 但标准是大写 |
| Base32 | 大小写均可, 标准是大写 |
| Base64 | 严格区分大小写 (A=0, a=26 不同!) |
| Base64URL | 严格区分大小写 |
10.3 换行问题
邮件 (MIME) 要求每 76 字符换行:
SGVsbG8sIFdvcmxkIQ==SGVsbG8sIFdvcmxkIQ==SGVsbG8sIFdvcmxkIQ==SGVsb
G8sIFdvcmxkIQ==SGVsbG8sIFdvcmxkIQ==
解码前应先去除换行。
10.4 URL 编码与 Base64 的混淆
URL 参数中的 Base64 数据:
?data=SGVsbG8sIFdvcmxk
实际上应该是:
?data=SGVsbG8sIFdvcmxkIQ%3D%3D (但 = 是可选的, 常被省略)
10.5 编码与加密的区别
Base64 = 编码 = 可逆, 无密钥, 所有人可读 (是"包装"不是加密)
AES = 加密 = 需密钥, 没有密钥不可解密
常见错误:
错误: "我们的数据用 Base64 加密了"
正确: "我们的数据用 Base64 编码了"
如果需要保密,应该用 AES/RSA/ChaCha20 等真正的加密算法
10.6 性能对比
| 编码 | 1MB 编码耗时 | 输出大小 | 注释 |
|---|---|---|---|
| Base16 | 快 | 2,097,152 B (200%) | 最简单 |
| Base32 | 快 | 1,677,722 B (160%) | 适合小数据 |
| Base64 | 快 | 1,398,102 B (133%) | 最通用 |
| Base85 | 中等 | 1,310,720 B (125%) | 效率更高 |
| Base91 | 慢 | ~1,284,142 B (123%) | 自定义 |
十一、Python 综合工具函数
import base64
import codecs
import binascii
class BaseEncoder:
"""Base 编码家族综合工具"""
@staticmethod
def base16_encode(data):
if isinstance(data, str):
data = data.encode()
return binascii.hexlify(data).decode().upper()
@staticmethod
def base16_decode(encoded):
return binascii.unhexlify(encoded.strip()).decode()
@staticmethod
def base32_encode(data):
if isinstance(data, str):
data = data.encode()
return base64.b32encode(data).decode()
@staticmethod
def base32_decode(encoded):
padding = -len(encoded) % 8
if padding:
encoded += '=' * padding
return base64.b32decode(encoded.upper()).decode()
@staticmethod
def base64_encode(data):
if isinstance(data, str):
data = data.encode()
return base64.b64encode(data).decode()
@staticmethod
def base64_decode(encoded):
padding = -len(encoded) % 4
if padding:
encoded += '=' * padding
return base64.b64decode(encoded).decode()
@staticmethod
def base64url_encode(data):
if isinstance(data, str):
data = data.encode()
return base64.urlsafe_b64encode(data).rstrip(b'=').decode()
@staticmethod
def base64url_decode(encoded):
padding = -len(encoded) % 4
if padding:
encoded += '=' * padding
return base64.urlsafe_b64decode(encoded).decode()
@staticmethod
def ascii85_encode(data):
if isinstance(data, str):
data = data.encode()
return base64.a85encode(data).decode()
@staticmethod
def ascii85_decode(encoded):
return base64.a85decode(encoded).decode()
# 使用示例
if __name__ == '__main__':
text = "Hello, World!"
encoders = {
'Base16': (BaseEncoder.base16_encode, BaseEncoder.base16_decode),
'Base32': (BaseEncoder.base32_encode, BaseEncoder.base32_decode),
'Base64': (BaseEncoder.base64_encode, BaseEncoder.base64_decode),
'Base64URL': (BaseEncoder.base64url_encode, BaseEncoder.base64url_decode),
'Ascii85': (BaseEncoder.ascii85_encode, BaseEncoder.ascii85_decode),
}
for name, (encode, decode) in encoders.items():
try:
encoded = encode(text)
decoded = decode(encoded)
status = "✓" if decoded == text else "✗"
print(f"{name:10s} {status} {encoded[:40]:40s} ({len(encoded)} chars)")
except Exception as e:
print(f"{name:10s} ✗ 错误: {e}")
十二、综合对照表
12.1 编码效率对比
| 编码 | 每 3 字节输入输出字符数 | 效率 | 额外开销 |
|---|---|---|---|
| Base16 | 6 | 50.0% | 100% |
| Base32 | 5 (需要 5 字节输入 → 8 字符) | 62.5% | 60% |
| Base64 | 4 | 75.0% | 33.3% |
| Base85 | 5 | 80.0% | 25.0% |
| Base91 | 约 4 | 约 81.5% | 约 23% |
12.2 各编码的使用建议
| 场景 | 推荐编码 | 理由 |
|---|---|---|
| 哈希值展示 | Base16 | 十六进制最易读,便于复制 |
| 密钥/令牌 | Base32 或 Base64URL | Base32 人可读,Base64URL 可嵌入 URL |
| URL 参数 | Base64URL (无填充) | 避免 + / = 特殊字符 |
| 邮件附件 | Base64 | MIME 标准 |
| 证书/PEM | Base64 | PEM 标准 |
| JSON 二进制数据 | Base64 | JSON 标准做法 |
| 文件签名/指纹 | Base16 (十六进制) | 通用标准 |
| CTF 简单题目 | Base64/Base32/Base16 | 送分题特征 |
| 需要最高密度 | Base85/Base91 | 特殊场景 |
总结
Base 编码家族是二进制到文本的核心工具,在现代计算机系统中无处不在。
核心要点:
- Base16(十六进制):每个字节 → 2 字符,最高可读性,用于哈希值、指纹等
- Base32:5 字节 → 8 字符,字符表不含 0/1/8/9,适合人读场景
- Base64:3 字节 → 4 字符,字符表 A-Z, a-z, 0-9, +, /,最通用
- Base64URL:与 Base64 相同,但
+→-、/→_,可直接用于 URL - **Base85 (Ascii85/Z85)**:更高密度,用于 PDF、ZeroMQ 等特殊场景
- Base91:非标准但效率最高的变体,主要出现在 CTF 中
与安全相关的重要提醒:
- Base 编码不是加密,无密钥,任何人可读
- Base 编码只是数据表示方式的变换
- 在 URL/文件中传输敏感数据时,Base 编码应配合真正的加密算法(AES 等)
- CTF 中遇到长不可读字符串,应先尝试 Base64 → Base32 → Base16 的顺序
在线工具推荐:
- CyberChef(推荐,支持所有变体及多层嵌套)
- base64decode.org
- hexed.it
- dcode.fr