SSD Nodes Learn Hosting plans →
Guide Matt ConnorDi Matt Connor · Aggiornato 2026-11-06

SSO per qualsiasi app con oauth2-proxy e OIDC

Scopri come proteggere un'app senza login con oauth2-proxy: configura forward auth in Nginx o Traefik ed evita errori di cookie e redirect.

Autenticazione forward: come fornire SSO a un'applicazione senza login

oauth2-proxy fornisce il single sign-on a un'applicazione che non dispone di un sistema di login proprio. Funziona perché il reverse proxy davanti all'applicazione interrompe ogni richiesta, chiede a oauth2-proxy se la richiesta contiene una sessione valida e inoltra la richiesta al servizio upstream solo quando la risposta è positiva. Il codice dell'applicazione non cambia, perché l'applicazione non vede mai il controllo.

Il controllo aggiunge una richiesta HTTP. Il proxy invia una copia degli header della richiesta in ingresso a /oauth2/auth e legge il codice di stato. Il codice 202 indica che il controllo è riuscito, quindi il proxy inoltra la richiesta originale all'applicazione. Il codice 401 indica l'assenza di una sessione valida, quindi il proxy reindirizza il browser a /oauth2/sign_in, che per impostazione predefinita mostra una pagina di login. /oauth2/start avvia un login OpenID Connect (OIDC) presso il provider di identità; skip_provider_button = true fa in modo che /oauth2/sign_in lo avvii automaticamente. OIDC è il livello di identità costruito sopra OAuth 2.0 e il provider è quello che già usi per i login.

Questo schema ha un nome in ogni reverse proxy. Nginx chiama la direttiva auth_request. Traefik chiama il middleware forwardAuth. Caddy lo indica come forward_auth. Anche il servizio che risponde alla sotto-richiesta può essere sostituito. oauth2-proxy è una scelta comune perché supporta OIDC senza componenti aggiuntivi e non richiede un database proprio.

Disegnare il confine di attendibilità prima di scrivere la configurazione

Dopo un controllo riuscito, oauth2-proxy restituisce l’identità negli header della risposta e il reverse proxy li copia nella richiesta verso l’upstream. Con set_xauthrequest abilitato, si ottengono X-Auth-Request-User e X-Auth-Request-Email. L’applicazione legge questi header e si fida del loro contenuto.

Questo è l’intero modello di sicurezza. È quindi importante esplicitarne la conseguenza. Qualsiasi elemento in grado di aprire una connessione TCP alla porta dell’applicazione può impostare autonomamente questi header e impersonare un utente qualsiasi. Un singolo curl -H "X-Auth-Request-Email: admin@example.com" http://127.0.0.1:3000/ consente di eludere completamente il controllo se raggiunge direttamente l’applicazione.

L’applicazione deve quindi essere raggiungibile soltanto tramite il proxy. In Docker Compose, rimuovere il mapping ports: dal servizio dell’applicazione e lasciarlo sulla rete interna, in modo che soltanto il container del proxy possa connettersi. Su un host senza container, associare l’applicazione a 127.0.0.1:3000 anziché a 0.0.0.0:3000. Verificare quindi ciò che è stato effettivamente esposto:

sudo ss -tlnp | grep 3000

Una riga contenente 0.0.0.0:3000 indica che l’applicazione risponde sull’IP pubblico e che il controllo di accesso è soltanto apparente. 127.0.0.1:3000 è il risultato corretto. Una regola firewall è un secondo livello utile, ma l’indirizzo di bind è quello che rimane valido anche se un altro strumento svuota il ruleset.

Install oauth2-proxy

A ottobre 2026 la release corrente è v7.15.5, pubblicata il 1 ottobre 2026. Risolve due avvisi di sicurezza critici. Uno riguarda un bypass di skip_auth_routes che interessa tutte le release successive alla v7.5.0. Non installare versioni precedenti. Installa il binario e verifica il download:

