# Alertes de connexion SSH sur votre téléphone : un hook PAM qui capte aussi scp, sftp et les redirections de port

> Recevez une notification push sur iPhone ou Android à chaque ouverture d’une session SSH sur votre serveur Linux. Un hook pam_exec qui ne ralentit jamais une connexion, garde la clé API accessible au seul root, silencie vos propres connexions et évite une élévation de privilèges root que la configuration habituelle laisse ouverte sur Debian 12 et Ubuntu.

*31.10.2026*

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

Si quelqu’un se connecte à votre serveur avec une clé volée ou un mot de passe deviné, la connexion elle-même est souvent le seul moment où vous auriez pu le remarquer. Ensuite, il ressemble à n’importe quel autre utilisateur. Une notification push sur votre téléphone pour chaque session SSH vous offre ce moment : soit vous reconnaissez la connexion, soit vous savez en quelques secondes que quelque chose ne va pas.

Il s’agit de détection, pas de prévention. Rien n’empêchera quelqu’un d’entrer. En revanche, vous serez prévenu pendant que vous pouvez encore agir.

Ce guide utilise PAM, la couche que traverse déjà chaque connexion SSH. Il a été testé sur Debian 12 et 13, Ubuntu 24.04 et Rocky Linux 9, face à une fausse API qui enregistrait chaque requête.

## Pourquoi pas /etc/profile, .bashrc ou sshrc

L’extrait que la plupart des gens copient est un appel `curl` placé dans `/etc/profile`, `~/.bashrc` ou `/etc/ssh/sshrc`. Nous avons vérifié ce que chacun voit réellement :

- **`/etc/profile`** ne s’exécute que pour les shells de connexion. Dans nos tests, `ssh host cmd`, `scp`, `sftp`, `rsync` et `ssh -N` ont tous ouvert une session sans l’exécuter.
- **`~/.bashrc`** appartient à l’utilisateur. Toute personne disposant de ce compte peut le modifier, et `ssh host bash --norc` l’ignore.
- **`/etc/ssh/sshrc`** fait mieux : il s’exécutait pour les commandes, scp, sftp et rsync. Mais il tourne sous l’utilisateur connecté, donc la clé API doit être lisible par tous les comptes. Et si l’utilisateur possède un `~/.ssh/rc`, sshd exécute celui-ci à la place et `sshrc` ne se lance jamais.
- **Aucun de ces emplacements ne voit `ssh -N`.** Une redirection de port ou un proxy SOCKS via SSH n’ouvre pas de shell, donc rien ne s’exécute.

Tous ces mécanismes s’exécutent dans la session, sous l’identité de l’utilisateur, une fois l’attaquant déjà entré. Un hook PAM, lui, s’exécute dans sshd, en tant que root, avant le début de la session.

## Comment PAM voit une connexion SSH

Avec `UsePAM yes` (la valeur par défaut sur les quatre distributions), sshd ouvre une session PAM juste après la réussite de l’authentification. Cela se produit avant que le client ne demande un shell, une commande ou sftp. Le hook se déclenche donc pour chaque connexion authentifiée, `ssh -N` compris, et il ne peut pas distinguer un shell interactif d’un `rsync` : `PAM_TTY` vaut simplement `ssh`, même lorsque vous obtenez un terminal. Une connexion multiplexée (`ControlMaster`) n’ouvre qu’une seule session PAM, quel que soit le nombre de commandes exécutées dessus.

`pam_exec` lance une commande à ce moment-là. Voici ce que nous avons confirmé sur les machines de test :

- Pour sshd, la commande s’exécute en tant que root.
- `pam_exec` attend la fin de la commande, et la connexion attend avec lui. Un `curl` lent ici signifie une connexion lente.
- Sa sortie part vers `/dev/null` sauf si vous ajoutez l’option `stdout`, ainsi rien ne peut fuiter dans une session.
- Son environnement est celui de PAM, pas celui de root. Il n’y a pas de `PATH` sur Debian ni sur Rocky.

