- 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
283 lines
6.0 KiB
Go
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")
|
|
}
|
|
} |