Monitoraggio della clipboard in Go: rilevamento e redazione di segreti

package main

import "regexp"

// secretPatterns è una lista di regex compilate. Ogni regex deve avere un gruppo
// nominato chiamato "secret" che isola il valore sensibile da redarre.
var secretPatterns = []*regexp.Regexp{
    // AWS Access Key ID
    regexp.MustCompile(`(?i)(AKIA[0-9A-Z]{16})`),
    // AWS Secret Access Key (euristica: 40 caratteri alfanumerici+/+ dopo prefisso noto)
    regexp.MustCompile(`(?i)aws_secret_access_key\s*[=:]\s*(?P<secret>[A-Za-z0-9/+=]{40})`),
    // JWT token (tre segmenti base64url separati da punti)
    regexp.MustCompile(`(?P<secret>eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+)`),
    // Blocco PEM private key
    regexp.MustCompile(`(?P<secret>-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]+?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----)`),
    // Assegnazione password= o password: generica (copre file di config, .env)
    regexp.MustCompile(`(?i)(?:password|passwd|secret|api_key|token)\s*[=:]\s*(?P<secret>[^\s"']{8,})`),
    // GitHub personal access token
    regexp.MustCompile(`(?P<secret>gh[ps]_[A-Za-z0-9]{36})`),
}

// findSecret restituisce la sottostringa del segreto trovato e la posizione
// del match completo, oppure stringa vuota e -1 se nessun pattern corrisponde.
func findSecret(content string) (fullMatch, secret string, start, end int) {
    for _, re := range secretPatterns {
        loc := re.FindStringIndex(content)
        if loc == nil {
            continue
        }
        match := content[loc[0]:loc[1]]
        names := re.SubexpNames()
        sub := re.FindStringSubmatch(content)
        secretVal := match
        for i, name := range names {
            if name == "secret" && i < len(sub) {
                secretVal = sub[i]
            }
        }
        return match, secretVal, loc[0], loc[1]
    }
    return "", "", -1, -1
}

package main

import "strings"

// redactSecret sostituisce la maggior parte del segreto con asterischi, mantenendo
// fino a 3 caratteri finali per la verifica dell'utente.
func redactSecret(content, secret string) string {
    if len(secret) == 0 {
        return content
    }

    visibleSuffix := 0
    switch {
    case len(secret) >= 12:
        visibleSuffix = 3
    case len(secret) >= 9:
        visibleSuffix = 2
    case len(secret) >= 6:
        visibleSuffix = 1
    }

    redacted := strings.Repeat("*", len(secret)-visibleSuffix) +
        secret[len(secret)-visibleSuffix:]

    return strings.Replace(content, secret, redacted, 1)
}

package main

import (
    "context"
    "log"
    "time"

    "github.com/atotto/clipboard"
    "github.com/gen2brain/beeep"
)

type Watcher struct {
    interval        time.Duration
    previousContent string
}

func NewWatcher(interval time.Duration) *Watcher {
    return &Watcher{interval: interval}
}

// Run esegue il polling della clipboard finche ctx non viene annullato.
// È sicuro chiamarlo da una singola goroutine; l'accesso alla clipboard non è
// concorrente. Non devono essere in esecuzione più watcher contemporaneamente.
func (w *Watcher) Run(ctx context.Context) {
    ticker := time.NewTicker(w.interval)
    defer ticker.Stop()

    for {
        select {
        case <-ctx.Done():
            log.Println("clipboard watcher: shutting down")
            return
        case <-ticker.C:
            w.check()
        }
    }
}

func (w *Watcher) check() {
    content, err := clipboard.ReadAll()
    if err != nil {
        // ReadAll puo fallire su Wayland/X11 se non c'è un owner; tratta come vuoto.
        return
    }
    if content == w.previousContent {
        return
    }
    w.previousContent = content

    _, secret, _, _ := findSecret(content)
    if secret == "" {
        return
    }

    redacted := redactSecret(content, secret)
    if err := clipboard.WriteAll(redacted); err != nil {
        log.Printf("clipboard watcher: failed to redact: %v", err)
        return
    }
    w.previousContent = redacted

    log.Printf("clipboard watcher: redacted a secret (%d chars)", len(secret))
    _ = beeep.Notify(
        "Clipboard Watcher",
        "Un potenziale segreto è stato rilevato e redatto dalla clipboard.",
        "",
    )
}

package main

import (
    "context"
    "log"
    "os"
    "os/signal"
    "syscall"
    "time"
)

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    // Intercetta SIGINT e SIGTERM per uno shutdown pulito.
    sigs := make(chan os.Signal, 1)
    signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
    go func() {
        <-sigs
        cancel()
    }()

    log.Println("clipboard watcher: starting (interval=500ms)")
    watcher := NewWatcher(500 * time.Millisecond)
    watcher.Run(ctx)
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.manuelfedele.clipboard-watcher</string>

    <key>ProgramArguments</key>
    <array>
        <string>/usr/local/bin/clipboard-watcher</string>
    </array>

    <key>RunAtLoad</key>
    <true/>

    <key>KeepAlive</key>
    <true/>

    <key>StandardOutPath</key>
    <string>/tmp/clipboard-watcher.log</string>

    <key>StandardErrorPath</key>
    <string>/tmp/clipboard-watcher.err</string>

    <!-- Richiesto per l'accesso alla clipboard su macOS Sonoma+ -->
    <key>EnvironmentVariables</key>
    <dict>
        <key>PATH</key>
        <string>/usr/local/bin:/usr/bin:/bin</string>
    </dict>
</dict>
</plist>

# Copia il binario in una posizione stabile
go build -o clipboard-watcher .
sudo cp clipboard-watcher /usr/local/bin/clipboard-watcher

# Carica il launch agent (gira come utente corrente, non come root)
launchctl load ~/Library/LaunchAgents/com.manuelfedele.clipboard-watcher.plist

# Verifica che sia in esecuzione
launchctl list | grep clipboard-watcher

[Unit]
Description=Clipboard secret watcher
After=graphical-session.target

[Service]
Type=simple
ExecStart=/usr/local/bin/clipboard-watcher
Restart=on-failure
RestartSec=5s
# Richiesto per l'accesso alla clipboard via X11 o Wayland
Environment=DISPLAY=:0
Environment=XAUTHORITY=%h/.Xauthority

[Install]
WantedBy=default.target

systemctl --user enable clipboard-watcher
systemctl --user start clipboard-watcher
systemctl --user status clipboard-watcher

# Build per l'architettura corrente
go build -o clipboard-watcher -ldflags="-s -w" .

# Su macOS, firma ad-hoc per uso locale (non richiede account developer)
codesign --sign - --force --preserve-metadata=entitlements ./clipboard-watcher

# Per la distribuzione, firma con il tuo Apple Developer ID
# codesign --sign "Developer ID Application: Your Name (TEAM_ID)" ./clipboard-watcher
# xcrun notarytool submit clipboard-watcher --apple-id ... --wait