Voici les variables utilisées par le script :

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Variable</th><th>Exemple</th><th>Origine</th></tr></thead>
<tbody>
<tr><th><code>PAM_TYPE</code></th><td><code>open_session</code></td><td>Aussi <code>close_session</code> à la déconnexion</td></tr>
<tr><th><code>PAM_SERVICE</code></th><td><code>sshd</code></td><td>Le fichier PAM utilisé</td></tr>
<tr><th><code>PAM_USER</code></th><td><code>root</code></td><td>Le compte qui s’est connecté</td></tr>
<tr><th><code>PAM_RHOST</code></th><td><code>198.51.100.23</code></td><td>L’adresse du client (une IP, avec le réglage par défaut de sshd <code>UseDNS no</code>)</td></tr>
<tr><th><code>SSH_AUTH_INFO_0</code></th><td><code>publickey ssh-ed25519 AAAA...</code></td><td>Défini par sshd : la méthode et la clé publique acceptée</td></tr>
</tbody>
</table>
</div>

`SSH_AUTH_INFO_0` était présent sur chaque distribution testée, sans `ExposeAuthInfo`. Cela signifie que la notification peut indiquer la clé utilisée, et pas seulement le compte.

## Ce dont vous avez besoin

- Un serveur Linux avec OpenSSH. Vérifiez que PAM est activé : `sudo sshd -T | grep -i usepam` doit afficher `usepam yes`.
- `curl` et `jq` : `sudo apt install curl jq`, ou `sudo dnf install jq` sur Rocky, Alma et RHEL (curl est déjà installé sur ces systèmes).
- L’application Pocket Alert [sur iPhone ou Android](/get-app) et une clé API depuis [Clés API](/account/apikeys). Créez une clé distincte pour chaque serveur, afin de pouvoir en révoquer une sans toucher aux autres.

## Le script

```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
```

Ce qu’il fait, et pourquoi :

- **L’appel HTTP s’exécute en arrière-plan.** Le script lance `curl` puis se termine aussitôt, de sorte que `pam_exec` cesse d’attendre. Avec une API qui répond normalement, après 4 secondes, ou pas du tout (une adresse qui perd les paquets), `ssh host true` a pris entre 0,15 et 0,36 seconde à chaque fois sur Debian 12 et Rocky 9. Un `curl` qui ne parvient pas à se connecter abandonne au bout de 15 secondes maximum, et l’échec est consigné dans syslog sous la forme `pa-ssh-login: push failed, curl exit code 7`.
- **Il se termine toujours avec le code 0**, et toutes les sorties sont redirigées, de sorte que la session ne voit rien. La sortie d’une connexion interactive et celle de `ssh host cmd` étaient identiques avec et sans le hook, à part l’heure dans la ligne « Last login ».
- **La clé n’apparaît jamais dans une ligne de commande.** `curl` lit l’en-tête `Token` depuis son entrée standard (`-K -`). Les arguments sont visibles par tous les utilisateurs locaux via `ps`. Pendant qu’une requête était bloquée, la clé n’apparaissait dans le `/proc/<pid>/cmdline` d’aucun processus.
- **Les valeurs non fiables entrent dans le JSON via `jq --arg`.** Nous avons exécuté le script avec un nom d’utilisateur, une adresse, un service et des informations de clé remplis de guillemets, de barres obliques inverses, de retours à la ligne, de `$(id)`, de caractères de contrôle et d’UTF-8 invalide. Chaque corps de requête était un JSON valide, et rien n’a été exécuté.
- **Les boutons ne sont ajoutés que pour une adresse IP.** L’API rejette tout le message avec un `400` si un bouton `view` ne contient pas une URL valide. Un `PAM_RHOST` inhabituel doit tout de même vous faire parvenir l’alerte, simplement sans boutons.
- **Les motifs sont comparés séparément.** `user@address` est découpé au dernier `@`, et chaque partie est comparée isolément. Les réunir en une seule chaîne permettrait à un compte nommé `x@10.8.0.5` de correspondre à `*@10.8.0.*` tout en se connectant depuis n’importe où.

Une connexion depuis une adresse inconnue arrive comme ceci, au niveau `high`, de sorte qu’elle passe le mode Concentration sur iPhone :

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

Pour savoir à quelle clé cela correspond, exécutez `ssh-keygen -lf ~/.ssh/authorized_keys` sur le serveur. Il affiche les mêmes empreintes, avec les commentaires.

