# SSH-Login-Benachrichtigungen aufs Handy: ein PAM-Hook, der auch scp, sftp und Port-Forwards erfasst

> Erhalte bei jedem SSH-Login auf deinem Linux-Server eine Push-Benachrichtigung auf iPhone oder Android. Ein pam_exec-Hook, der einen Login nie verlangsamt, den API-Schlüssel nur für root lesbar hält, eigene Logins stummschaltet und eine Root-Eskalation verhindert, die das übliche Setup auf Debian 12 und Ubuntu offenlässt.

*31.10.2026*

<!-- source: https://pocketalert.app/de/blog/ssh-login-alerts -->

Wenn sich jemand mit einem gestohlenen Schlüssel oder einem erratenen Passwort auf deinem Server anmeldet, ist der Login selbst oft der einzige Moment, in dem du es hättest bemerken können. Danach sieht die Sitzung aus wie die jedes anderen Benutzers. Eine Push-Benachrichtigung auf dein Handy für jede SSH-Sitzung gibt dir genau diesen Moment: Du erkennst den Login wieder, oder du weißt innerhalb von Sekunden, dass etwas nicht stimmt.

Das ist Erkennung, keine Vorbeugung. Es hält niemanden davon ab, reinzukommen. Es sorgt aber dafür, dass du davon erfährst, solange du noch handeln kannst.

Der Guide nutzt PAM, die Schicht, durch die jeder SSH-Login ohnehin läuft. Getestet wurde auf Debian 12 und 13, Ubuntu 24.04 und Rocky Linux 9, gegen eine Fake-API, die jede Anfrage protokollierte.

## Warum nicht /etc/profile, .bashrc oder sshrc

Das Snippet, das die meisten kopieren, ist ein `curl`-Aufruf in `/etc/profile`, `~/.bashrc` oder `/etc/ssh/sshrc`. Wir haben getestet, was jede dieser Stellen tatsächlich mitbekommt:

- **`/etc/profile`** läuft nur für Login-Shells. In unseren Tests haben sich `ssh host cmd`, `scp`, `sftp`, `rsync` und `ssh -N` alle angemeldet, ohne dass der Hook lief.
- **`~/.bashrc`** gehört dem Benutzer. Wer dieses Konto hat, kann sie bearbeiten, und `ssh host bash --norc` überspringt sie.
- **`/etc/ssh/sshrc`** ist besser: Sie lief bei Befehlen, scp, sftp und rsync. Aber sie läuft als der angemeldete Benutzer, also muss der API-Schlüssel für jedes Konto lesbar sein. Und wenn der Benutzer eine `~/.ssh/rc` hat, führt sshd diese stattdessen aus, und `sshrc` läuft nie.
- **Keine davon sieht `ssh -N`.** Ein Port-Forward oder ein SOCKS-Proxy über SSH öffnet keine Shell, also läuft nichts.

Alle diese Varianten laufen innerhalb der Sitzung, als Benutzer, nachdem der Angreifer schon drin ist. Ein PAM-Hook läuft innerhalb von sshd, als root, bevor die Sitzung beginnt.

## Wie PAM einen SSH-Login sieht

Mit `UsePAM yes` (der Standard auf allen vier Distributionen) öffnet sshd direkt nach erfolgreicher Authentifizierung eine PAM-Sitzung. Das passiert, bevor der Client eine Shell, einen Befehl oder sftp anfordert. Der Hook wird also für jede authentifizierte Verbindung ausgelöst, `ssh -N` eingeschlossen, und er kann eine interaktive Shell nicht von einem `rsync` unterscheiden: `PAM_TTY` lautet einfach `ssh`, selbst wenn du ein Terminal bekommst. Eine gebündelte Verbindung (`ControlMaster`) öffnet eine einzige PAM-Sitzung, egal wie viele Befehle darüber laufen.

`pam_exec` führt an dieser Stelle einen Befehl aus. Das haben wir auf den Testmaschinen bestätigt:

- Bei sshd läuft der Befehl als root.
- `pam_exec` wartet, bis der Befehl beendet ist, und der Login wartet mit. Ein langsames `curl` hier bedeutet einen langsamen Login.
- Die Ausgabe geht nach `/dev/null`, sofern du nicht die Option `stdout` setzt, sodass nichts in eine Sitzung lecken kann.
- Die Umgebung ist die PAM-Umgebung, nicht die von root. Auf Debian und Rocky gibt es keinen `PATH`.