cd /tmp
curl -fsSLO https://github.com/oauth2-proxy/oauth2-proxy/releases/download/v7.15.5/oauth2-proxy-v7.15.5.linux-amd64.tar.gz
curl -fsSLO https://github.com/oauth2-proxy/oauth2-proxy/releases/download/v7.15.5/oauth2-proxy-v7.15.5.linux-amd64.tar.gz-sha256sum.txt
sha256sum -c oauth2-proxy-v7.15.5.linux-amd64.tar.gz-sha256sum.txt
tar -xzf oauth2-proxy-v7.15.5.linux-amd64.tar.gz
sudo install -m 755 oauth2-proxy-v7.15.5.linux-amd64/oauth2-proxy /usr/local/bin/oauth2-proxy
oauth2-proxy --version

sha256sum -c deve stampare una riga che termina con OK. Se stampa FAILED, interrompi la procedura e scarica nuovamente il file invece di eseguire il binario.

In Docker l'immagine è quay.io/oauth2-proxy/oauth2-proxy. Devi fissare il tag: quay.io/oauth2-proxy/oauth2-proxy:v7.15.5. Lasciarlo su latest trasforma un normale docker compose pull in un aggiornamento non pianificato dell'unico processo che protegge tutte le applicazioni sul server.

Il cookie di sessione è crittografato e cookie_secret è la chiave. La chiave di crittografia deve avere esattamente 16, 24 o 32 byte, perché viene usata come chiave AES (Advanced Encryption Standard). oauth2-proxy accetta un valore codificato in base64 sicuro per gli URL che, una volta decodificato, produce una di queste lunghezze. Accetta anche un secret non codificato con una di queste lunghezze. In caso contrario, non si avvia e restituisce un errore di avvio che indica il cookie secret. Il comando seguente genera un valore di 44 caratteri che codifica una chiave di 32 byte.

openssl rand -base64 32 | tr -- '+/' '-_'

Il parametro tr non è ornamentale. Converte la codifica base64 standard nell'alfabeto sicuro per gli URL usato da oauth2-proxy per decodificare il secret.

Per questo valore valgono due regole. Usare un secret diverso per ogni deployment. Se si esegue più di un'istanza di oauth2-proxy dietro lo stesso dominio, assegnare a tutte lo stesso secret, perché un cookie crittografato da un'istanza deve poter essere letto dalle altre.

Scrivere la configurazione di oauth2-proxy

Mantieni le impostazioni in un file invece di usare una riga di comando lunga, in modo che il client secret non compaia mai nell'output di ps.

# /etc/oauth2-proxy/oauth2-proxy.cfg
http_address = "127.0.0.1:4180"
reverse_proxy = true

provider = "oidc"
oidc_issuer_url = "https://id.example.com/application/o/myapp/"
client_id = "REPLACE_ME"
client_secret = "REPLACE_ME"

redirect_url = "https://app.example.com/oauth2/callback"
cookie_secret = "REPLACE_ME"
cookie_secure = true
cookie_domains = [".example.com"]
whitelist_domains = [".example.com"]

email_domains = ["*"]
set_xauthrequest = true
upstreams = ["static://202"]

reverse_proxy = true indica a oauth2-proxy di considerare attendibili gli header X-Forwarded-* inviati dal proxy che lo precede. Senza questa impostazione, oauth2-proxy considera l'indirizzo del proxy stesso come indirizzo del client e può valutare erroneamente se la richiesta è arrivata tramite HTTPS.

trusted_proxy_ips limita i peer autorizzati a fornire questi header. Per impostazione predefinita, considera attendibile ogni origine. In questo caso è sicuro solo perché http_address mantiene oauth2-proxy in ascolto su 127.0.0.1. Se invece oauth2-proxy è in ascolto su una rete Docker, impostalo sull'indirizzo del reverse proxy.

upstreams = ["static://202"] fa sì che oauth2-proxy risponda con 202 a una richiesta autenticata senza fare il proxy di alcun contenuto. È esattamente ciò che serve per la forward auth, perché il reverse proxy gestisce il proxying. Nell'altra modalità di distribuzione, oauth2-proxy si trova direttamente nel percorso delle richieste tramite upstreams = ["http://127.0.0.1:3000"] e senza alcun auth_request. È una soluzione più semplice per una sola applicazione, ma non scala a dieci.

