- 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
1860 lines
54 KiB
Go
1860 lines
54 KiB
Go
package e2e
|
|
|
|
import (
|
|
"context"
|
|
"crypto/ecdsa"
|
|
"crypto/elliptic"
|
|
"crypto/rand"
|
|
"crypto/x509"
|
|
"crypto/x509/pkix"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"encoding/pem"
|
|
"fmt"
|
|
"io"
|
|
"math/big"
|
|
"net"
|
|
"net/http"
|
|
"sync"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
|
|
"security-connector/common/crypto"
|
|
"security-connector/common/proto"
|
|
"security-connector/common/types"
|
|
"security-connector/connector/keys"
|
|
"security-connector/connector/tpm"
|
|
serverCrypto "security-connector/server/crypto"
|
|
)
|
|
|
|
// TestConfiguration holds the configuration for E2E tests
|
|
type TestConfiguration struct {
|
|
ServerPort int
|
|
}
|
|
|
|
// Global test configuration
|
|
var (
|
|
serverPort int32 = 19999
|
|
)
|
|
|
|
// findFreePort finds a free port on localhost
|
|
func findFreePort(start int) (int, error) {
|
|
for port := start; port < start+100; port++ {
|
|
addr := fmt.Sprintf("localhost:%d", port)
|
|
ln, err := net.Listen("tcp", addr)
|
|
if err == nil {
|
|
ln.Close()
|
|
return port, nil
|
|
}
|
|
}
|
|
return 0, fmt.Errorf("could not find free port")
|
|
}
|
|
|
|
// GenerateTestCertificate generates a self-signed certificate for testing
|
|
func GenerateTestCertificate() ([]byte, []byte, error) {
|
|
privKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
template := x509.Certificate{
|
|
SerialNumber: big.NewInt(1),
|
|
Subject: pkix.Name{
|
|
Organization: []string{"Test"},
|
|
},
|
|
NotBefore: time.Now(),
|
|
NotAfter: time.Now().Add(24 * time.Hour),
|
|
KeyUsage: x509.KeyUsageDigitalSignature,
|
|
ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
|
|
BasicConstraintsValid: true,
|
|
IPAddresses: []net.IP{net.ParseIP("127.0.0.1")},
|
|
}
|
|
|
|
certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, &privKey.PublicKey, privKey)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER})
|
|
keyPEM := pem.EncodeToMemory(&pem.Block{Type: "EC PRIVATE KEY", Bytes: mustMarshalECPrivateKey(privKey)})
|
|
|
|
return certPEM, keyPEM, nil
|
|
}
|
|
|
|
func mustMarshalECPrivateKey(priv *ecdsa.PrivateKey) []byte {
|
|
keyBytes, err := x509.MarshalECPrivateKey(priv)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return keyBytes
|
|
}
|
|
|
|
// MockServer is a simple HTTP server for testing
|
|
type MockServer struct {
|
|
t *testing.T
|
|
server *http.Server
|
|
port int
|
|
auth *MockAuthenticator
|
|
keyManager *serverCrypto.ServerKeyManager
|
|
deviceCount int32
|
|
}
|
|
|
|
// NewMockServer creates a new mock server for testing
|
|
func NewMockServer(t *testing.T, port int) *MockServer {
|
|
km, _ := serverCrypto.NewServerKeyManager(crypto.CipherSuiteInternational)
|
|
|
|
server := &MockServer{
|
|
t: t,
|
|
port: port,
|
|
auth: NewMockAuthenticator(km),
|
|
keyManager: km,
|
|
}
|
|
|
|
mux := http.NewServeMux()
|
|
mux.HandleFunc("/api/v1/device/register", server.handleRegister)
|
|
mux.HandleFunc("/api/v1/device/challenge", server.handleChallenge)
|
|
mux.HandleFunc("/api/v1/device/auth", server.handleAuth)
|
|
mux.HandleFunc("/api/v1/connector/cross_session", server.handleCrossSession)
|
|
|
|
server.server = &http.Server{
|
|
Handler: mux,
|
|
}
|
|
|
|
return server
|
|
}
|
|
|
|
func (s *MockServer) Start() error {
|
|
ln, err := net.Listen("tcp", fmt.Sprintf("localhost:%d", s.port))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
go s.server.Serve(ln)
|
|
return nil
|
|
}
|
|
|
|
func (s *MockServer) Stop() {
|
|
s.server.Shutdown(context.Background())
|
|
}
|
|
|
|
func (s *MockServer) handleRegister(w http.ResponseWriter, r *http.Request) {
|
|
var req proto.RegisterRequest
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
resp, err := s.auth.RegisterDevice(&req)
|
|
if err != nil {
|
|
resp := proto.NewErrorResponse(proto.TypeRegisterResponse, proto.ErrInternalError, err.Error())
|
|
json.NewEncoder(w).Encode(resp)
|
|
return
|
|
}
|
|
|
|
json.NewEncoder(w).Encode(resp)
|
|
}
|
|
|
|
func (s *MockServer) handleChallenge(w http.ResponseWriter, r *http.Request) {
|
|
var req proto.APIRequest
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
resp, err := s.auth.CreateChallenge(req.DeviceID)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
json.NewEncoder(w).Encode(resp)
|
|
}
|
|
|
|
func (s *MockServer) handleAuth(w http.ResponseWriter, r *http.Request) {
|
|
var req proto.ChallengeResponse
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
resp, err := s.auth.VerifyChallengeResponse(req.DeviceID, &req)
|
|
if err != nil {
|
|
resp := proto.NewErrorResponse(proto.TypeAuthResponse, proto.ErrAuthFailed, err.Error())
|
|
json.NewEncoder(w).Encode(resp)
|
|
return
|
|
}
|
|
|
|
json.NewEncoder(w).Encode(resp)
|
|
}
|
|
|
|
func (s *MockServer) handleCrossSession(w http.ResponseWriter, r *http.Request) {
|
|
var req proto.CrossSessionRequest
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
resp, err := s.auth.RequestCrossSession(&req)
|
|
if err != nil {
|
|
resp := proto.NewErrorResponse(proto.TypeCrossSessionResponse, proto.ErrInternalError, err.Error())
|
|
json.NewEncoder(w).Encode(resp)
|
|
return
|
|
}
|
|
|
|
json.NewEncoder(w).Encode(resp)
|
|
}
|
|
|
|
// MockAuthenticator is a simplified authenticator for testing
|
|
type MockAuthenticator struct {
|
|
mu sync.RWMutex
|
|
devices map[string]*types.Device
|
|
challenges map[string]*types.Challenge
|
|
keyManager *serverCrypto.ServerKeyManager
|
|
|
|
// Cross-session session cache: key = "sourceID-targetID", value = cross SK
|
|
crossSessions map[string][]byte
|
|
}
|
|
|
|
func NewMockAuthenticator(km *serverCrypto.ServerKeyManager) *MockAuthenticator {
|
|
return &MockAuthenticator{
|
|
devices: make(map[string]*types.Device),
|
|
challenges: make(map[string]*types.Challenge),
|
|
keyManager: km,
|
|
crossSessions: make(map[string][]byte),
|
|
}
|
|
}
|
|
|
|
func (a *MockAuthenticator) RegisterDevice(req *proto.RegisterRequest) (*proto.RegisterResponse, error) {
|
|
a.mu.Lock()
|
|
defer a.mu.Unlock()
|
|
|
|
// Parse device public key
|
|
devicePubKeyBytes, err := base64.StdEncoding.DecodeString(req.TPMPublicKey)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("invalid TPM public key: %w", err)
|
|
}
|
|
|
|
devicePubKey, err := crypto.ParsePublicKey(devicePubKeyBytes)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to parse device public key: %w", err)
|
|
}
|
|
|
|
// Derive KEK
|
|
kek, err := a.keyManager.DeriveDeviceKEK(req.DeviceID, devicePubKey)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to derive KEK: %w", err)
|
|
}
|
|
|
|
// Generate session key
|
|
sessionKey, err := crypto.DeriveKey(nil, kek.Key, crypto.HKDFInfoSession, crypto.AES256KeySize)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to derive session key: %w", err)
|
|
}
|
|
|
|
// Encrypt KEK with session key (simplified)
|
|
encryptedKEK, err := a.keyManager.EncryptKEKForDevice(kek, sessionKey)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to encrypt KEK: %w", err)
|
|
}
|
|
|
|
// Get server public key
|
|
serverPubKey, err := a.keyManager.GetServerPublicKey()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get server public key: %w", err)
|
|
}
|
|
|
|
// Create device entry
|
|
device := &types.Device{
|
|
DeviceID: req.DeviceID,
|
|
Status: types.StatusPending,
|
|
TPMPublicKey: req.TPMPublicKey,
|
|
KeyVersion: kek.Version,
|
|
KEKID: kek.KeyID,
|
|
FirmwareHash: req.FirmwareHash,
|
|
CreatedAt: time.Now(),
|
|
UpdatedAt: time.Now(),
|
|
}
|
|
a.devices[req.DeviceID] = device
|
|
|
|
return &proto.RegisterResponse{
|
|
APIResponse: *proto.NewSuccessResponse(proto.TypeRegisterResponse),
|
|
EncryptedKEK: base64.StdEncoding.EncodeToString(encryptedKEK),
|
|
KEKVersion: kek.Version,
|
|
ServerPublicKey: base64.StdEncoding.EncodeToString(serverPubKey),
|
|
ValidUntil: time.Now().Add(24 * time.Hour).Unix(),
|
|
}, nil
|
|
}
|
|
|
|
func (a *MockAuthenticator) CreateChallenge(deviceID string) (*proto.ChallengeRequest, error) {
|
|
a.mu.Lock()
|
|
defer a.mu.Unlock()
|
|
|
|
device, exists := a.devices[deviceID]
|
|
if !exists {
|
|
return nil, fmt.Errorf("device not found: %s", deviceID)
|
|
}
|
|
|
|
nonce, _ := crypto.GenerateNonce(32)
|
|
challenge, _ := crypto.GenerateNonce(32)
|
|
|
|
a.challenges[deviceID] = &types.Challenge{
|
|
DeviceID: deviceID,
|
|
Nonce: nonce,
|
|
Challenge: challenge,
|
|
ExpiresAt: time.Now().Add(5 * time.Minute),
|
|
Used: false,
|
|
}
|
|
|
|
device.LastAuthAt = nil
|
|
device.UpdatedAt = time.Now()
|
|
|
|
return &proto.ChallengeRequest{
|
|
APIRequest: proto.APIRequest{
|
|
Type: proto.TypeChallengeRequest,
|
|
DeviceID: deviceID,
|
|
},
|
|
Nonce: base64.StdEncoding.EncodeToString(nonce),
|
|
Challenge: base64.StdEncoding.EncodeToString(challenge),
|
|
ExpireAt: time.Now().Add(5 * time.Minute).Unix(),
|
|
}, nil
|
|
}
|
|
|
|
func (a *MockAuthenticator) VerifyChallengeResponse(deviceID string, resp *proto.ChallengeResponse) (*proto.AuthResponse, error) {
|
|
a.mu.Lock()
|
|
defer a.mu.Unlock()
|
|
|
|
challenge, exists := a.challenges[deviceID]
|
|
if !exists {
|
|
return nil, fmt.Errorf("no active challenge found")
|
|
}
|
|
|
|
if time.Now().After(challenge.ExpiresAt) {
|
|
delete(a.challenges, deviceID)
|
|
return nil, fmt.Errorf("challenge expired")
|
|
}
|
|
|
|
if challenge.Used {
|
|
return nil, fmt.Errorf("challenge already used")
|
|
}
|
|
|
|
// Verify nonce matches
|
|
respNonce, err := base64.StdEncoding.DecodeString(resp.Nonce)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("invalid nonce encoding: %w", err)
|
|
}
|
|
|
|
if string(respNonce) != string(challenge.Nonce) {
|
|
return nil, fmt.Errorf("nonce mismatch")
|
|
}
|
|
|
|
// Mark challenge as used
|
|
challenge.Used = true
|
|
|
|
// Get device
|
|
device, exists := a.devices[deviceID]
|
|
if !exists {
|
|
return nil, fmt.Errorf("device not found")
|
|
}
|
|
|
|
// Parse device public key
|
|
devicePubKeyBytes, err := base64.StdEncoding.DecodeString(device.TPMPublicKey)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("invalid TPM public key: %w", err)
|
|
}
|
|
|
|
devicePubKey, err := crypto.ParsePublicKey(devicePubKeyBytes)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to parse device public key: %w", err)
|
|
}
|
|
|
|
// Verify signature
|
|
signature, err := base64.StdEncoding.DecodeString(resp.Signature)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("invalid signature encoding: %w", err)
|
|
}
|
|
|
|
// Build signed data (challenge + nonce)
|
|
signedData := append(challenge.Challenge, challenge.Nonce...)
|
|
if !crypto.Verify(devicePubKey, signedData, signature) {
|
|
return nil, fmt.Errorf("signature verification failed")
|
|
}
|
|
|
|
// Generate session key
|
|
kek, err := a.keyManager.GetDeviceKEK(deviceID)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get KEK: %w", err)
|
|
}
|
|
|
|
sessionKey, err := crypto.DeriveKey(nil, kek.Key, crypto.HKDFInfoSession, crypto.AES256KeySize)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to derive session key: %w", err)
|
|
}
|
|
|
|
// Update device status
|
|
device.Status = types.StatusActive
|
|
device.LastAuthAt = timePtr(time.Now())
|
|
device.UpdatedAt = time.Now()
|
|
|
|
// Clean up challenge
|
|
delete(a.challenges, deviceID)
|
|
|
|
return &proto.AuthResponse{
|
|
APIResponse: *proto.NewSuccessResponse(proto.TypeAuthResponse),
|
|
SessionKey: base64.StdEncoding.EncodeToString(sessionKey),
|
|
ValidUntil: time.Now().Add(24 * time.Hour).Unix(),
|
|
}, nil
|
|
}
|
|
|
|
func (a *MockAuthenticator) RequestCrossSession(req *proto.CrossSessionRequest) (*proto.CrossSessionResponse, error) {
|
|
a.mu.Lock()
|
|
defer a.mu.Unlock()
|
|
|
|
// Validate both devices exist and are active
|
|
sourceDevice, exists := a.devices[req.SourceDeviceID]
|
|
if !exists {
|
|
return nil, fmt.Errorf("source device not found: %s", req.SourceDeviceID)
|
|
}
|
|
|
|
targetDevice, exists := a.devices[req.TargetDeviceID]
|
|
if !exists {
|
|
return nil, fmt.Errorf("target device not found: %s", req.TargetDeviceID)
|
|
}
|
|
|
|
if sourceDevice.Status != types.StatusActive {
|
|
return nil, fmt.Errorf("source device not active: %s", req.SourceDeviceID)
|
|
}
|
|
|
|
if targetDevice.Status != types.StatusActive {
|
|
return nil, fmt.Errorf("target device not active: %s", req.TargetDeviceID)
|
|
}
|
|
|
|
// Determine canonical key for session (smaller ID goes first)
|
|
var sessionKey string
|
|
if req.SourceDeviceID < req.TargetDeviceID {
|
|
sessionKey = req.SourceDeviceID + "-" + req.TargetDeviceID
|
|
} else {
|
|
sessionKey = req.TargetDeviceID + "-" + req.SourceDeviceID
|
|
}
|
|
|
|
// Get or generate Cross_SK for this pair
|
|
crossSK, exists := a.crossSessions[sessionKey]
|
|
if !exists {
|
|
crossSK = make([]byte, crypto.AES256KeySize)
|
|
if _, err := rand.Read(crossSK); err != nil {
|
|
return nil, fmt.Errorf("failed to generate cross session key: %w", err)
|
|
}
|
|
a.crossSessions[sessionKey] = crossSK
|
|
}
|
|
|
|
// Parse source device public key
|
|
sourcePubKeyBytes, err := base64.StdEncoding.DecodeString(sourceDevice.TPMPublicKey)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("invalid source public key: %w", err)
|
|
}
|
|
sourcePubKey, err := crypto.ParsePublicKey(sourcePubKeyBytes)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to parse source public key: %w", err)
|
|
}
|
|
|
|
// Parse target device public key
|
|
targetPubKeyBytes, err := base64.StdEncoding.DecodeString(targetDevice.TPMPublicKey)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("invalid target public key: %w", err)
|
|
}
|
|
targetPubKey, err := crypto.ParsePublicKey(targetPubKeyBytes)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to parse target public key: %w", err)
|
|
}
|
|
|
|
// Encrypt Cross_SK for source device using ECDH
|
|
sourceEncryptedSK, err := crypto.EncryptWithECDH(crossSK, sourcePubKey, a.keyManager.GetServerPrivateKey())
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to encrypt cross SK for source: %w", err)
|
|
}
|
|
|
|
// Encrypt Cross_SK for target device using ECDH
|
|
targetEncryptedSK, err := crypto.EncryptWithECDH(crossSK, targetPubKey, a.keyManager.GetServerPrivateKey())
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to encrypt cross SK for target: %w", err)
|
|
}
|
|
|
|
return &proto.CrossSessionResponse{
|
|
APIResponse: *proto.NewSuccessResponse(proto.TypeCrossSessionResponse),
|
|
EncryptedCrossSK: base64.StdEncoding.EncodeToString(sourceEncryptedSK),
|
|
TargetEncryptedSK: base64.StdEncoding.EncodeToString(targetEncryptedSK),
|
|
}, nil
|
|
}
|
|
|
|
func timePtr(t time.Time) *time.Time {
|
|
return &t
|
|
}
|
|
|
|
// Connector represents a test connector client
|
|
type Connector struct {
|
|
ID string
|
|
TPM *tpm.MockTPM
|
|
KeyManager *keys.Manager
|
|
DeviceKey *tpm.TPMKey
|
|
KEK []byte
|
|
SessionKey []byte
|
|
Certificate string
|
|
}
|
|
|
|
// NewConnector creates a new test connector
|
|
func NewConnector(id string) (*Connector, error) {
|
|
tmpDir := fmt.Sprintf("/tmp/e2e_connector_%s", id)
|
|
|
|
tpmInstance := tpm.NewMockTPM()
|
|
km, err := keys.NewManager(tmpDir, crypto.CipherSuiteInternational)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to create key manager: %w", err)
|
|
}
|
|
|
|
return &Connector{
|
|
ID: id,
|
|
TPM: tpmInstance,
|
|
KeyManager: km,
|
|
}, nil
|
|
}
|
|
|
|
// Register performs device registration
|
|
func (c *Connector) Register(serverURL string) error {
|
|
// Generate device key in TPM
|
|
deviceKey, err := c.TPM.GenerateKey("device_key", tpm.KeyTypeSigning)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to generate device key: %w", err)
|
|
}
|
|
c.DeviceKey = deviceKey
|
|
|
|
// Get public key
|
|
publicKey, err := c.TPM.GetPublicKeyBase64("device_key")
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get public key: %w", err)
|
|
}
|
|
|
|
// Generate nonce for quote
|
|
nonce, _ := crypto.GenerateNonce(32)
|
|
|
|
// Generate TPM quote
|
|
quote, _, err := c.TPM.QuoteToBase64("device_key", nonce, 0xFFFFFFFF)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to generate TPM quote: %w", err)
|
|
}
|
|
|
|
// Create registration request
|
|
req := &proto.RegisterRequest{
|
|
APIRequest: proto.APIRequest{
|
|
Type: proto.TypeRegisterRequest,
|
|
DeviceID: c.ID,
|
|
},
|
|
TPMPublicKey: publicKey,
|
|
TPMQuote: quote,
|
|
QuotePCRMask: 0xFFFFFFFF,
|
|
Nonce: base64.StdEncoding.EncodeToString(nonce),
|
|
DeviceID: c.ID,
|
|
FirmwareHash: "mock_firmware_hash",
|
|
}
|
|
|
|
// Send registration request
|
|
resp, err := c.sendRequest(serverURL+"/api/v1/device/register", req)
|
|
if err != nil {
|
|
return fmt.Errorf("registration failed: %w", err)
|
|
}
|
|
|
|
registerResp, ok := resp.(*proto.RegisterResponse)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected response type")
|
|
}
|
|
|
|
if registerResp.Code != proto.ErrSuccess {
|
|
return fmt.Errorf("registration failed: %s - %s", registerResp.Code, registerResp.Message)
|
|
}
|
|
|
|
// Store the key
|
|
if err := c.KeyManager.StoreKey("device_key", deviceKey.PrivateKey); err != nil {
|
|
return fmt.Errorf("failed to store key: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Authenticate performs challenge-response authentication
|
|
func (c *Connector) Authenticate(serverURL string) error {
|
|
// Request challenge
|
|
challengeReq := proto.APIRequest{
|
|
Type: proto.TypeChallengeRequest,
|
|
DeviceID: c.ID,
|
|
}
|
|
|
|
resp, err := c.sendRequest(serverURL+"/api/v1/device/challenge", challengeReq)
|
|
if err != nil {
|
|
return fmt.Errorf("challenge request failed: %w", err)
|
|
}
|
|
|
|
challengeResp, ok := resp.(*proto.ChallengeRequest)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected response type")
|
|
}
|
|
|
|
// Decode challenge
|
|
nonce, err := base64.StdEncoding.DecodeString(challengeResp.Nonce)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to decode nonce: %w", err)
|
|
}
|
|
|
|
challenge, err := base64.StdEncoding.DecodeString(challengeResp.Challenge)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to decode challenge: %w", err)
|
|
}
|
|
|
|
// Sign challenge + nonce with TPM
|
|
signedData := append(challenge, nonce...)
|
|
signature, err := c.TPM.SignBase64("device_key", signedData)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to sign: %w", err)
|
|
}
|
|
|
|
// Send auth response
|
|
authResp := &proto.ChallengeResponse{
|
|
APIRequest: proto.APIRequest{
|
|
Type: proto.TypeChallengeResponse,
|
|
DeviceID: c.ID,
|
|
},
|
|
Nonce: challengeResp.Nonce,
|
|
Signature: signature,
|
|
}
|
|
|
|
authResult, err := c.sendRequest(serverURL+"/api/v1/device/auth", authResp)
|
|
if err != nil {
|
|
return fmt.Errorf("auth failed: %w", err)
|
|
}
|
|
|
|
authResponse, ok := authResult.(*proto.AuthResponse)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected response type")
|
|
}
|
|
|
|
if authResponse.Code != proto.ErrSuccess {
|
|
return fmt.Errorf("auth failed: %s - %s", authResponse.Code, authResponse.Message)
|
|
}
|
|
|
|
// Decode session key
|
|
sessionKey, err := base64.StdEncoding.DecodeString(authResponse.SessionKey)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to decode session key: %w", err)
|
|
}
|
|
c.SessionKey = sessionKey
|
|
|
|
return nil
|
|
}
|
|
|
|
// RequestCrossSession requests an encrypted cross-session key for inter-connector communication
|
|
func (c *Connector) RequestCrossSession(serverURL string, targetDeviceID string) ([]byte, error) {
|
|
crossReq := &proto.CrossSessionRequest{
|
|
APIRequest: proto.APIRequest{
|
|
Type: proto.TypeCrossSessionRequest,
|
|
DeviceID: c.ID,
|
|
},
|
|
SourceDeviceID: c.ID,
|
|
TargetDeviceID: targetDeviceID,
|
|
Purpose: "inter-connector encrypted communication",
|
|
}
|
|
|
|
resp, err := c.sendRequest(serverURL+"/api/v1/connector/cross_session", crossReq)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("cross session request failed: %w", err)
|
|
}
|
|
|
|
crossResp, ok := resp.(*proto.CrossSessionResponse)
|
|
if !ok {
|
|
return nil, fmt.Errorf("unexpected response type")
|
|
}
|
|
|
|
if crossResp.Code != proto.ErrSuccess {
|
|
return nil, fmt.Errorf("cross session failed: %s - %s", crossResp.Code, crossResp.Message)
|
|
}
|
|
|
|
// Decode encrypted cross SK
|
|
encryptedCrossSK, err := base64.StdEncoding.DecodeString(crossResp.EncryptedCrossSK)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to decode encrypted cross SK: %w", err)
|
|
}
|
|
|
|
// Decrypt with ECDH using device private key
|
|
crossSK, err := crypto.DecryptWithECDH(encryptedCrossSK, c.DeviceKey.PrivateKey)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to decrypt cross SK: %w", err)
|
|
}
|
|
|
|
return crossSK, nil
|
|
}
|
|
|
|
func (c *Connector) sendRequest(url string, req interface{}) (interface{}, error) {
|
|
body, err := json.Marshal(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to marshal request: %w", err)
|
|
}
|
|
|
|
httpReq, err := http.NewRequest(http.MethodPost, url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to create request: %w", err)
|
|
}
|
|
|
|
httpReq.Header.Set("Content-Type", "application/json")
|
|
httpReq.Body = io.NopCloser(&readerWrapper{body: body})
|
|
|
|
client := &http.Client{}
|
|
|
|
resp, err := client.Do(httpReq)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("request failed: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
respBody, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to read response: %w", err)
|
|
}
|
|
|
|
// Parse response based on type
|
|
var baseResp struct {
|
|
Type string `json:"type"`
|
|
}
|
|
|
|
if err := json.Unmarshal(respBody, &baseResp); err != nil {
|
|
return nil, fmt.Errorf("failed to parse response: %w", err)
|
|
}
|
|
|
|
switch baseResp.Type {
|
|
case string(proto.TypeRegisterResponse):
|
|
var resp proto.RegisterResponse
|
|
if err := json.Unmarshal(respBody, &resp); err != nil {
|
|
return nil, fmt.Errorf("failed to parse register response: %w", err)
|
|
}
|
|
return &resp, nil
|
|
|
|
case string(proto.TypeChallengeRequest):
|
|
var resp proto.ChallengeRequest
|
|
if err := json.Unmarshal(respBody, &resp); err != nil {
|
|
return nil, fmt.Errorf("failed to parse challenge response: %w", err)
|
|
}
|
|
return &resp, nil
|
|
|
|
case string(proto.TypeAuthResponse):
|
|
var resp proto.AuthResponse
|
|
if err := json.Unmarshal(respBody, &resp); err != nil {
|
|
return nil, fmt.Errorf("failed to parse auth response: %w", err)
|
|
}
|
|
return &resp, nil
|
|
|
|
case string(proto.TypeCrossSessionResponse):
|
|
var resp proto.CrossSessionResponse
|
|
if err := json.Unmarshal(respBody, &resp); err != nil {
|
|
return nil, fmt.Errorf("failed to parse cross session response: %w", err)
|
|
}
|
|
return &resp, nil
|
|
|
|
default:
|
|
var resp proto.APIResponse
|
|
if err := json.Unmarshal(respBody, &resp); err != nil {
|
|
return nil, fmt.Errorf("failed to parse error response: %w", err)
|
|
}
|
|
return nil, fmt.Errorf("server error: %s - %s", resp.Code, resp.Message)
|
|
}
|
|
}
|
|
|
|
type readerWrapper struct {
|
|
body []byte
|
|
pos int
|
|
}
|
|
|
|
func (r *readerWrapper) Read(p []byte) (n int, err error) {
|
|
if r.pos >= len(r.body) {
|
|
return 0, io.EOF
|
|
}
|
|
n = copy(p, r.body[r.pos:])
|
|
r.pos += n
|
|
return n, nil
|
|
}
|
|
|
|
// E2E Tests
|
|
|
|
func TestTwoConnectorRegistration(t *testing.T) {
|
|
// Find free port
|
|
port := int(atomic.AddInt32(&serverPort, 1))
|
|
|
|
// Start server
|
|
server := NewMockServer(t, port)
|
|
if err := server.Start(); err != nil {
|
|
t.Fatalf("Failed to start server: %v", err)
|
|
}
|
|
defer server.Stop()
|
|
|
|
// Give server time to start
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
serverURL := fmt.Sprintf("http://localhost:%d", port)
|
|
|
|
// Create first connector
|
|
conn1, err := NewConnector("DEV_e2e_001")
|
|
if err != nil {
|
|
t.Fatalf("Failed to create connector 1: %v", err)
|
|
}
|
|
|
|
// Create second connector
|
|
conn2, err := NewConnector("DEV_e2e_002")
|
|
if err != nil {
|
|
t.Fatalf("Failed to create connector 2: %v", err)
|
|
}
|
|
|
|
// Register both connectors
|
|
if err := conn1.Register(serverURL); err != nil {
|
|
t.Fatalf("Connector 1 registration failed: %v", err)
|
|
}
|
|
t.Log("Connector 1 registered successfully")
|
|
|
|
if err := conn2.Register(serverURL); err != nil {
|
|
t.Fatalf("Connector 2 registration failed: %v", err)
|
|
}
|
|
t.Log("Connector 2 registered successfully")
|
|
|
|
// Verify both devices are registered
|
|
if len(server.auth.devices) != 2 {
|
|
t.Errorf("Expected 2 registered devices, got %d", len(server.auth.devices))
|
|
}
|
|
}
|
|
|
|
func TestTwoConnectorAuthentication(t *testing.T) {
|
|
// Find free port
|
|
port := int(atomic.AddInt32(&serverPort, 1))
|
|
|
|
// Start server
|
|
server := NewMockServer(t, port)
|
|
if err := server.Start(); err != nil {
|
|
t.Fatalf("Failed to start server: %v", err)
|
|
}
|
|
defer server.Stop()
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
serverURL := fmt.Sprintf("http://localhost:%d", port)
|
|
|
|
// Create and register two connectors
|
|
conn1, _ := NewConnector("DEV_auth_001")
|
|
conn2, _ := NewConnector("DEV_auth_002")
|
|
|
|
if err := conn1.Register(serverURL); err != nil {
|
|
t.Fatalf("Connector 1 registration failed: %v", err)
|
|
}
|
|
|
|
if err := conn2.Register(serverURL); err != nil {
|
|
t.Fatalf("Connector 2 registration failed: %v", err)
|
|
}
|
|
|
|
// Authenticate both
|
|
if err := conn1.Authenticate(serverURL); err != nil {
|
|
t.Fatalf("Connector 1 authentication failed: %v", err)
|
|
}
|
|
t.Log("Connector 1 authenticated successfully")
|
|
|
|
if err := conn2.Authenticate(serverURL); err != nil {
|
|
t.Fatalf("Connector 2 authentication failed: %v", err)
|
|
}
|
|
t.Log("Connector 2 authenticated successfully")
|
|
|
|
// Verify both have session keys
|
|
if len(conn1.SessionKey) == 0 {
|
|
t.Error("Connector 1 should have a session key")
|
|
}
|
|
if len(conn2.SessionKey) == 0 {
|
|
t.Error("Connector 2 should have a session key")
|
|
}
|
|
|
|
// Verify session keys are different (derived from different KEKs)
|
|
if string(conn1.SessionKey) == string(conn2.SessionKey) {
|
|
t.Error("Session keys should be different for different devices")
|
|
}
|
|
}
|
|
|
|
func TestConnectorAuthAfterChallengeExpiry(t *testing.T) {
|
|
// Find free port
|
|
port := int(atomic.AddInt32(&serverPort, 1))
|
|
|
|
// Start server
|
|
server := NewMockServer(t, port)
|
|
if err := server.Start(); err != nil {
|
|
t.Fatalf("Failed to start server: %v", err)
|
|
}
|
|
defer server.Stop()
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
serverURL := fmt.Sprintf("http://localhost:%d", port)
|
|
|
|
// Create and register connector
|
|
conn, _ := NewConnector("DEV_expiry_001")
|
|
|
|
if err := conn.Register(serverURL); err != nil {
|
|
t.Fatalf("Registration failed: %v", err)
|
|
}
|
|
|
|
// First auth should work
|
|
if err := conn.Authenticate(serverURL); err != nil {
|
|
t.Fatalf("First authentication failed: %v", err)
|
|
}
|
|
|
|
// The challenge was consumed in first auth, so second auth with new challenge should work
|
|
// (Challenge expiry tests require waiting 5 minutes - not practical in unit test)
|
|
// Just verify that the connector can authenticate again with a fresh challenge
|
|
if err := conn.Authenticate(serverURL); err != nil {
|
|
t.Errorf("Second authentication with fresh challenge failed (expected to work): %v", err)
|
|
}
|
|
}
|
|
|
|
func TestConcurrentConnectorRegistration(t *testing.T) {
|
|
// Find free port
|
|
port := int(atomic.AddInt32(&serverPort, 1))
|
|
|
|
// Start server
|
|
server := NewMockServer(t, port)
|
|
if err := server.Start(); err != nil {
|
|
t.Fatalf("Failed to start server: %v", err)
|
|
}
|
|
defer server.Stop()
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
serverURL := fmt.Sprintf("http://localhost:%d", port)
|
|
|
|
// Create multiple connectors concurrently
|
|
const numConnectors = 5
|
|
connectors := make([]*Connector, numConnectors)
|
|
|
|
var wg sync.WaitGroup
|
|
errCh := make(chan error, numConnectors)
|
|
|
|
for i := 0; i < numConnectors; i++ {
|
|
wg.Add(1)
|
|
go func(idx int) {
|
|
defer wg.Done()
|
|
|
|
conn, err := NewConnector(fmt.Sprintf("DEV_concurrent_%03d", idx))
|
|
if err != nil {
|
|
errCh <- fmt.Errorf("failed to create connector: %w", err)
|
|
return
|
|
}
|
|
|
|
if err := conn.Register(serverURL); err != nil {
|
|
errCh <- fmt.Errorf("registration failed: %w", err)
|
|
return
|
|
}
|
|
|
|
connectors[idx] = conn
|
|
}(i)
|
|
}
|
|
|
|
wg.Wait()
|
|
close(errCh)
|
|
|
|
// Check for errors
|
|
for err := range errCh {
|
|
t.Errorf("Concurrent registration error: %v", err)
|
|
}
|
|
|
|
// Verify all registered
|
|
if len(server.auth.devices) != numConnectors {
|
|
t.Errorf("Expected %d registered devices, got %d", numConnectors, len(server.auth.devices))
|
|
}
|
|
|
|
// Verify all authenticated
|
|
for i, conn := range connectors {
|
|
if conn == nil {
|
|
t.Errorf("Connector %d was not created", i)
|
|
continue
|
|
}
|
|
if err := conn.Authenticate(serverURL); err != nil {
|
|
t.Errorf("Connector %d authentication failed: %v", i, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestInvalidDeviceRegistration(t *testing.T) {
|
|
// Find free port
|
|
port := int(atomic.AddInt32(&serverPort, 1))
|
|
|
|
// Start server
|
|
server := NewMockServer(t, port)
|
|
if err := server.Start(); err != nil {
|
|
t.Fatalf("Failed to start server: %v", err)
|
|
}
|
|
defer server.Stop()
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
serverURL := fmt.Sprintf("http://localhost:%d", port)
|
|
|
|
// Try to authenticate without registration
|
|
conn, _ := NewConnector("DEV_notregistered")
|
|
err := conn.Authenticate(serverURL)
|
|
if err == nil {
|
|
t.Error("Authentication should fail for unregistered device")
|
|
}
|
|
}
|
|
|
|
func TestChallengeNonceMismatch(t *testing.T) {
|
|
// Find free port
|
|
port := int(atomic.AddInt32(&serverPort, 1))
|
|
|
|
// Start server
|
|
server := NewMockServer(t, port)
|
|
if err := server.Start(); err != nil {
|
|
t.Fatalf("Failed to start server: %v", err)
|
|
}
|
|
defer server.Stop()
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
serverURL := fmt.Sprintf("http://localhost:%d", port)
|
|
|
|
// Create connector
|
|
conn, _ := NewConnector("DEV_nonce_001")
|
|
if err := conn.Register(serverURL); err != nil {
|
|
t.Fatalf("Registration failed: %v", err)
|
|
}
|
|
|
|
// Get a challenge
|
|
challengeReq := proto.APIRequest{
|
|
Type: proto.TypeChallengeRequest,
|
|
DeviceID: conn.ID,
|
|
}
|
|
|
|
resp, err := conn.sendRequest(serverURL+"/api/v1/device/challenge", challengeReq)
|
|
if err != nil {
|
|
t.Fatalf("Challenge request failed: %v", err)
|
|
}
|
|
|
|
challengeResp := resp.(*proto.ChallengeRequest)
|
|
|
|
// Send auth with wrong nonce
|
|
authResp := &proto.ChallengeResponse{
|
|
APIRequest: proto.APIRequest{
|
|
Type: proto.TypeChallengeResponse,
|
|
DeviceID: conn.ID,
|
|
},
|
|
Nonce: base64.StdEncoding.EncodeToString([]byte("wrong_nonce_32_bytes_data_here!!!!")),
|
|
Signature: "wrong_signature",
|
|
}
|
|
|
|
_, err = conn.sendRequest(serverURL+"/api/v1/device/auth", authResp)
|
|
// Should fail - but our mock doesn't properly verify signature since it's in the HTTP layer
|
|
// The server should still reject due to nonce mismatch
|
|
_ = challengeResp // Use the variable
|
|
}
|
|
|
|
func TestDeviceToDeviceEncryptedCommunication(t *testing.T) {
|
|
// Find free port
|
|
port := int(atomic.AddInt32(&serverPort, 1))
|
|
|
|
// Start server
|
|
server := NewMockServer(t, port)
|
|
if err := server.Start(); err != nil {
|
|
t.Fatalf("Failed to start server: %v", err)
|
|
}
|
|
defer server.Stop()
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
serverURL := fmt.Sprintf("http://localhost:%d", port)
|
|
|
|
// Create two connectors
|
|
conn1, _ := NewConnector("DEV_comm_001")
|
|
conn2, _ := NewConnector("DEV_comm_002")
|
|
|
|
// Register both
|
|
if err := conn1.Register(serverURL); err != nil {
|
|
t.Fatalf("Connector 1 registration failed: %v", err)
|
|
}
|
|
if err := conn2.Register(serverURL); err != nil {
|
|
t.Fatalf("Connector 2 registration failed: %v", err)
|
|
}
|
|
|
|
// Authenticate both to get session keys
|
|
if err := conn1.Authenticate(serverURL); err != nil {
|
|
t.Fatalf("Connector 1 authentication failed: %v", err)
|
|
}
|
|
if err := conn2.Authenticate(serverURL); err != nil {
|
|
t.Fatalf("Connector 2 authentication failed: %v", err)
|
|
}
|
|
|
|
// Verify both have session keys
|
|
if len(conn1.SessionKey) == 0 || len(conn2.SessionKey) == 0 {
|
|
t.Fatal("Both connectors must have session keys")
|
|
}
|
|
|
|
// Test 1: Device 1 encrypts data with its session key, device 2 can decrypt with its own session key
|
|
// (In real scenario, they'd derive a shared key via ECDH)
|
|
testMessage := []byte("secret data from device 1")
|
|
|
|
// Encrypt with device 1's session key
|
|
ciphertext1, err := crypto.EncryptAES256GCM(conn1.SessionKey, testMessage, nil)
|
|
if err != nil {
|
|
t.Fatalf("Encryption with device 1 session key failed: %v", err)
|
|
}
|
|
|
|
// Decrypt with device 1's session key - should work
|
|
decrypted1, err := crypto.DecryptAES256GCM(conn1.SessionKey, ciphertext1, nil)
|
|
if err != nil {
|
|
t.Fatalf("Decryption with device 1 session key failed: %v", err)
|
|
}
|
|
if string(decrypted1) != string(testMessage) {
|
|
t.Error("Decrypted message doesn't match original")
|
|
}
|
|
|
|
// Test 2: Device 2 CANNOT decrypt data encrypted with device 1's key
|
|
// (This tests that session keys are device-specific)
|
|
_, err = crypto.DecryptAES256GCM(conn2.SessionKey, ciphertext1, nil)
|
|
if err == nil {
|
|
t.Error("Device 2 should NOT be able to decrypt data encrypted with device 1's key")
|
|
} else {
|
|
t.Log("Correctly rejected cross-device decryption (session keys are device-specific)")
|
|
}
|
|
|
|
// Test 3: Different devices get different session keys
|
|
if string(conn1.SessionKey) == string(conn2.SessionKey) {
|
|
t.Error("Session keys should be different for different devices")
|
|
}
|
|
|
|
// Test 4: Simulate ECDH key exchange between devices
|
|
// In real scenario, devices would:
|
|
// 1. Exchange public keys
|
|
// 2. Derive shared secret via ECDH
|
|
// 3. Derive shared encryption key
|
|
|
|
// For this test, simulate ECDH by deriving same key with same info but different base keys
|
|
// In real ECDH, both sides compute the same shared secret
|
|
// Here: both use same info but their different session keys as input
|
|
sharedKey1, err := crypto.DeriveKey(nil, conn1.SessionKey, "device-shared-secret", 32)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive shared key from device 1: %v", err)
|
|
}
|
|
|
|
sharedKey2, err := crypto.DeriveKey(nil, conn2.SessionKey, "device-shared-secret", 32)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive shared key from device 2: %v", err)
|
|
}
|
|
|
|
// Keys are different because they were derived from different session keys
|
|
// In real ECDH, shared secrets would be identical (different math, same result)
|
|
// This demonstrates why real ECDH is needed for device-to-device encryption
|
|
if string(sharedKey1) == string(sharedKey2) {
|
|
t.Log("Note: With same info but different keys, derived keys differ (expected)")
|
|
}
|
|
|
|
// Encrypt with device 1's derived shared key
|
|
testMessage2 := []byte("data for device 2")
|
|
ciphertextShared, err := crypto.EncryptAES256GCM(sharedKey1, testMessage2, nil)
|
|
if err != nil {
|
|
t.Fatalf("Encryption with shared key failed: %v", err)
|
|
}
|
|
|
|
// Decrypt with device 2's derived key - should FAIL because keys are different
|
|
_, err = crypto.DecryptAES256GCM(sharedKey2, ciphertextShared, nil)
|
|
if err == nil {
|
|
t.Error("Cross-device decryption should fail with wrong derived key")
|
|
} else {
|
|
t.Log("Correctly rejected cross-device decryption with different derived keys")
|
|
}
|
|
|
|
// Now test with SAME shared key on both sides (simulating correct ECDH)
|
|
// Use device 1's key for both encrypt and decrypt
|
|
ciphertextSameKey, err := crypto.EncryptAES256GCM(sharedKey1, testMessage2, nil)
|
|
if err != nil {
|
|
t.Fatalf("Encryption with same key failed: %v", err)
|
|
}
|
|
|
|
decryptedSameKey, err := crypto.DecryptAES256GCM(sharedKey1, ciphertextSameKey, nil)
|
|
if err != nil {
|
|
t.Fatalf("Decryption with same key failed: %v", err)
|
|
}
|
|
if string(decryptedSameKey) != string(testMessage2) {
|
|
t.Error("Same-key roundtrip failed")
|
|
}
|
|
|
|
t.Log("Device-to-device encrypted communication verified")
|
|
}
|
|
|
|
func TestDeviceToDeviceWrongSessionKey(t *testing.T) {
|
|
// Find free port
|
|
port := int(atomic.AddInt32(&serverPort, 1))
|
|
|
|
// Start server
|
|
server := NewMockServer(t, port)
|
|
if err := server.Start(); err != nil {
|
|
t.Fatalf("Failed to start server: %v", err)
|
|
}
|
|
defer server.Stop()
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
serverURL := fmt.Sprintf("http://localhost:%d", port)
|
|
|
|
// Create one connector (conn2 would be unauthorized in real scenario)
|
|
conn1, _ := NewConnector("DEV_wrong_001")
|
|
|
|
// Only register and authenticate conn1
|
|
if err := conn1.Register(serverURL); err != nil {
|
|
t.Fatalf("Connector 1 registration failed: %v", err)
|
|
}
|
|
if err := conn1.Authenticate(serverURL); err != nil {
|
|
t.Fatalf("Connector 1 authentication failed: %v", err)
|
|
}
|
|
|
|
// Conn1 encrypts data with its session key
|
|
testMessage := []byte("secret for conn2")
|
|
ciphertext, err := crypto.EncryptAES256GCM(conn1.SessionKey, testMessage, nil)
|
|
if err != nil {
|
|
t.Fatalf("Encryption failed: %v", err)
|
|
}
|
|
|
|
// Simulate conn2 trying to decrypt without proper authentication
|
|
// (In real scenario, conn2 would have its own different session key)
|
|
randomKey := make([]byte, 32)
|
|
rand.Read(randomKey)
|
|
|
|
_, err = crypto.DecryptAES256GCM(randomKey, ciphertext, nil)
|
|
if err == nil {
|
|
t.Error("Decryption with wrong key should fail")
|
|
} else {
|
|
t.Log("Correctly rejected decryption with wrong key")
|
|
}
|
|
}
|
|
|
|
func TestCrossSessionRequestResponse(t *testing.T) {
|
|
// Find free port
|
|
port := int(atomic.AddInt32(&serverPort, 1))
|
|
|
|
// Start server
|
|
server := NewMockServer(t, port)
|
|
if err := server.Start(); err != nil {
|
|
t.Fatalf("Failed to start server: %v", err)
|
|
}
|
|
defer server.Stop()
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
serverURL := fmt.Sprintf("http://localhost:%d", port)
|
|
|
|
// Create two connectors
|
|
conn1, _ := NewConnector("DEV_cross_001")
|
|
conn2, _ := NewConnector("DEV_cross_002")
|
|
|
|
// Register and authenticate both
|
|
if err := conn1.Register(serverURL); err != nil {
|
|
t.Fatalf("Connector 1 registration failed: %v", err)
|
|
}
|
|
if err := conn2.Register(serverURL); err != nil {
|
|
t.Fatalf("Connector 2 registration failed: %v", err)
|
|
}
|
|
|
|
if err := conn1.Authenticate(serverURL); err != nil {
|
|
t.Fatalf("Connector 1 authentication failed: %v", err)
|
|
}
|
|
if err := conn2.Authenticate(serverURL); err != nil {
|
|
t.Fatalf("Connector 2 authentication failed: %v", err)
|
|
}
|
|
|
|
// Request cross-session key from conn1's perspective
|
|
crossSK1, err := conn1.RequestCrossSession(serverURL, "DEV_cross_002")
|
|
if err != nil {
|
|
t.Fatalf("Cross-session request failed for conn1: %v", err)
|
|
}
|
|
t.Logf("Connector 1 received Cross_SK (len=%d)", len(crossSK1))
|
|
|
|
// Request cross-session key from conn2's perspective
|
|
crossSK2, err := conn2.RequestCrossSession(serverURL, "DEV_cross_001")
|
|
if err != nil {
|
|
t.Fatalf("Cross-session request failed for conn2: %v", err)
|
|
}
|
|
t.Logf("Connector 2 received Cross_SK (len=%d)", len(crossSK2))
|
|
|
|
// Both should receive the SAME cross SK (server generates one key, encrypts differently for each)
|
|
if string(crossSK1) != string(crossSK2) {
|
|
t.Errorf("Cross SKs should be identical - got conn1=%x, conn2=%x", crossSK1[:8], crossSK2[:8])
|
|
}
|
|
t.Log("Both connectors received same Cross_SK from server")
|
|
|
|
// Verify Cross_SK is different from device session keys
|
|
if string(crossSK1) == string(conn1.SessionKey) {
|
|
t.Error("Cross_SK should differ from device session key")
|
|
}
|
|
|
|
// Encrypt with Cross_SK and decrypt with Cross_SK
|
|
testMessage := []byte("inter-connector secret message")
|
|
ciphertext, err := crypto.EncryptAES256GCM(crossSK1, testMessage, nil)
|
|
if err != nil {
|
|
t.Fatalf("Encryption with Cross_SK failed: %v", err)
|
|
}
|
|
|
|
decrypted, err := crypto.DecryptAES256GCM(crossSK1, ciphertext, nil)
|
|
if err != nil {
|
|
t.Fatalf("Decryption with Cross_SK failed: %v", err)
|
|
}
|
|
if string(decrypted) != string(testMessage) {
|
|
t.Error("Cross_SK roundtrip failed")
|
|
}
|
|
t.Log("Cross_SK encrypt/decrypt roundtrip verified")
|
|
}
|
|
|
|
func TestCrossSessionUnauthorizedDevice(t *testing.T) {
|
|
// Find free port
|
|
port := int(atomic.AddInt32(&serverPort, 1))
|
|
|
|
// Start server
|
|
server := NewMockServer(t, port)
|
|
if err := server.Start(); err != nil {
|
|
t.Fatalf("Failed to start server: %v", err)
|
|
}
|
|
defer server.Stop()
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
serverURL := fmt.Sprintf("http://localhost:%d", port)
|
|
|
|
// Create one registered connector
|
|
conn1, _ := NewConnector("DEV_unauth_001")
|
|
|
|
if err := conn1.Register(serverURL); err != nil {
|
|
t.Fatalf("Connector 1 registration failed: %v", err)
|
|
}
|
|
if err := conn1.Authenticate(serverURL); err != nil {
|
|
t.Fatalf("Connector 1 authentication failed: %v", err)
|
|
}
|
|
|
|
// Try to request cross-session with non-existent target
|
|
_, err := conn1.RequestCrossSession(serverURL, "DEV_nonexistent_999")
|
|
if err == nil {
|
|
t.Error("Cross-session request should fail for non-existent target device")
|
|
} else {
|
|
t.Logf("Correctly rejected cross-session to non-existent device: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCrossSessionUnregisteredDevice(t *testing.T) {
|
|
// Find free port
|
|
port := int(atomic.AddInt32(&serverPort, 1))
|
|
|
|
// Start server
|
|
server := NewMockServer(t, port)
|
|
if err := server.Start(); err != nil {
|
|
t.Fatalf("Failed to start server: %v", err)
|
|
}
|
|
defer server.Stop()
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
serverURL := fmt.Sprintf("http://localhost:%d", port)
|
|
|
|
// Create connector that is registered but not authenticated
|
|
conn1, _ := NewConnector("DEV_notauth_001")
|
|
|
|
if err := conn1.Register(serverURL); err != nil {
|
|
t.Fatalf("Connector 1 registration failed: %v", err)
|
|
}
|
|
// Intentionally NOT authenticating
|
|
|
|
// Try to request cross-session - should fail because device is not active
|
|
_, err := conn1.RequestCrossSession(serverURL, "DEV_cross_001")
|
|
if err == nil {
|
|
t.Error("Cross-session request should fail for inactive device")
|
|
} else {
|
|
t.Logf("Correctly rejected cross-session from inactive device: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCrossSessionBothEncryptDecrypt(t *testing.T) {
|
|
// Find free port
|
|
port := int(atomic.AddInt32(&serverPort, 1))
|
|
|
|
// Start server
|
|
server := NewMockServer(t, port)
|
|
if err := server.Start(); err != nil {
|
|
t.Fatalf("Failed to start server: %v", err)
|
|
}
|
|
defer server.Stop()
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
serverURL := fmt.Sprintf("http://localhost:%d", port)
|
|
|
|
// Create two connectors
|
|
conn1, _ := NewConnector("DEV_both_001")
|
|
conn2, _ := NewConnector("DEV_both_002")
|
|
|
|
// Register and authenticate both
|
|
if err := conn1.Register(serverURL); err != nil {
|
|
t.Fatalf("Connector 1 registration failed: %v", err)
|
|
}
|
|
if err := conn2.Register(serverURL); err != nil {
|
|
t.Fatalf("Connector 2 registration failed: %v", err)
|
|
}
|
|
|
|
if err := conn1.Authenticate(serverURL); err != nil {
|
|
t.Fatalf("Connector 1 authentication failed: %v", err)
|
|
}
|
|
if err := conn2.Authenticate(serverURL); err != nil {
|
|
t.Fatalf("Connector 2 authentication failed: %v", err)
|
|
}
|
|
|
|
// Get cross SK for both directions
|
|
crossSK1, _ := conn1.RequestCrossSession(serverURL, "DEV_both_002")
|
|
crossSK2, _ := conn2.RequestCrossSession(serverURL, "DEV_both_001")
|
|
|
|
// Verify both got the same key
|
|
if string(crossSK1) != string(crossSK2) {
|
|
t.Fatal("Both should get same Cross_SK")
|
|
}
|
|
|
|
// Test: Conn1 encrypts, Conn2 decrypts
|
|
messageFromConn1 := []byte("Hello from connector 1")
|
|
ciphertext, err := crypto.EncryptAES256GCM(crossSK1, messageFromConn1, nil)
|
|
if err != nil {
|
|
t.Fatalf("Conn1 encryption failed: %v", err)
|
|
}
|
|
|
|
decryptedByConn2, err := crypto.DecryptAES256GCM(crossSK2, ciphertext, nil)
|
|
if err != nil {
|
|
t.Fatalf("Conn2 decryption failed: %v", err)
|
|
}
|
|
if string(decryptedByConn2) != string(messageFromConn1) {
|
|
t.Error("Message from Conn1 was corrupted during cross-device transport")
|
|
}
|
|
t.Log("Conn1 -> Conn2 message verified")
|
|
|
|
// Test: Conn2 encrypts, Conn1 decrypts
|
|
messageFromConn2 := []byte("Reply from connector 2")
|
|
ciphertext2, err := crypto.EncryptAES256GCM(crossSK2, messageFromConn2, nil)
|
|
if err != nil {
|
|
t.Fatalf("Conn2 encryption failed: %v", err)
|
|
}
|
|
|
|
decryptedByConn1, err := crypto.DecryptAES256GCM(crossSK1, ciphertext2, nil)
|
|
if err != nil {
|
|
t.Fatalf("Conn1 decryption failed: %v", err)
|
|
}
|
|
if string(decryptedByConn1) != string(messageFromConn2) {
|
|
t.Error("Message from Conn2 was corrupted during cross-device transport")
|
|
}
|
|
t.Log("Conn2 -> Conn1 message verified")
|
|
|
|
t.Log("Bidirectional inter-connector encrypted communication verified")
|
|
}
|
|
|
|
// TC-Int-004: Server restart device recovery
|
|
// 服务端重启后设备重新认证
|
|
func TestServerRestartDeviceRecovery(t *testing.T) {
|
|
// Find free port
|
|
port := int(atomic.AddInt32(&serverPort, 1))
|
|
|
|
// Start first server instance
|
|
server := NewMockServer(t, port)
|
|
if err := server.Start(); err != nil {
|
|
t.Fatalf("Failed to start server: %v", err)
|
|
}
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
serverURL := fmt.Sprintf("http://localhost:%d", port)
|
|
|
|
// Create and register connector
|
|
conn, _ := NewConnector("DEV_recovery_001")
|
|
|
|
if err := conn.Register(serverURL); err != nil {
|
|
server.Stop()
|
|
t.Fatalf("Registration failed: %v", err)
|
|
}
|
|
t.Log("Connector registered successfully")
|
|
|
|
// Authenticate
|
|
if err := conn.Authenticate(serverURL); err != nil {
|
|
server.Stop()
|
|
t.Fatalf("First authentication failed: %v", err)
|
|
}
|
|
t.Log("Connector authenticated successfully")
|
|
|
|
// Verify device status is active
|
|
if len(server.auth.devices) != 1 {
|
|
t.Errorf("Expected 1 device, got %d", len(server.auth.devices))
|
|
}
|
|
|
|
// Stop server (simulating restart)
|
|
server.Stop()
|
|
t.Log("Server stopped (simulating restart)")
|
|
|
|
// Start new server instance (simulating server restart with fresh state)
|
|
server2 := NewMockServer(t, port)
|
|
if err := server2.Start(); err != nil {
|
|
t.Fatalf("Failed to start second server instance: %v", err)
|
|
}
|
|
defer server2.Stop()
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
// Verify device is no longer in new server's memory (fresh start)
|
|
if len(server2.auth.devices) != 0 {
|
|
t.Errorf("New server should have no devices after restart, got %d", len(server2.auth.devices))
|
|
}
|
|
|
|
// Re-register the device - in real scenario, device would use persisted KEK
|
|
// In Phase 1, we just verify re-registration works
|
|
if err := conn.Register(serverURL); err != nil {
|
|
t.Fatalf("Re-registration after server restart failed: %v", err)
|
|
}
|
|
t.Log("Connector re-registered successfully after server restart")
|
|
|
|
// Re-authenticate
|
|
if err := conn.Authenticate(serverURL); err != nil {
|
|
t.Fatalf("Re-authentication after server restart failed: %v", err)
|
|
}
|
|
t.Log("Connector re-authenticated successfully")
|
|
|
|
// Verify device is active again
|
|
if len(server2.auth.devices) != 1 {
|
|
t.Errorf("Expected 1 device after re-auth, got %d", len(server2.auth.devices))
|
|
}
|
|
|
|
for _, d := range server2.auth.devices {
|
|
if d.Status != types.StatusActive {
|
|
t.Errorf("Device status should be Active after re-auth, got %v", d.Status)
|
|
}
|
|
}
|
|
|
|
t.Log("Server restart recovery verified")
|
|
}
|
|
|
|
// TC-Multi-001: Multiple device registration and state verification
|
|
func TestMultiDeviceRegistration(t *testing.T) {
|
|
port := int(atomic.AddInt32(&serverPort, 1))
|
|
server := NewMockServer(t, port)
|
|
if err := server.Start(); err != nil {
|
|
t.Fatalf("Failed to start server: %v", err)
|
|
}
|
|
defer server.Stop()
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
serverURL := fmt.Sprintf("http://localhost:%d", port)
|
|
|
|
// Create 5 connectors
|
|
const deviceCount = 5
|
|
connectors := make([]*Connector, deviceCount)
|
|
for i := 0; i < deviceCount; i++ {
|
|
conn, err := NewConnector(fmt.Sprintf("DEV_multi_%03d", i+1))
|
|
if err != nil {
|
|
t.Fatalf("Failed to create connector %d: %v", i+1, err)
|
|
}
|
|
connectors[i] = conn
|
|
}
|
|
|
|
// Register all connectors
|
|
for i, conn := range connectors {
|
|
if err := conn.Register(serverURL); err != nil {
|
|
t.Fatalf("Connector %d registration failed: %v", i+1, err)
|
|
}
|
|
t.Logf("Connector %d registered: %s", i+1, conn.ID)
|
|
}
|
|
|
|
// Verify all devices are registered
|
|
if len(server.auth.devices) != deviceCount {
|
|
t.Errorf("Expected %d devices, got %d", deviceCount, len(server.auth.devices))
|
|
}
|
|
|
|
// Verify each device exists in server
|
|
for i, conn := range connectors {
|
|
if _, exists := server.auth.devices[conn.ID]; !exists {
|
|
t.Errorf("Device %d (%s) not found in server", i+1, conn.ID)
|
|
}
|
|
}
|
|
|
|
t.Logf("All %d connectors registered successfully", deviceCount)
|
|
}
|
|
|
|
// TC-Multi-002: Concurrent multi-device authentication
|
|
func TestMultiDeviceConcurrentAuth(t *testing.T) {
|
|
port := int(atomic.AddInt32(&serverPort, 1))
|
|
server := NewMockServer(t, port)
|
|
if err := server.Start(); err != nil {
|
|
t.Fatalf("Failed to start server: %v", err)
|
|
}
|
|
defer server.Stop()
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
serverURL := fmt.Sprintf("http://localhost:%d", port)
|
|
|
|
// Create and register 4 connectors
|
|
connectors := []*Connector{}
|
|
for i := 0; i < 4; i++ {
|
|
conn, _ := NewConnector(fmt.Sprintf("DEV_conc_%03d", i+1))
|
|
if err := conn.Register(serverURL); err != nil {
|
|
t.Fatalf("Registration failed for connector %d: %v", i+1, err)
|
|
}
|
|
connectors = append(connectors, conn)
|
|
}
|
|
|
|
// Concurrent authentication
|
|
var wg sync.WaitGroup
|
|
authResults := make([]error, len(connectors))
|
|
|
|
for i, conn := range connectors {
|
|
wg.Add(1)
|
|
go func(idx int, c *Connector) {
|
|
defer wg.Done()
|
|
authResults[idx] = c.Authenticate(serverURL)
|
|
}(i, conn)
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
// Check all authentications succeeded
|
|
for i, err := range authResults {
|
|
if err != nil {
|
|
t.Errorf("Connector %d authentication failed: %v", i+1, err)
|
|
} else {
|
|
t.Logf("Connector %d authenticated successfully", i+1)
|
|
}
|
|
}
|
|
|
|
// Verify all session keys are different
|
|
sessionKeys := make(map[string]bool)
|
|
for _, conn := range connectors {
|
|
if len(conn.SessionKey) == 0 {
|
|
t.Errorf("Connector %s has no session key", conn.ID)
|
|
}
|
|
sessionKeys[string(conn.SessionKey)] = true
|
|
}
|
|
|
|
if len(sessionKeys) != len(connectors) {
|
|
t.Error("Session keys should all be unique for different devices")
|
|
}
|
|
}
|
|
|
|
// TC-Multi-003: Mesh cross-session communication (all-to-all)
|
|
func TestMultiDeviceMeshCrossSession(t *testing.T) {
|
|
port := int(atomic.AddInt32(&serverPort, 1))
|
|
server := NewMockServer(t, port)
|
|
if err := server.Start(); err != nil {
|
|
t.Fatalf("Failed to start server: %v", err)
|
|
}
|
|
defer server.Stop()
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
serverURL := fmt.Sprintf("http://localhost:%d", port)
|
|
|
|
// Create 3 connectors
|
|
conn1, _ := NewConnector("DEV_mesh_001")
|
|
conn2, _ := NewConnector("DEV_mesh_002")
|
|
conn3, _ := NewConnector("DEV_mesh_003")
|
|
|
|
connectors := []*Connector{conn1, conn2, conn3}
|
|
|
|
// Register and authenticate all
|
|
for _, conn := range connectors {
|
|
if err := conn.Register(serverURL); err != nil {
|
|
t.Fatalf("Registration failed for %s: %v", conn.ID, err)
|
|
}
|
|
if err := conn.Authenticate(serverURL); err != nil {
|
|
t.Fatalf("Authentication failed for %s: %v", conn.ID, err)
|
|
}
|
|
}
|
|
|
|
t.Log("All 3 connectors registered and authenticated")
|
|
|
|
// Test all-to-all communication via cross-session
|
|
// For each pair: conn[i] -> conn[j]
|
|
for i, src := range connectors {
|
|
for j, dst := range connectors {
|
|
if i == j {
|
|
continue
|
|
}
|
|
|
|
crossSK, err := src.RequestCrossSession(serverURL, dst.ID)
|
|
if err != nil {
|
|
t.Fatalf("Cross-session %s->%s failed: %v", src.ID, dst.ID, err)
|
|
}
|
|
|
|
// Encrypt message from src to dst
|
|
message := []byte(fmt.Sprintf("Message from %s to %s", src.ID, dst.ID))
|
|
ciphertext, err := crypto.EncryptAES256GCM(crossSK, message, nil)
|
|
if err != nil {
|
|
t.Fatalf("Encryption %s->%s failed: %v", src.ID, dst.ID, err)
|
|
}
|
|
|
|
// Decrypt with same cross SK (should work since same key)
|
|
decrypted, err := crypto.DecryptAES256GCM(crossSK, ciphertext, nil)
|
|
if err != nil {
|
|
t.Fatalf("Decryption %s->%s failed: %v", src.ID, dst.ID, err)
|
|
}
|
|
|
|
if string(decrypted) != string(message) {
|
|
t.Errorf("Message corruption in %s->%s", src.ID, dst.ID)
|
|
}
|
|
|
|
t.Logf("Verified %s -> %s", src.ID, dst.ID)
|
|
}
|
|
}
|
|
|
|
t.Log("Mesh cross-session communication verified (3 devices, 6 pairs)")
|
|
}
|
|
|
|
// TC-Multi-004: Broadcast-like message distribution
|
|
func TestMultiDeviceBroadcastMessage(t *testing.T) {
|
|
port := int(atomic.AddInt32(&serverPort, 1))
|
|
server := NewMockServer(t, port)
|
|
if err := server.Start(); err != nil {
|
|
t.Fatalf("Failed to start server: %v", err)
|
|
}
|
|
defer server.Stop()
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
serverURL := fmt.Sprintf("http://localhost:%d", port)
|
|
|
|
// Create 4 connectors
|
|
connectors := make([]*Connector, 4)
|
|
for i := 0; i < 4; i++ {
|
|
conn, _ := NewConnector(fmt.Sprintf("DEV_bcast_%03d", i+1))
|
|
if err := conn.Register(serverURL); err != nil {
|
|
t.Fatalf("Registration failed: %v", err)
|
|
}
|
|
if err := conn.Authenticate(serverURL); err != nil {
|
|
t.Fatalf("Authentication failed: %v", err)
|
|
}
|
|
connectors[i] = conn
|
|
}
|
|
|
|
// Simulate broadcast: one device sends to all others
|
|
broadcaster := connectors[0]
|
|
broadcastMessage := []byte("Broadcast message to all devices")
|
|
|
|
t.Logf("Broadcaster: %s, recipients: %d", broadcaster.ID, len(connectors)-1)
|
|
|
|
for i := 1; i < len(connectors); i++ {
|
|
recipient := connectors[i]
|
|
crossSK, err := broadcaster.RequestCrossSession(serverURL, recipient.ID)
|
|
if err != nil {
|
|
t.Fatalf("Cross-session to %s failed: %v", recipient.ID, err)
|
|
}
|
|
|
|
ciphertext, err := crypto.EncryptAES256GCM(crossSK, broadcastMessage, nil)
|
|
if err != nil {
|
|
t.Fatalf("Encryption to %s failed: %v", recipient.ID, err)
|
|
}
|
|
|
|
decrypted, err := crypto.DecryptAES256GCM(crossSK, ciphertext, nil)
|
|
if err != nil {
|
|
t.Fatalf("Decryption from broadcaster to %s failed: %v", recipient.ID, err)
|
|
}
|
|
|
|
if string(decrypted) != string(broadcastMessage) {
|
|
t.Errorf("Broadcast message corrupted for recipient %s", recipient.ID)
|
|
}
|
|
|
|
t.Logf("Broadcast verified to %s", recipient.ID)
|
|
}
|
|
|
|
t.Log("Broadcast message distribution verified")
|
|
}
|
|
|
|
// TC-Multi-005: Sequential re-registration stress test
|
|
func TestMultiDeviceSequentialReRegistration(t *testing.T) {
|
|
port := int(atomic.AddInt32(&serverPort, 1))
|
|
server := NewMockServer(t, port)
|
|
if err := server.Start(); err != nil {
|
|
t.Fatalf("Failed to start server: %v", err)
|
|
}
|
|
defer server.Stop()
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
serverURL := fmt.Sprintf("http://localhost:%d", port)
|
|
|
|
// Create 3 connectors and register them
|
|
connectors := make([]*Connector, 3)
|
|
for i := 0; i < 3; i++ {
|
|
conn, _ := NewConnector(fmt.Sprintf("DEV_seq_%03d", i+1))
|
|
if err := conn.Register(serverURL); err != nil {
|
|
t.Fatalf("Initial registration failed for %s: %v", conn.ID, err)
|
|
}
|
|
connectors[i] = conn
|
|
}
|
|
|
|
// Verify initial registration count
|
|
if len(server.auth.devices) != 3 {
|
|
t.Errorf("Expected 3 devices after initial registration, got %d", len(server.auth.devices))
|
|
}
|
|
|
|
// Re-register each device sequentially
|
|
for i, conn := range connectors {
|
|
if err := conn.Register(serverURL); err != nil {
|
|
t.Errorf("Re-registration %d failed for %s: %v", i+1, conn.ID, err)
|
|
} else {
|
|
t.Logf("Re-registration %d successful for %s", i+1, conn.ID)
|
|
}
|
|
|
|
// Verify count stays at 3 (re-registration should not create duplicates)
|
|
if len(server.auth.devices) != 3 {
|
|
t.Errorf("After re-reg %d: expected 3 devices, got %d", i+1, len(server.auth.devices))
|
|
}
|
|
}
|
|
|
|
t.Log("Sequential re-registration stress test passed")
|
|
}
|
|
|
|
// TC-Multi-006: Device identity consistency after cross-session operations
|
|
func TestMultiDeviceCrossSessionIdentityConsistency(t *testing.T) {
|
|
port := int(atomic.AddInt32(&serverPort, 1))
|
|
server := NewMockServer(t, port)
|
|
if err := server.Start(); err != nil {
|
|
t.Fatalf("Failed to start server: %v", err)
|
|
}
|
|
defer server.Stop()
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
serverURL := fmt.Sprintf("http://localhost:%d", port)
|
|
|
|
conn1, _ := NewConnector("DEV_id_001")
|
|
conn2, _ := NewConnector("DEV_id_002")
|
|
|
|
// Register and authenticate
|
|
if err := conn1.Register(serverURL); err != nil {
|
|
t.Fatalf("Conn1 registration failed: %v", err)
|
|
}
|
|
if err := conn2.Register(serverURL); err != nil {
|
|
t.Fatalf("Conn2 registration failed: %v", err)
|
|
}
|
|
if err := conn1.Authenticate(serverURL); err != nil {
|
|
t.Fatalf("Conn1 auth failed: %v", err)
|
|
}
|
|
if err := conn2.Authenticate(serverURL); err != nil {
|
|
t.Fatalf("Conn2 auth failed: %v", err)
|
|
}
|
|
|
|
// Get cross SK multiple times for same pair
|
|
crossSK1a, _ := conn1.RequestCrossSession(serverURL, "DEV_id_002")
|
|
crossSK1b, _ := conn1.RequestCrossSession(serverURL, "DEV_id_002")
|
|
crossSK2a, _ := conn2.RequestCrossSession(serverURL, "DEV_id_001")
|
|
|
|
// Keys should be identical for same pair
|
|
if string(crossSK1a) != string(crossSK1b) {
|
|
t.Error("Multiple cross-session requests returned different keys")
|
|
}
|
|
if string(crossSK1a) != string(crossSK2a) {
|
|
t.Error("Cross-session keys don't match between same pair")
|
|
}
|
|
|
|
// Encrypt with first key, decrypt with second
|
|
message := []byte("identity consistency test")
|
|
ciphertext, _ := crypto.EncryptAES256GCM(crossSK1a, message, nil)
|
|
decrypted, _ := crypto.DecryptAES256GCM(crossSK1b, ciphertext, nil)
|
|
|
|
if string(decrypted) != string(message) {
|
|
t.Error("Cross-session encryption/decryption consistency failed")
|
|
}
|
|
|
|
t.Log("Cross-session identity consistency verified")
|
|
} |