Diese Variablen nutzt das Skript:

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Variable</th><th>Beispiel</th><th>Herkunft</th></tr></thead>
<tbody>
<tr><th><code>PAM_TYPE</code></th><td><code>open_session</code></td><td>Beim Logout auch <code>close_session</code></td></tr>
<tr><th><code>PAM_SERVICE</code></th><td><code>sshd</code></td><td>Die verwendete PAM-Datei</td></tr>
<tr><th><code>PAM_USER</code></th><td><code>root</code></td><td>Das Konto, das sich angemeldet hat</td></tr>
<tr><th><code>PAM_RHOST</code></th><td><code>198.51.100.23</code></td><td>Die Client-Adresse (eine IP, bei sshds Standard <code>UseDNS no</code>)</td></tr>
<tr><th><code>SSH_AUTH_INFO_0</code></th><td><code>publickey ssh-ed25519 AAAA...</code></td><td>Von sshd gesetzt: die Methode und der akzeptierte öffentliche Schlüssel</td></tr>
</tbody>
</table>
</div>

`SSH_AUTH_INFO_0` war auf jeder getesteten Distribution vorhanden, ohne `ExposeAuthInfo`. Das bedeutet, die Push-Benachrichtigung kann den verwendeten Schlüssel benennen, nicht nur das Konto.

## Was du brauchst

- Einen Linux-Server mit OpenSSH. Prüfe, ob PAM aktiv ist: `sudo sshd -T | grep -i usepam` sollte `usepam yes` ausgeben.
- `curl` und `jq`: `sudo apt install curl jq`, oder `sudo dnf install jq` auf Rocky, Alma und RHEL (curl ist dort schon installiert).
- Die Pocket-Alert-App auf [iPhone oder Android](/get-app) und einen API-Schlüssel unter [API Keys](/account/apikeys). Lege für jeden Server einen eigenen Schlüssel an, dann kannst du einen widerrufen, ohne die anderen anzufassen.

## Das Skript

```bash
#!/bin/bash
# /usr/local/sbin/pa-ssh-login
# Run by pam_exec when a session opens. It must never slow down or break a login.
PATH=/usr/sbin:/usr/bin:/sbin:/bin
CONF=/etc/pa-ssh-login.conf

[ "$PAM_TYPE" = open_session ] || exit 0
[ "$(stat -c '%u %a' "$CONF" 2>/dev/null)" = "0 600" ] || exit 0
# shellcheck source=/dev/null
. "$CONF"
[ -n "$POCKETALERT_API_KEY" ] || exit 0

host=$(uname -n)
if [ "$PAM_SERVICE" = sshd ]; then
  who=${PAM_USER:-unknown}
  from=${PAM_RHOST:-unknown}
  title="SSH login: $who@$host"
  auth=${SSH_AUTH_INFO_0%%$'\n'*}
  case $auth in
    publickey\ *) auth="Key: $(ssh-keygen -lf - <<<"${auth#publickey }" 2>/dev/null | awk '{print $2, $NF}')" ;;
    '') auth="Method: unknown" ;;
    *) auth="Method: ${auth%% *}" ;;
  esac
  message="From $from"$'\n'"$auth"
else
  who=${PAM_RUSER:-unknown}
  from=local
  title="$PAM_SERVICE on $host: $who as ${PAM_USER:-unknown}"
  message="Terminal: ${PAM_TTY:-none}"
fi

level=${PA_UNKNOWN_LEVEL:-high}
read -ra rules <<<"${PA_KNOWN:-}"
for rule in "${rules[@]}"; do
  # shellcheck disable=SC2053 # user@address, both halves are glob patterns on purpose
  if [[ $who == ${rule%@*} && $from == ${rule##*@} ]]; then
    level=${PA_KNOWN_LEVEL:-low}
    break
  fi
done
[ "$level" = none ] && exit 0

ip=
[[ $from =~ ^[0-9A-Fa-f:.]+$ ]] && ip=$from

json=$(jq -n --arg title "$title" --arg message "$message" --arg level "$level" --arg ip "$ip" '
  {title: $title, message: $message, level: $level}
  + (if $ip == "" then {} else {actions: [
      {type: "copy", label: "Copy IP", value: $ip},
      {type: "view", label: "Look up IP", value: ("https://ipinfo.io/" + $ip)}
    ]} end)') || exit 0

{
  printf 'header = "Token: %s"\n' "$POCKETALERT_API_KEY" |
    curl -fsS -o /dev/null --connect-timeout 5 --max-time 15 -K - \
      -H 'Content-Type: application/json' --data-binary "$json" \
      "${POCKETALERT_API_URL:-https://api.pocketalert.app/v1/messages}" ||
    logger -t pa-ssh-login "push failed, curl exit code $?"
} </dev/null >/dev/null 2>&1 &

exit 0
```

