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

185 lines
4.3 KiB
Go

// EasyTier coordinator - handles EasyTier tunnel coordination
package easytier
import (
"crypto/rand"
"encoding/base64"
"fmt"
"sync"
"time"
"security-connector/common/proto"
"security-connector/common/types"
)
// Coordinator manages EasyTier network participation
type Coordinator struct {
mu sync.RWMutex
// Nodes indexed by device ID
nodes map[string]*types.EasyTierNode
// Networks indexed by network ID
networks map[string]*Network
// Server address for EasyTier
serverAddr string
}
// Network represents an EasyTier network
type Network struct {
NetworkID string
Name string
CreatedAt time.Time
}
// NewCoordinator creates a new EasyTier coordinator
func NewCoordinator() *Coordinator {
return &Coordinator{
nodes: make(map[string]*types.EasyTierNode),
networks: make(map[string]*Network),
}
}
// SetServerAddress sets the EasyTier server address
func (c *Coordinator) SetServerAddress(addr string) {
c.mu.Lock()
defer c.mu.Unlock()
c.serverAddr = addr
}
// CreateNetwork creates a new EasyTier network
func (c *Coordinator) CreateNetwork(networkID, name string) error {
c.mu.Lock()
defer c.mu.Unlock()
if _, exists := c.networks[networkID]; exists {
return fmt.Errorf("network already exists: %s", networkID)
}
c.networks[networkID] = &Network{
NetworkID: networkID,
Name: name,
CreatedAt: time.Now(),
}
return nil
}
// AuthorizeDevice authorizes a device to join an EasyTier network
// Returns the credential string (device_id:temp_key) for --enable-creds mode
func (c *Coordinator) AuthorizeDevice(networkID, deviceID string) (*EasyTierResponse, error) {
c.mu.Lock()
defer c.mu.Unlock()
// Check if network exists
network, exists := c.networks[networkID]
if !exists {
// Create network if it doesn't exist (for Phase 1)
network = &Network{
NetworkID: networkID,
Name: "default",
CreatedAt: time.Now(),
}
c.networks[networkID] = network
}
// Generate credential (device_id:temp_key format)
credential, err := generateCredential(deviceID)
if err != nil {
return nil, fmt.Errorf("failed to generate credential: %w", err)
}
// Create node entry
node := &types.EasyTierNode{
NodeID: deviceID,
DeviceID: deviceID,
NetworkID: networkID,
Status: "active",
Credential: credential,
JoinedAt: time.Now(),
}
c.nodes[deviceID] = node
return &EasyTierResponse{
APIResponse: *proto.NewSuccessResponse(proto.TypeEasytierJoin),
Credential: credential,
ServerAddr: c.serverAddr,
NetworkID: networkID,
}, nil
}
// RevokeDevice revokes a device's EasyTier access
func (c *Coordinator) RevokeDevice(deviceID string) error {
c.mu.Lock()
defer c.mu.Unlock()
node, exists := c.nodes[deviceID]
if !exists {
return fmt.Errorf("node not found: %s", deviceID)
}
node.Status = "revoked"
return nil
}
// GetNode retrieves a node by device ID
func (c *Coordinator) GetNode(deviceID string) (*types.EasyTierNode, error) {
c.mu.RLock()
defer c.mu.RUnlock()
node, exists := c.nodes[deviceID]
if !exists {
return nil, fmt.Errorf("node not found: %s", deviceID)
}
return node, nil
}
// ListNodes lists all nodes in a network
func (c *Coordinator) ListNodes(networkID string) []*types.EasyTierNode {
c.mu.RLock()
defer c.mu.RUnlock()
var nodes []*types.EasyTierNode
for _, node := range c.nodes {
if node.NetworkID == networkID {
nodes = append(nodes, node)
}
}
return nodes
}
// EasyTierResponse is the response for EasyTier join
type EasyTierResponse struct {
proto.APIResponse
Credential string `json:"credential"`
ServerAddr string `json:"server_addr"`
NetworkID string `json:"network_id"`
}
// generateCredential generates a credential in device_id:temp_key format
func generateCredential(deviceID string) (string, error) {
// Generate a random key
key := make([]byte, 16)
if _, err := rand.Read(key); err != nil {
return "", err
}
keyStr := base64.StdEncoding.EncodeToString(key)
return fmt.Sprintf("%s:%s", deviceID, keyStr), nil
}
// GenerateCommand generates the EasyTier join command
func (c *Coordinator) GenerateCommand(networkID, deviceID string) string {
node, exists := c.nodes[deviceID]
if !exists {
return ""
}
// Format: easytier-node --enable-creds -n <network_id> -c <credential>
return fmt.Sprintf("easytier-node --enable-creds -n %s -c %s", networkID, node.Credential)
}