Linked Agents

type LinkManager struct {
    links        map[string]*LinkedAgent  // routingID → LinkedAgent
    pipeToRoute  map[string]string        // pipePath → routingID
    nextID       uint32                   // Counter for routing IDs
    outboundData chan *LinkDataOut        // Data to send to server
    responseChannels map[string]chan *LinkDataOut  // Sync wait channels
    unlinkNotifications chan string       // Unlink events
}

// Sequential hex IDs: 1, 2, 3, ..., a, b, c, ...
func (lm *LinkManager) GenerateRoutingID() string {
    id := atomic.AddUint32(&lm.nextID, 1)
    return fmt.Sprintf("%x", id)
}

func connectToPipe(pipePath string) (net.Conn, error) {
    // Pipe path format: \\server\pipe\name
    // Example: \\192.168.1.50\pipe\spoolss

    timeout := 30 * time.Second
    deadline := time.Now().Add(timeout)

    for time.Now().Before(deadline) {
        conn, err := dialPipe(pipePath)
        if err == nil {
            return conn, nil
        }
        time.Sleep(100 * time.Millisecond)
    }
    return nil, fmt.Errorf("connection timeout")
}

func performLinkAuth(conn net.Conn) error {
    // 1. Read challenge from SMB agent
    challenge, _ := readMessage(conn)

    // 2. Sign challenge
    response := append([]byte("AUTH:"), challenge...)

    // 3. Send response
    writeMessage(conn, response)

    // 4. Read confirmation
    confirm, _ := readMessage(conn)
    if string(confirm) != "OK" {
        return fmt.Errorf("authentication failed")
    }
    return nil
}

link := &LinkedAgent{
    RoutingID: routingID,
    PipePath:  pipePath,
    Conn:      conn,
    Connected: time.Now(),
    LastSeen:  time.Now(),
    IsActive:  true,
}

lm.links[routingID] = link
lm.pipeToRoute[pipePath] = routingID

// Start data handler goroutine
go lm.handleIncomingData(link)

{
  "data": "<commands for edge>",
  "lc": [{"r": "1", "p": "<encrypted>"}],
  "lr": [{"r": "3", "p": "<handshake response>"}]
}

{
  "agent_id": "<edge_id>",
  "results": [<edge results>],
  "ld": [{"r": "1", "p": "<encrypted results>"}],
  "lu": ["3"]
}

// Server side: build nested commands for grandchildren
func (m *Manager) getCommandsForLinkedAgents(edgeClientID string) {
    for _, linkedClientID := range linkedAgents {
        // Get commands for this linked agent
        pendingCmds, _ := m.commandBuffer.GetCommand(linkedClientID)

        // RECURSIVE: Get nested data for this agent's children
        nestedHandshakes, nestedCommands, _ := m.getPendingLinkResponsesSeparate(linkedClientID)

        // Build combined payload
        payload := map[string]interface{}{
            "commands": cmds,
            "lr": nestedHandshakes,  // Nested handshake responses
            "lc": nestedCommands,    // Nested link commands
        }

        // Encrypt and add to response
    }
}

// Server side: process nested link data recursively
func (m *Manager) processLinkData(edgeClientID string, linkData []interface{}) {
    for _, item := range linkData {
        // Decrypt linked agent's payload
        linkedData := decryptLinkedPayload(payload, linkedConn.Secret1)

        // Process this agent's results
        m.processResults(ctx, tx, linkedClientID, linkedData.Results)

        // RECURSIVE: Process nested link data from grandchildren
        if len(linkedData.NestedLinkData) > 0 {
            m.processLinkData(linkedClientID, linkedData.NestedLinkData)
        }
    }
}

func (lr *LinkRouting) ResolveRoutingID(edgeClientID, routingID string) (string, error) {
    var linkedClientID string
    err := lr.db.QueryRow(`
        SELECT linked_clientID FROM link_routing
        WHERE edge_clientID = $1 AND routing_id = $2 AND status = 'active'`,
        edgeClientID, routingID).Scan(&linkedClientID)
    return linkedClientID, err
}

func writeMessage(conn net.Conn, data []byte) error {
    // 4-byte little-endian length + data
    length := uint32(len(data))
    header := []byte{
        byte(length),
        byte(length >> 8),
        byte(length >> 16),
        byte(length >> 24),
    }
    conn.Write(header)
    conn.Write(data)
    return nil
}

func readMessage(conn net.Conn) ([]byte, error) {
    header := make([]byte, 4)
    conn.Read(header)
    length := uint32(header[0]) | uint32(header[1])<<8 | ...
    data := make([]byte, length)
    conn.Read(data)
    return data, nil
}

func (c *UnlinkCommand) Execute(args []string) {
    routingID := args[0]
    lm := GetLinkManager()

    // Send graceful disconnect
    sendDisconnectMessage(link.Conn)

    // Close connection
    link.Conn.Close()
    link.IsActive = false

    // Queue unlink notification for server
    lm.unlinkNotifications <- routingID

    // Clean up maps
    delete(lm.links, routingID)
    delete(lm.pipeToRoute, link.PipePath)
}

func (lr *LinkRouting) DisconnectLink(edgeClientID, routingID string) {
    // Mark link as disconnected
    lr.db.Exec(`
        UPDATE link_routing SET status = 'disconnected'
        WHERE edge_clientID = $1 AND routing_id = $2`,
        edgeClientID, routingID)

    // Clear parent relationship in connections
    lr.db.Exec(`
        UPDATE connections SET parent_clientID = NULL, link_type = NULL
        WHERE newclientID = $1`,
        linkedClientID)
}

// Encrypt command for linked agent
func encryptForLinkedAgent(data []byte, secret string) (string, error) {
    key := sha256.Sum256([]byte(secret))
    block, _ := aes.NewCipher(key[:])
    aesGCM, _ := cipher.NewGCM(block)
    nonce := make([]byte, aesGCM.NonceSize())
    rand.Read(nonce)
    ciphertext := aesGCM.Seal(nonce, nonce, data, nil)
    return base64.StdEncoding.EncodeToString(ciphertext), nil
}

// Decrypt results from linked agent
func decryptLinkedPayload(payload string, secret string) ([]byte, error) {
    ciphertext, _ := base64.StdEncoding.DecodeString(payload)
    key := sha256.Sum256([]byte(secret))
    block, _ := aes.NewCipher(key[:])
    aesGCM, _ := cipher.NewGCM(block)
    nonce := ciphertext[:aesGCM.NonceSize()]
    ciphertext = ciphertext[aesGCM.NonceSize():]
    return aesGCM.Open(nil, nonce, ciphertext, nil)
}