# Notifiche push per il login SSH sul telefono: un hook PAM che intercetta anche scp, sftp e port forward

> Ricevi una notifica push su iPhone o Android ogni volta che qualcuno apre una sessione SSH sul tuo server Linux. Un hook pam_exec che non rallenta mai un login, tiene la chiave API accessibile solo a root, silenzia i tuoi login e evita un'escalation a root che la configurazione standard lascia aperta su Debian 12 e Ubuntu.

*31.10.2026*

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

Se qualcuno entra nel tuo server con una chiave rubata o una password indovinata, il login stesso è spesso l'unico momento in cui potresti accorgertene. Dopo, sembra un utente qualsiasi. Una notifica push sul telefono per ogni sessione SSH ti dà proprio quel momento: riconosci il login, oppure in pochi secondi sai che qualcosa non va.

Questo è rilevamento, non prevenzione. Non impedisce a nessuno di entrare. Fa in modo che tu lo venga a sapere mentre puoi ancora fare qualcosa.

La guida usa PAM, il livello che ogni login SSH attraversa. È stata testata su Debian 12 e 13, Ubuntu 24.04 e Rocky Linux 9, contro un'API finta che registrava ogni richiesta.

## Perché non /etc/profile, .bashrc o sshrc

Lo snippet che la maggior parte copia è una chiamata `curl` in `/etc/profile`, `~/.bashrc` o `/etc/ssh/sshrc`. Abbiamo verificato cosa vede davvero ciascuno di questi:

- **`/etc/profile`** viene eseguito solo per le shell di login. Nei nostri test, `ssh host cmd`, `scp`, `sftp`, `rsync` e `ssh -N` hanno effettuato il login senza eseguirlo.
- **`~/.bashrc`** appartiene all'utente. Chiunque abbia quell'account può modificarlo, e `ssh host bash --norc` lo salta.
- **`/etc/ssh/sshrc`** è meglio: veniva eseguito per i comandi, scp, sftp e rsync. Ma gira come l'utente che ha effettuato il login, quindi la chiave API deve essere leggibile da ogni account. E se l'utente ha un `~/.ssh/rc`, sshd esegue quello al posto suo e `sshrc` non viene mai eseguito.
- **Nessuno dei tre vede `ssh -N`.** Un port forward o un proxy SOCKS over SSH non apre una shell, quindi non viene eseguito nulla.

Tutti questi girano dentro la sessione, come utente, quando l'attaccante è già dentro. Un hook PAM gira dentro sshd, come root, prima che la sessione inizi.

## Come PAM vede un login SSH

Con `UsePAM yes` (il default su tutte e quattro le distribuzioni), sshd apre una sessione PAM subito dopo che l'autenticazione ha successo. Succede prima che il client chieda una shell, un comando o sftp. Quindi l'hook scatta per ogni connessione autenticata, `ssh -N` compreso, e non può distinguere una shell interattiva da un `rsync`: `PAM_TTY` vale semplicemente `ssh` anche quando ottieni un terminale. Una connessione multiplexata (`ControlMaster`) apre una sola sessione PAM, indipendentemente da quanti comandi passano su di essa.

`pam_exec` esegue un comando in quel punto. Ecco cosa abbiamo confermato sulle macchine di test:

- Per sshd, il comando viene eseguito come root.
- `pam_exec` attende che il comando termini, e il login attende con lui. Una `curl` lenta qui significa un login lento.
- Il suo output va a `/dev/null` a meno che tu non aggiunga l'opzione `stdout`, quindi nulla può trapelare in una sessione.
- Il suo ambiente è quello di PAM, non quello di root. Su Debian e Rocky non c'è un `PATH`.

Queste sono le variabili che usa lo script:

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Variabile</th><th>Esempio</th><th>Da dove arriva</th></tr></thead>
<tbody>
<tr><th><code>PAM_TYPE</code></th><td><code>open_session</code></td><td>Anche <code>close_session</code> al logout</td></tr>
<tr><th><code>PAM_SERVICE</code></th><td><code>sshd</code></td><td>Il file PAM in uso</td></tr>
<tr><th><code>PAM_USER</code></th><td><code>root</code></td><td>L'account che ha effettuato il login</td></tr>
<tr><th><code>PAM_RHOST</code></th><td><code>198.51.100.23</code></td><td>L'indirizzo del client (un IP, con il default di 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>Impostata da sshd: il metodo e la chiave pubblica accettata</td></tr>
</tbody>
</table>
</div>

`SSH_AUTH_INFO_0` era presente su ogni distribuzione che abbiamo provato, senza `ExposeAuthInfo`. Significa che la notifica può indicare la chiave usata, non solo l'account.

## Cosa ti serve

- Un server Linux con OpenSSH. Verifica che PAM sia attivo: `sudo sshd -T | grep -i usepam` dovrebbe stampare `usepam yes`.
- `curl` e `jq`: `sudo apt install curl jq`, oppure `sudo dnf install jq` su Rocky, Alma e RHEL (curl è già installato lì).
- L'app Pocket Alert per [iPhone o Android](/get-app) e una chiave API da [Chiavi API](/account/apikeys). Crea una chiave separata per ogni server, così puoi revocarne una senza toccare le altre.

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

