Tunnels HTTP auto-hébergés avec SSH et nginx

Vincent Bernat

Un ami veut re­lire votre ar­ticle de blog en cours de ré­dac­tion, mais sa pré­vi­sua­li­sa­tion ne tourne que sur localhost:​8080. Plu­sieurs ou­tils peuvent ai­der. Cer­tains sont des ser­vices com­mer­ciaux, comme ngrok ou Cloud­flare Quick Tun­nels. D’autres peuvent être auto-hé­ber­gés, mais exigent un client dé­dié, comme frp ou lo­cal­tun­nel. D’autres en­core se contentent d’un simple client SSH, mais re­posent sur un ser­veur SSH spé­ci­fique, comme sish. Voyons com­ment mettre en place une so­lu­tion auto-hé­ber­gée avec juste OpenSSH et nginx !

$ ssh -R 0:localhost:8080 http-over-ssh
Allocated port 41535 for remote forward to localhost:8080
https://6J3jK1WmB15c6WmjW_X-Wg--1789928654@p41535.ssh.luffy.cx/

Configuration de base#

Tout d’abord, nous re­di­ri­geons vers votre ser­vice lo­cal les connexions re­çues sur un port d’un ser­veur distant :

$ ssh -N -R 0:localhost:8080 web02.luffy.cx
Allocated port 41535 for remote forward to localhost:8080

Lorsque nous in­di­quons 0 comme port dis­tant, le ser­veur al­loue un port libre. En­suite, nous confi­gu­rons nginx pour re­layer les re­quêtes de https://​p41535.​ssh.​luffy.cx vers http://​127.0.0.1:41535 :

server {
  listen 0.0.0.0:443 ssl ;
  listen [::0]:443 ssl ;
  server_name ~^p(?<port>\d\d\d\d\d)\.ssh\.luffy\.cx$;
  location / {
    proxy_pass http://127.0.0.1:$port;
  }
}

Il faut aussi ajou­ter des en­re­gis­tre­ments DNS pour *.ssh.​luffy.cx et ob­te­nir un cer­ti­fi­cat gé­né­rique au­près de Let’s Encrypt :

*.ssh.luffy.cx.               CNAME web02.luffy.cx.
ssh.luffy.cx.                 CAA   0 issuewild "letsencrypt.org"
_acme-challenge.ssh.luffy.cx  CNAME ssh.luffy.cx.acme.luffy.cx.

acme.​luffy.cx est une zone hé­ber­gée sur Route 53. Je l’uti­lise pour les dé­fis ACME DNS-01, aussi bien pour les cer­ti­fi­cats gé­né­riques que pour les do­maines ser­vis par plu­sieurs ser­veurs web. Dans mon cas, NixOS ob­tient les cer­ti­fi­cats au­to­ma­ti­quement.

Contrôle d’accès#

Le port est le seul « se­cret1 » qui pro­tège la confi­den­tia­lité du contenu. D’autres so­lu­tions de re­di­rec­tion ajoutent une chaîne aléa­toire au nom de do­maine pour em­pê­cher un in­trus d’énu­mé­rer les va­leurs possibles.

Grâce au mo­dule ngx_​http_​secure_​link_​module, nous pou­vons ren­for­cer un peu la sé­cu­rité de cette confi­gu­ra­tion. Ce mo­dule cal­cule une em­preinte2 sur un en­semble de va­leurs, dont un se­cret, et la com­pare à celle four­nie dans la re­quête. L’em­preinte est en­co­dée en base64 : im­pos­sible donc de la pla­cer dans le nom de do­maine, qui est in­sen­sible à la casse. Nous l’in­sé­rons plu­tôt dans l’URL, comme nom d’uti­li­sa­teur, avec sa date d’ex­pi­ration3 :

https://6J3jK1WmB15c6WmjW_X-Wg--1789928654@p41535.ssh.luffy.cx/fr/blog
        ╰─────────┬──────────╯  ╰───┬────╯  ╰─┬─╯             ╰──┬───╯
              empreinte        expiration   port              chemin

Le client en­voie le nom d’uti­li­sa­teur au ser­veur avec l’au­then­ti­fi­ca­tion HTTP ba­sique. Cela fonc­tionne avec la plu­part des clients HTTP, dont curl. Nginx ex­pose le nom d’uti­li­sa­teur dans la va­riable $remote_​user. Le mo­dule at­tend l’em­preinte et la date d’ex­pi­ra­tion sé­pa­rées par une vir­gule. À l’aide d’une di­rec­tive map, nous ex­tra­yons les deux par­ties de $remote_​user et les for­ma­tons comme at­tendu4. Nous four­nis­sons aussi au mo­dule la chaîne à ha­cher. Elle contient la date d’ex­pi­ra­tion, le port et un secret :

map $remote_user $httpssh_link {
  "~^([-_A-Za-z0-9]{22})--([0-9]+)$" "$1,$2";
}
server {
  # […]
  location / {
    secure_link $httpssh_link;
    secure_link_md5 "$secure_link_expires $port ZuPerS3cr3!";
  }
}

Le mo­dule ren­voie le ré­sul­tat de la vé­ri­fi­ca­tion dans la va­riable $secure_link :

  • vide si les em­preintes ne cor­res­pondent pas ;
  • "0" si elles cor­res­pondent, mais que le lien a expiré ;
  • "1" sinon.

