- 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
326 lines
7.8 KiB
Go
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
|
|
} |