SSD Nodes Learn Hosting plans →
Gidsen Matt ConnorDoor Matt Connor · Bijgewerkt 2026-11-06

Applicatie beveiligen met SSO via oauth2-proxy

Beveilig applicaties zonder eigen inlogscherm met oauth2-proxy via forward auth. Voorkom cookie- en redirectfouten door de juiste configuratie in Nginx of Traefik toe te passen.

Forward auth: hoe een applicatie zonder login SSO krijgt

oauth2-proxy biedt single sign-on aan een applicatie die zelf geen login heeft. Dit werkt doordat de reverse proxy voor die applicatie elk verzoek tegenhoudt, aan oauth2-proxy vraagt of het verzoek een geldige sessie bevat, en het verzoek alleen doorstuurt naar de upstream als het antwoord ja is. De applicatiecode verandert nooit, omdat de applicatie de controle niet ziet.

De controle is één extra HTTP-verzoek. De proxy stuurt een kopie van de inkomende request headers naar /oauth2/auth en leest de statuscode. Een 202 betekent dat de controle is geslaagd, dus stuurt de proxy het oorspronkelijke verzoek door naar de app. Een 401 betekent geen geldige sessie, dus stuurt de proxy de browser naar /oauth2/sign_in, die standaard een inlogpagina toont. /oauth2/start start een OpenID Connect (OIDC) login bij uw identity provider; skip_provider_button = true zorgt ervoor dat /oauth2/sign_in dit automatisch start. OIDC is de identiteitslaag gebouwd bovenop OAuth 2.0, en de provider is wat u ook gebruikt voor logins.

Dit patroon heeft in elke reverse proxy een naam. Nginx noemt de directive auth_request. Traefik noemt de middleware forwardAuth. Caddy spelt het als forward_auth. De service die het sub-verzoek beantwoordt is eveneens uitwisselbaar. oauth2-proxy is een veelgebruikte keuze omdat deze standaard OIDC spreekt en geen eigen database nodig heeft.

Trek de vertrouwensgrens voordat u een configuratie schrijft

Na een succesvolle controle stuurt oauth2-proxy de identiteit terug als response headers, waarna de reverse proxy deze kopieert naar het upstream-verzoek. Met set_xauthrequest ingeschakeld krijgt u X-Auth-Request-User en X-Auth-Request-Email. De applicatie leest deze headers en vertrouwt ze.

Dit is het volledige beveiligingsmodel, dus spreek de consequentie hardop uit. Alles wat een TCP-verbinding kan openen naar de applicatiepoort, kan deze headers zelf instellen en zich voordoen als elke willekeurige gebruiker. Een enkele curl -H "X-Auth-Request-Email: admin@example.com" http://127.0.0.1:3000/ is een volledige omzeiling als deze de app rechtstreeks bereikt.

De applicatie mag daarom niet bereikbaar zijn, behalve via de proxy. Verwijder in Docker Compose de ports:-mapping van de app-service en laat deze op het interne netwerk staan, zodat alleen de proxy-container er verbinding mee kan maken. Bind de app op een bare-metal host aan 127.0.0.1:3000 in plaats van 0.0.0.0:3000. Controleer vervolgens wat u daadwerkelijk heeft blootgesteld:

sudo ss -tlnp | grep 3000

Een regel met 0.0.0.0:3000 betekent dat de app antwoordt op het publieke IP-adres en dat uw poortbeveiliging slechts decoratie is. 127.0.0.1:3000 is wat u wilt zien. Een firewallregel is een nuttige tweede laag, maar het bind-adres is de instelling die blijft bestaan als een andere tool uw ruleset leegt.

Installatie van oauth2-proxy

Sinds oktober 2026 is de huidige release v7.15.5, gepubliceerd op 1 oktober 2026. Deze versie verhelpt twee kritieke beveiligingslekken, waaronder een omzeiling van skip_auth_routes die elke release na v7.5.0 treft. Installeer daarom geen oudere versies. Installeer het binaire bestand en verifieer de 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 moet een regel afdrukken die eindigt op OK. Als de uitvoer FAILED is, stop dan en download het bestand opnieuw in plaats van het binaire bestand uit te voeren.

