it-swarm.it

Posso scoprire quale chiave ssh è stata utilizzata per accedere a un account?

È possibile scoprire quale chiave ssh è stata utilizzata per accedere a un account? Ho un account su un server a cui ho accesso a molte persone (affidabili!) Tramite SSH. Troverei utile poter sapere chi ha effettuato l'accesso e quando. Ho l'accesso come root in modo da poter guardare i registri, ma non sembra esserci nulla. Esiste un interruttore di configurazione che consentirà di identificare la chiave nei registri?

62
Andrew Stacey

Se vai nel file di configurazione sshd (di solito /etc/ssh/sshd_config) e modifica la direttiva LogLevel su VERBOSE:

LogLevel VERBOSE

... puoi vedere qualcosa del genere nei registri:

24 giu 22:43:42 localhost sshd [29779]: trovata chiave RSA corrispondente: d8: d5: f3: 5a: 7e: 27: 42: 91: e6: a5: e6: 9e: f9: fd: d3: ce
24 giu 22:43:42 localhost sshd [29779]: Chiave pubblica accettata per caleb dalla porta 127.0.0.1 59630 ssh2

A partire dal man sshd_config:

   LogLevel
          Gives  the  verbosity  level that is used when logging messages from
          sshd(8).  The possible values are: QUIET, FATAL, ERROR,  INFO,  VER-
          BOSE,  DEBUG,  DEBUG1,  DEBUG2,  and  DEBUG3.   The default is INFO.
          DEBUG and DEBUG1 are equivalent.  DEBUG2  and  DEBUG3  each  specify
          higher  levels of debugging output.  Logging with a DEBUG level vio-
          lates the privacy of users and is not recommended.
39
Caleb

Un po 'simile a la risposta di @ user37161 . Se l'account condiviso esegue una shell personalizzata e Shell deve sapere quale utente è presente, l'esecuzione dello script "wrapper" potrebbe non essere sufficiente, poiché le informazioni non vengono passate nella shell personalizzata, tranne attraverso metodi che potrebbero causare razza condizioni.

Invece puoi usare il environment= opzione nel file authorized_keys per impostare una variabile d'ambiente, che la Shell personalizzata può quindi leggere.

Dentro il tuo .ssh/authorized_keys file, anteporre ogni riga con un set di variabili di ambiente, come il seguente:

environment="REMOTEUSER=jrhacker" ssh-rsa ....
environment="REMOTEUSER=jbloggs" ssh-rsa ....

Quindi la shell personalizzata, o uno qualsiasi dei vari script rc, può leggere $REMOTEUSER variabile e intraprendere l'azione appropriata.

Tuttavia, si noti che se si utilizza una Shell standard, l'utente che ha effettuato l'accesso è in grado di modificare il file per contrastare varie cose. Inoltre, vi sono alcuni rischi nel consentire agli utenti di impostare variabili di ambiente come LDPRELOAD. Vedi il sshd_config documentazione su PermitUserEnvironment.

18
Chris Cogdon

Aggiornamento 2016-10-31 sul formato del registro

Alcuni script per una corretta installazione

Esiste un metodo completamente utilizzabile per tracciare/registrare le connessioni ssh per chiave con estensione al nome utente.

Introduzione

Oltre alla risposta di @Caleb, vorrei condividere alcuni piccoli trucchi lì:

Nota: Sto lavorando su Debian 6..

Installazione del server

Livello registro SSHD

Innanzitutto assicurarsi che la configurazione del server abbia un livello di registrazione sufficiente:

come root, questo imposterà ed effettuerà il login dettagliato:

sed '/^[^#]*LogLevel.*\(QUIET\|FATAL\|ERROR\|INFO\)/{s/^/# /;h;s/$/\nLogLevel VERBOSE/};${p;g;/./!{iLogLevel VERBOSE'$'\n;};D}'  -i /etc/ssh/sshd_config

Potrebbe essere scritto:

sed '
     /^[^#]*LogLevel.*\(QUIET\|FATAL\|ERROR\|INFO\)/{
        s/^/# /;
        h;
        s/$/\nLogLevel VERBOSE/
    };
    ${
        p;
        g;
        /./!{
            iLogLevel VERBOSE
        };
        D
    }'  -i /etc/ssh/sshd_config

o in uno script sed sed :

#!/bin/sed -f
/^[^#]*LogLevel.*\(QUIET\|FATAL\|ERROR\|INFO\)/{
    s/^/# /;
    h;
    s/$/\nLogLevel VERBOSE/
};
${
    p;
    g;
    /./!{
        iLogLevel VERBOSE
    };
    D
}

Che potrebbe essere eseguito come:

patchSshdConfigLogLevel.sed -i /etc/ssh/sshd_config

Che per attivando questo:

service ssh restart

Syslog: rendere le impronte digitali leggibili dall'utente

Ora prendi le impronte digitali nel file leggibile dall'utente:

echo ':msg, regex, "Found matching .* key:" -/var/log/sshdusers.log' \
    > /etc/rsyslog.d/ssh_key_user.conf 
echo ':msg, regex, "Accepted publickey for" -/var/log/sshdusers.log' \
    >> /etc/rsyslog.d/ssh_key_user.conf 

service rsyslog restart

Prova a (ri) accedere da ssh per assicurarti che il nuovo file sshdusers.log viene creato (e contiene qualcosa), quindi

chmod 644 /var/log/sshdusers.log

Uso

Questo stamperà l'impronta digitale delle sessioni correnti:

sed -ne "/sshd.$PPID.:.*matching .SA key/{s/^.* //g;h};\${x;p}" /var/log/sshdusers.log
sed -ne "/sshd.\($(($(ps ho ppid $PPID)))\|$PPID\).:.*\(Accepted publickey\|matching .SA key\)/{s/^.* //g;h};\${x;p}" /var/log/sshdusers.log