## Le fichier de configuration

La clé est placée dans un fichier que seul root peut lire. Le script refuse de le charger s’il n’appartient pas à root ou s’il n’a pas le mode `600`, car il l’interprète comme du code shell. Saisissez la clé à une invite masquée, pour qu’elle n’apparaisse pas dans l’historique de votre shell :

```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` liste les connexions attendues, sous forme de motifs glob `user@address` séparés par des espaces. Dans l’exemple, tout compte issu de votre sortie VPN en `203.0.113.10` est considéré comme attendu, de même que `deploy` depuis le sous-réseau de CI. Elles arrivent en `low` : dans le fil, sans son. Tout le reste passe au niveau `PA_UNKNOWN_LEVEL`. Avec une offre payante, vous pouvez le régler sur `critical`, qui joue le son même en mode silencieux et en mode Ne pas déranger. Avec l’offre gratuite, `critical` est livré en `high`. Consultez les [niveaux de priorité](https://info.pocketalert.app/features/priority-levels.html) pour savoir ce que fait chaque niveau sur iOS et Android.

Les motifs sont des globs, pas des CIDR : `198.51.100.*` couvre un /24, et les autres plages nécessitent plusieurs motifs. Réglez `PA_KNOWN_LEVEL=none` pour ne rien envoyer du tout pour les connexions attendues.

Comptez vos connexions avant de laisser ce réglage sur `low`. L’offre gratuite autorise 50 messages par jour, et chaque connexion SSH en consomme un. Une tâche CI qui lance `rsync` toutes les 15 minutes en utilise 96. Attribuez à ces sources le niveau `none`, ou passez à une offre payante. Une fois la limite quotidienne atteinte, l’API refuse les messages jusqu’à 00:00 UTC, y compris celui de la seule connexion qui vous importe.

## Branchez-le dans PAM, en haut

Cette étape compte davantage que le script. Gardez un shell root ouvert dans un autre terminal pendant que vous modifiez PAM, afin qu’une faute de frappe ne vous enferme pas dehors. sshd relit son fichier PAM à chaque connexion : il n’y a donc rien à redémarrer.

```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
```

Sur Debian, la dernière commande affiche :

```
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
```

La ligne est donc placée au-dessus de la première ligne `session`, et non à la fin du fichier, où la plupart des guides l’ajoutent. La raison se trouve dans `/etc/pam.d/sshd` de Debian 12 et d’Ubuntu 24.04 :

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

`user_readenv=1` charge dans l’environnement PAM les variables du fichier `~/.pam_environment` propre à l’utilisateur. Toute ligne `pam_exec` placée en dessous lui transmet ces variables, avec la commande qu’elle lance. La page de manuel de `pam_exec` le signale : « Commands called by pam_exec need to be aware of that the user can have control over the environment. » (les commandes appelées par pam_exec doivent savoir que l’utilisateur peut contrôler l’environnement)

Nous avons vérifié ce que cela implique sur Ubuntu 24.04. Avec le hook en fin de fichier, un utilisateur ordinaire a écrit `LD_PRELOAD /tmp/x.so` dans son `~/.pam_environment`, puis s’est connecté. La bibliothèque a été chargée dans le script root, puis dans chaque programme que ce script a lancé, avec l’uid 0. Cela revient à un shell root pour quiconque peut se connecter en SSH. Avec le hook en haut, la variable n’était pas présente. Debian 13 et Rocky 9 ne définissent pas `user_readenv`, mais placer le hook en premier ne coûte rien là non plus. Il en va de même pour toute ligne `pam_exec` que vous avez déjà placée sous `pam_env`.

Les options de la ligne :

- **`optional`** : si le script est absent ou échoue, la connexion se poursuit. Nous avons renommé le script puis nous sommes connectés. Cela a fonctionné, sans rien afficher.
- **`type=open_session`** : `pam_exec` n’exécute pas du tout le script à la déconnexion. C’est important pour la même raison que la position : à la déconnexion, `pam_env` a déjà été exécuté, et dans notre test le `LD_PRELOAD` issu de `~/.pam_environment` était de nouveau présent dans l’environnement.
- **`quiet`** : si la commande échoue, `pam_exec` n’affiche pas son code de sortie à l’utilisateur.

Sur les systèmes de la famille RHEL, la ligne se retrouve au-dessus de `pam_selinux.so close`, de sorte qu’elle s’exécute dans le contexte SELinux de sshd. Nos tests ont été menés dans des conteneurs où SELinux n’était pas en mode enforcing. Si les notifications n’arrivent pas sur un système en mode enforcing, vérifiez avec `sudo ausearch -m avc -ts recent`.

Les mises à jour de paquets peuvent remplacer `/etc/pam.d/sshd`, ou laisser à côté une copie `.dpkg-dist` ou `.rpmnew`. Après une mise à jour d’OpenSSH, vérifiez que la ligne est toujours là.

## Testez-le

Vous pouvez appeler le script à la main, de la même façon que `pam_exec` :

```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
```

Une notification intitulée `SSH login: test@<hostname>` devrait arriver en quelques secondes, avec `Method: unknown`, puisqu’il n’y a pas eu de vraie connexion SSH. Si vous voulez d’abord voir la requête, ajoutez `POCKETALERT_API_URL=http://<your test endpoint>` à la configuration, et retirez-le une fois terminé.

Connectez-vous ensuite depuis une source absente de `PA_KNOWN`. Sur les machines de test, chacun de ces cas a produit une notification : un shell interactif, `ssh host cmd`, `scp`, `sftp`, `rsync`, une connexion par mot de passe et `ssh -N`.

## Optionnel : su et sudo

Le même script peut signaler `su` et `sudo`, via leurs propres fichiers PAM. Ils nécessitent une option supplémentaire :

```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
```

Sans `seteuid`, `pam_exec` lance la commande avec l’identifiant réel du processus appelant. Pour `su` et `sudo`, il s’agit de l’utilisateur qui a tapé la commande, et non de root. Sur nos machines de test, le script s’exécutait sous l’uid 1000, ne pouvait pas lire le fichier de configuration et n’envoyait rien. Avec `seteuid`, il s’exécute en tant que root, et la notification ressemble à `sudo on web-1: alice as root`.

Pour ces services, le script compare `PA_KNOWN` à l’utilisateur qui a lancé la commande, avec `local` comme adresse. `alice@local` silencie le `sudo` d’Alice. `root@local` silencie les scripts qui s’exécutent en root et passent à un autre utilisateur avec `su`, ce qui produit également une notification.

Réfléchissez au volume avant d’ajouter `sudo`. Chaque commande `sudo` ouvre une session, donc chacune génère une notification. Sur un serveur où les utilisateurs emploient `sudo` toute la journée, n’activer le hook que pour `su` suffit généralement.

## Les boutons

Avec les offres payantes, chaque notification SSH comporte deux [boutons d’action](/features/action-buttons) : **Copy IP** copie l’adresse dans le presse-papiers pour une règle de pare-feu ou une recherche dans les journaux, et **Look up IP** l’ouvre sur ipinfo.io, afin de vérifier s’il s’agit de votre fournisseur ou d’un réseau d’hébergement situé sur un autre continent. Avec l’offre gratuite, le serveur retire les boutons, et la notification est livrée normalement.

## Ce que cela ne couvre pas

- **Les connexions échouées.** Les sessions PAM ne s’ouvrent qu’après la réussite de l’authentification. Le devinage de mots de passe relève de fail2ban, ou d’une vérification du journal de sshd dans journald.
- **Tout ce qui se passe après la connexion.** Quelqu’un qui obtient root peut supprimer la ligne de `/etc/pam.d/sshd`. Il ne peut pas annuler la notification de la connexion qui lui a permis d’entrer : la requête est déjà partie avant le lancement de son shell.
- **Les connexions qui ne passent pas par la pile PAM de sshd.** Cela inclut la console locale, les autres services d’accès distant, et sshd avec `UsePAM no`.
- **Distinguer un shell d’un transfert de fichiers.** Comme expliqué plus haut, PAM ne le sait pas encore. L’adresse et la clé suffisent généralement à distinguer votre tâche CI d’une personne.

Cela couvre le moment où quelqu’un entre. Pour les autres événements serveur qui méritent une notification, consultez les [alertes de sécurité](/use-cases/security-alerts).