In Docker is de image quay.io/oauth2-proxy/oauth2-proxy; u dient de tag vast te zetten: quay.io/oauth2-proxy/oauth2-proxy:v7.15.5. Het gebruik van latest verandert een routinematige docker compose pull in een ongeplande upgrade van het proces dat alle applicaties op de server beveiligt.

De sessie-cookie is versleuteld en cookie_secret is de sleutel. De encryptiesleutel moet exact 16, 24 of 32 bytes lang zijn, omdat deze fungeert als een AES (advanced encryption standard) sleutel. oauth2-proxy accepteert een URL-veilige base64-waarde die decodeert naar een van deze lengtes, of een raw secret van een van deze lengtes; anders weigert het programma te starten en verschijnt er een opstartfout die de cookie secret benoemt. Het onderstaande commando genereert een waarde van 44 tekens die een sleutel van 32 bytes codeert.

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

De tr is niet louter cosmetisch. Deze zet standaard base64 om naar het URL-veilige alfabet dat oauth2-proxy gebruikt bij het decoderen van de secret.

Er gelden twee regels voor deze waarde. Gebruik een unieke secret voor elke implementatie. Wanneer u meer dan één oauth2-proxy-instantie achter hetzelfde domein draait, geef ze dan allemaal dezelfde secret, omdat een cookie die door de ene instantie is versleuteld, leesbaar moet zijn voor de andere.

De oauth2-proxy configuratie schrijven

Sla de instellingen op in een bestand in plaats van een lange opdrachtregel, zodat het client secret nooit zichtbaar is in de ps output.

# /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 instrueert oauth2-proxy om de X-Forwarded-* headers van de proxy ervoor te vertrouwen. Zonder deze instelling beschouwt oauth2-proxy het adres van de proxy zelf als het clientadres en kan het onjuist beoordelen of het verzoek via HTTPS is binnengekomen.

trusted_proxy_ips beperkt welke peers deze headers mogen aanleveren. De standaardinstelling vertrouwt elke bron, wat hier alleen veilig is omdat http_address de oauth2-proxy op 127.0.0.1 houdt. Wanneer oauth2-proxy op een Docker-netwerk luistert, stelt u dit in op het adres van uw reverse proxy.

upstreams = ["static://202"] zorgt ervoor dat oauth2-proxy een 202-antwoord geeft op een geauthenticeerd verzoek zonder zelf verkeer door te sturen. Dit is precies wat forward auth vereist, aangezien de reverse proxy de afhandeling van het verkeer verzorgt. De andere implementatievorm plaatst oauth2-proxy direct in het verzoekpad met upstreams = ["http://127.0.0.1:3000"] en zonder enige auth_request. Dat is eenvoudiger voor één applicatie, maar schaalt niet naar tien.

email_domains = ["*"] staat elk adres toe dat uw provider authenticeert. Beperk dit tot uw eigen domein, of beter nog, beperk de toegang met een groepsbinding in de provider, aangezien u daar al het gebruikersbeheer uitvoert.

Draai het onder systemd als een eigen gebruiker:

# /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

/ping dat OK print, betekent dat het proces is gestart en de configuratie heeft geladen. Dit is het eigen health-endpoint van oauth2-proxy en dit vereist nooit een sessie. Als er geen antwoord komt, lees dan journalctl -u oauth2-proxy -n 50; een onjuiste issuer URL en een cookie secret met de verkeerde lengte zorgen beide voor een fout bij het opstarten en beide worden in de logs vermeld.

Registreer de redirect URI bij uw provider

Maak een OIDC-applicatie aan bij uw provider en stel de redirect URI exact in op de redirect_url uit de configuratie: https://app.example.com/oauth2/callback. Exact betekent dat het schema, de host, de poort en het pad karakter voor karakter overeenkomen. Een afsluitende slash maakt het een andere URI.