Plug-in per .bashrc

E infine, c'è un piccolo componente aggiuntivo da mettere alla fine del tuo /etc/bash.bashrc o dell'utente .bashrc:

ssh_oPwd=$OLDPWD
ssh_oUmask=$(umask)
umask 077
ssh_tempdir=$(mktemp -d /tmp/ssh-id-XXXXXXX)
cd $ssh_tempdir || exit 1

ssh_crtFp=$(
    sed -ne "/sshd.\($(($(ps ho ppid $PPID)))\|$PPID\).:.*\(Accepted publickey\|matching .SA key\)/{s/^.* //g;h};\${x;p}" /var/log/sshdusers.log
)
for ((ssh_i=1;ssh_i<=$(wc -l <$HOME/.ssh/authorized_keys);ssh_i++));do
    export ssh_line="$(sed -ne ${ssh_i}p <$HOME/.ssh/authorized_keys)"
    echo "$ssh_line" >tempKey
    export ssh_lFp=($(ssh-keygen -l -f tempKey))
    if [ "${ssh_lFp[1]}" == "$ssh_crtFp" ] ;then
        export SSH_KEY_USER=${ssh_line##* }
        break
      fi
  done

cd $OLDPWD
OLDPWD=$ssh_oPwd
rm -fR $ssh_tempdir
umask $ssh_oUmask
unset ssh_lFp ssh_line ssh_i ssh_crtFp ssh_tempdir ssh_oUmask ssh_oPwd

quindi dopo il login di nuovo da SSH, vedrai:

set | grep ^SSH
SSH_CLIENT='192.168.1.31 43734 22'
SSH_CONNECTION='192.168.1.31 43734 192.168.1.2 22'
[email protected]
SSH_TTY=/dev/pts/2

Nota In alcune installazioni, il file della chiave autorizzata potrebbe avere un nome diverso, come $HOME/.ssh/authorized_keys2...

15
F. Hauri

Supponiamo che gli utenti "joe" e "deb" abbiano accesso all'account "x". Quindi nell'account x è .ssh_authorized_keys aggiungi le righe:

command='wrapper joe' joe public key
command='wrapper deb' deb public key

Anche nello script wrapper puoi fare tutto quello che vuoi, registrando che la chiave privata di joe ha utilizzato ssh in una data e ora particolari con il comando $ORIGINAL_COMMAND.

10
user37161

Puoi provare questo:

ssh-add -L | awk '{ print $2 }' | xargs -i grep '{}' ~/.ssh/authorized_keys  | head -n 1

Questo sarà:

  • ssh-add -L: Elenca le chiavi pubbliche
  • awk '{ print $2 }': Ottieni solo l'impronta digitale
  • xargs -i grep '{}' ~/.ssh/authorized_keys: Con ogni tasto, controlla quale è su authorized_keys
  • head -n 1: Ottieni solo il primo
3
pci

Su Fedora 20+ i tentativi di accesso e i successi vengono salvati in /var/log/audit/audit.log. Questo registro salva i tentativi di accesso (errori e esiti positivi) e l'impronta digitale della chiave utilizzata per il tentativo di accesso viene salvata nel campo denominato fp.

È possibile confrontare l'impronta digitale della chiave registrata con le impronte digitali nelle lettere autorizzate eseguendola riga per riga tramite ssh-keygen -l

Una spiegazione dettagliata per quanto riguarda gli accessi ssh e il loro rilevamento di sicurezza e intrusioni è qui: http://vpathak.tumblr.com/post/121343814158/Fedora-audit-log-with-love-from-russia =

3
vpathak

Oltre a @F. Hauri risposta, preparo utile "LoggedIn Prompt".

Un file aggiuntivo è facoltativo ($ HOME/.ssh/users):

[email protected] kszumny
[email protected] kszumny
[email protected] tom
[email protected]
[email protected] chris
[email protected] chris

Questa parte deve essere incollata su /etc/profile (per tutti gli utenti) o ~/.bashrc

other_users_Prompt()
{
    pids=`ps fx | grep "sshd:\s" | awk '{print $1}'`
    users=""
    for uid in $pids
    do
        ssh_crtFp=`sed -ne "/sshd.$uid.:.*matching .SA key/{s/^.* //g;p;q}" /var/log/sshdusers.log`
        for ((ssh_i=1;ssh_i<=$(wc -l <$HOME/.ssh/authorized_keys);ssh_i++));do
            export ssh_line="$(sed -ne ${ssh_i}p <$HOME/.ssh/authorized_keys)"
            echo "$ssh_line" >tempKey
            export ssh_lFp=($(ssh-keygen -l -f tempKey))
            if [ "${ssh_lFp[1]}" == "$ssh_crtFp" ] ;then
                export SSH_KEY_USER=${ssh_line##* }
                ST_USER=`cat $HOME/.ssh/users | grep "${SSH_KEY_USER}" | awk '{print $2}'`
                if [ -z "$ST_USER" ]; then
                    ST_USER=$SSH_KEY_USER
                fi
                if [ -z "$users" ]; then
                    users="$ST_USER"
                else
                    users="$users\n$ST_USER"
                fi
                break
            fi
        done
    done

    if [ `echo -e "$users" | sort | uniq -c | wc -l` == 1  ]; then
       exit
    fi

    users=`echo -e "$users" | sort | uniq -c | awk '{print $2"("$1")"}' | xargs echo -e`
    echo -e "[LoggedIn:$users] "

}

PS1='$(other_users_Prompt)\[email protected]\h:\w\$ '

Risultato

enter image description here

0
noisy