Il piping di un messaggio firmato 'ssh-agent' è protetto da password?

8

C'è un filesystem crittografato su un server I ssh nell'uso dell'autenticazione a chiave pubblica. Poiché un ssh-agent inoltrato può firmare in modo deterministico un messaggio (vedi anche il protocollo ssh-agent sezione 2.6.2), considero l'utilizzo di un messaggio memorizzato sul server combinato 1 con la sua firma (usando una chiave RSA privata memorizzata sul client tramite il% co_de inoltrato) come password inviata al programma di crittografia per risolvere la mia domanda Come decrittografare un contenitore crittografato tramite ssh senza immettere una passphrase mentre richiede l'autenticazione di alcuni client? (ma in pratica qualsiasi richiesta di richiesta di password potrebbe essere coinvolta qui) e quindi scartata di nuovo. Ma questa è una buona idea (= sicura)? Che tipo di combinazione tra messaggio e firma dovrei effettivamente usare? È necessario utilizzare una coppia di chiavi diversa da quella per l'autenticazione ssh? O sto cercando di inventare una ruota triangolare?

1 La combinazione del messaggio originale con la firma in realtà aiuta in qualche modo rispetto all'uso semplicemente della firma? (A parte l'entropia, ma supponiamo che lo stretching chiave sia applicato comunque)

Ecco un breve riassunto di come funziona l'autenticazione della chiave pubblica SSHv2:
ssh-agent sul server remoto si aspetta che sshd o ssh del client firmi un messaggio predeterminato con la sua chiave privata (che non è memorizzata in remoto ) e il server può quindi verificarlo tramite la chiave pubblica inoltrata e controllarlo contro il database ssh-agent dell'utente.
authorized_keys -forwarding di solito consiste in una connessione a un terzo PC. Il PC intermedio genera il messaggio, ma chiede al ssh-agent del client originale di firmarlo, senza mai conoscere la chiave privata stessa. Questa stessa istruzione di firma è ciò che voglio usare per ottenere un "segreto" (la firma, non la chiave pubblica) che può essere usato come password che non è memorizzato da nessuna parte (e non può essere riprodotto sul client da solo se il messaggio -to-essere-firmato è memorizzato solo sul server) - nessun terzo PC coinvolto, solo l'agente che inoltra.

Ecco un'illustrazione del processo che intendo implementare:

Client:                   Server:
>ssh-add SECRET RSA KEY
>ssh -A server            <-- connect, forward agent (authentication does not
                                         need to use that specific secret key)

                          Connect to the 'SSH_AUTH_SOCK' unix socket and ask
                          the client's ssh-agent to sign MESSAGE with SECRET RSA KEY
                          (knowing only the respective PUBLIC RSA KEY to identify it)
ssh-agent signs MESSAGE --> SIGNATURE
                          [optionally verify SIGNATURE]

                          Use SIGNATURE as PASSWORD,
                          pipe that to the program and forget it.

A mio avviso ciò implica quanto segue:
Se il server viene rubato, il ladro dovrebbe intercettare il client che firma ssh-agent , altrimenti non può ottenere MESSAGE . Se il client viene rubato, senza PASSWORD non può essere generato nemmeno MESSAGE . Quindi sia il server che il client devono essere rubati e la passphrase di SIGNATURE può essere ottenuta - la forzatura bruta di cui sarebbe altrettanto fastidiosa come la forzatura bruta della stessa password originale ...

modifica Ho scritto un piccolo script Python per questo, SECRET RSA KEY

    
posta Tobias Kienzler 26.10.2012 - 17:39
fonte

3 risposte

3

Non è meno sicuro che inserire una password su SSH per decodificare il contenitore.

Qualunque decodifica di un contenitore su un sistema remoto è al sicuro è un problema completamente diverso.

    
risposta data 03.11.2012 - 11:49
fonte
2

Ecco i miei pensieri su ciò che un utente malintenzionato potrebbe fare:

  • Attacchi solo server :
    • Agente : Ottieni MESSAGGIO e connettiti al socket dell'agente ssh per ottenere SIGNATURE. Può essere mitigato da ssh-add -c , -x o -t
    • Entrambi : intercettazione
    • Entrambi : ... molte cose che potrebbero funzionare localmente, ad es. avvolgere il prompt della passphrase, forzare brutemente la passphrase del contenitore (il metodo Agent può facilmente scegliere uno più complesso, mentre la passphrase della chiave privata può rimanere piuttosto semplice); attacchi cold boot o lettura della passphrase dalla memoria di un sistema in esecuzione mentre il container è montato
  • Anche il client attacca :
    • Passphrase : Keylogger
    • Agente : ottieni la chiave privata non crittografata

Ad ogni modo, ecco un'effettiva implementazione per ottenere una firma: ssh-agent-sign (disclaimer: l'ho scritto)

    
risposta data 08.11.2012 - 12:36
fonte
1

Heh, in realtà ho avuto la stessa idea per la crittografia dei dati su macchine remote quando sono incappato nella tua domanda. Non capisco perché sia necessario combinare MESSAGE e SIGNATURE per creare PASSWORD . Non è sufficiente SIGNATURE ? Se non è MESSAGE non aiuterà. Per come la vedo io, la prima cosa da stabilire è se una firma è una chiave strong come una chiave privata. Per stabilirlo, alcune cose devono essere determinate:

  • La firma ha la stessa entropia della chiave privata? - La lunghezza della firma ha sempre le stesse dimensioni della chiave utilizzata. Quindi, per quanto riguarda la lunghezza della chiave, la quantità di entropia non viene influenzata.
  • La firma è casuale come la chiave utilizzata? (In realtà non lo so)
  • Il contenuto di MESSAGE ha qualche effetto sulla casualità di SIGNATURE ? (Non lo so neanche)

Per quanto riguarda MESSAGE : Penso che sarebbe saggio renderlo il più casuale possibile usando openssl rand (però, forse no ).

Non vedo alcun problema con il protocollo stesso

Un suggerimento: anziché collegare la firma direttamente a qualcosa che si desidera crittografare, è possibile decodificare la chiave effettiva ( KEY ) da utilizzare. In questo modo è possibile consentire a più firme di decrittografare gli stessi dati (salvando la chiave effettiva più volte crittografata con diverse firme). Quindi il protocollo sarebbe simile a questo.

Client:                   Server:
>ssh-add SECRET
>ssh -A server            
                          Locate keyfile for available signature
                          Ask ssh-agent to sign MESSAGE from keyfile with SECRET
ssh-agent returns SIGNATURE
                          Use SIGNATURE to decrypt PASSWORD from keyfile
                          Use PASSWORD to decrypt the actual data

Penso che ci proveremo e proveremo a implementarlo usando solo socat e bash, non dovrebbe essere così difficile: -)

    
risposta data 04.06.2014 - 22:03
fonte

Leggi altre domande sui tag