《MMO 服务器开发》16.3 封包加密与签名

seq(4, BE) | nonce(12) | ciphertext + tag(16)

// file: internal/guard/crypto.go
// tier: L1
// verify: go test ./internal/guard/ -run 'TestSeal|TestOpen|TestReplayWindow|TestDeriveKey'

package guard

import (
	"crypto/aes"
	"crypto/cipher"
	"crypto/hmac"
	"crypto/rand"
	"crypto/sha256"
	"encoding/binary"
	"errors"
	"io"
)

// 加密封套布局：seq(4, BE) | nonce(12) | ciphertext+tag。
// seq 明文随封套传输，接收端用它查重放窗口；nonce 由发送端随机生成，
// 每个 (key, nonce) 组合在 GCM 下只能出现一次，随机 96 位碰撞概率可忽略。
const (
	SeqLen   = 4
	NonceLen = 12
)

// 加解密错误。
var (
	ErrReplay    = errors.New("guard: sequence replayed or too old")
	ErrShortSeal = errors.New("guard: sealed envelope too short")
	ErrBadTag    = errors.New("guard: authentication tag mismatch")
)

// Sealer 用一把对称密钥封装/解封载荷。密钥方向单一：客户端→服务端与服务端→
// 客户端各用一把，避免同一 (key, nonce) 在两个方向复用。
type Sealer struct {
	aead  cipher.AEAD
	nonce func([]byte) error // 随机源，测试可注入以确定化
}

// NewSealer 用 32 字节密钥构造一个 AES-256-GCM Sealer。
func NewSealer(key []byte) (*Sealer, error) {
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}
	aead, err := cipher.NewGCM(block)
	if err != nil {
		return nil, err
	}
	return &Sealer{aead: aead, nonce: func(b []byte) error {
		_, err := io.ReadFull(rand.Reader, b)
		return err
	}}, nil
}

// Seal 把明文封成 seq | nonce | ciphertext+tag。seq 必须单调递增，
// 接收端的重放窗口依赖它。
func (s *Sealer) Seal(seq uint32, plaintext []byte) ([]byte, error) {
	nonce := make([]byte, NonceLen)
	if err := s.nonce(nonce); err != nil {
		return nil, err
	}
	out := make([]byte, SeqLen+NonceLen, SeqLen+NonceLen+len(plaintext)+s.aead.Overhead())
	binary.BigEndian.PutUint32(out[0:SeqLen], seq)
	copy(out[SeqLen:SeqLen+NonceLen], nonce)
	// 把 seq 作为附加认证数据（AAD）：篡改 seq 会让 tag 校验失败，
	// 于是重放窗口看到的序号一定是发送端真正签过的序号。
	var aad [SeqLen]byte
	binary.BigEndian.PutUint32(aad[:], seq)
	return s.aead.Seal(out, nonce, plaintext, aad[:]), nil
}

// Open 校验并解开封套，同时用 w 做防重放检查。
func (s *Sealer) Open(w *ReplayWindow, sealed []byte) (uint32, []byte, error) {
	if len(sealed) < SeqLen+NonceLen+s.aead.Overhead() {
		return 0, nil, ErrShortSeal
	}
	seq := binary.BigEndian.Uint32(sealed[0:SeqLen])
	nonce := sealed[SeqLen : SeqLen+NonceLen]
	var aad [SeqLen]byte
	binary.BigEndian.PutUint32(aad[:], seq)
	plaintext, err := s.aead.Open(nil, nonce, sealed[SeqLen+NonceLen:], aad[:])
	if err != nil {
		return 0, nil, ErrBadTag
	}
	// 只有 tag 校验通过后才推进窗口：否则攻击者可用伪造的序号把窗口顶飞，
	// 让合法包被误判为「过旧」。
	if !w.Accept(seq) {
		return 0, nil, ErrReplay
	}
	return seq, plaintext, nil
}

// ReplayWindow 是一个 64 位滑动窗口，记录最近见过的序号。收到 seq 时：
// 高于窗口右沿 → 右移并置位；落在窗口内且未见过 → 置位；已见过或低于
// 左沿 → 拒绝。这是 IPsec/DTLS 里抗重放的标准做法。
type ReplayWindow struct {
	highest uint32
	bitmap  uint64
	init    bool
}

// Accept 判断 seq 是否新鲜，并把窗口推进到包含它。
func (w *ReplayWindow) Accept(seq uint32) bool {
	if !w.init {
		w.init = true
		w.highest = seq
		w.bitmap = 1
		return true
	}
	if seq > w.highest {
		if shift := seq - w.highest; shift >= 64 {
			w.bitmap = 1
		} else {
			w.bitmap = (w.bitmap << shift) | 1
		}
		w.highest = seq
		return true
	}
	diff := w.highest - seq
	if diff >= 64 {
		return false // 落在窗口左沿之外，过旧
	}
	mask := uint64(1) << diff
	if w.bitmap&mask != 0 {
		return false // 已经见过
	}
	w.bitmap |= mask
	return true
}

// DeriveKey 从握手密钥材料派生一把 32 字节方向密钥。
// 用 HMAC-SHA256 做一次带方向标签的派生——label 不同则密钥不同，
// 于是 c2s 与 s2c 各有一把独立密钥，(key, nonce) 不会跨方向复用。
func DeriveKey(secret []byte, label string) []byte {
	mac := hmac.New(sha256.New, secret)
	mac.Write([]byte(label))
	return mac.Sum(nil) // 32 字节，正好一把 AES-256 密钥
}

c2s := DeriveKey(secret, "c2s")   // 客户端 → 服务端
s2c := DeriveKey(secret, "s2c")   // 服务端 → 客户端

// snippet: internal/guard/crypto_test.go（节选）

func TestSealDetectsTamper(t *testing.T) {
	s := mustSealer(t, testKey(3))
	sealed, _ := s.Seal(7, []byte("gold 1000"))
	sealed[len(sealed)-1] ^= 0x01 // 翻一个密文字节
	var w ReplayWindow
	if _, _, err := s.Open(&w, sealed); err != ErrBadTag {
		t.Fatalf("tampered open = %v, want ErrBadTag", err)
	}
}

func TestOpenRejectsReplay(t *testing.T) {
	s := mustSealer(t, testKey(7))
	sealed, _ := s.Seal(42, []byte("hi"))
	var w ReplayWindow
	if _, _, err := s.Open(&w, sealed); err != nil {
		t.Fatalf("first open: %v", err)
	}
	if _, _, err := s.Open(&w, sealed); err != ErrReplay {
		t.Fatalf("replay = %v, want ErrReplay", err)
	}
}