Cosa fa, e perché:

- **La chiamata HTTP gira in background.** Lo script avvia `curl` ed esce subito, così `pam_exec` smette di attendere. Con l'API che risponde normalmente, dopo 4 secondi, o per niente (un indirizzo che scarta i pacchetti), `ssh host true` ha impiegato tra 0,15 e 0,36 secondi ogni volta su Debian 12 e Rocky 9. Una `curl` che non riesce a connettersi si arrende al massimo dopo 15 secondi, e il fallimento finisce nel syslog come `pa-ssh-login: push failed, curl exit code 7`.
- **Esce sempre con 0**, e ogni output è reindirizzato, quindi la sessione non vede nulla. L'output di un login interattivo e di `ssh host cmd` era identico con e senza l'hook, a parte l'orario nella riga "Last login".
- **La chiave non compare mai su una riga di comando.** `curl` legge l'header `Token` dal suo standard input (`-K -`). Gli argomenti sono visibili a tutti gli utenti locali con `ps`. Mentre una richiesta era in attesa, la chiave non era presente in `/proc/<pid>/cmdline` di nessun processo.
- **I valori non fidati entrano nel JSON tramite `jq --arg`.** Abbiamo eseguito lo script con un nome utente, un indirizzo, un servizio e informazioni sulla chiave pieni di virgolette, backslash, a capo, `$(id)`, caratteri di controllo e UTF-8 non valido. Ogni corpo di richiesta era JSON valido, e nulla è stato eseguito.
- **I pulsanti vengono aggiunti solo per un indirizzo IP.** L'API rifiuta l'intero messaggio con `400` se un pulsante `view` non contiene un URL valido. Un `PAM_RHOST` anomalo deve comunque farti arrivare l'avviso, solo senza pulsanti.
- **I pattern vengono confrontati per metà.** `user@address` viene diviso all'ultima `@`, e ciascun lato viene confrontato da solo. Unire le due parti in un'unica stringa permetterebbe a un account chiamato `x@10.8.0.5` di corrispondere a `*@10.8.0.*` pur connettendosi da qualsiasi posto.

Un login da un indirizzo sconosciuto arriva così, con priorità `high`, quindi passa la Full immersion su iPhone:

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

Per capire a quale chiave corrisponde, esegui `ssh-keygen -lf ~/.ssh/authorized_keys` sul server. Stampa le stesse impronte, con i commenti.

## Il file di configurazione

La chiave va in un file che solo root può leggere. Lo script si rifiuta di caricarlo se non è di proprietà di root con permessi `600`, perché lo script lo carica come codice shell. Digita la chiave a un prompt nascosto, così non finisce nella cronologia della 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` elenca i login che ti aspetti, come pattern glob `user@address` separati da spazi. Nell'esempio, qualsiasi account che esce dalla tua VPN su `203.0.113.10` è atteso, e lo è anche `deploy` dalla subnet della CI. Arrivano come `low`: nel feed, senza suono. Tutto il resto segue `PA_UNKNOWN_LEVEL`. Con un piano a pagamento puoi impostarlo su `critical`, che suona anche con l'interruttore silenzioso e con Non disturbare. Nel piano gratuito, `critical` viene consegnato come `high`. Vedi [livelli di priorità](https://info.pocketalert.app/features/priority-levels.html) per sapere cosa fa ciascun livello su iOS e Android.

I pattern sono glob, non CIDR: `198.51.100.*` copre una /24, e altri intervalli richiedono più pattern. Imposta `PA_KNOWN_LEVEL=none` per non inviare nulla per i login attesi.

Conta i tuoi login prima di lasciarlo su `low`. Il piano gratuito consente 50 messaggi al giorno, e ogni connessione SSH è un messaggio. Un job CI che esegue `rsync` ogni 15 minuti ne consuma 96. Assegna `none` a queste sorgenti, oppure passa a un piano a pagamento. Una volta raggiunto il limite giornaliero, l'API rifiuta i messaggi fino alle 00:00 UTC, e tra questi finirebbe anche l'unico login che ti interessa.

## Aggancialo a PAM, in cima

Questa parte conta più dello script. Tieni aperta una shell root in un altro terminale mentre modifichi PAM, così un errore di battitura non ti chiude fuori. sshd legge il suo file PAM a ogni connessione, quindi non serve riavviare nulla.

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

Su Debian, l'ultimo comando stampa:

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

Questo mette la riga sopra la prima riga `session`, non in fondo al file dove la aggiungono la maggior parte delle guide. Il motivo sta nel file `/etc/pam.d/sshd` di Debian 12 e Ubuntu 24.04:

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

`user_readenv=1` carica nell'ambiente PAM le variabili dal file `~/.pam_environment` dell'utente. Ogni riga `pam_exec` sotto questa le passa al comando che esegue. La pagina di manuale di `pam_exec` avverte: "I comandi chiamati da pam_exec devono tenere conto del fatto che l'utente può controllare l'ambiente."

Abbiamo verificato cosa significa su Ubuntu 24.04. Con l'hook in fondo al file, un utente normale ha scritto `LD_PRELOAD /tmp/x.so` in `~/.pam_environment` ed è entrato. La libreria è stata caricata nello script root, e in ogni programma che lo script ha eseguito, con uid 0. È una shell root per chiunque possa fare login via SSH. Con l'hook in cima, la variabile non c'era. Debian 13 e Rocky 9 non impostano `user_readenv`, ma mettere l'hook per primo non costa nulla nemmeno lì. Lo stesso vale per qualsiasi riga `pam_exec` che hai già sotto `pam_env`.

Le opzioni della riga:

- **`optional`**: se lo script manca o fallisce, il login va avanti. Abbiamo rinominato lo script e ci siamo connessi. Ha funzionato, senza stampare nulla.
- **`type=open_session`**: `pam_exec` non esegue affatto lo script al logout. Conta per lo stesso motivo della posizione: al logout, `pam_env` è già stato eseguito, e nel nostro test il `LD_PRELOAD` di `~/.pam_environment` era di nuovo nell'ambiente.
- **`quiet`**: se il comando fallisce, `pam_exec` non mostra all'utente il codice di uscita.

Sui sistemi della famiglia RHEL la riga finisce sopra `pam_selinux.so close`, quindi viene eseguita nel contesto SELinux di sshd. I nostri test sono stati eseguiti in container senza SELinux in modalità enforcing. Se le push non arrivano su un sistema in enforcing, controlla con `sudo ausearch -m avc -ts recent`.

Gli aggiornamenti dei pacchetti possono sostituire `/etc/pam.d/sshd`, oppure lasciare accanto una copia `.dpkg-dist` o `.rpmnew`. Dopo un aggiornamento di OpenSSH, verifica che la riga sia ancora lì.

## Testalo

Puoi chiamare lo script a mano, nello stesso modo in cui lo fa `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
```

Una push intitolata `SSH login: test@<hostname>` dovrebbe arrivare in pochi secondi, con `Method: unknown`, perché non c'è stato un vero login SSH. Se vuoi vedere prima la richiesta, aggiungi `POCKETALERT_API_URL=http://<your test endpoint>` alla configurazione, e rimuovilo quando hai finito.

