È 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 (fidate!) Tramite SSH. Troverei utile poter sapere chi ha effettuato l'accesso e quando. Ho 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?

Se vai nel file di configurazione sshd (di solito /etc/ssh/sshd_config) e cambi 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
Jun 24 22:43:42 localhost sshd [29779]: Chiave pubblica accettata per caleb dalla porta 127.0.0.1 59630 ssh2

Da 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.

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

Invece è possibile utilizzare l' environment=opzione nel file authorized_keys per impostare una variabile di ambiente, che la shell personalizzata può quindi leggere.

All'interno del .ssh/authorized_keysfile, 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 la $REMOTEUSERvariabile 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 la sshd_configdocumentazione su PermitUserEnvironment.

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.0 .

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 :

#!/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 l' attivazione di 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.logsia creato (e contenga 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.bashrco 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'
SSH_KEY_USER=user@mydesk
SSH_TTY=/dev/pts/2

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

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

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

Inoltre, nello script wrapper puoi fare tutto ciò che vuoi, registrando la chiave privata di joe è stata utilizzata sshin una determinata data e ora con il comando $ORIGINAL_COMMAND.

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

Puoi provare questo:

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

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

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

kszumny@laptop kszumny
kszumny@comp2 kszumny
tom@laptop tom
pati@home
chris@workstation1 chris
chris@workstation2 chris

Questa parte deve essere incollata su /etc/profile(per tutti gli utenti) o su~/.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)\u@\h:\w\$ '

Risultato