```bash
sudo install -m 0755 -o root -g root pa-ssh-login /usr/local/sbin/pa-ssh-login
```

Was es tut und warum:

- **Der HTTP-Aufruf läuft im Hintergrund.** Das Skript startet `curl` und beendet sich sofort, sodass `pam_exec` nicht mehr wartet. Antwortet die API normal, nach 4 Sekunden oder gar nicht (eine Adresse, die Pakete verwirft), brauchte `ssh host true` auf Debian 12 und Rocky 9 jedes Mal zwischen 0,15 und 0,36 Sekunden. Ein `curl`, das sich nicht verbinden kann, gibt nach höchstens 15 Sekunden auf, und der Fehler landet im Syslog als `pa-ssh-login: push failed, curl exit code 7`.
- **Es beendet sich immer mit 0**, und jede Ausgabe ist umgeleitet, sodass die Sitzung nichts sieht. Die Ausgabe eines interaktiven Logins und von `ssh host cmd` war mit und ohne Hook identisch, abgesehen von der Zeit in der Zeile „Last login“.
- **Der Schlüssel taucht nie in einer Befehlszeile auf.** `curl` liest den `Token`-Header von seiner Standardeingabe (`-K -`). Argumente sind für jeden lokalen Benutzer in `ps` sichtbar. Während eine Anfrage hing, stand der Schlüssel in keiner `/proc/<pid>/cmdline`.
- **Unvertrauenswürdige Werte gelangen über `jq --arg` in das JSON.** Wir haben das Skript mit einem Benutzernamen, einer Adresse, einem Dienst und Schlüsselinfos voller Anführungszeichen, Backslashes, Zeilenumbrüchen, `$(id)`, Steuerzeichen und ungültigem UTF-8 laufen lassen. Jeder Request-Body war gültiges JSON, und nichts wurde ausgeführt.
- **Die Buttons werden nur für eine IP-Adresse hinzugefügt.** Die API weist die ganze Nachricht mit `400` ab, wenn ein `view`-Button keine gültige URL enthält. Eine seltsame `PAM_RHOST` soll dir trotzdem die Benachrichtigung liefern, nur eben ohne Buttons.
- **Muster werden pro Hälfte abgeglichen.** `user@address` wird am letzten `@` getrennt, und jede Seite wird einzeln verglichen. Würde man beides zu einem String zusammenfügen, könnte ein Konto namens `x@10.8.0.5` auf `*@10.8.0.*` passen, obwohl die Verbindung von überall kommt.

Ein Login von einer unbekannten Adresse kommt so an, mit `high`, damit er den Fokus-Modus auf dem iPhone durchbricht:

```
SSH login: root@web-1
From 198.51.100.23
Key: SHA256:iZtVU4EwMulogUeoneZkIXA9eeQfCvpyRB66QrrxBRA (ED25519)
```

Um herauszufinden, welcher Schlüssel das ist, führe auf dem Server `ssh-keygen -lf ~/.ssh/authorized_keys` aus. Es gibt dieselben Fingerprints aus, mit den Kommentaren.

## Die Konfigurationsdatei

Der Schlüssel kommt in eine Datei, die nur root lesen kann. Das Skript lädt sie nur, wenn sie root gehört und den Modus `600` hat, weil das Skript sie als Shell-Code einliest. Tippe den Schlüssel an einer versteckten Eingabeaufforderung ein, damit er nicht in deiner Shell-History landet:

```bash
sudo bash -c 'umask 077; read -rsp "API key: " k; echo; printf "POCKETALERT_API_KEY=%s\n" "$k" > /etc/pa-ssh-login.conf'
sudo tee -a /etc/pa-ssh-login.conf >/dev/null <<'EOF'
PA_KNOWN="*@203.0.113.10 deploy@198.51.100.*"
PA_KNOWN_LEVEL=low
PA_UNKNOWN_LEVEL=high
EOF
sudo stat -c '%U %a' /etc/pa-ssh-login.conf   # root 600
```

