web-dev-qa-db-fra.com

Puis-je savoir quelle clé ssh a été utilisée pour accéder à un compte?

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 autorisé 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 il ne semble rien y avoir. Y a-t-il un commutateur de configuration qui permettra d'identifier la clé dans les journaux?

sshlogsauthentication
62
Andrew Stacey

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

LogLevel VERBOSE

... vous pouvez voir quelque chose comme ça 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
24 juin 22:43:42 localhost sshd [29779]: Publickey accepté pour caleb à partir du port 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.
39
Caleb

Un peu similaire à réponse de @ user37161 . Si le compte partagé exécute un shell personnalisé et que le shell a besoin de savoir quel utilisateur est là, l'exécution du script "wrapper" peut ne pas être suffisante, car les informations ne sont pas transmises dans le shell personnalisé, sauf par le biais de méthodes pouvant provoquer une course conditions.

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

À l'intérieur de votre .ssh/authorized_keys fichier, ajoutez à chaque ligne un ensemble 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 le $REMOTEUSER variable et effectuez l'action appropriée.

Cependant, notez que si vous utilisez un shell standard, l'utilisateur connecté est capable de modifier le fichier pour contrecarrer diverses choses. En outre, il existe certains risques en permettant aux utilisateurs de définir des variables d'environnement telles que LDPRELOAD. Voir le sshd_config documentation sur PermitUserEnvironment.

18
Chris Cogdon

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

Quelques scripts pour une installation correcte

Il existe une méthode entièrement utilisable pour suivre/consigner les connexions ssh par clé avec extension au nom d'utilisateur.

Introduction

En plus de la réponse de @Caleb, j'aimerais y partager quelques petits trucs:

Nota: je travaille sur Debian 6..

Installation du serveur

Niveau de journalisation SSHD

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

en tant que root, cela définira et active la connexion verbeuse:

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

Prenez maintenant 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 (re) vous connecter depuis ssh pour vous assurer que le nouveau fichier sshdusers.log est créé (et contient quelque chose), puis

chmod 644 /var/log/sshdusers.log

Usage

Cela 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 add-on à mettre à la fin de votre /etc/bash.bashrc ou 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 la reconnexion 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

Nota Sur certaines installations, le fichier de clé autorisé peut avoir un nom différent, comme $HOME/.ssh/authorized_keys2...

15
F. Hauri

Supposons que les utilisateurs "joe" et "deb" aient accès au compte "x". Puis dans le compte x's .ssh_authorized_keys vous ajoutez les lignes:

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

De plus, dans le script wrapper, vous pouvez faire tout ce que vous voulez, en enregistrant que la clé privée de joe a utilisé ssh à une date et une heure particulières avec la commande $ORIGINAL_COMMAND.

10
user37161

Vous pouvez essayer ceci:

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

Cette volonté:

  • ssh-add -L: Liste des clés publiques
  • awk '{ print $2 }': Obtenez juste l'empreinte digitale
  • xargs -i grep '{}' ~/.ssh/authorized_keys: Avec chaque touche, vérifiez laquelle est sur authorized_keys
  • head -n 1: Obtenez uniquement le premier
3
pci

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 succès) et l'empreinte digitale 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 touches autorisées en l'exécutant ligne par ligne via ssh-keygen -l

Une explication détaillée concernant les connexions ssh et leur détection de sécurité et d'intrusion est ici: http://vpathak.tumblr.com/post/121343814158/Fedora-audit-log-with-love-from-russia =

3
vpathak

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

Un fichier supplémentaire est facultatif ($ HOME/.ssh/utilisateurs):

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 à ~/.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

enter image description here

0
noisy