Swarm Security: Defending Against Memory-Injection

// internal/swarm/blackboard/injection_test.go
func TestMINJA_PheromoneFloodIsClamped(t *testing.T) {
    b := NewMemoryBoard(nil)
    ctx := context.Background()
    camp := uuid.New()

    // Attacker tries to set pheromone way above the legitimate range to
    // dominate ranking. Either the board must clamp to 1.0 or refuse.
    id, _ := b.Write(ctx, Finding{
        CampaignID:    camp,
        AgentName:     "recon",
        Type:          TypeCVEMatch,
        Target:        "victim",
        PheromoneBase: 9999.0,
        HalfLifeSec:   3600,
    })
    results, _ := b.Query(ctx, Predicate{Types: []FindingType{TypeCVEMatch}})
    var got float64
    for _, r := range results {
        if r.ID == id {
            got = r.Pheromone
        }
    }
    if got > 1.0 {
        t.Errorf("pheromone-flood not clamped: got %f, want ≤ 1.0", got)
    }
}

// internal/swarm/provenance/provenance.go

// NewSigner generates a fresh keypair. Call once per agent per process.
func NewSigner() (*Signer, error) {
    pub, priv, err := ed25519.GenerateKey(rand.Reader)
    if err != nil {
        return nil, fmt.Errorf("generate ed25519 key: %w", err)
    }
    return &Signer{priv: priv, pub: pub}, nil
}

// Sign produces a signature over the canonical bytes of a finding.
func (s *Signer) Sign(campaignID, agentName, findingType, target string,
    data []byte, createdUnix int64) []byte {
    msg := canonicalBytes(campaignID, agentName, findingType, target, data, createdUnix)
    return ed25519.Sign(s.priv, msg)
}

// Verify checks a signature against the public key + canonical bytes.
// Returns nil if the signature is valid; an error otherwise.
func Verify(pub []byte, sig []byte, campaignID, agentName, findingType,
    target string, data []byte, createdUnix int64) error {
    if len(pub) != ed25519.PublicKeySize {
        return errors.New("provenance: bad public key length")
    }
    if len(sig) != ed25519.SignatureSize {
        return errors.New("provenance: bad signature length")
    }
    msg := canonicalBytes(campaignID, agentName, findingType, target, data, createdUnix)
    if !ed25519.Verify(ed25519.PublicKey(pub), msg, sig) {
        return errors.New("provenance: signature verification failed (possible tamper)")
    }
    return nil
}

func canonicalBytes(campaignID, agentName, findingType, target string,
    data []byte, createdUnix int64) []byte {
    v := struct {
        C string `json:"c"` // campaign id
        A string `json:"a"` // agent name
        T string `json:"t"` // finding type
        G string `json:"g"` // tarGet
        D []byte `json:"d"` // data
        U int64  `json:"u"` // unix-ts
    }{C: campaignID, A: agentName, T: findingType, G: target, D: data, U: createdUnix}
    out, _ := json.Marshal(v)
    return out
}

// internal/swarm/memorygraft/detector.go

// Config tunes the detector. Zero-values pick conservative defaults.
type Config struct {
    BurstWindow            time.Duration // default 60s
    BurstThreshold         int           // default 50
    RepeatTitleThreshold   int           // default 5
    DuplicateDataThreshold int           // default 3
}

// Alert describes one suspicious pattern detected on the blackboard.
type Alert struct {
    Kind        string    // "burst" | "repeat-title" | "duplicate-data" | "type-mismatch"
    AgentName   string
    Description string
    Severity    string    // "low" | "medium" | "high"
    FirstSeen   time.Time
    Count       int
}

var expectedAuthors = map[blackboard.FindingType]map[string]bool{
    blackboard.TypeCVEMatch:      {"classifier": true},
    blackboard.TypeMisconfig:     {"classifier": true},
    blackboard.TypeExploitChain:  {"exploit": true},
    blackboard.TypeExploitResult: {"exploit": true},
    blackboard.TypePortOpen:      {"recon": true, "nmap": true},
    blackboard.TypeSubdomain:     {"recon": true},
}

// internal/swarm/ratelimit/ratelimit.go

// New builds a limiter that fills at perSecond tokens/second,
// with a bucket cap of burst tokens.
func New(perSecond, burst float64) *Limiter {
    if burst <= 0 {
        burst = perSecond
    }
    return &Limiter{
        rate:   perSecond,
        burst:  burst,
        tokens: burst,
        last:   time.Now(),
    }
}

// Take blocks until one token is available (or ctx is done).
func (l *Limiter) Take(ctx context.Context) error {
    if l == nil || l.rate <= 0 {
        return nil
    }
    for {
        l.mu.Lock()
        now := time.Now()
        elapsed := now.Sub(l.last).Seconds()
        l.tokens += elapsed * l.rate
        if l.tokens > l.burst {
            l.tokens = l.burst
        }
        l.last = now
        if l.tokens >= 1 {
            l.tokens--
            l.mu.Unlock()
            return nil
        }
        need := 1 - l.tokens
        wait := time.Duration(need / l.rate * float64(time.Second))
        l.mu.Unlock()
        select {
        case <-ctx.Done():
            return ctx.Err()
        case <-time.After(wait):
        }
    }
}

// internal/scope/validator.go

// ValidateCommand extracts all IPs and domains from a command string and
// validates each against the scope. Returns ErrScopeViolation if any
// target is out of scope. Called before every command execution.
func ValidateCommand(cmd string, scope ScopeDefinition) error {
    matches := ipAndDomainPattern.FindAllString(cmd, -1)
    for _, match := range matches {
        if isCommonNonTarget(match) {
            continue
        }
        if err := Validate(match, scope); err != nil {
            return fmt.Errorf("command contains out-of-scope target: %w", err)
        }
    }
    return nil
}

// internal/pipeline/cleanup_memory.go

// RunCleanup executes all pending cleanup actions for a campaign in reverse order.
func (m *MemoryCleanupRegistry) RunCleanup(ctx context.Context, campaignID uuid.UUID) *CleanupReport {
    m.mu.Lock()
    actions := m.actions[campaignID]
    delete(m.actions, campaignID)
    m.mu.Unlock()

    report := &CleanupReport{CampaignID: campaignID, TotalCount: len(actions)}
    for i := len(actions) - 1; i >= 0; i-- {
        // ... execute action[i], append to report.Executed or report.Failed
    }
    return report
}