接口鉴权与传输安全：签名、AK/SK、JWT 及加密方案

接口鉴权与传输安全：签名、AK/SK、JWT 及加密方案 | 极客日志

类型	手段	典型场景	落地产品/场景示例	复杂度	安全性
鉴权	API Key	内部/开放平台简单鉴权	Stripe、SendGrid、多数 SaaS 控制台 API	低	中
鉴权	签名（如 HMAC）	开放 API、防篡改	微信支付/支付宝开放平台、部分银行/支付回调	中	高
鉴权	AK/SK	云厂商 API	阿里云、AWS、腾讯云、华为云、七牛对象存储	中	高
鉴权	JWT	无状态会话、微服务	前后端分离登录态、Auth0、Spring Security、很多 B 端后台	中	中高
鉴权	OAuth 2.0	第三方授权、开放平台	微信/QQ/微博登录、GitHub 授权、企业微信/飞书开放平台	高	高
鉴权	Basic / Digest	传统 HTTP 认证	内网监控/运维接口、部分老旧企业系统、路由器/摄像头管理	低	低/中
传输保护	对称/非对称加解密	敏感字段或报文加密	银企直连、支付报文、部分政务/医疗接口	中高	高

服务端 -> 客户端：构造参数并排序
客户端 -> 服务端：拼接 HMAC-SHA256(Secret, 参数字符串)
客户端 -> 服务端：请求 + Header 中带 signature/timestamp
服务端 -> 客户端：用同一 Secret 重算签名
服务端 -> 客户端：比对签名并校验时间
结果：200 或 401

# ========== HMAC 签名鉴权：客户端生成签名 + 服务端验签 ==========
# 依赖：标准库 hmac、hashlib，无需安装任何包
import hmac
import hashlib
import secrets
import time
from urllib.parse import urlencode

# 与服务端约定好的密钥，双方各持一份，绝不通过请求传递
# 生成方式（生产环境生成一次后持久化，客户端与服务端各存一份）：
SECRET = secrets.token_bytes(32)  # 32 字节，HMAC-SHA256 足够
# 若需可读的字符串形式（如放配置）：
# SECRET = secrets.token_hex(32).encode()

def make_signature(params: dict) -> str:
    """
    生成签名：参数按 key 排序 → 拼成 key1=val1&key2=val2 → 对该串做 HMAC-SHA256。
    注意：签名时不要包含 signature 自身，否则服务端无法复现。
    """
    sorted_params = sorted(params.items())
    sign_str = urlencode(sorted_params)
    sig = hmac.new(SECRET, sign_str.encode(), hashlib.sha256).hexdigest()
    return sig

# ---------- 客户端：构造带签名的请求 ----------
# 业务参数 + 防重放：timestamp 与 nonce（一次性随机串）
params = {
    "name": "test",
    "timestamp": str(int(time.time())),  # 服务端可据此拒绝过期请求
    "nonce": secrets.token_hex(8),  # 每次请求不同，防重放
}
params["signature"] = make_signature(params)
# 实际发请求时：params 可放在 query、body，或把 signature/timestamp 单独放 Header
print("客户端签名结果:", params["signature"])

# ---------- 服务端：验签 ----------
def verify_signature(params: dict) -> bool:
    """从参数中取出客户端传来的签名，用剩余参数重算，一致则通过。"""
    received = params.pop("signature", None)
    if not received:
        return False
    expected = make_signature(params)  # 用 compare_digest 避免时序攻击，不要用 ==
    return hmac.compare_digest(received, expected)

# 模拟服务端收到的参数（nonce 需与客户端一致）
params_for_verify = {
    "name": "test",
    "timestamp": params["timestamp"],
    "nonce": params["nonce"],
    "signature": params["signature"],
}
print("验签通过:", verify_signature(params_for_verify))

Method+URI -> 规范请求串 -> 签名字符串 -> HMAC-SK 得 Signature -> Authorization Header

# ========== AK/SK 鉴权：规范请求 + HMAC 签名 ==========
# 依赖：标准库 hmac、hashlib，无需安装
# 以下为简化版，真实对接阿里云/AWS 时请按官方文档拼规范请求（含 Header 排序等）
import hmac
import hashlib
import secrets

# 真实对接云厂商时从控制台获取；若自建类似机制可这样生成并入库下发：
ACCESS_KEY = "AK" + secrets.token_hex(16)  # 例如 AKa1b2c3d...
SECRET_KEY = secrets.token_urlsafe(32)  # SecretKey 仅本地/服务端持有，不可泄露

def canonical_request(method: str, path: str, query: str, body: str) -> str:
    """
    拼出「规范请求串」，云厂商会严格规定格式（如每行顺序、Header 列表等）。
    这里简化成：Method + Path + Query + Body 的 SHA256，实际需对照文档。
    """
    body_hash = hashlib.sha256((body or "").encode()).hexdigest()
    return f"{method}\n{path}\n{query}\n{body_hash}"