email_domains = ["*"] ammette ogni indirizzo che il provider autenticherà. Limitalo al tuo dominio oppure, meglio ancora, restringi l'accesso con un'associazione a un gruppo nel provider, perché è lì che gestisci già gli utenti.

Eseguilo con systemd usando un utente dedicato:

# /etc/systemd/system/oauth2-proxy.service
[Unit]
Description=oauth2-proxy
After=network-online.target
Wants=network-online.target

[Service]
User=oauth2-proxy
Group=oauth2-proxy
ExecStart=/usr/local/bin/oauth2-proxy --config=/etc/oauth2-proxy/oauth2-proxy.cfg
Restart=on-failure
ProtectSystem=strict
PrivateTmp=true
NoNewPrivileges=true

[Install]
WantedBy=multi-user.target
sudo useradd --system --no-create-home --shell /usr/sbin/nologin oauth2-proxy
sudo install -d -m 750 /etc/oauth2-proxy
sudo chown -R oauth2-proxy:oauth2-proxy /etc/oauth2-proxy
sudo chmod 600 /etc/oauth2-proxy/oauth2-proxy.cfg
sudo systemctl daemon-reload
sudo systemctl enable --now oauth2-proxy
curl -s http://127.0.0.1:4180/ping

La stampa di /ping e OK indica che il processo è stato avviato e ha caricato la configurazione. È l'endpoint di salute di oauth2-proxy e non richiede mai una sessione. Se non risponde nulla, consulta journalctl -u oauth2-proxy -n 50, perché un URL dell'issuer errato e un cookie secret di lunghezza non valida causano entrambi un errore all'avvio e lo indicano nei log.

Registrare l’URI di reindirizzamento presso il provider

Creare un’applicazione OIDC nel provider e impostare l’URI di reindirizzamento esattamente sul redirect_url della configurazione: https://app.example.com/oauth2/callback. Per esattamente si intende che schema, host, porta e percorso corrispondano carattere per carattere. Una slash finale rende l’URI diverso.

Questo è l’errore più comune dell’intera configurazione e si verifica prima ancora che intervenga oauth2-proxy. Il provider rifiuta la richiesta di autorizzazione e visualizza la propria pagina di errore, quindi nel log di oauth2-proxy non compare nulla. L’indizio è nella barra degli indirizzi: il browser si trova ancora sul dominio del provider e la stringa di query contiene error=invalid_request oppure la pagina nomina direttamente redirect_uri. In questo caso, correggere il record dell’applicazione nel provider, non la configurazione del proxy.

Copiare l’URL dell’issuer dal provider invece di digitarlo. oauth2-proxy aggiunge /.well-known/openid-configuration a oidc_issuer_url e recupera quel documento di discovery all’avvio. Verificarlo prima manualmente:

curl -s https://id.example.com/application/o/myapp/.well-known/openid-configuration | head -c 400

Un JSON che contiene una chiave authorization_endpoint è un primo controllo; anche issuer nel documento deve corrispondere esattamente a oidc_issuer_url. Un errore 404 o una pagina di errore HTML indicano che l’URL è errato e oauth2-proxy non riuscirà ad avviarsi, restituendo lo stesso errore 404. Se non è ancora stato scelto un provider, il confronto tra Keycloak, Authentik e Zitadel illustra i compromessi, mentre eseguire Authentik come server SSO autonomo descrive la parte relativa al provider di questa configurazione.

Nginx: auth_request

Nginx esegue l'autenticazione delegata con auth_request, che avvia una sotto-richiesta interna e determina il comportamento in base al relativo codice di stato.

# in the http context, next to your other maps
map $http_upgrade $connection_upgrade {
  default upgrade;
  ''      close;
}

