¿Es posible averiguar qué clave ssh se utilizó para acceder a una cuenta? Tengo una cuenta en un servidor a la que dejo que varias personas (¡de confianza!) Tengan acceso a través de ssh. Me resultaría útil poder saber quién inició sesión y cuándo. Tengo acceso a la raíz para poder mirar los registros, pero no parece haber nada allí. ¿Hay algún interruptor de configuración que ponga alguna forma de identificar la clave en los registros?

Si ingresa al archivo de configuración sshd (generalmente /etc/ssh/sshd_config) y cambia la directiva LogLevel a VERBOSE:

LogLevel VERBOSE

... puedes ver algo como esto en los registros:

24 de junio 22:43:42 localhost sshd [29779]: Clave RSA coincidente encontrada: d8: d5: f3: 5a: 7e: 27: 42: 91: e6: a5: e6: 9e: f9: fd: d3: ce
junio 24 22:43:42 localhost sshd [29779]: clave pública aceptada para caleb desde el puerto 127.0.0.1 59630 ssh2

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

Algo similar a la respuesta de @ user37161 . Si la cuenta compartida está ejecutando un shell personalizado y el shell necesita saber qué usuario está allí, entonces ejecutar el script "wrapper" podría no ser suficiente, ya que la información allí no se pasa al shell personalizado, excepto a través de métodos que podrían causar una carrera condiciones

En su lugar, puede usar la environment=opción en el archivo Authorized_keys para establecer una variable de entorno, que el shell personalizado puede leer.

Dentro de su .ssh/authorized_keysarchivo, anteponga cada línea con un conjunto de variables de entorno, como el siguiente:

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

Luego, el shell personalizado, o cualquiera de los diversos scripts rc, puede leer la $REMOTEUSERvariable y tomar la acción adecuada.

Sin embargo, tenga en cuenta que si está utilizando un shell estándar, entonces el usuario conectado puede modificar el archivo para frustrar varias cosas. Además, existen algunos riesgos al permitir a los usuarios establecer variables de entorno como LDPRELOAD. Ver la sshd_configdocumentación sobre PermitUserEnvironment.

Actualizar 2016-10-31 sobre el formato de registro

Algunas secuencias de comandos para una instalación adecuada

Hay un método completamente utilizable para rastrear / registrar conexiones ssh por clave con la experencia de nombre de usuario.

Introducción

Además de la respuesta de @Caleb, me gustaría compartir algunos pequeños trucos allí:

Nota: estoy trabajando en Debian 6.0 .

Instalación del servidor

Nivel de registro SSHD

Primero, asegúrese de que la configuración del servidor tenga un nivel de registro suficiente:

como root, esto establecerá un inicio de sesión detallado y activo:

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

Podría escribirse:

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

o en un script sed :

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

Que podría ejecutarse como:

patchSshdConfigLogLevel.sed -i /etc/ssh/sshd_config

Que por activar esto:

service ssh restart

Syslog: hacer que las huellas digitales sean legibles por el usuario

Ahora tome huellas digitales en un archivo legible por el usuario:

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

Intente (re) iniciar sesión desde ssh para asegurarse de que sshdusers.logse cree un nuevo archivo (y que contenga algo), luego

chmod 644 /var/log/sshdusers.log

Uso

Esto imprimirá la huella digital de las sesiones actuales:

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

Complemento para .bashrc

Y finalmente, hay un pequeño complemento para poner al final de su /etc/bash.bashrcusuario .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

así que después de volver a iniciar sesión desde SSH, verá:

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 En algunas instalaciones, el archivo de clave autorizado puede tener un nombre diferente, como $HOME/.ssh/authorized_keys2...

Supongamos que los usuarios "joe" y "deb" tienen acceso a la cuenta "x". Luego, en la cuenta x, .ssh_authorized_keysagrega las líneas:

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

También en la secuencia de comandos del contenedor puede hacer lo que quiera, registrando la clave privada de Joe que ha estado usando sshen una fecha y hora en particular con el comando $ORIGINAL_COMMAND.

En fedora 20+, los intentos y éxitos de inicio de sesión se guardan en /var/log/audit/audit.log. Este registro guarda los intentos de inicio de sesión (fallas y éxitos), y la huella digital clave utilizada para el intento de inicio de sesión se guarda en el campo denominado fp.

Puede comparar la huella digital clave iniciada con las huellas digitales en las claves autorizadas ejecutándola línea por línea a través de ssh-keygen -l

Una explicación detallada con respecto a los inicios de sesión ssh y su seguridad y detección de intrusos está aquí: http://vpathak.tumblr.com/post/121343814158/fedora-audit-log-with-love-from-russia

Puedes probar esto:

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

Además de @F. Respuesta de Hauri, preparo un útil "mensaje LoggedIn"

Un archivo adicional es opcional ($ HOME / .ssh / users):

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

Esta parte se debe pegar en /etc/profile(para todos los usuarios) o en~/.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\$ '

Resultado