def sign(secret_key: str, string_to_sign: str) -> str:
    """对「签名字符串」做 HMAC-SHA256，得到最终签名。"""
    return hmac.new(
        secret_key.encode(), string_to_sign.encode(), hashlib.sha256
    ).hexdigest()

# ---------- 客户端：构造 Authorization ----------
method, path, query, body = "GET", "/api/resource", "a=1&b=2", ""
canon = canonical_request(method, path, query, body)
signature = sign(SECRET_KEY, canon)
# 常见格式：AK <AccessKey>:<Signature>，具体以云厂商文档为准
auth_header = f"AK {ACCESS_KEY}:{signature}"
print("Authorization:", auth_header)

# 服务端：用同一 SECRET_KEY，对收到的请求按相同规则拼规范串、重算 signature 并比对

# ========== API Key 鉴权：客户端在 Header 中携带 Key ==========
# pip install requests
import requests
import secrets

# 服务端签发时生成并入库，客户端拿到的即此值；示例里直接生成一个
API_KEY = "sk-" + secrets.token_urlsafe(24)  # 例如 sk-AbCdEf123...

# 请求时把 Key 放在 Header，服务端从 request.headers.get("X-API-Key") 取出并查库校验
resp = requests.get("https://api.example.com/data", headers={"X-API-Key": API_KEY})
# resp.raise_for_status()
# data = resp.json()

# ========== 异步调用带 API Key 的接口 ==========
# pip install httpx
import httpx

async def fetch_with_api_key(url: str, api_key: str) -> dict:
    """在异步场景下用 httpx 发请求，不阻塞事件循环。"""
    async with httpx.AsyncClient() as client:
        resp = await client.get(url, headers={"X-API-Key": api_key})
        resp.raise_for_status()
        return resp.json()

# 使用：result = await fetch_with_api_key("https://api.example.com/data", "sk-xxx")

Header . Payload . Signature

# ========== JWT 签发与校验 ==========
# pip install pyjwt
import jwt
import secrets
import time

# HS256 建议至少 256 位密钥；生成一次后持久化，服务端与签发/验签方共用
SECRET = secrets.token_hex(32)  # 32 字节 = 256 位，hex 后为 64 字符
# 若已有固定字符串：SECRET = "your-256-bit-secret-string-at-least-32-chars"

# ---------- 服务端：登录成功后签发 Token ----------
# sub：主体（通常为用户 ID）；exp：过期时间（建议设短一点，配合 refresh token）
payload = {
    "sub": "user123",
    "exp": int(time.time()) + 3600,  # 1 小时后过期
}
token = jwt.encode(payload, SECRET, algorithm="HS256")
print("签发 Token:", token)

# ---------- 服务端：收到请求后验签并解析 ----------
# decode 会同时校验签名和 exp，过期或篡改会抛异常
decoded = jwt.decode(token, SECRET, algorithms=["HS256"])
print("解析出的 Payload:", decoded)
# 含 sub、exp 等

资源接口 <- 授权服务 <- 客户端
client_id + client_secret -> access_token -> Authorization: Bearer access_token -> 资源

# ========== OAuth 2.0 客户端凭证：先换 Token，再调接口 ==========
# pip install requests
import requests

def get_token(token_url: str, client_id: str, client_secret: str) -> str:
    """向授权服务器用 client 身份换 access_token。"""
    r = requests.post(
        token_url,
        data={
            "grant_type": "client_credentials",
            "client_id": client_id,
            "client_secret": client_secret,
        },
        headers={"Content-Type": "application/x-www-form-urlencoded"},
    )
    r.raise_for_status()
    return r.json()["access_token"]

# 使用示例：
# token = get_token("https://auth.example.com/oauth/token", "cid", "csecret")
# resp = requests.get("https://api.example.com/resource", headers={"Authorization": f"Bearer {token}"})

# ========== 异步 OAuth 2.0 客户端凭证 ==========
# pip install httpx
import httpx

async def get_token_async(token_url: str, client_id: str, client_secret: str) -> str:
    """异步请求 token 端点，适合在 asyncio / FastAPI 等异步环境中使用。"""
    async with httpx.AsyncClient() as client:
        r = await client.post(
            token_url,
            data={
                "grant_type": "client_credentials",
                "client_id": client_id,
                "client_secret": client_secret,
            },
            headers={"Content-Type": "application/x-www-form-urlencoded"},
        )
        r.raise_for_status()
        return r.json()["access_token"]

# 使用：token = await get_token_async(...)
# 再：async with httpx.AsyncClient() as c: r = await c.get(resource_url, headers={"Authorization": f"Bearer {token}"})

# ========== Basic Auth：用户名密码 Base64 后放 Header ==========
# 仅用标准库 base64，无需安装
import base64

def basic_header(username: str, password: str) -> str:
    """拼出 Authorization: Basic xxx，注意仅编码不加密，务必走 HTTPS。"""
    raw = f"{username}:{password}"
    b64 = base64.b64encode(raw.encode()).decode()
    return f"Basic {b64}"

# 使用方式一：手动带 Header
# requests.get(url, headers={"Authorization": basic_header("user", "pass")})
# 使用方式二：requests 自带的 auth 参数会自动做 Basic
# requests.get(url, auth=("user", "pass"))