Poi accedi da un posto che non è in `PA_KNOWN`. Sulle macchine di test, ciascuno di questi ha prodotto una push: una shell interattiva, `ssh host cmd`, `scp`, `sftp`, `rsync`, un login con password e `ssh -N`.

## Opzionale: su e sudo

Lo stesso script può segnalare `su` e `sudo`, tramite i loro file PAM. Richiedono un'opzione in più:

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

Senza `seteuid`, `pam_exec` esegue il comando con l'ID utente reale del processo chiamante. Per `su` e `sudo` è l'utente che ha digitato il comando, non root. Sulle nostre macchine di test lo script girava come uid 1000, non riusciva a leggere il file di configurazione e non inviava nulla. Con `seteuid` gira come root, e la push appare così: `sudo on web-1: alice as root`.

Per questi servizi lo script confronta `PA_KNOWN` con l'utente che ha eseguito il comando, usando `local` come indirizzo. `alice@local` silenzia il `sudo` di Alice. `root@local` silenzia gli script che girano come root e passano a un altro utente con `su`, che producono comunque una push.

Pensa al volume prima di aggiungere `sudo`. Ogni comando `sudo` apre una sessione, quindi ognuno genera una push. Su un server dove le persone usano `sudo` tutto il giorno, agganciare solo `su` di solito basta.

## I pulsanti

Con i piani a pagamento, ogni push SSH ha due [pulsanti di azione](/features/action-buttons): **Copia IP** copia l'indirizzo negli appunti per una regola del firewall o una ricerca nei log, e **Cerca IP** lo apre su ipinfo.io, così puoi capire se è il tuo provider o una rete di hosting su un altro continente. Nel piano gratuito il server rimuove i pulsanti, mentre la push viene consegnata normalmente.

## Cosa non copre

- **Login falliti.** Le sessioni PAM si aprono solo dopo un'autenticazione riuscita. Il tentativo di indovinare la password è compito di fail2ban, oppure di un controllo del log di sshd nel journal.
- **Qualsiasi cosa dopo il login.** Chi ottiene root può cancellare la riga da `/etc/pam.d/sshd`. Non può però ritirare la push per il login che lo ha fatto entrare: la richiesta è già partita prima che la sua shell si avvii.
- **Login che non passano dallo stack PAM di sshd.** Ci rientrano la console locale, altri servizi di accesso remoto e sshd con `UsePAM no`.
- **Distinguere una shell da un trasferimento di file.** Come spiegato sopra, PAM non lo sa ancora. Indirizzo e chiave bastano di solito a distinguere il tuo job CI da una persona.

Questo copre il momento in cui qualcuno entra. Per altri eventi del server che meritano una push, vedi [avvisi di sicurezza](/use-cases/security-alerts).