Dit is het meest voorkomende probleem in de gehele installatie en het treedt op nog voordat oauth2-proxy überhaupt betrokken is. De provider wijst het autorisatieverzoek af en toont zijn eigen foutpagina, waardoor er niets in het logbestand van oauth2-proxy verschijnt. De aanwijzing is de adresbalk: de browser bevindt zich nog steeds op het domein van uw provider en de query-string bevat error=invalid_request of de paginanamen redirect_uri direct. Wanneer u dit ziet, corrigeer dan de applicatieregistratie bij de provider, niet de proxy-configuratie.

Kopieer de issuer URL van de provider in plaats van deze over te typen. oauth2-proxy voegt /.well-known/openid-configuration toe aan oidc_issuer_url en haalt dat discovery-document op bij het opstarten. Controleer dit eerst zelf:

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

JSON die een authorization_endpoint-sleutel bevat is een eerste controle; de issuer van het document moet ook exact overeenkomen met oidc_issuer_url. Een 404 of een HTML-foutpagina betekent dat het onjuist is, en oauth2-proxy zal bij het opstarten op diezelfde 404 falen. Als u nog geen provider heeft gekozen, behandelt de vergelijking van Keycloak, Authentik en Zitadel de afwegingen, en het draaien van Authentik als uw eigen SSO-server doorloopt de provider-helft van deze exacte configuratie.

Nginx: auth_request

Nginx voert forward auth uit met auth_request, wat een interne sub-request activeert en vertakt op basis van de statuscode.

# 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;
  }
}

Drie details hierin zijn van belang. proxy_pass_request_body off met een lege Content-Length voorkomt dat nginx een request body doorstuurt naar het authenticatie-eindpunt, dat enkel de headers nodig heeft.

Het paar auth_request_set $auth_cookie en add_header Set-Cookie stuurt een vernieuwde sessie-cookie terug naar de browser. Laat dit weg en cookie_refresh doet stilzwijgend niets, omdat nginx de Set-Cookie van de sub-request negeert en de browser de oude waarde behoudt totdat de sessie verloopt. Dit paar verwerkt één cookie; gesplitste sessie-cookies vereisen aanvullende afhandeling voor de overige delen, of Redis-sessieopslag.

error_page 401 = @oauth2_signin is wat een mislukte controle omzet in een login. Zonder deze instelling krijgt een niet-geauthenticeerde bezoeker een kale 401 Authorization Required-pagina te zien zonder mogelijkheid om verder te gaan.

Test altijd voordat u de configuratie opnieuw laadt:

sudo nginx -t && sudo systemctl reload nginx

Als de omliggende richtlijnen nieuw voor u zijn, behandelt de anatomie van een nginx reverse proxy configuratie de onderliggende laag.

Traefik: forwardAuth middleware

Traefik heeft twee middlewares nodig voor dezelfde taak. De eerste voert de controle uit. De tweede toont de inlogpagina wanneer de controle faalt.

# 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}"

Koppel beide aan de router die voor uw applicatie staat, met oauth-errors vóór oauth-auth. Publiceer oauth2-proxy op een eigen router op oauth.example.com, omdat de browser /oauth2/sign_in en /oauth2/callback moet kunnen bereiken zonder de controle te passeren. Stel voor deze aparte inlog-host redirect_url in op https://oauth.example.com/oauth2/callback en registreer die URI bij de provider.

Met de bovenstaande oauth2-proxy configuratie rendert /oauth2/sign_in een inlogpagina. Voor een automatische redirect stelt u skip_provider_button = true in binnen oauth2-proxy en voegt u statusRewrites: {"401": 302} toe onder de errors instellingen van Traefik. Zonder deze rewrite retourneert Traefik de automatische redirect met een 401-status en volgt de browser deze niet. De rewrite alleen start de inlogprocedure niet.

trustForwardHeader: true vertrouwt inkomende X-Forwarded-* headers; Traefik levert de originele host en URI aan oauth2-proxy. Deze optie is verouderd in de huidige Traefik-documentatie. Stel whitelist_domains in om ook die host te dekken, anders verwerpt oauth2-proxy de rd parameter als een open-redirect risico en belandt iedereen na het inloggen op /. Een Traefik-server staat meestal voor meerdere applicaties tegelijk, en meerdere Docker Compose applicaties routeren via één Traefik-instantie toont de router-indeling waar dit op aansluit.

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