`PA_KNOWN` listet die Logins auf, die du erwartest, als `user@address`-Glob-Muster, getrennt durch Leerzeichen. Im Beispiel gilt jedes Konto von deinem VPN-Ausgang `203.0.113.10` als erwartet, ebenso `deploy` aus dem CI-Subnetz. Sie kommen als `low` an: im Feed, ohne Ton. Alles andere bekommt `PA_UNKNOWN_LEVEL`. Mit einem kostenpflichtigen Tarif kannst du das auf `critical` setzen, was auch den lautlosen Schalter und Nicht stören durchbricht. Im kostenlosen Tarif wird `critical` als `high` zugestellt. Was jede Stufe auf iOS und Android bewirkt, steht unter [Prioritätsstufen](https://info.pocketalert.app/features/priority-levels.html).

Muster sind Globs, kein CIDR: `198.51.100.*` deckt ein /24 ab, andere Bereiche brauchen mehr als ein Muster. Setze `PA_KNOWN_LEVEL=none`, wenn für erwartete Logins gar keine Benachrichtigung rausgehen soll.

Zähle deine Logins, bevor du es bei `low` belässt. Der kostenlose Tarif erlaubt 50 Nachrichten pro Tag, und jede SSH-Verbindung ist eine Nachricht. Ein CI-Job, der alle 15 Minuten `rsync` ausführt, verbraucht davon 96. Gib solchen Quellen `none`, oder wechsle auf einen kostenpflichtigen Tarif. Ist das Tageslimit erreicht, nimmt die API bis 00:00 UTC keine Nachrichten mehr an, und dazu gehört dann genau der eine Login, der dich interessiert.

## Am Anfang in PAM einhängen

Dieser Teil ist wichtiger als das Skript. Lass in einem anderen Terminal eine Root-Shell offen, während du PAM änderst, damit ein Tippfehler dich nicht aussperren kann. sshd liest seine PAM-Datei bei jeder Verbindung neu, es ist also kein Neustart nötig.

```bash
sudo cp /etc/pam.d/sshd /root/pam.d-sshd.bak
sudo sed -i '0,/^session/s|^session|session    optional     pam_exec.so quiet type=open_session /usr/local/sbin/pa-ssh-login\n&|' /etc/pam.d/sshd
sudo grep -n -m2 '^session' /etc/pam.d/sshd
```

Auf Debian gibt der letzte Befehl aus:

```
19:session    optional     pam_exec.so quiet type=open_session /usr/local/sbin/pa-ssh-login
20:session [success=ok ignore=ignore module_unknown=ignore default=bad]        pam_selinux.so close
```

Das setzt die Zeile über die erste `session`-Zeile, nicht ans Ende der Datei, wo die meisten Anleitungen sie hinzufügen. Der Grund steht in `/etc/pam.d/sshd` von Debian 12 und Ubuntu 24.04:

```
session    required     pam_env.so user_readenv=1 envfile=/etc/default/locale
```

`user_readenv=1` lädt Variablen aus der eigenen `~/.pam_environment` des Benutzers in die PAM-Umgebung. Jede `pam_exec`-Zeile darunter gibt sie an den Befehl weiter, den sie ausführt. Die Manpage von `pam_exec` warnt davor: „Commands called by pam_exec need to be aware of that the user can have control over the environment.“

Wir haben auf Ubuntu 24.04 geprüft, was das heißt. Mit dem Hook am Dateiende hat ein normaler Benutzer `LD_PRELOAD /tmp/x.so` in seine `~/.pam_environment` geschrieben und sich angemeldet. Die Bibliothek wurde in das Root-Skript geladen und in jedes Programm, das es startete, als UID 0. Das ist eine Root-Shell für jeden, der sich per SSH anmelden kann. Mit dem Hook am Anfang war die Variable nicht vorhanden. Debian 13 und Rocky 9 setzen `user_readenv` nicht, aber den Hook zuerst zu platzieren kostet dort auch nichts. Dasselbe gilt für jede `pam_exec`-Zeile, die du bereits unterhalb von `pam_env` hast.

Die Optionen in der Zeile:

- **`optional`**: Schlägt das Skript fehl oder fehlt es, geht der Login trotzdem weiter. Wir haben das Skript umbenannt und uns angemeldet. Es hat funktioniert, ohne etwas auszugeben.
- **`type=open_session`**: `pam_exec` führt das Skript beim Logout gar nicht aus. Das ist aus demselben Grund wichtig wie die Position: Beim Logout hat `pam_env` schon gelaufen, und in unserem Test war das `LD_PRELOAD` aus `~/.pam_environment` wieder in der Umgebung.
- **`quiet`**: Schlägt der Befehl fehl, gibt `pam_exec` seinen Exit-Status nicht an den Benutzer aus.

Auf RHEL-artigen Systemen landet die Zeile über `pam_selinux.so close`, läuft also im SELinux-Kontext von sshd. Unsere Tests liefen in Containern ohne erzwungenes SELinux. Kommen auf einem System mit erzwungenem SELinux keine Pushes an, prüfe `sudo ausearch -m avc -ts recent`.

Paket-Upgrades können `/etc/pam.d/sshd` ersetzen oder daneben eine Kopie `.dpkg-dist` bzw. `.rpmnew` hinterlassen. Prüfe nach einem OpenSSH-Upgrade, ob die Zeile noch da ist.

## Testen

Du kannst das Skript von Hand aufrufen, so wie `pam_exec` es tut:

```bash
sudo env PAM_TYPE=open_session PAM_SERVICE=sshd PAM_USER=test PAM_RHOST=203.0.113.9 /usr/local/sbin/pa-ssh-login
```

Eine Push-Benachrichtigung mit dem Titel `SSH login: test@<hostname>` sollte innerhalb weniger Sekunden ankommen, mit `Method: unknown`, da kein echter SSH-Login stattfand. Wenn du die Anfrage vorher sehen willst, füge `POCKETALERT_API_URL=http://<your test endpoint>` zur Konfiguration hinzu und entferne es danach wieder.

Melde dich dann von einem Ort an, der nicht in `PA_KNOWN` steht. Auf den Testmaschinen erzeugte jeder dieser Logins genau eine Push-Benachrichtigung: eine interaktive Shell, `ssh host cmd`, `scp`, `sftp`, `rsync`, ein Passwort-Login und `ssh -N`.

## Optional: su und sudo

Dasselbe Skript kann `su` und `sudo` melden, über deren eigene PAM-Dateien. Dafür braucht es eine zusätzliche Option:

```bash
for f in su sudo; do
  sudo sed -i '0,/^session/s|^session|session    optional     pam_exec.so quiet seteuid type=open_session /usr/local/sbin/pa-ssh-login\n&|' /etc/pam.d/$f
done
```

Ohne `seteuid` führt `pam_exec` den Befehl mit der realen Benutzer-ID des aufrufenden Prozesses aus. Bei `su` und `sudo` ist das der Benutzer, der den Befehl eingegeben hat, nicht root. Auf unseren Testmaschinen lief das Skript als UID 1000, konnte die Konfigurationsdatei nicht lesen und sendete nichts. Mit `seteuid` läuft es als root, und die Push-Benachrichtigung sieht so aus: `sudo on web-1: alice as root`.

Für diese Dienste gleicht das Skript `PA_KNOWN` gegen den Benutzer ab, der den Befehl ausgeführt hat, mit `local` als Adresse. `alice@local` stummschaltet das eigene `sudo` von Alice. `root@local` stummschaltet Skripte, die als root laufen und mit `su` zu einem anderen Benutzer wechseln, was ebenfalls eine Push-Benachrichtigung erzeugt.

Überlege dir die Menge, bevor du `sudo` hinzufügst. Jeder `sudo`-Befehl öffnet eine Sitzung, also ist jeder einzelne eine Push-Benachrichtigung. Auf einem Server, auf dem Leute den ganzen Tag `sudo` nutzen, reicht meist der Hook nur für `su`.

## Die Buttons

In kostenpflichtigen Tarifen hat jede SSH-Push-Benachrichtigung zwei [Aktionsbuttons](/features/action-buttons): **Copy IP** legt die Adresse in die Zwischenablage, etwa für eine Firewall-Regel oder eine Log-Suche, und **Look up IP** öffnet sie auf ipinfo.io, sodass du siehst, ob es dein Provider ist oder ein Hosting-Netz auf einem anderen Kontinent. Im kostenlosen Tarif entfernt der Server die Buttons, die Push-Benachrichtigung selbst wird wie gewohnt zugestellt.

## Was das nicht abdeckt

- **Fehlgeschlagene Logins.** PAM-Sitzungen öffnen sich nur nach erfolgreicher Authentifizierung. Das Erraten von Passwörtern ist Aufgabe von fail2ban oder einer Prüfung des sshd-Logs im Journal.
- **Alles nach dem Login.** Wer root bekommt, kann die Zeile aus `/etc/pam.d/sshd` löschen. Die Push-Benachrichtigung für den Login, der ihm den Zugang verschafft hat, kann er nicht zurücknehmen: Die Anfrage ist schon unterwegs, bevor seine Shell startet.
- **Logins, die nicht über den PAM-Stack von sshd laufen.** Dazu gehören die lokale Konsole, andere Fernzugriffsdienste und sshd mit `UsePAM no`.
- **Unterscheidung zwischen Shell und Dateiübertragung.** Wie oben erklärt, weiß PAM das noch nicht. Adresse und Schlüssel reichen meist, um deinen CI-Job von einer Person zu unterscheiden.

Damit ist der Moment abgedeckt, in dem jemand reinkommt. Weitere Serverereignisse, die eine Push-Benachrichtigung wert sind, findest du unter [Sicherheitswarnungen](/use-cases/security-alerts).
