Files
ssw-mvp/scard/code/server/keyring/keyring_test.go
T
admin 3247e9fd15 init: ssw-mvp initial commit
- boot/ (Java/Maven, JNPF 7.0) — 移除旧的 boot/.git,源码直接纳入仓库
- web/ (Vue 3 + Vite + Ant Design Vue, pnpm)
- docs/, scard/, nax/
- refs/INDEX.md + refs/国标/(其余 refs/* 开源子仓库不纳入)
- 已忽略: connector_data/, jweb/, log/, web/{dist,node_modules,.pnpm}, boot/*/target/, .DS_Store, .idea, .vscode
2026-08-05 18:29:12 +08:00

283 lines
6.0 KiB
Go

package keyring
import (
"crypto/rand"
"testing"
"security-connector/common/proto"
)
func TestNewKeyRing(t *testing.T) {
kr := NewKeyRing()
if kr == nil {
t.Fatal("KeyRing should not be nil")
}
if kr.deviceKeys == nil {
t.Error("DeviceKeys map should be initialized")
}
if kr.keyVersions == nil {
t.Error("KeyVersions map should be initialized")
}
}
func TestInitializeDeviceKeys(t *testing.T) {
kr := NewKeyRing()
kek := make([]byte, 32)
rand.Read(kek)
keys, err := kr.InitializeDeviceKeys("DEV_test_001", kek)
if err != nil {
t.Fatalf("InitializeDeviceKeys failed: %v", err)
}
if keys.DeviceID != "DEV_test_001" {
t.Errorf("DeviceID mismatch")
}
if len(keys.KEK) != 32 {
t.Error("KEK should be 32 bytes")
}
if len(keys.DEK) != 32 {
t.Error("DEK should be 32 bytes")
}
if keys.KEKVersion != 1 {
t.Errorf("KEKVersion should be 1, got %d", keys.KEKVersion)
}
if keys.DEKVersion != 1 {
t.Errorf("DEKVersion should be 1, got %d", keys.DEKVersion)
}
}
func TestGetDeviceKeys(t *testing.T) {
kr := NewKeyRing()
kek := make([]byte, 32)
rand.Read(kek)
kr.InitializeDeviceKeys("DEV_test_001", kek)
keys, err := kr.GetDeviceKeys("DEV_test_001")
if err != nil {
t.Fatalf("GetDeviceKeys failed: %v", err)
}
if keys.DeviceID != "DEV_test_001" {
t.Errorf("DeviceID mismatch")
}
}
func TestGetDeviceKeysNotFound(t *testing.T) {
kr := NewKeyRing()
_, err := kr.GetDeviceKeys("nonexistent")
if err == nil {
t.Error("GetDeviceKeys should fail for nonexistent device")
}
}
func TestGetDEK(t *testing.T) {
kr := NewKeyRing()
kek := make([]byte, 32)
rand.Read(kek)
kr.InitializeDeviceKeys("DEV_test_001", kek)
dek, err := kr.GetDEK("DEV_test_001")
if err != nil {
t.Fatalf("GetDEK failed: %v", err)
}
if len(dek) == 0 {
t.Error("DEK should not be empty")
}
}
func TestUpdateKEK(t *testing.T) {
kr := NewKeyRing()
kek := make([]byte, 32)
rand.Read(kek)
kr.InitializeDeviceKeys("DEV_test_001", kek)
newKEK := make([]byte, 32)
rand.Read(newKEK)
if err := kr.UpdateKEK("DEV_test_001", newKEK, 2); err != nil {
t.Fatalf("UpdateKEK failed: %v", err)
}
keys, _ := kr.GetDeviceKeys("DEV_test_001")
if keys.KEKVersion != 2 {
t.Errorf("KEKVersion should be 2, got %d", keys.KEKVersion)
}
}
func TestUpdateKEKNotFound(t *testing.T) {
kr := NewKeyRing()
newKEK := make([]byte, 32)
rand.Read(newKEK)
if err := kr.UpdateKEK("nonexistent", newKEK, 1); err == nil {
t.Error("UpdateKEK should fail for nonexistent device")
}
}
func TestIncrementalKeyUpdate(t *testing.T) {
kr := NewKeyRing()
kek := make([]byte, 32)
rand.Read(kek)
kr.InitializeDeviceKeys("DEV_test_001", kek)
req := &proto.KeyIncrementalUpdate{
DeviceID: "DEV_test_001",
KeyVersion: 5,
KeyID: "KEK_DEV_test_001",
PartialUpdate: proto.PartialKey{
Offset: 16,
Length: 15,
Data: "c29sdmVyYW5kb20ta2V5",
},
}
if err := kr.IncrementalKeyUpdate(req); err != nil {
t.Fatalf("IncrementalKeyUpdate failed: %v", err)
}
}
func TestIncrementalKeyUpdateVersionTooLow(t *testing.T) {
kr := NewKeyRing()
kek := make([]byte, 32)
rand.Read(kek)
kr.InitializeDeviceKeys("DEV_test_001", kek)
req := &proto.KeyIncrementalUpdate{
DeviceID: "DEV_test_001",
KeyVersion: 0, // Too low
KeyID: "KEK_DEV_test_001",
}
if err := kr.IncrementalKeyUpdate(req); err == nil {
t.Error("IncrementalKeyUpdate should fail for version <= current")
}
}
func TestExportImportEncryptedKeys(t *testing.T) {
kr := NewKeyRing()
kek := make([]byte, 32)
rand.Read(kek)
kr.InitializeDeviceKeys("DEV_test_001", kek)
transportKey := make([]byte, 32)
rand.Read(transportKey)
// Export
ciphertext, err := kr.ExportEncryptedKeys("DEV_test_001", transportKey)
if err != nil {
t.Fatalf("ExportEncryptedKeys failed: %v", err)
}
// Create new keyring and import
kr2 := NewKeyRing()
if err := kr2.ImportEncryptedKeys("DEV_test_001", transportKey, ciphertext); err != nil {
t.Fatalf("ImportEncryptedKeys failed: %v", err)
}
// Verify keys match
origKeys, _ := kr.GetDeviceKeys("DEV_test_001")
importedKeys, _ := kr2.GetDeviceKeys("DEV_test_001")
if importedKeys.KEKVersion != origKeys.KEKVersion {
t.Errorf("KEKVersion mismatch after import")
}
}
func TestRotateDEK(t *testing.T) {
kr := NewKeyRing()
kek := make([]byte, 32)
rand.Read(kek)
kr.InitializeDeviceKeys("DEV_test_001", kek)
// Get original DEK
origDEK, _ := kr.GetDEK("DEV_test_001")
// Rotate
if err := kr.RotateDEK("DEV_test_001"); err != nil {
t.Fatalf("RotateDEK failed: %v", err)
}
// Get new DEK
newDEK, _ := kr.GetDEK("DEV_test_001")
// DEK should be different (encrypted form, so just check version)
keys, _ := kr.GetDeviceKeys("DEV_test_001")
if keys.DEKVersion != 2 {
t.Errorf("DEKVersion should be 2, got %d", keys.DEKVersion)
}
_ = origDEK
_ = newDEK
}
func TestRotateDEKNotFound(t *testing.T) {
kr := NewKeyRing()
if err := kr.RotateDEK("nonexistent"); err == nil {
t.Error("RotateDEK should fail for nonexistent device")
}
}
func TestGetKeyVersion(t *testing.T) {
kr := NewKeyRing()
kek := make([]byte, 32)
rand.Read(kek)
kr.InitializeDeviceKeys("DEV_test_001", kek)
version := kr.GetKeyVersion("KEK_DEV_test_001")
if version != 1 {
t.Errorf("KeyVersion should be 1, got %d", version)
}
}
func TestSealUnsealKey(t *testing.T) {
kr := NewKeyRing()
key := []byte("secret_data_to_seal")
srk := make([]byte, 32) // Use a 32-byte key as SRK substitute
rand.Read(srk)
// Seal
sealed, err := kr.SealKey(key, srk)
if err != nil {
t.Fatalf("SealKey failed: %v", err)
}
// Unseal
unsealed, err := kr.UnsealKey(sealed, srk)
if err != nil {
t.Fatalf("UnsealKey failed: %v", err)
}
if string(unsealed) != string(key) {
t.Error("Unsealed key does not match original")
}
}
func TestSealUnsealKeyWrongKey(t *testing.T) {
kr := NewKeyRing()
key := []byte("secret_data")
srk1 := make([]byte, 32)
srk2 := make([]byte, 32)
rand.Read(srk1)
rand.Read(srk2)
sealed, _ := kr.SealKey(key, srk1)
_, err := kr.UnsealKey(sealed, srk2)
if err == nil {
t.Error("Unseal should fail with wrong key")
}
}