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

291 lines
7.6 KiB
Go

// Server-side cryptographic operations for security connector
// Handles ECDH key exchange, KEK generation, session key derivation
package crypto
import (
"crypto/ecdsa"
"crypto/elliptic"
"crypto/rand"
"crypto/x509"
"encoding/pem"
"errors"
"fmt"
"sync"
"security-connector/common/crypto"
)
// ServerKeyManager manages server-side cryptographic keys
type ServerKeyManager struct {
mu sync.RWMutex
// Cipher suite (GM or International)
cipherSuite crypto.CipherSuite
// Server's ECDH key pair for key exchange
serverECDH *ecdsa.PrivateKey
// Server's SM2 key pair (used when GM cipher suite is active)
serverSM2 *crypto.SM2PrivateKey
// Root key (HSM-level) - used to derive KEKs
rootKey []byte
// Device-specific KEKs (key encryption keys)
deviceKEKs map[string]*DeviceKEK
// Root certificate
rootCert *x509.Certificate
}
// DeviceKEK represents a device's KEK
type DeviceKEK struct {
KeyID string
DeviceID string
Version int
Key []byte // Encrypted with root key
CreatedAt int64
}
// NewServerKeyManager creates a new server key manager
func NewServerKeyManager(cipherSuiteType crypto.CipherSuiteType) (*ServerKeyManager, error) {
skm := &ServerKeyManager{
deviceKEKs: make(map[string]*DeviceKEK),
cipherSuite: crypto.GetCipherSuiteByType(cipherSuiteType),
}
// Generate server key pair based on cipher suite
if err := skm.generateServerKeyPair(); err != nil {
return nil, fmt.Errorf("failed to generate server key pair: %w", err)
}
// Generate root key (in production, this would come from HSM)
if err := skm.GenerateRootKey(); err != nil {
return nil, fmt.Errorf("failed to generate root key: %w", err)
}
return skm, nil
}
// generateServerKeyPair generates the server's key pair based on cipher suite
func (skm *ServerKeyManager) generateServerKeyPair() error {
skm.mu.Lock()
defer skm.mu.Unlock()
if skm.cipherSuite.GetType() == crypto.CipherSuiteGM {
// Generate SM2 key pair for GM mode
sm2Key, err := crypto.GenerateSM2Key()
if err != nil {
return err
}
skm.serverSM2 = sm2Key
} else {
// Generate ECDH P-256 key pair for International mode
privateKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
if err != nil {
return err
}
skm.serverECDH = privateKey
}
return nil
}
// GenerateRootKey generates the root key (simplified for Phase 1)
func (skm *ServerKeyManager) GenerateRootKey() error {
skm.mu.Lock()
defer skm.mu.Unlock()
// Generate a random root key (in production, this comes from HSM)
rootKey := make([]byte, crypto.AES256KeySize)
if _, err := rand.Read(rootKey); err != nil {
return err
}
skm.rootKey = rootKey
return nil
}
// GetServerPublicKey returns the server's ECDH public key
func (skm *ServerKeyManager) GetServerPublicKey() ([]byte, error) {
skm.mu.RLock()
defer skm.mu.RUnlock()
if skm.cipherSuite.GetType() == crypto.CipherSuiteGM {
if skm.serverSM2 == nil {
return nil, errors.New("server SM2 key not initialized")
}
return crypto.EncodeSM2PublicKey(skm.serverSM2.PublicKey)
} else {
if skm.serverECDH == nil {
return nil, errors.New("server ECDH key not initialized")
}
return x509.MarshalPKIXPublicKey(&skm.serverECDH.PublicKey)
}
}
// GetServerPrivateKey returns the server's ECDH private key
func (skm *ServerKeyManager) GetServerPrivateKey() *ecdsa.PrivateKey {
skm.mu.RLock()
defer skm.mu.RUnlock()
return skm.serverECDH
}
// DeriveDeviceKEK derives a KEK for a specific device using ECDH
func (skm *ServerKeyManager) DeriveDeviceKEK(deviceID string, devicePublicKey interface{}) (*DeviceKEK, error) {
skm.mu.Lock()
defer skm.mu.Unlock()
var sharedSecret []byte
if skm.cipherSuite.GetType() == crypto.CipherSuiteGM {
// Use SM2 ECDH
sm2PubKey, ok := devicePublicKey.(*crypto.SM2PublicKey)
if !ok {
return nil, fmt.Errorf("expected SM2 public key for GM mode")
}
var err error
sharedSecret, err = crypto.SM2ECDH(skm.serverSM2, sm2PubKey)
if err != nil {
return nil, fmt.Errorf("SM2 ECDH failed: %w", err)
}
} else {
// Use P-256 ECDH
ecdsaPubKey, ok := devicePublicKey.(*ecdsa.PublicKey)
if !ok {
return nil, fmt.Errorf("expected ECDSA public key for international mode")
}
sharedX, _ := skm.serverECDH.Curve.ScalarMult(ecdsaPubKey.X, ecdsaPubKey.Y, skm.serverECDH.D.Bytes())
if sharedX == nil {
return nil, errors.New("ECDH failed: shared point is at infinity")
}
sharedSecret = sharedX.Bytes()
}
// Derive KEK using HKDF
kek, err := skm.cipherSuite.DeriveKey(nil, sharedSecret, crypto.HKDFInfoKEK, crypto.AES256KeySize)
if err != nil {
return nil, err
}
// Create device KEK entry
kekEntry := &DeviceKEK{
KeyID: fmt.Sprintf("KEK_%s_001", deviceID),
DeviceID: deviceID,
Version: 1,
Key: kek,
CreatedAt: 0,
}
skm.deviceKEKs[deviceID] = kekEntry
return kekEntry, nil
}
// GetDeviceKEK retrieves a device's KEK
func (skm *ServerKeyManager) GetDeviceKEK(deviceID string) (*DeviceKEK, error) {
skm.mu.RLock()
defer skm.mu.RUnlock()
kek, exists := skm.deviceKEKs[deviceID]
if !exists {
return nil, fmt.Errorf("KEK not found for device: %s", deviceID)
}
return kek, nil
}
// DeriveSessionKey derives a session key from master secret
func (skm *ServerKeyManager) DeriveSessionKey(masterSecret []byte, deviceID string) ([]byte, error) {
skm.mu.RLock()
defer skm.mu.RUnlock()
info := fmt.Sprintf("session_%s", deviceID)
return crypto.DeriveKey(nil, masterSecret, info, crypto.AES256KeySize)
}
// EncryptKEKForDevice encrypts the KEK with the session key
func (skm *ServerKeyManager) EncryptKEKForDevice(kek *DeviceKEK, sessionKey []byte) ([]byte, error) {
ciphertext, err := skm.cipherSuite.Encrypt(sessionKey, kek.Key, nil)
if err != nil {
return nil, fmt.Errorf("failed to encrypt KEK: %w", err)
}
return ciphertext, nil
}
// SignData signs data using the server's private key
func (skm *ServerKeyManager) SignData(data []byte) ([]byte, error) {
skm.mu.RLock()
defer skm.mu.RUnlock()
return crypto.Sign(skm.serverECDH, data)
}
// VerifyDeviceSignature verifies a signature from a device
func (skm *ServerKeyManager) VerifyDeviceSignature(devicePublicKey *ecdsa.PublicKey, data []byte, signature []byte) bool {
return crypto.Verify(devicePublicKey, data, signature)
}
// GenerateNonce generates a random nonce
func (skm *ServerKeyManager) GenerateNonce() ([]byte, error) {
return crypto.GenerateNonce(32)
}
// EncryptKeyBundle creates an encrypted key bundle for device
func (skm *ServerKeyManager) EncryptKeyBundle(deviceID string, sessionKey []byte) ([]byte, int, error) {
kek, err := skm.GetDeviceKEK(deviceID)
if err != nil {
return nil, 0, err
}
// Encrypt KEK with session key using cipher suite
encryptedKEK, err := skm.cipherSuite.Encrypt(sessionKey, kek.Key, nil)
if err != nil {
return nil, 0, fmt.Errorf("failed to encrypt KEK: %w", err)
}
// Create bundle
bundle := struct {
EncryptedKEK []byte `json:"encrypted_kek"`
KEKVersion int `json:"kek_version"`
}{
EncryptedKEK: encryptedKEK,
KEKVersion: kek.Version,
}
return []byte(fmt.Sprintf("%v", bundle)), kek.Version, nil
}
// PEM encode helpers
// EncodePublicKeyPEM encodes a public key to PEM format
func EncodePublicKeyPEM(key *ecdsa.PublicKey) ([]byte, error) {
derBytes, err := x509.MarshalPKIXPublicKey(key)
if err != nil {
return nil, err
}
block := &pem.Block{
Type: "PUBLIC KEY",
Bytes: derBytes,
}
return pem.EncodeToMemory(block), nil
}
// EncodePrivateKeyPEM encodes a private key to PEM format
func EncodePrivateKeyPEM(key *ecdsa.PrivateKey) ([]byte, error) {
derBytes, err := x509.MarshalECPrivateKey(key)
if err != nil {
return nil, err
}
block := &pem.Block{
Type: "EC PRIVATE KEY",
Bytes: derBytes,
}
return pem.EncodeToMemory(block), nil
}