- 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
291 lines
7.6 KiB
Go
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
|
|
} |