Implicazioni di sicurezza di una corsa socket durante il tunneling di un sottocomando

Question

Desidero eseguire il tunneling di un sottocomando tramite una connessione ascoltando una porta, eseguendo il sottocomando (per connettersi a tale porta) e quindi inoltrando i dati attraverso il collegamento:

package main 

import (
    "fmt" 
    "net" 
    "os" 
    "os/exec" 
) 

func main() { 
    ln, err := net.ListenTCP("tcp4", &net.TCPAddr{IP: localhost}) 
    if err != nil { 
     fmt.Fprintln(os.Stderr, err) 
     os.Exit(1) 
    } 
    defer ln.Close() 

    port := ln.Addr().(*net.TCPAddr).Port 

    cmd := exec.Command(
     "git", 
     "clone", 
     fmt.Sprintf("git://127.0.0.1:%d/project.git", port), 
    ) 

    cmd.Stdout = os.Stdout 
    cmd.Stderr = os.Stderr 

    if err := cmd.Start(); err != nil { 
     fmt.Fprintln(os.Stderr, err) 
     os.Exit(1) 
    } 
    defer cmd.Process.Kill() 

    errs := make(chan error, 1) 
    go func() { 
     errs <- cmd.Wait() 
    }() 

    conns := make(chan net.Conn, 1) 
    go func() { 
     conn, err := ln.Accept() 
     if err == nil { 
      conns <- conn 
     } else { 
      fmt.Println(err) 
      errs <- err 
     } 
    }() 

    select { 
    case err := <-errs: 
     fmt.Fprintln(os.Stderr, err) 
     os.Exit(1) 
    case conn := <-conns: 
     defer conn.Close() 
     // TODO Tunnel data from `conn` through another connection. 
    } 

    fmt.Println("done.") 
} 

var localhost = net.IPv4(127, 0, 0, 1) 

Tuttavia, c'è una gara qui tra il momento in cui iniziamo l'ascolto e il momento in cui il sub-comandi in realtà si collega per l'ascoltatore, in cui un altro processo in grado di connettersi a chi ascolta. Credo che questa razza possa essere sfruttata da un utente malintenzionato per comunicare con il processo all'altro estremo della connessione e ottenere risultati che altrimenti richiederebbero l'escalation dei privilegi (ad esempio gli attacchi che richiedono autorizzazioni speciali stanno sostituendo il comando git con un programma dannoso o semplicemente leggendo il contenuto della directory clonata, in questo caso).

Questo dovrebbe essere un problema? Se è così, c'è un modo in cui può essere prevenuto? Sebbene la domanda venga posta usando Go come esempio, le risposte e i commenti in qualsiasi lingua sono ben accetti.

Answer 1

Sì, è una preoccupazione. Può essere prevenuto usando una qualche forma di autenticazione in modo che il tuo server permetta solo connessioni da client legittimi.

Answer 2

Espandere la risposta di Warren Dew, supponendo che l'altra estremità del tunnel si connetta a un server SSH, quindi eseguirà l'autenticazione del server/client Git.

Un approccio più generale per "aggiungere" l'autenticazione a un sottocomando a tale scopo è quello di avvolgere il sottocomando in un contenitore come la finestra mobile e di avere il tunnel del sottocomando attraverso una connessione che si autentichi. Sebbene la condizione di competizione del tunnel sia ancora presente, è ad un "livello" più alto (cioè all'interno del container), nel senso che un attaccante senza privilegi non sarà in grado di sfruttare la condizione di competizione nel sistema base. Lo svantaggio di questo approccio è la sua complessità intrinseca e il sovraccarico (anche se minimo) dell'esecuzione del sottocomando in un contenitore.