De volgorde is hier van belang. Het /oauth2/*-blok komt eerst en bevat geen forward_auth, omdat een bezoeker die niet is ingelogd de paden voor aanmelden en de callback moet kunnen bereiken. Plaats de controle vóór deze paden, anders blijft de login zichzelf redirecten totdat de browser de verbinding verbreekt.

copy_headers zorgt ervoor dat de identiteit wordt doorgegeven aan de upstream-aanvraag; dit genereert alleen waarden wanneer oauth2-proxy wordt uitgevoerd met set_xauthrequest = true. De keuze tussen de verschillende proxies is een afzonderlijk vraagstuk, en de vergelijking tussen Nginx, Caddy en Traefik behandelt dit onderwerp.

Waarom keert de login terug naar de inlogpagina?

U meldt zich aan bij de provider, deze stuurt u terug, en oauth2-proxy stuurt u opnieuw naar de inlogpagina. Deze lus betekent dat oauth2-proxy bij het volgende verzoek geen geldige sessie accepteert. De sessie-cookie kan ontbreken, of deze kan aanwezig zijn maar de validatie niet doorstaan, bijvoorbeeld wanneer instanties verschillende cookie-secrets gebruiken. Open de ontwikkelaarstools van de browser, zoek het verzoek naar /oauth2/callback dat volgt op de redirect van uw provider, en lees de Set-Cookie response header. Een cookie die daar wordt gezet maar ontbreekt bij het volgende verzoek, is de cookie die de browser weigert. Als de cookie wel aanwezig is, controleer dan het serverlogboek op validatiefouten zoals cookie signature not valid en bevestig dat alle instanties hetzelfde secret gebruiken.

Wanneer de cookie die ontbreekt de CSRF-cookie is die oauth2-proxy bij vertrek heeft gezet, ontstaat er geen lus. Het proces stopt bij de callback en het logboek benoemt de situatie:

No cookies were found in OAuth callback.

of, wanneer een andere cookie wel is aangekomen maar de juiste niet:

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

CSRF staat voor cross-site request forgery, en deze cookie bestaat zodat een callback gekoppeld kan worden aan de login die deze heeft gestart. De browser ontvangt een 403-foutpagina met de melding:

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

Ontbrekende cookies delen de eerste drie onderstaande oorzaken; tijdsverschil (clock drift) is een andere oorzaak van validatiefouten. Controleer deze vier in volgorde.

  1. cookie_secure = true terwijl de browser de site via onversleuteld HTTP heeft bereikt. Behalve op localhost zal een browser geen cookie opslaan die gemarkeerd is als Secure op een http:// origin, waardoor deze nooit wordt teruggestuurd. Beëindig TLS (transport layer security) correct, of stel cookie_secure = false alleen in tijdens het testen op localhost.
  2. Een cookie_domains waarde die de hostnaam in de adresbalk niet dekt. .example.com dekt app.example.com en doet niets voor app.example.net.
  3. De browser verwijdert de cookie. Een strikte privacy-extensie of het blokkeren van third-party cookies kan _oauth2_proxy_csrf verwijderen tussen de uitgaande redirect en de callback, of de sessie-cookie daarna.
  4. Tijdsverschil (clock drift). Als de klok van de server ver voorloopt op die van de provider, kan het ID-token verlopen lijken en de validatie niet doorstaan. timedatectl zou System clock synchronized: yes moeten rapporteren.

Eén extra oorzaak veroorzaakt de CSRF-fout zonder dat er iets verkeerd is geconfigureerd. Standaard houdt oauth2-proxy één enkele CSRF-cookie bij, waardoor twee tabbladen die op hetzelfde moment een login starten, elkaars cookie overschrijven. cookie_csrf_per_request = true geeft elke login een eigen cookie.

Observeer het proces vanaf de serverzijde in plaats van te gissen:

sudo journalctl -u oauth2-proxy -f

Laad de applicatie in een privévenster. Elk verzoek wordt gelogd met de bijbehorende status, dus een callback die direct wordt gevolgd door een nieuwe redirect naar de login is de lus, zoals vastgelegd in het logboek.

Paden die de login moeten overslaan: API's, webhooks en websockets

Forward auth gaat uit van een browser die een cookie vasthoudt. Aanroepers zonder browser falen.

Een API-client die Authorization: Bearer <token> verstuurt, heeft geen cookie. De bovenstaande proxyconfiguraties sturen deze daarom door naar de inlogpagina van oauth2-proxy, tenzij bearer-token-authenticatie is ingeschakeld. Er zijn twee nette oplossingen. Door skip_jwt_bearer_tokens = true in te stellen, accepteert oauth2-proxy een geldig JWT (JSON web token) bearer-token van de geconfigureerde uitgever met een audience die voor deze client wordt geaccepteerd. Dit is de juiste keuze wanneer uw API-clients al geschikte tokens van de provider ontvangen. De aud van het token moet overeenkomen met client_id of een audience die via extra_jwt_issuers is geconfigureerd. Vrijstel anders het pad:

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

Elke waarde is een reguliere expressie die wordt vergeleken met het gedecodeerde pad zonder queryparameters, optioneel voorafgegaan door een HTTP-methode en =. POST=^/webhook/ laat de webhook-ontvanger open voor POST, terwijl een mens die naar hetzelfde pad bladert nog steeds de loginpagina krijgt, mits het authenticatieverzoek de oorspronkelijke methode behoudt. Nginx auth_request en Caddy forward_auth voeren GET-controles uit, dus methode-specifieke vrijstellingen vereisen in die opstellingen aparte routering bij de reverse proxy. Elk item is een gat in uw beveiliging, dus veranker de expressies met ^ en houd ze zo specifiek als de aanroeper toelaat.

Draai versie v7.15.5 of later voordat u op deze functies vertrouwt. Eerdere releases na v7.5.0 konden worden misleid om een beveiligd pad vrij te stellen met een verzoek dat gebruikmaakte van dot-segmenten, een dubbele voorwaartse slash of een puntkomma (advisory GHSA-63jm-59jj-478j), en het verankeren van de expressies voorkwam dit niet. De gecorrigeerde release weigert dergelijke ambigue paden vrij te stellen, dus controleer na het upgraden of uw publieke routes nog steeds overeenkomen.

Websockets zijn het geval waar mensen de fout in gaan. Het upgrade-verzoek is een gewoon HTTP GET-verzoek dat dezelfde cookies bevat als elk ander verzoek, dus het doorstaat de controle normaal gesproken en heeft geen vrijstelling nodig. Wat wel fout gaat, is de proxying eromheen. Zonder de headers Upgrade en Connection op de beveiligde locatie wordt de upgrade nooit voltooid en blijft de client van de applicatie het proberen met een WebSocket connection ... failed-melding in de browserconsole. Het vrijstellen van het pad lost daar niets op, omdat het verzoek al geautoriseerd was.

Er is één echte beperking van toepassing. De controle wordt eenmalig uitgevoerd, bij de upgrade. Een websocket die urenlang open blijft, wordt nooit opnieuw gecontroleerd, dus het verwijderen van een gebruiker in uw provider sluit de socket die zij al bezitten niet. Herstart de applicatie om actieve verbindingen te verbreken.

Standaard bevindt de volledige sessie zich in de cookie, versleuteld met uw cookie_secret. Hierdoor blijft oauth2-proxy stateless en is er geen extra service nodig. Er is echter een limiet, omdat browsers een cookie beperken tot ongeveer 4 KB. Wanneer het ID-token een lange lijst met groepsclaims bevat, splitst oauth2-proxy de sessie over _oauth2_proxy_0, _oauth2_proxy_1 en verder. Na enkele delen worden de request headers zo groot dat nginx antwoordt met 400 Request Header Or Cookie Too Large voordat de applicatie het verzoek ooit ziet.

Verplaats de sessie naar de serverzijde wanneer dit gebeurt:

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

De browser bevat dan een kort ticket en de versleutelde sessie staat in Redis. De keerzijde is een service die beschikbaar moet blijven: als Redis uitvalt, kan oauth2-proxy geen sessies laden; het verlies van de opgeslagen sessiegegevens dwingt iedereen om opnieuw in te loggen. De cookie-opslag heeft zijn eigen nadeel: twee verzoeken die op hetzelfde moment dezelfde sessie verversen, kunnen conflicteren en een nieuwe login afdwingen.

Wat forward auth u niet biedt

Dit is een poortwachter bij de deur. Het is geen autorisatie binnen de applicatie, en dat verschil bepaalt of de aanpak geschikt is voor uw situatie.

Zodra een gebruiker erdoor is, ziet de applicatie wat deze altijd zag. Als de app eigen rollen heeft, vult forward auth deze niet in, tenzij de app header-gebaseerde authenticatie ondersteunt en een header koppelt aan een account. Grafana doet dit via de auth.proxy instellingen. De meeste zelfgehoste apps doen dit niet, dus iedereen die door de poort komt is dezelfde identiteit voor de applicatie, en die identiteit is vaak een admin.

Het beschermt ook niet de eigen API-tokens van de applicatie. Een personal access token uitgegeven door de app authenticeert bij de app, niet bij oauth2-proxy, dus het token werkt niet meer zodra de poort ervoor staat. Stel het API-pad vrij om dit te herstellen en dat token wordt het enige dat het pad beveiligt. U draait nu twee authenticatiesystemen op één service, en SSO dekt er slechts één van.

Intrekking is het derde hiaat. Het verwijderen van een gebruiker in uw provider stopt nieuwe logins, maar oauth2-proxy controleert een bestaande sessie niet bij de provider totdat cookie_refresh aan de beurt is. Als refresh uit staat, blijft de sessie-cookie geldig totdat deze verloopt, en cookie_expire staat standaard op 168 uur, wat een week toegang kan betekenen voor iemand die u zojuist heeft verwijderd. Zet cookie_refresh op iets korts, zoals een uur. Wanneer de provider die refresh weigert omdat de refresh token van de gebruiker niet langer geldig is, wist oauth2-proxy de sessie en dwingt een nieuwe login af bij het volgende verzoek dat de refresh probeert. Refresh wordt niet door elke provider ondersteund, dus test dit met die van u.

Het auditspoor stopt ook bij de poort. oauth2-proxy logt wie erdoor kwam en wanneer. De applicatie logt een naamloze sessie. Als u moet verantwoorden wie een instelling heeft gewijzigd, is header-identiteit in de app het minimum, en zijn echte accounts per gebruiker het eerlijke antwoord.

Wanneer de SSO-belasting betalen de betere keuze is

Forward auth is de juiste oplossing wanneer een applicatie geen inlogfunctie heeft, of gebruikmaakt van één gedeeld wachtwoord, en u op één centrale plek gebruikers wilt toevoegen of verwijderen. Het kost een middag werk en één extra proces, en het werkt met elke applicatie die HTTP ondersteunt.

Het is de verkeerde oplossing wanneer verschillende personen verschillende rechten nodig hebben binnen dezelfde applicatie. Een gate kan niet uitdrukken dat "Ana de dashboards mag bewerken en Bo ze alleen mag inzien". Als de leverancier een SSO-abonnement aanbiedt, is de koppeling van groepen aan rollen meestal waar u daadwerkelijk voor betaalt. Dit proberen na te bootsen met headers en proxy-regels is kwetsbaarder dan ervoor betalen. Het prijsmodel achter die SSO-abonnementen is het lezen waard voordat u een besluit neemt.

Elke applicatie met een mobiele of desktop-client die geen browsercookies meestuurt, zal bij elk verzoek problemen ondervinden met de gate.

FAQ

Wat is forward auth?

Forward auth is een patroon waarbij de reverse proxy bij elk inkomend verzoek een aparte authenticatieservice raadpleegt voordat het verzoek wordt doorgestuurd naar de upstream-service. De proxy stuurt de request headers naar een endpoint zoals /oauth2/auth en leest de statuscode uit. 202 betekent toegestaan, waardoor het oorspronkelijke verzoek wordt doorgezet naar de applicatie. 401 betekent geen geldige sessie, waarna de proxy de browser doorverwijst naar een inlogpagina. Nginx implementeert dit met de auth_request-richtlijn, Traefik met de forwardAuth-middleware en Caddy met forward_auth.

Waarom stuurt oauth2-proxy mij in een lus terug naar de inlogpagina?

Het sessie-cookie ontbreekt of de validatie ervan mislukt, waardoor elke controle geen geldige sessie vindt en u terugstuurt naar de inlogpagina. Instanties die verschillende cookie-secrets gebruiken, wijzen elkaars cookies af. Een andere oorzaak is cookie_secure = true op een site die de browser via onversleuteld HTTP heeft bereikt, omdat een browser, behalve op localhost, geen Secure-cookie opslaat op een http://-oorsprong. Controleer ook op een cookie_domains-waarde die niet overeenkomt met de hostnaam in de adresbalk. Lees de Set-Cookie-header op de /oauth2/callback-respons in de ontwikkelaarstools van uw browser om te zien welk cookie ontbreekt. Als het cookie wel wordt geretourneerd, controleer dan het serverlogboek op validatiefouten. Als het CSRF-cookie ontbreekt, krijgt u een 403-pagina met de melding Login Failed: Unable to find a valid CSRF token. Please try again. in plaats van een lus, en toont het logboek No cookies were found in OAuth callback. wanneer er geen cookies zijn ontvangen.

Hoe laat ik een API-client of webhook door oauth2-proxy heen?

Gebruik skip_auth_routes met een verankerde reguliere expressie, optioneel beperkt tot één HTTP-methode, bijvoorbeeld POST=^/webhook/, en gebruik versie 7.15.5 of hoger, waarin een kritieke omzeiling van deze uitzonderingen is verholpen. Methode-specifieke uitzonderingen vereisen dat het authenticatieverzoek de oorspronkelijke methode behoudt; de voorbeelden voor Nginx en Caddy voeren GET-controles uit, dus verwerk die uitzonderingen in de routering van de reverse proxy. Als uw API-clients al beschikken over geldige JWT's die zijn uitgegeven door de geconfigureerde provider met een geaccepteerde audience, accepteert skip_jwt_bearer_tokens = true die tokens in plaats van een cookie en blijft het pad beschermd. De audience moet overeenkomen met client_id of een audience die is geconfigureerd via extra_jwt_issuers. Alles wat in skip_auth_routes staat vermeld, is voor iedereen ongeauthenticeerd, dus houd elke expressie zo specifiek als de aanroeper toelaat.

Geeft oauth2-proxy de applicatie rechten per gebruiker?

Nee. Het is een toegangspoort, geen autorisatiesysteem. Het bepaalt wie de applicatie bereikt, en iedereen die de applicatie bereikt ziet er voor de applicatie identiek uit, tenzij die applicatie identiteitsheaders leest en deze koppelt aan accounts. Grafana kan dit via de auth.proxy-instellingen. De meeste zelfgehoste applicaties kunnen dit niet, waardoor elke persoon die de poort passeert dezelfde identiteit deelt waarmee de applicatie draait.

Kan iemand oauth2-proxy omzeilen door zelf de identiteitsheader in te stellen?

Ja, als zij de applicatie rechtstreeks kunnen bereiken. De identiteit komt aan als een eenvoudige header zoals X-Auth-Request-Email, en de applicatie vertrouwt alles wat deze ontvangt. Iedereen die een verbinding kan openen met de applicatiepoort, kan die header sturen en zich voordoen als elke gewenste gebruiker. Bind de applicatie aan 127.0.0.1, of houd deze op een intern Docker-netwerk zonder gepubliceerde poort, en bevestig dit met sudo ss -tlnp.

Was dit artikel nuttig?

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