Ist es möglich herauszufinden, mit welchem ​​SSH-Schlüssel auf ein Konto zugegriffen wurde? Ich habe ein Konto auf einem Server, auf den mehrere (vertrauenswürdige!) Personen über ssh zugreifen können. Ich finde es nützlich zu wissen, wer wann angemeldet ist. Ich habe root-Zugriff, damit ich die Protokolle einsehen kann, aber es scheint nichts da zu sein. Gibt es einen Konfigurationsschalter, mit dem der Schlüssel in den Protokollen identifiziert werden kann?

Wenn Sie (normalerweise /etc/ssh/sshd_config) in die sshd-Konfigurationsdatei gehen und die LogLevel-Direktive in VERBOSE ändern:

LogLevel VERBOSE

... Sie können so etwas in den Protokollen sehen:

24 Juni 22.43.42 localhost sshd [29779]: gefunden RSA - Schlüssel: d8: d5: f3: 5a: 7e: 27: 42: 91: e6: a5: e6: 9e: f9: fd: d3: ce
Juni 24 22:43:42 localhost sshd [29779]: Akzeptiert publickey für caleb von 127.0.0.1 port 59630 ssh2

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

Etwas ähnlich der Antwort von @ user37161 . Wenn auf dem gemeinsam genutzten Konto eine benutzerdefinierte Shell ausgeführt wird und die Shell wissen muss, welcher Benutzer sich dort befindet, ist die Ausführung des Skripts "wrapper" möglicherweise nicht ausreichend, da Informationen nur über Methoden an die benutzerdefinierte Shell weitergegeben werden, die Race verursachen können Bedingungen.

Stattdessen können Sie die environment=Option in authorized_keys-Datei verwenden, um eine Umgebungsvariable festzulegen, die von der benutzerdefinierten Shell gelesen werden kann.

Stellen Sie in Ihrer .ssh/authorized_keysDatei jeder Zeile eine Umgebungsvariable voran, die wie folgt lautet:

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

Dann kann die benutzerdefinierte Shell oder eines der verschiedenen rc-Skripte die $REMOTEUSERVariable lesen und die entsprechende Aktion ausführen.

Beachten Sie jedoch, dass der angemeldete Benutzer die Datei ändern kann, wenn Sie eine Standard-Shell verwenden, um verschiedene Dinge zu verhindern. Es birgt auch einige Risiken, Benutzern das Festlegen von Umgebungsvariablen wie z LDPRELOAD. Siehe die sshd_configDokumentation zu PermitUserEnvironment.

Aktualisieren Sie 2016-10-31 über das Protokollformat

Einige Skripte zur korrekten Installation

Es gibt eine vollständig verwendbare Methode zum Verfolgen / Protokollieren von SSH-Verbindungen nach Schlüssel unter Berücksichtigung des Benutzernamens.

Einführung

Zusätzlich zu @Calebs Antwort möchte ich hier einige kleine Tricks vorstellen:

Nota: Ich arbeite an Debian 6.0 .

Server-Installation

SSHD-Protokollstufe

Stellen Sie zunächst sicher, dass die Serverkonfiguration über eine ausreichende Protokollierungsstufe verfügt:

Als root wird hiermit die ausführliche Protokollierung festgelegt und aktiviert:

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

Könnte geschrieben werden:

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

oder in einem sed script :

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

Welches könnte ausgeführt werden als:

patchSshdConfigLogLevel.sed -i /etc/ssh/sshd_config

Als für die Aktivierung dieses:

service ssh restart

Syslog: Fingerabdrücke benutzerlesbar machen

Nehmen Sie nun Fingerabdrücke in einer vom Benutzer lesbaren Datei auf:

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

Versuchen Sie, sich von ssh aus (erneut) anzumelden, um sicherzustellen, dass eine neue Datei sshdusers.logerstellt wird (und etwas enthält)

chmod 644 /var/log/sshdusers.log

Verwendungszweck

Dadurch wird der Fingerabdruck der aktuellen Sitzung gedruckt:

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 für .bashrc

Und schließlich gibt es ein kleines Add-On , das Sie am Ende Ihres /etc/bash.bashrcoder des Benutzers anbringen können .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

Nach dem erneuten Anmelden von SSH sehen Sie:

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

Hinweis Bei einigen Installationen hat die autorisierte Schlüsseldatei möglicherweise einen anderen Namen, z. B. $HOME/.ssh/authorized_keys2...

Angenommen, die Benutzer "joe" und "deb" haben Zugriff auf das Konto "x". Dann .ssh_authorized_keysaddieren Sie in Konto x die Zeilen:

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

Auch im Wrapper-Skript können Sie alles tun, was Sie wollen, indem Sie sshmit dem Befehl protokollieren, dass der private Schlüssel von joe zu einem bestimmten Datum und zu einer bestimmten Uhrzeit verwendet wurde $ORIGINAL_COMMAND.

Auf fedora 20+ werden die Anmeldeversuche und -erfolge in /var/log/audit/audit.log gespeichert. Dieses Protokoll speichert die Anmeldeversuche (Fehler und Erfolge) und der für den Anmeldeversuch verwendete Schlüsselfingerabdruck wird im Feld mit dem Namen fp gespeichert.

Sie können den Fingerabdruck des angemeldeten Schlüssels mit den Fingerabdrücken in den authorized_keys vergleichen, indem Sie ihn Zeile für Zeile durch ssh-keygen -l ausführen

Eine ausführliche Erklärung zu SSH-Anmeldungen und deren Sicherheit und Erkennung von Eindringlingen finden Sie hier: http://vpathak.tumblr.com/post/121343814158/fedora-audit-log-with-love-from-russia

Sie können dies versuchen:

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

Neben @F. Hauri antworte, ich bereite nützliche "LoggedIn prompt" vor.

Eine zusätzliche Datei ist optional ($ HOME / .ssh / users):

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

Dieser Teil sollte in /etc/profile(für alle Benutzer) oder in eingefügt werden~/.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\$ '

Ergebnis