Files
ssw-mvp/scard/code/server/keyring/keyring.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

326 lines
7.8 KiB
Go

// Key management module - handles KEK/DEK management and incremental updates
package keyring
import (
"crypto/aes"
"crypto/cipher"
"crypto/rand"
"encoding/base64"
"encoding/json"
"errors"
"fmt"
"sync"
"time"
"security-connector/common/crypto"
"security-connector/common/proto"
)
// KeyRing manages device keys (KEK/DEK)
type KeyRing struct {
mu sync.RWMutex
// Device keys indexed by device ID
deviceKeys map[string]*DeviceKeys
// Key versions indexed by key ID
keyVersions map[string]int
}
// DeviceKeys holds all keys for a device
type DeviceKeys struct {
DeviceID string
KEK []byte // Key Encryption Key
DEK []byte // Data Encryption Key
KEKVersion int
DEKVersion int
CreatedAt time.Time
UpdatedAt time.Time
}
// NewKeyRing creates a new key ring manager
func NewKeyRing() *KeyRing {
return &KeyRing{
deviceKeys: make(map[string]*DeviceKeys),
keyVersions: make(map[string]int),
}
}
// InitializeDeviceKeys initializes keys for a new device
func (kr *KeyRing) InitializeDeviceKeys(deviceID string, kek []byte) (*DeviceKeys, error) {
kr.mu.Lock()
defer kr.mu.Unlock()
// Generate DEK
dek := make([]byte, crypto.AES256KeySize)
if _, err := rand.Read(dek); err != nil {
return nil, fmt.Errorf("failed to generate DEK: %w", err)
}
deviceKeys := &DeviceKeys{
DeviceID: deviceID,
KEK: kek,
DEK: dek,
KEKVersion: 1,
DEKVersion: 1,
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
}
kr.deviceKeys[deviceID] = deviceKeys
kr.keyVersions[fmt.Sprintf("KEK_%s", deviceID)] = 1
kr.keyVersions[fmt.Sprintf("DEK_%s", deviceID)] = 1
return deviceKeys, nil
}
// GetDeviceKeys retrieves keys for a device
func (kr *KeyRing) GetDeviceKeys(deviceID string) (*DeviceKeys, error) {
kr.mu.RLock()
defer kr.mu.RUnlock()
keys, exists := kr.deviceKeys[deviceID]
if !exists {
return nil, errors.New("device keys not found")
}
return keys, nil
}
// GetDEK retrieves the DEK for a device
func (kr *KeyRing) GetDEK(deviceID string) ([]byte, error) {
keys, err := kr.GetDeviceKeys(deviceID)
if err != nil {
return nil, err
}
return keys.DEK, nil
}
// UpdateKEK updates the KEK for a device
func (kr *KeyRing) UpdateKEK(deviceID string, newKEK []byte, version int) error {
kr.mu.Lock()
defer kr.mu.Unlock()
keys, exists := kr.deviceKeys[deviceID]
if !exists {
return errors.New("device keys not found")
}
// Re-encrypt DEK with new KEK
updatedDEK, err := crypto.EncryptAES256GCM(newKEK, keys.DEK, nil)
if err != nil {
return fmt.Errorf("failed to re-encrypt DEK: %w", err)
}
keys.KEK = newKEK
keys.DEK = updatedDEK
keys.KEKVersion = version
keys.UpdatedAt = time.Now()
return nil
}
// IncrementalKeyUpdate handles partial key updates
func (kr *KeyRing) IncrementalKeyUpdate(req *proto.KeyIncrementalUpdate) error {
kr.mu.Lock()
defer kr.mu.Unlock()
keys, exists := kr.deviceKeys[req.DeviceID]
if !exists {
return errors.New("device keys not found")
}
// Get current key version
keyVersion := kr.keyVersions[req.KeyID]
if req.KeyVersion <= keyVersion {
return errors.New("key version must be greater than current version")
}
// For KEK updates, apply partial update
if req.KeyID != "" && len(req.PartialUpdate.Data) > 0 {
partialData, err := base64.StdEncoding.DecodeString(req.PartialUpdate.Data)
if err != nil {
return fmt.Errorf("failed to decode partial data: %w", err)
}
// Apply partial update to the key
if len(partialData) != req.PartialUpdate.Length {
return errors.New("partial data length mismatch")
}
// Verify signature (simplified for Phase 1)
// In production, this would verify FPGA signature
// For now, just update the key version
kr.keyVersions[req.KeyID] = req.KeyVersion
// Update device keys timestamp
keys.UpdatedAt = time.Now()
}
return nil
}
// ExportEncryptedKeys exports device keys encrypted with a transport key
func (kr *KeyRing) ExportEncryptedKeys(deviceID string, transportKey []byte) ([]byte, error) {
kr.mu.RLock()
defer kr.mu.RUnlock()
keys, exists := kr.deviceKeys[deviceID]
if !exists {
return nil, errors.New("device keys not found")
}
// Create key bundle
bundle := struct {
KEK []byte `json:"kek"`
DEK []byte `json:"dek"`
KEKVersion int `json:"kek_version"`
DEKVersion int `json:"dek_version"`
EncryptedAt int64 `json:"encrypted_at"`
}{
KEK: keys.KEK,
DEK: keys.DEK,
KEKVersion: keys.KEKVersion,
DEKVersion: keys.DEKVersion,
EncryptedAt: time.Now().Unix(),
}
bundleJSON, err := json.Marshal(bundle)
if err != nil {
return nil, fmt.Errorf("failed to marshal key bundle: %w", err)
}
// Encrypt with transport key
ciphertext, err := crypto.EncryptAES256GCM(transportKey, bundleJSON, nil)
if err != nil {
return nil, fmt.Errorf("failed to encrypt key bundle: %w", err)
}
return ciphertext, nil
}
// ImportEncryptedKeys imports and decrypts device keys
func (kr *KeyRing) ImportEncryptedKeys(deviceID string, transportKey []byte, ciphertext []byte) error {
kr.mu.Lock()
defer kr.mu.Unlock()
// Decrypt bundle
bundleJSON, err := crypto.DecryptAES256GCM(transportKey, ciphertext, nil)
if err != nil {
return fmt.Errorf("failed to decrypt key bundle: %w", err)
}
var bundle struct {
KEK []byte `json:"kek"`
DEK []byte `json:"dek"`
KEKVersion int `json:"kek_version"`
DEKVersion int `json:"dek_version"`
}
if err := json.Unmarshal(bundleJSON, &bundle); err != nil {
return fmt.Errorf("failed to unmarshal key bundle: %w", err)
}
// Store keys
kr.deviceKeys[deviceID] = &DeviceKeys{
DeviceID: deviceID,
KEK: bundle.KEK,
DEK: bundle.DEK,
KEKVersion: bundle.KEKVersion,
DEKVersion: bundle.DEKVersion,
UpdatedAt: time.Now(),
}
return nil
}
// RotateDEK rotates the DEK for a device
func (kr *KeyRing) RotateDEK(deviceID string) error {
kr.mu.Lock()
defer kr.mu.Unlock()
keys, exists := kr.deviceKeys[deviceID]
if !exists {
return errors.New("device keys not found")
}
// Generate new DEK
newDEK := make([]byte, crypto.AES256KeySize)
if _, err := rand.Read(newDEK); err != nil {
return fmt.Errorf("failed to generate new DEK: %w", err)
}
// Re-encrypt new DEK with KEK
encryptedDEK, err := crypto.EncryptAES256GCM(keys.KEK, newDEK, nil)
if err != nil {
return fmt.Errorf("failed to encrypt new DEK: %w", err)
}
keys.DEK = encryptedDEK
keys.DEKVersion++
keys.UpdatedAt = time.Now()
kr.keyVersions[fmt.Sprintf("DEK_%s", deviceID)] = keys.DEKVersion
return nil
}
// GetKeyVersion gets the current version of a key
func (kr *KeyRing) GetKeyVersion(keyID string) int {
kr.mu.RLock()
defer kr.mu.RUnlock()
return kr.keyVersions[keyID]
}
// SealKey seals a key with TPM SRK (simplified for Phase 1)
func (kr *KeyRing) SealKey(key []byte, srk []byte) ([]byte, error) {
// Simplified sealing - in production use TPM2_Seal
// For Phase 1, we use AES encryption as a stand-in
block, err := aes.NewCipher(srk)
if err != nil {
return nil, err
}
gcm, err := cipher.NewGCM(block)
if err != nil {
return nil, err
}
nonce := make([]byte, gcm.NonceSize())
if _, err := rand.Read(nonce); err != nil {
return nil, err
}
ciphertext := gcm.Seal(nonce, nonce, key, nil)
return ciphertext, nil
}
// UnsealKey unseals a key with TPM SRK (simplified for Phase 1)
func (kr *KeyRing) UnsealKey(sealedKey []byte, srk []byte) ([]byte, error) {
// Simplified unsealing - in production use TPM2_Unseal
block, err := aes.NewCipher(srk)
if err != nil {
return nil, err
}
gcm, err := cipher.NewGCM(block)
if err != nil {
return nil, err
}
nonceSize := gcm.NonceSize()
if len(sealedKey) < nonceSize {
return nil, errors.New("sealed key too short")
}
nonce, ciphertext := sealedKey[:nonceSize], sealedKey[nonceSize:]
plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)
if err != nil {
return nil, err
}
return plaintext, nil
}