- 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
185 lines
4.3 KiB
Go
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)
|
|
} |