server {
  listen 443 ssl;
  server_name app.example.com;

  location /oauth2/ {
    proxy_pass       http://127.0.0.1:4180;
    proxy_set_header Host                    $host;
    proxy_set_header X-Real-IP               $remote_addr;
    proxy_set_header X-Auth-Request-Redirect $request_uri;
  }

  location = /oauth2/auth {
    proxy_pass       http://127.0.0.1:4180;
    proxy_set_header Host             $host;
    proxy_set_header X-Real-IP        $remote_addr;
    proxy_set_header X-Forwarded-Uri  $request_uri;
    proxy_set_header Content-Length   "";
    proxy_pass_request_body           off;
  }

  location / {
    auth_request /oauth2/auth;
    error_page 401 = @oauth2_signin;

    auth_request_set $user  $upstream_http_x_auth_request_user;
    auth_request_set $email $upstream_http_x_auth_request_email;
    proxy_set_header X-User  $user;
    proxy_set_header X-Email $email;

    auth_request_set $auth_cookie $upstream_http_set_cookie;
    add_header Set-Cookie $auth_cookie;

    proxy_pass http://127.0.0.1:3000;
    proxy_set_header Host       $host;
    proxy_set_header Upgrade    $http_upgrade;
    proxy_set_header Connection $connection_upgrade;
  }

  location @oauth2_signin {
    return 302 /oauth2/sign_in?rd=$scheme://$host$request_uri;
  }
}

Tre dettagli sono essenziali. proxy_pass_request_body off con Content-Length vuoto impedisce a nginx di inoltrare un corpo della richiesta all'endpoint di autenticazione, che richiede soltanto gli header.

La coppia auth_request_set $auth_cookie e add_header Set-Cookie restituisce al browser un cookie di sessione aggiornato. Se la si omette, cookie_refresh non produce alcun effetto, perché nginx scarta Set-Cookie della sotto-richiesta e il browser conserva il valore precedente fino alla scadenza della sessione. Questa coppia gestisce un cookie; per i cookie di sessione suddivisi servono una gestione aggiuntiva delle altre parti oppure l'archiviazione delle sessioni in Redis.

error_page 401 = @oauth2_signin trasforma un controllo non riuscito in un accesso. Senza questa direttiva, un visitatore non autenticato riceve una pagina 401 Authorization Required vuota e non ha modo di procedere.

Eseguire sempre il test prima del reload:

sudo nginx -t && sudo systemctl reload nginx

Se le direttive circostanti non sono familiari, l'anatomia di una configurazione reverse proxy nginx descrive il livello sottostante.

Traefik: middleware forwardAuth

Traefik richiede due middleware per lo stesso compito. Uno esegue il controllo. L'altro serve la pagina di accesso quando il controllo fallisce.

# dynamic configuration
http:
  middlewares:
    oauth-auth:
      forwardAuth:
        address: https://oauth.example.com/oauth2/auth
        trustForwardHeader: true
    oauth-errors:
      errors:
        status:
          - "401-403"
        service: oauth-backend
        query: "/oauth2/sign_in?rd={url}"

Collega entrambi al router che espone la tua applicazione, con oauth-errors prima di oauth-auth, e pubblica oauth2-proxy su un router separato all'indirizzo oauth.example.com, perché il browser deve poter raggiungere /oauth2/sign_in e /oauth2/callback senza passare dal controllo. Per questo host di accesso separato, imposta redirect_url su https://oauth.example.com/oauth2/callback e registra quell'URI presso il provider.

Con la configurazione di oauth2-proxy precedente, /oauth2/sign_in visualizza una pagina di accesso. Per un redirect automatico, imposta skip_provider_button = true in oauth2-proxy e aggiungi statusRewrites: {"401": 302} nelle impostazioni errors di Traefik. Senza questa riscrittura, Traefik restituisce il redirect automatico con stato 401 e il browser non lo segue. La sola riscrittura non avvia il flusso di accesso.

trustForwardHeader: true considera attendibili gli header X-Forwarded-* in ingresso; Traefik fornisce a oauth2-proxy l'host e l'URI originali. Questa opzione è deprecata nella documentazione attuale di Traefik. Imposta whitelist_domains per includere anche quell'host; in caso contrario, oauth2-proxy elimina il parametro rd perché lo considera un rischio di open redirect e, dopo l'accesso, tutti vengono reindirizzati a /. Un server Traefik espone generalmente più applicazioni contemporaneamente e instradare più applicazioni Docker Compose tramite un'unica istanza Traefik mostra la struttura dei router in cui si integra questa configurazione.

Caddy: forward_auth