明文 -> AES 加密 -> 密文 -> 传输 -> AES 解密 -> 明文

# ========== 对称加密 AES + 非对称 RSA（混合加密思路） ==========
# pip install cryptography
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import padding
from cryptography.hazmat.primitives.asymmetric import rsa, padding as rsa_padding
from cryptography.hazmat.primitives import hashes
import os

# ---------- AES 对称加解密：同一密钥加解密，适合对 body 或字段加密 ----------
def aes_encrypt(key: bytes, plaintext: str) -> bytes:
    """CBC 模式需要 IV，这里把 IV 拼在密文前 16 字节，解密时先取出再解。"""
    iv = os.urandom(16)
    padder = padding.PKCS7(128).padder()
    padded = padder.update(plaintext.encode()) + padder.finalize()
    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    enc = cipher.encryptor().update(padded) + cipher.encryptor().finalize()
    return iv + enc  # 实际传参时可 base64 编码后放 body

def aes_decrypt(key: bytes, ciphertext: bytes) -> str:
    """前 16 字节为 IV，后面为密文；解密后去掉 PKCS7 padding。"""
    iv, enc = ciphertext[:16], ciphertext[16:]
    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    dec = cipher.decryptor().update(enc) + cipher.decryptor().finalize()
    unpadder = padding.PKCS7(128).unpadder()
    return (unpadder.update(dec) + unpadder.finalize()).decode()

# 示例：32 字节 key 对应 AES-256；生产里可从密钥管理服务获取或由 KDF 派生
key = os.urandom(32)  # 或 secrets.token_bytes(32)
ct = aes_encrypt(key, "hello api")
print("解密结果:", aes_decrypt(key, ct))

# ---------- RSA：公钥加密、私钥解密，常用于加密「对称密钥」或做签名 ----------
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,
    backend=default_backend(),
)
public_key = private_key.public_key()

def rsa_encrypt(pub_key, data: bytes) -> bytes:
    """用对方公钥加密，仅对方私钥可解密；数据不宜过长，适合加密 AES 的 key。"""
    return pub_key.encrypt(
        data, rsa_padding.OAEP(rsa_padding.MGF1(hashes.SHA256()), hashes.SHA256(), None)
    )

# 混合加密常见用法：生成随机 AES key → 用 RSA 公钥加密该 key → 用 AES 加密 body
# 请求里带：encrypted_key + ciphertext，对方用私钥解出 key 再解 body

场景	建议方式
内部/简单对接	API Key 或简单签名
开放 API、防篡改	签名（HMAC）或 AK/SK
需加密传输	在鉴权之上加 AES/RSA 或混合加密
无状态、多服务	JWT
第三方授权、开放平台	OAuth 2.0

架构场景	说明	常用鉴权与传输方式	注意点
Web 前后端	浏览器/SPA/小程序 ↔ 后端服务	JWT、Session + Cookie、OAuth 2.0 授权码	Token 存放与刷新、CORS、HTTPS；避免敏感密钥暴露在前端
车机端云	车机/T-Box/IVI ↔ 车云平台	设备证书 + 签名、AK/SK、或厂商自定义签名协议	弱网与断网续传、设备身份绑定、OTA 与密钥轮换
云对云 API	某云/自建服务 ↔ 另一云或第三方 API	AK/SK、OAuth 2.0 客户端凭证、mTLS、API Key	服务账号与权限最小化、审计与调用限流、密钥轮换与保管
A2A（应用对应用）	服务 ↔ 服务、API ↔ API，无用户参与	同云对云：AK/SK、Client Credentials、API Key、签名	机器身份、调用链与审计、idempotency 与重试策略

接口鉴权与传输安全：签名、AK/SK、JWT 及加密方案

一、为什么需要接口鉴权

二、鉴权与传输安全：如何区分与总览

三、基于签名的鉴权

3.1 签名（HMAC）

3.2 AK/SK（Access Key / Secret Key）

四、基于凭证与标准的鉴权

4.1 API Key

4.2 JWT（JSON Web Token）

4.3 OAuth 2.0（客户端凭证示例）

4.4 Basic Auth

五、传输保护：加密与解密

六、小结与选型建议

按场景选方式

按架构/部署形态选型（Web 前后端、车机端云、云对云、A2A）

七、参考资料

更多推荐文章

相关免费在线工具

接口鉴权与传输安全：签名、AK/SK、JWT 及加密方案

一、为什么需要接口鉴权

二、鉴权与传输安全：如何区分与总览

三、基于签名的鉴权

3.1 签名（HMAC）

3.2 AK/SK（Access Key / Secret Key）

四、基于凭证与标准的鉴权

4.1 API Key

4.2 JWT（JSON Web Token）

4.3 OAuth 2.0（客户端凭证示例）

4.4 Basic Auth

五、传输保护：加密与解密

六、小结与选型建议

按场景选方式

按架构/部署形态选型（Web 前后端、车机端云、云对云、A2A）

七、参考资料

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具