Est-il possible de savoir quelle clé SSH a été utilisée pour accéder à un compte? J'ai un compte sur un serveur auquel j'ai laissé plusieurs personnes (de confiance!) Accéder via ssh. Je trouverais utile de pouvoir savoir qui s'est connecté et quand. J'ai un accès root pour pouvoir consulter les journaux, mais rien ne semble s'y trouver. Existe-t-il un commutateur de configuration permettant d'identifier la clé dans les journaux?

Si vous allez dans le fichier de configuration sshd (généralement /etc/ssh/sshd_config) et modifiez la directive LogLevel en VERBOSE:

LogLevel VERBOSE

... vous pouvez voir quelque chose comme ceci dans les journaux:

24 juin 22:43:42 localhost sshd [29779]: Clé RSA correspondante trouvée: d8: d5: f3: 5a: 7e: 27: 42: 91: e6: a5: e6: 9e: f9: fd: d3: ce
juin 24 22:43:42 sshd localhost [29779]: Publickey accepté pour caleb à partir du port 59630 ssh2 du 127.0.0.1

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.

Un peu similaire à la réponse de @ user37161 . Si le compte partagé exécute un shell personnalisé et que celui-ci a besoin de savoir quel utilisateur se trouve, l'exécution du script "wrapper" risque de ne pas être suffisante, car les informations qui y sont transférées ne sont pas transmises au shell personnalisé, sauf par le biais de méthodes pouvant entraîner une course. conditions.

À la place, vous pouvez utiliser l' environment=option du fichier allowed_keys pour définir une variable d'environnement, que le shell personnalisé peut ensuite lire.

Dans votre .ssh/authorized_keysfichier, ajoutez à chaque ligne un jeu de variables d’environnement, comme suit:

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

Ensuite, le shell personnalisé, ou l’un des divers scripts rc, peut lire la $REMOTEUSERvariable et prendre les mesures appropriées.

Cependant, notez que si vous utilisez un shell standard, l'utilisateur connecté est capable de modifier le fichier pour contrecarrer diverses choses. De plus, permettre aux utilisateurs de définir des variables d'environnement telles que LDPRELOAD. Voir la sshd_configdocumentation sur PermitUserEnvironment.

Mise à niveau 2016-10-31 sur le format du journal

Quelques scripts pour une installation correcte

Il existe une méthode utilisable complète pour suivre / consigner les connexions SSH par clé avec expention au nom d'utilisateur.

introduction

En plus de la réponse de @Caleb, je voudrais partager quelques petites astuces:

Note: Je travaille sur Debian 6.0 .

Installation du serveur

Niveau de journal SSHD

Tout d'abord, assurez-vous que la configuration du serveur a un niveau de journalisation suffisant:

en tant que root, cela va définir et activer loggin prolixe:

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

Pourrait être écrit:

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

ou dans un script sed :

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

Qui pourrait être exécuté comme:

patchSshdConfigLogLevel.sed -i /etc/ssh/sshd_config

Que pour activer ceci:

service ssh restart

Syslog: rendre les empreintes digitales lisibles par l'utilisateur

Maintenant, prenez les empreintes digitales dans un fichier lisible par l'utilisateur:

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

Essayez de vous (re) connecter à partir de ssh pour vous assurer que le nouveau fichier sshdusers.logest créé (et contient quelque chose), puis

chmod 644 /var/log/sshdusers.log

Usage

Ceci imprimera l'empreinte digitale des sessions en cours:

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 pour .bashrc

Et enfin, il y a un petit ajout à mettre à la fin de votre /etc/bash.bashrcou de l'utilisateur .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

donc, après vous être reconnecté à partir de SSH, vous verrez:

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

Note Lors de certaines installations, le fichier de clé autorisé peut être nommé différemment, comme $HOME/.ssh/authorized_keys2...

Supposons que les utilisateurs "joe" et "deb" aient accès au compte "x". Ensuite, dans le compte x, .ssh_authorized_keysvous ajoutez les lignes:

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

Dans le script d'encapsidation, vous pouvez également faire ce que vous voulez, en enregistrant la clé privée utilisée sshpar joe à une date et une heure données avec commande $ORIGINAL_COMMAND.

Sur Fedora 20+, les tentatives de connexion et les succès sont enregistrés dans /var/log/audit/audit.log. Ce journal enregistre les tentatives de connexion (échecs et réussites) et l'empreinte digitale de la clé utilisée pour la tentative de connexion est enregistrée dans le champ nommé fp.

Vous pouvez comparer l'empreinte digitale de la clé connectée avec les empreintes digitales dans les allowed_keys en l'exécutant ligne par ligne via ssh-keygen -l.

Une explication détaillée concernant les connexions SSH et leur sécurité et la détection d'intrusion est disponible à l' adresse suivante : http://vpathak.tumblr.com/post/121343814158/fedora-audit-log-with-love-from-russia

Vous pouvez essayer ceci:

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

En plus de @F. Hauri répond, je prépare utile "invite LoggedIn".

Un fichier supplémentaire est optionnel ($ HOME / .ssh / users):

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

Cette partie doit être collée dans /etc/profile(pour tous les utilisateurs) ou dans~/.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\$ '

Résultat