app.example.com {
  handle /oauth2/* {
    reverse_proxy 127.0.0.1:4180 {
      header_up X-Real-IP {remote_host}
      header_up X-Forwarded-Uri {uri}
    }
  }
  handle {
    forward_auth 127.0.0.1:4180 {
      uri /oauth2/auth
      header_up X-Real-IP {remote_host}
      copy_headers X-Auth-Request-User X-Auth-Request-Email
      @error status 401
      handle_response @error {
        redir * /oauth2/sign_in?rd={scheme}://{host}{uri}
      }
    }
    reverse_proxy 127.0.0.1:3000
  }
}

L’ordine è importante. Il blocco /oauth2/* viene prima e non contiene alcun forward_auth, perché un visitatore non autenticato deve poter raggiungere i percorsi di accesso e di callback. Se si esegue il controllo prima di questi percorsi, il reindirizzamento di accesso torna al percorso stesso finché il browser interrompe il tentativo.

copy_headers trasferisce l’identità alla richiesta upstream e produce valori solo quando oauth2-proxy viene eseguito con set_xauthrequest = true. La scelta tra i proxy richiede una valutazione separata; il confronto tra nginx, Caddy e Traefik la analizza.

Perché il login torna alla pagina di accesso?

Accedi presso il provider, che ti reindirizza al sito, ma oauth2-proxy ti reindirizza nuovamente alla pagina di accesso. Il loop indica che, alla richiesta successiva, oauth2-proxy non accetta una sessione valida. Il cookie di sessione può mancare oppure può essere presente ma non superare la convalida, ad esempio quando le istanze usano secret del cookie diversi. Apri gli strumenti per sviluppatori del browser, individua la richiesta a /oauth2/callback successiva al reindirizzamento dal provider e leggi l'header di risposta Set-Cookie. Se un cookie viene impostato in quella risposta ma manca nella richiesta successiva, il browser lo sta rifiutando. Se invece è presente, controlla il log del server per errori di convalida come cookie signature not valid e verifica che tutte le istanze usino lo stesso secret.

Quando il cookie che scompare è il cookie CSRF impostato da oauth2-proxy durante il reindirizzamento verso il provider, il flusso non entra in loop. Si interrompe al callback e il log indica il caso:

No cookies were found in OAuth callback.

oppure, quando un altro cookie è arrivato ma quello corretto no:

Cookies were found in OAuth callback, but none was a CSRF cookie.

CSRF significa falsificazione di richieste cross-site. Questo cookie serve a collegare il callback al login che lo ha avviato. Il browser riceve una pagina di errore 403 contenente:

Login Failed: Unable to find a valid CSRF token. Please try again.

L'assenza dei cookie ha in comune le prime tre cause riportate di seguito; anche la deriva dell'orologio può causare errori di convalida. Controlla queste quattro cause nell'ordine indicato.

  1. cookie_secure = true mentre il browser ha raggiunto il sito tramite HTTP semplice. Tranne che per localhost, un browser non memorizza un cookie contrassegnato con Secure su un'origine http://, quindi non lo invia mai nuovamente. Configura correttamente la terminazione TLS (transport layer security) oppure imposta cookie_secure = false solo durante i test su localhost.
  2. Un valore cookie_domains che non comprende il nome host mostrato nella barra degli indirizzi. .example.com comprende app.example.com e non ha alcun effetto su app.example.net.
  3. Il browser elimina il cookie. Un'estensione per la privacy con criteri restrittivi o il blocco dei cookie di terze parti può rimuovere _oauth2_proxy_csrf tra il reindirizzamento in uscita e il callback, oppure eliminare il cookie di sessione subito dopo.
  4. Deriva dell'orologio. Se l'orologio del server è molto avanti rispetto a quello del provider, il token ID può risultare scaduto e non superare la convalida. timedatectl dovrebbe riportare System clock synchronized: yes.

Un'altra causa produce l'errore CSRF anche quando la configurazione è corretta. Per impostazione predefinita, oauth2-proxy conserva un solo cookie CSRF, quindi due schede che avviano un login nello stesso momento si sovrascrivono a vicenda. cookie_csrf_per_request = true assegna a ogni login un cookie distinto.

Osserva il problema dal lato server invece di procedere per tentativi:

sudo journalctl -u oauth2-proxy -f

Apri l'applicazione in una finestra privata. Ogni richiesta viene registrata con il relativo stato; quindi un callback seguito subito da un altro reindirizzamento alla pagina di accesso identifica il loop nel log.

Percorsi che devono saltare il login: API, webhook e websocket

L’autenticazione inoltrata presuppone un browser che conservi un cookie. I client che non usano un browser non funzionano.

Un client API che invia Authorization: Bearer <token> non dispone di cookie. Di conseguenza, le configurazioni del proxy riportate sopra lo indirizzano alla pagina di login di oauth2-proxy, a meno che non sia abilitata l’autenticazione tramite bearer token. Esistono due soluzioni corrette. Impostando skip_jwt_bearer_tokens = true, oauth2-proxy accetta un bearer token JWT (JSON web token) valido emesso dall’issuer configurato, con un’audience accettata per questo client. Questa soluzione è adatta quando i client API ricevono già token appropriati dal provider. Il valore aud del token deve corrispondere a client_id oppure a un’audience configurata tramite extra_jwt_issuers. In alternativa, esenta il percorso:

skip_auth_routes = [
  "^/api/",
  "POST=^/webhook/",
  "GET=^/healthz$"
]

Ogni valore è un’espressione regolare confrontata con il percorso decodificato, senza i parametri di query. Può essere preceduta facoltativamente da un metodo HTTP e da =. POST=^/webhook/ lascia aperto il ricevitore dei webhook alle richieste POST, mentre un utente che accede allo stesso percorso tramite browser continua a essere indirizzato al login, purché la richiesta di autenticazione conservi il metodo originale. Nginx auth_request e Caddy forward_auth eseguono controlli GET. In queste configurazioni, le esenzioni specifiche per metodo richiedono quindi un routing separato nel reverse proxy. Ogni voce crea una lacuna nel controllo di accesso. Ancora le espressioni con ^ e mantienile il più restrittive possibile in base a ciò che consente il chiamante.

Usa la versione v7.15.5 o successiva prima di affidarti a queste impostazioni. Nelle versioni successive a v7.5.0 ma precedenti alla correzione, era possibile indurre il sistema a esentare un percorso protetto tramite una richiesta contenente segmenti . o .., una doppia barra iniziale oppure un punto e virgola (advisory GHSA-63jm-59jj-478j). L'ancoraggio delle espressioni non impediva l'attacco. La versione corretta rifiuta di esentare percorsi ambigui. Dopo l'aggiornamento, verifica quindi che i percorsi pubblici corrispondano ancora alle regole previste.

I websocket sono il caso più spesso interpretato erroneamente. La richiesta di upgrade è una normale richiesta HTTP GET e contiene gli stessi cookie delle altre richieste. Supera quindi normalmente il controllo e non richiede alcuna esenzione. Il problema riguarda il proxying della connessione. Senza gli header Upgrade e Connection nella location protetta, l'upgrade non viene completato. Il client dell'applicazione ritenta quindi continuamente e nella console del browser compare un messaggio WebSocket connection ... failed. Esentare il percorso non risolve il problema, perché la richiesta era già stata autorizzata.

Esiste comunque un limite concreto. Il controllo viene eseguito una sola volta, durante l'upgrade. Un websocket che rimane aperto per ore non viene ricontrollato. Se rimuovi un utente dal provider, il socket già aperto da quell'utente non viene quindi chiuso. Riavvia l'applicazione per interrompere le connessioni attive.

Per impostazione predefinita, l’intera sessione viene memorizzata nel cookie e crittografata con il tuo cookie_secret. In questo modo oauth2-proxy resta stateless e non richiede servizi aggiuntivi. Esiste però un limite, perché i browser impongono ai cookie una dimensione massima di circa 4 KB. Quando il token ID contiene un elenco lungo di claim relativi ai gruppi, oauth2-proxy suddivide la sessione tra _oauth2_proxy_0, _oauth2_proxy_1 e quelli successivi. Dopo alcune parti, gli header della richiesta diventano abbastanza grandi da indurre nginx a rispondere con 400 Request Header Or Cookie Too Large prima che l’applicazione possa ricevere la richiesta.

In questo caso, sposta la sessione sul server:

session_store_type = "redis"
redis_connection_url = "redis://127.0.0.1:6379"

Il browser conserva quindi un ticket breve, mentre la sessione crittografata viene memorizzata in Redis. Il costo è un servizio che deve restare attivo: se Redis non è disponibile, oauth2-proxy non può caricare le sessioni; la perdita dei dati delle sessioni memorizzate obbliga tutti gli utenti a eseguire nuovamente l’accesso. Anche il cookie store presenta un limite: due richieste che aggiornano la stessa sessione nello stesso momento possono entrare in conflitto e obbligare l’utente a eseguire nuovamente l’accesso.

Cosa non offre il forward auth

È un controllo all'ingresso. Non è l'autorizzazione all'interno dell'applicazione, e questa differenza determina se l'approccio è adatto al tuo caso.

Dopo l'accesso dell'utente, l'applicazione vede ciò che vedeva prima. Se l'app dispone di ruoli propri, il forward auth non li assegna, a meno che l'app supporti l'autenticazione basata su header e associ un header a un account. Grafana lo supporta tramite le impostazioni auth.proxy. La maggior parte delle applicazioni self-hosted non lo supporta. Di conseguenza, per l'applicazione tutti gli utenti che superano il controllo sono la stessa identità, spesso un amministratore.

Il forward auth non protegge nemmeno i token API dell'applicazione. Un personal access token emesso dall'app autentica direttamente l'utente presso l'app, non presso oauth2-proxy. Il token smette quindi di funzionare non appena il controllo viene anteposto all'applicazione. Per riattivarlo, devi escludere il percorso API. In questo modo, però, quel token diventa l'unica protezione del percorso. Sullo stesso servizio gestisci ora due sistemi di autenticazione, ma l'SSO copre soltanto uno dei due.

La revoca è la terza lacuna. L'eliminazione di un utente dal provider impedisce i nuovi accessi, ma oauth2-proxy non verifica una sessione esistente presso il provider finché non arriva la scadenza di cookie_refresh. Con il refresh disabilitato, il cookie di sessione resta valido fino alla sua scadenza. cookie_expire ha come valore predefinito 168 ore, quindi un utente appena rimosso può mantenere l'accesso per una settimana. Imposta cookie_refresh su un intervallo breve, ad esempio un'ora. Quando il provider rifiuta il refresh perché il refresh token dell'utente non è più valido, oauth2-proxy cancella la sessione e impone un nuovo accesso alla richiesta successiva che tenta il refresh. Non tutti i provider supportano il refresh. Verifica quindi il comportamento con il tuo provider.

Anche la traccia di audit si ferma al controllo. oauth2-proxy registra chi è passato e quando. L'applicazione registra una sessione senza nome. Se devi stabilire chi ha modificato un'impostazione, l'identità tramite header nell'applicazione è il requisito minimo. Account distinti per ogni utente sono la soluzione corretta.

Quando il costo dell’SSO è la scelta migliore

L’autenticazione delegata è lo strumento giusto quando un’applicazione non dispone di alcun login o usa una sola password condivisa e vuoi gestire l’abilitazione e la revoca degli utenti in un unico punto. Richiede un pomeriggio di lavoro e un processo aggiuntivo, e funziona con qualsiasi applicazione che utilizzi HTTP.

È lo strumento sbagliato quando persone diverse devono avere autorizzazioni diverse nella stessa applicazione. Un controllo di accesso non può esprimere «Ana può modificare i dashboard e Bo può solo consultarli». Se il fornitore offre un livello SSO a pagamento, la mappatura tra gruppi e ruoli è in genere il vero elemento che stai acquistando. Ricrearla con header e regole del proxy è più fragile che pagarla. Il modello di prezzo alla base di questi livelli SSO merita una lettura prima di decidere.

Qualsiasi applicazione con un client mobile o desktop che non trasmette i cookie del browser renderà il controllo di accesso problematico a ogni richiesta.

FAQ

Che cos'è l'autenticazione forward?

L'autenticazione forward è un modello in cui il reverse proxy interroga un servizio di autenticazione separato per ogni richiesta in ingresso prima di inoltrarla al servizio upstream. Il proxy invia gli header della richiesta a un endpoint come /oauth2/auth e legge il codice di stato. 202 significa che la richiesta è autorizzata, quindi la richiesta originale viene inoltrata all'applicazione. 401 significa che non esiste una sessione valida, quindi il proxy reindirizza il browser alla pagina di accesso. Nginx la implementa con la direttiva auth_request, Traefik con il middleware forwardAuth e Caddy con forward_auth.

Perché oauth2-proxy mi reindirizza alla pagina di accesso in un ciclo continuo?

Il cookie di sessione manca oppure non supera la convalida, quindi ogni controllo rileva che non esiste una sessione valida e reindirizza nuovamente alla pagina di accesso. Le istanze che usano secret cookie diversi rifiutano i cookie delle altre istanze. Un'altra causa è cookie_secure = true su un sito raggiunto dal browser tramite HTTP in chiaro, perché, tranne che su localhost, un browser non memorizza un cookie Secure su un'origine http://. Controlla anche che il valore cookie_domains includa l'hostname visualizzato nella barra degli indirizzi. Leggi l'header Set-Cookie nella risposta /oauth2/callback tramite gli strumenti per sviluppatori del browser per vedere quale cookie manca. Se il cookie viene restituito, controlla il log del server per verificare la presenza di errori di convalida. Se manca il cookie CSRF, viene visualizzata una pagina 403 con il messaggio Login Failed: Unable to find a valid CSRF token. Please try again. invece di un ciclo continuo e, quando non arriva alcun cookie, il log contiene No cookies were found in OAuth callback..

Come posso consentire il passaggio di un client API o di un webhook tramite oauth2-proxy?

Usa skip_auth_routes con un'espressione regolare ancorata, eventualmente limitata a un solo metodo HTTP, ad esempio POST=^/webhook/, ed esegui la versione v7.15.5 o successiva, che correggeva un bypass critico di queste esenzioni. Le esenzioni specifiche per metodo richiedono che la richiesta di autenticazione conservi il metodo originale; gli esempi per nginx e Caddy eseguono controlli GET, quindi gestisci queste esenzioni nel routing del reverse proxy. Se i client API dispongono già di JWT validi emessi dal provider configurato e con un'audience accettata, skip_jwt_bearer_tokens = true accetta questi token al posto di un cookie e mantiene la protezione del percorso. L'audience deve corrispondere a client_id oppure a un'audience configurata tramite extra_jwt_issuers. Tutto ciò che è elencato in skip_auth_routes non richiede autenticazione per nessuno, quindi mantieni ogni espressione il più restrittiva possibile in base a quanto consentito dal chiamante.

oauth2-proxy assegna all'applicazione autorizzazioni specifiche per ogni utente?

No. È un punto di controllo, non un sistema di autorizzazione. Decide chi può raggiungere l'applicazione, ma tutti gli utenti che la raggiungono risultano identici all'applicazione, a meno che quest'ultima non legga gli header di identità e non li associ agli account. Grafana può farlo tramite le impostazioni auth.proxy. La maggior parte delle applicazioni self-hosted non supporta questa funzione, quindi tutte le persone che superano il punto di controllo condividono l'unica identità con cui è in esecuzione l'applicazione.

È possibile bypassare oauth2-proxy impostando direttamente l'header di identità?

Sì, se è possibile raggiungere direttamente l'applicazione. L'identità arriva in un header non cifrato come X-Auth-Request-Email e l'applicazione si fida di qualunque valore riceva. Chiunque possa aprire una connessione alla porta dell'applicazione può inviare quell'header e impersonare qualsiasi utente. Associa l'applicazione a 127.0.0.1 oppure mantienila su una rete Docker interna senza porte pubblicate e verifica la configurazione con sudo ss -tlnp.

Questo articolo ti è stato utile?

#oauth2-proxy#sso#oidc#reverse-proxy#forward-auth