Files
go-sms-V2/internal/util/crypto_test.go
T

108 lines
3.0 KiB
Go

package util
import (
"strings"
"testing"
)
// TestEncryptAESGCM_RoundTrip 验证加解密往返与随机 nonce。
func TestEncryptAESGCM_RoundTrip(t *testing.T) {
key := DeriveKey("day8-secret")
plaintext := []byte(`{"api_key":"go-sms-12345","mobile":"13800138000"}`)
c1, err := EncryptAESGCM(key, plaintext)
if err != nil {
t.Fatal(err)
}
c2, _ := EncryptAESGCM(key, plaintext)
if string(c1) == string(c2) {
t.Error("随机 nonce 下两次密文不应相同")
}
got, err := DecryptAESGCM(key, c1)
if err != nil || string(got) != string(plaintext) {
t.Fatalf("往返失败: (%q, %v)", got, err)
}
}
// TestEncryptAESGCM_KeyLength 验证密钥长度校验。
func TestEncryptAESGCM_KeyLength(t *testing.T) {
for _, n := range []int{0, 8, 15, 17, 24 + 1, 33} {
if _, err := EncryptAESGCM(make([]byte, n), []byte("x")); err == nil {
t.Errorf("密钥长度 %d 应报错", n)
}
}
for _, n := range []int{16, 24, 32} {
if _, err := EncryptAESGCM(make([]byte, n), []byte("x")); err != nil {
t.Errorf("密钥长度 %d 不应报错: %v", n, err)
}
}
}
// TestDecryptAESGCM_Tampered 验证 GCM 完整性校验(篡改即失败)。
func TestDecryptAESGCM_Tampered(t *testing.T) {
key := DeriveKey("k")
c, _ := EncryptAESGCM(key, []byte("payload"))
c[len(c)-1] ^= 0xFF // 篡改末字节
if _, err := DecryptAESGCM(key, c); err == nil {
t.Error("篡改密文应解密失败")
}
if _, err := DecryptAESGCM(DeriveKey("other"), c); err == nil {
t.Error("错误密钥应解密失败")
}
if _, err := DecryptAESGCM(key, []byte("short")); err == nil {
t.Error("过短密文应报错")
}
}
// TestSecretHelpers 验证 base64 便捷封装。
func TestSecretHelpers(t *testing.T) {
enc, err := EncryptSecret("passphrase", "go-sms-Api-Key-123")
if err != nil {
t.Fatal(err)
}
if strings.Contains(enc, "go-sms-Api-Key-123") {
t.Error("密文不应包含明文")
}
got, err := DecryptSecret("passphrase", enc)
if err != nil || got != "go-sms-Api-Key-123" {
t.Fatalf("往返失败: (%q, %v)", got, err)
}
if _, err := DecryptSecret("wrong", enc); err == nil {
t.Error("错误口令应失败")
}
if _, err := DecryptSecret("p", "not-base64!!"); err == nil {
t.Error("非法 base64 应失败")
}
}
// TestRandomHex 验证随机串长度、字符集与唯一性。
func TestRandomHex(t *testing.T) {
if _, err := RandomHex(0); err == nil {
t.Error("n=0 应报错")
}
s, err := RandomHex(16)
if err != nil || len(s) != 32 {
t.Fatalf("RandomHex(16) = (%q,%v), 期望 32 字符", s, err)
}
seen := map[string]struct{}{}
for i := 0; i < 1000; i++ {
h, _ := RandomHex(8)
if _, dup := seen[h]; dup {
t.Fatalf("随机串重复: %s", h)
}
seen[h] = struct{}{}
}
}
// TestDeriveKey 验证密钥派生稳定性与长度。
func TestDeriveKey(t *testing.T) {
k1, k2 := DeriveKey("abc"), DeriveKey("abc")
if len(k1) != 32 || string(k1) != string(k2) {
t.Fatal("同口令应稳定派生 32 字节密钥")
}
if string(DeriveKey("abd")) == string(k1) {
t.Fatal("不同口令应派生不同密钥")
}
}