Si l’em­preinte est in­cor­recte ou ab­sente, nous ren­voyons une er­reur 401 avec un en-tête WWW-Authenticate pour ré­cla­mer des iden­ti­fiants. Si le lien a ex­piré, nous ren­voyons une er­reur 410. Nous re­ti­rons l’en-tête Authorization avant de trans­mettre la re­quête et ajou­tons quelques di­rec­tives pour re­layer les connexions WebSocket. Voici la confi­gu­ra­tion complète5 :

map $remote_user $httpssh_link {
  "~^([-_A-Za-z0-9]{22})--([0-9]+)$" "$1,$2";
}
server {
  listen 0.0.0.0:443 ssl ;
  listen [::0]:443 ssl ;
  server_name ~^p(?<port>\d\d\d\d\d)\.ssh\.luffy\.cx$;
  location / {
    secure_link $httpssh_link;
    secure_link_md5 "$secure_link_expires $port ZuPerS3cr3!";
    if ($secure_link = "") {
      add_header WWW-Authenticate 'Basic realm="tunnel"' always;
      return 401;
    }
    if ($secure_link = "0") {
      return 410;
    }
    proxy_pass http://127.0.0.1:$port;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header Authorization "";
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
    proxy_buffering off;
    proxy_read_timeout 30m;
  }
}

Je pense que vous vous po­sez main­te­nant la ques­tion évi­dente : « Com­ment gé­né­rer l’em­preinte ? » Un jeu d’enfant !

$ expires=$(( $(date +%s) + 86400 ))
$ port=41535
$ secret='ZuPerS3cr3!'
$ printf '%s %s %s' "$expires" "$port" "$secret" \
>   | openssl md5 -binary \
>   | openssl base64 \
>   | tr +/ -_ | tr -d =
6J3jK1WmB15c6WmjW_X-Wg

Bon, je sup­pose que vous vous dites main­te­nant : « Vincent, ce n’est pas très pra­tique ! Si ça ne te dé­range pas, je vais gar­der ngrok. » D’ac­cord, d’ac­cord. Écri­vons un script pour flui­difier ça.

Script utilitaire#

La prin­ci­pale dif­fi­culté est de trou­ver le port éphé­mère al­loué par OpenSSH, car il n’ap­pa­raît dans au­cune va­riable d’en­vi­ron­ne­ment6. Pour contour­ner cet obs­tacle, nous cher­chons parmi les an­cêtres les pro­ces­sus sshd-session7 :

pids=$(
  pid=$$
  while [ "$pid" -gt 1 ]; do
    line=$(ps -o comm=,pid=,ppid= -p "$pid")
    echo "$line"
    pid=${line##* }
  done | awk '$1 == "sshd-session" { printf "pid=%s,\n", $2 }'
)
if [ -z "$pids" ]; then
  echo "not an ssh session" >&2
  exit 1
fi

En­suite, nous ré­cu­pé­rons les ports en écoute as­so­ciés à ces pro­ces­sus sshd-session8 :

ports=$(sudo -n ss --listening --numeric --tcp --processes --no-header \
  | grep -F "$pids" \
  | awk '{ print $4 }' | awk -F: '{ print $NF }' \
  | sort -un)
if [ -z "$ports" ]; then
  echo "no forwarded port, use ssh -R 0:localhost:PORT" >&2
  exit 1
fi

En­fin, nous af­fi­chons les URL et gar­dons la ses­sion ouverte :

lifetime=86400
secret='ZuPerS3cr3!'
expires=$(( $(date +%s) + lifetime ))
for port in $ports; do
  token=$(printf '%s %s %s' "$expires" "$port" "$secret" \
            | openssl md5 -binary \
            | openssl base64 \
            | tr +/ -_ | tr -d =)
  echo "https://$token--$expires@p$port.ssh.luffy.cx/"
done
sleep infinity

J’ins­talle ce script sous le nom http-over-ssh sur le ser­veur et j’ajoute cette en­trée à mon ~/.​ssh/config :

Host http-over-ssh
  Hostname web02.luffy.cx
  RemoteCommand http-over-ssh
  ControlPath none

Avec cette so­lu­tion, je ne dé­pends que d’OpenSSH et de nginx, deux lo­gi­ciels qui tournent déjà sur ce ser­veur. Une com­mande toute simple me four­nit un tun­nel auto-hé­bergé et une URL à par­ta­ger. Pour l’es­sayer, ré­cu­pé­rez le script uti­li­taire com­plet, qui contient quelques pe­tites amé­lio­ra­tions. Si vous uti­li­sez NixOS, comme toute per­sonne de goût, je­tez aussi un œil à mon http-over-ssh.nix. ❄️

Mise à jour (10.2026)

Cet ar­ticle a été lon­gue­ment dis­cuté sur Ha­cker News et Lobsters.

Mise à jour (10.2026)

Je suis de­puis passé sur Caddy qui n’in­clut pas de mo­dule pour tes­ter la va­li­dité d’une URL. À la place, Caddy in­ter­roge un ser­vice HTTP lo­cal écrit en Go via la di­rec­tive forward_​auth. Cela per­met au pas­sage de pla­cer l’em­preinte dans le nom de domaine.