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

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/profileviene eseguito solo per le shell di login. Nei nostri test,ssh host cmd,scp,sftp,rsyncessh -Nhanno effettuato il login senza eseguirlo.~/.bashrcappartiene all'utente. Chiunque abbia quell'account può modificarlo, essh host bash --norclo 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 esshrcnon 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_execattende che il comando termini, e il login attende con lui. Unacurllenta qui significa un login lento.- Il suo output va a
/dev/nulla meno che tu non aggiunga l'opzionestdout, 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:
| Variabile | Esempio | Da dove arriva |
|---|---|---|
PAM_TYPE | open_session | Anche close_session al logout |
PAM_SERVICE | sshd | Il file PAM in uso |
PAM_USER | root | L'account che ha effettuato il login |
PAM_RHOST | 198.51.100.23 | L'indirizzo del client (un IP, con il default di sshd UseDNS no) |
SSH_AUTH_INFO_0 | publickey ssh-ed25519 AAAA... | Impostata da sshd: il metodo e la chiave pubblica accettata |
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 usepamdovrebbe stampareusepam yes. curlejq:sudo apt install curl jq, oppuresudo dnf install jqsu Rocky, Alma e RHEL (curl è già installato lì).- L'app Pocket Alert per iPhone o Android e una chiave API da Chiavi API. Crea una chiave separata per ogni server, così puoi revocarne una senza toccare le altre.
Lo script
#!/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
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
curled esce subito, cosìpam_execsmette di attendere. Con l'API che risponde normalmente, dopo 4 secondi, o per niente (un indirizzo che scarta i pacchetti),ssh host trueha impiegato tra 0,15 e 0,36 secondi ogni volta su Debian 12 e Rocky 9. Unacurlche non riesce a connettersi si arrende al massimo dopo 15 secondi, e il fallimento finisce nel syslog comepa-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 cmdera identico con e senza l'hook, a parte l'orario nella riga "Last login". - La chiave non compare mai su una riga di comando.
curllegge l'headerTokendal suo standard input (-K -). Gli argomenti sono visibili a tutti gli utenti locali conps. Mentre una richiesta era in attesa, la chiave non era presente in/proc/<pid>/cmdlinedi 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
400se un pulsanteviewnon contiene un URL valido. UnPAM_RHOSTanomalo deve comunque farti arrivare l'avviso, solo senza pulsanti. - I pattern vengono confrontati per metà.
user@addressviene diviso all'ultima@, e ciascun lato viene confrontato da solo. Unire le due parti in un'unica stringa permetterebbe a un account chiamato[email protected]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:
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 [email protected].*"
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à 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.
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_execnon esegue affatto lo script al logout. Conta per lo stesso motivo della posizione: al logout,pam_envè già stato eseguito, e nel nostro test ilLD_PRELOADdi~/.pam_environmentera di nuovo nell'ambiente.quiet: se il comando fallisce,pam_execnon 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:
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ù:
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: 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.