{"canonical_url":"https://engineer.company/nb/glossary/openid-connect/","content_markdown":"# OpenID Connect\n\n## Hva det er\n\nOpenID Connect er en standard som lar en applikasjon få vite hvem en person er,\nfra en tjeneste som nettopp har logget personen inn. Spesifikasjonen kaller seg\nselv et enkelt identitetslag oppå OAuth 2.0, og det er akkurat slik den er\nbygget: de samme omdirigeringene, endepunktene og tokenene som i OAuth, pluss\nett token til, ett endepunkt til og reglene for hvordan de kontrolleres. I\ndagligtale blir den ofte forkortet til OIDC. Kjernespesifikasjonen ble endelig i\nfebruar 2014. Den gjeldende teksten, der andre runde med rettelser er tatt inn,\ner datert 15. desember 2023 og vedlikeholdes av en arbeidsgruppe i OpenID\nFoundation.\n\nOAuth alene svarer på spørsmålet «hva har denne applikasjonen lov til?».\nApplikasjonen får et tilgangstoken som er ment for et API, og det er ikke\nmeningen at applikasjonen selv skal lese det. OpenID Connect stiller i tillegg\nspørsmålet «hvem logget inn?» og besvarer det med et ID-token: et JSON\nWeb Token, adressert til applikasjonen selv, som forteller hvem personen er, hvem\nsom går god for det, når tokenet ble utstedt, og hvilken applikasjon det er\nment for. ID-tokener skal være signert. Spesifikasjonen tillater bare `alg: none`\nhvis responstypen ikke returnerer noe ID-token fra autorisasjonsendepunktet, og\nklienten uttrykkelig ba om `none` ved registrering.\n\nTil denne jobben gir spesifikasjonen OAuth-rollene nye navn. En OpenID Provider\n(OP) er en autorisasjonsserver som autentiserer personer og utsteder ID-tokener.\nEn Relying Party (RP) er OAuth-klienten som trenger å vite hvem personen er, og\npersonen selv kalles End-User. En forespørsel blir en OpenID\nConnect-forespørsel ved å ha `openid` med i scopet, og den verdien er\nobligatorisk: mangler den, er oppførselen etter spesifikasjonens egne ord helt\nuspesifisert.\n\nAndre scope-verdier ber om profildata. `profile` dekker navn, kallenavn, bilde,\nspråkinnstilling og lignende claims, `email` gir `email` og `email_verified`, og\n`address` og `phone` gjør det navnene sier. Applikasjonen kan hente disse\nclaimene fra leverandørens UserInfo-endepunkt, et helt vanlig OAuth-beskyttet\nAPI som den kaller med tilgangstokenet.\n\nDet finnes tre måter å kjøre det på. Authorization code-flyten sender bare en\nkortlivet kode gjennom nettleseren og henter selve tokenene med en\nHTTPS-forespørsel til tokenendepunktet. Implicit-flyten leverer tokenene rett i omdirigeringen, og\nhybrid-flyten blander de to. En tilhørende spesifikasjon, OpenID Connect\nDiscovery 1.0, lar applikasjonen slå opp alle endepunkter og signeringsnøkler ut\nfra én adresse.\n\n## Hvorfor det er viktig\n\nGrunnen til å ta det i bruk er single sign-on. Med én identitetsleverandør foran\nmange applikasjoner har folk ett sett med innloggingsopplysninger, applikasjonene\nlagrer ingen av dem, og reglene for hvordan man logger inn, fra krav til passord\ntil en ekstra faktor, settes ett sted, hos leverandøren. Sperrer man en konto\nhos leverandøren, kan den ikke lenger starte en ny økt i noen av applikasjonene\nsom lener seg på den, og dermed blir offboarding ett steg og ikke en sjekkliste.\n\nStandarden tetter også et hull som team faller i når de bygger innlogging på ren\nOAuth. RFC 6749 advarer om at en offentlig klient i implicit-flyten ikke kan se\nhvilken klient et tilgangstoken ble utstedt til. En klient som går ut fra at\nbare ressurseieren kan gi den et gyldig token, kan derfor lures: En angriper med\net token utstedt til en annen applikasjon leverer det inn og blir tatt for\npersonen bak. Et ID-token oppgir i `aud`-claimet hvilken applikasjon det er\ntil, og applikasjonen kontrollerer det.\n\nFordi det er en standard, kan arbeidet gjenbrukes. Spesifikasjonen lover\nprofilopplysninger på en interoperabel måte, så koden som logger folk inn via én\nleverandør, kan logge dem inn via en annen også. Med Discovery lærer\napplikasjonen leverandørens endepunkter og signeringsnøkler å kjenne ut fra\nissuer-URL-en i stedet for fra innstillinger noen har skrevet av for hånd.\n\nTil slutt gir OpenID Connect hver person en stabil identifikator.\nSpesifikasjonen sier klart at paret `iss` (utstederen) og `sub`\n(subjektidentifikatoren) er de eneste claimene en applikasjon kan stole på som\nstabil identifikator for en person. `sub` er unik hos utstederen, blir aldri\ngjenbrukt og er på høyst 255 ASCII-tegn. En leverandør kan til og med gi hver\napplikasjon sin egen `sub`, en såkalt parvis identifikator, slik at\napplikasjonene ikke kan koble sammen det en person gjør, uten tillatelse.\n\n## Slik ser det ut i praksis\n\nTa en webapplikasjon som er registrert hos en OpenID Provider på\n`https://server.example.com` med klient-ID-en `s6BhdRkqt3`; verdiene nedenfor er\nhentet fra spesifikasjonens egne eksempler. Applikasjonen begynner med å hente\nleverandørens konfigurasjon fra den faste adressen under utstederen:\n\n```http\nGET /.well-known/openid-configuration HTTP/1.1\nHost: server.example.com\n```\n\nSvaret er et JSON-dokument. I forkortet form:\n\n```json\n{\n  \"issuer\": \"https://server.example.com\",\n  \"authorization_endpoint\": \"https://server.example.com/connect/authorize\",\n  \"token_endpoint\": \"https://server.example.com/connect/token\",\n  \"userinfo_endpoint\": \"https://server.example.com/connect/userinfo\",\n  \"jwks_uri\": \"https://server.example.com/jwks.json\",\n  \"scopes_supported\": [\"openid\", \"profile\", \"email\", \"address\", \"phone\"],\n  \"id_token_signing_alg_values_supported\": [\"RS256\", \"ES256\", \"HS256\"]\n}\n```\n\nDiscovery krever at `issuer` i dokumentet er identisk med issuer-URL-en som\napplikasjonen satte foran den faste stien, og applikasjonen stopper hvis de to\ner ulike. Deretter sender den personens nettleser til autorisasjonsendepunktet\nmed code-flyten, scopet `openid` og to tilfeldige verdier den har lagret sammen\nmed nettleserøkten: `state` for omdirigeringen og `nonce` for ID-tokenet. En\noffentlig klient ville også sendt PKCE-parameterne, som RFC 9700 gjør\nobligatoriske for den; de er utelatt her for å holde linjene korte.\n\n```http\nGET /connect/authorize?response_type=code\u0026client_id=s6BhdRkqt3\n    \u0026redirect_uri=https%3A%2F%2Fclient.example.org%2Fcb\n    \u0026scope=openid%20profile%20email\n    \u0026state=af0ifjsldkj\u0026nonce=n-0S6_WzA2Mj HTTP/1.1\nHost: server.example.com\n```\n\nLeverandøren logger personen inn og sender nettleseren tilbake med en kode, som\napplikasjonen løser inn ved token-endepunktet akkurat som i vanlig OAuth.\nForskjellen ligger i svaret, som nå har et `id_token` ved siden av\ntilgangstokenet (forkortet her):\n\n```json\n{\n  \"access_token\": \"SlAV32hkKG\",\n  \"token_type\": \"Bearer\",\n  \"refresh_token\": \"8xLOxBtZp8\",\n  \"expires_in\": 3600,\n  \"id_token\": \"eyJhbGciOiJSUzI1NiIsImtpZCI6IjFlOWdkazcifQ.ewogImlzc...\"\n}\n```\n\nID-tokenet består av tre base64url-deler, skilt med punktum. Den første\ndekodes til `{\"alg\":\"RS256\",\"kid\":\"1e9gdk7\"}`: signeringsalgoritmen og ID-en til\nnøkkelen i leverandørens publiserte nøkkelsett. Den midterste delen inneholder\nselve claimene, og i spesifikasjonens eksempel ser de slik ut:\n\n```json\n{\n  \"iss\": \"https://server.example.com\",\n  \"sub\": \"24400320\",\n  \"aud\": \"s6BhdRkqt3\",\n  \"nonce\": \"n-0S6_WzA2Mj\",\n  \"exp\": 1311281970,\n  \"iat\": 1311280970,\n  \"auth_time\": 1311280969,\n  \"acr\": \"urn:mace:incommon:iap:silver\"\n}\n```\n\nFør applikasjonen stoler på ett eneste ord av dette, validerer den tokenet, og\nspesifikasjonen lister opp stegene. `iss` må stemme nøyaktig med leverandørens\nissuer. `aud` må inneholde applikasjonens egen klient-ID og ingen mottakere den\nikke stoler på. Signaturen må kunne verifiseres med leverandørens nøkler fra\n`jwks_uri` og med algoritmen i headeren; kom tokenet, som her, direkte fra\ntoken-endepunktet over TLS, kan en kontroll av serverens TLS-sertifikat tre inn\ni stedet for signaturkontrollen. Klokken må være før `exp`, og `nonce` må være\nverdien applikasjonen selv sendte. Først da logger den personen inn, med\n`https://server.example.com` pluss `24400320` som nøkkel, og bruker\ntilgangstokenet til å hente e-post og profilopplysninger fra UserInfo-endepunktet\nhvis den trenger dem.\n\nÉn leverandør for mange systemer er like mye en organisatorisk endring som en\nteknisk. I ett av prosjektene her på nettstedet,\n[tilgangsstyring på tvers av M365 og SSO](/nb/portfolio/led-access-management-across-m365-and-sso/),\nble identitetene og tilgangene samlet i M365, 1Password, Red Hat SSO og OKTA\nSSO. Minste privilegium ble håndhevet, og onboarding og offboarding ble\nstandardisert, slik at tilganger ble trukket tilbake raskt og konsekvent i\nstedet for å bli hengende igjen etter at noen hadde gått videre.\n\n## Hvor det går galt\n\n**E-postadressen brukes som kontonøkkel.** Det er det opplagte valget og det\ngale. Spesifikasjonen sier at en utsteder over tid kan gi den samme\ne-postadressen til en annen person, og at `email`, `phone_number`,\n`preferred_username` og `name` ikke skal brukes som unike identifikatorer. En\napplikasjon som slår opp folk på e-post, kan gi én persons konto til den neste\nsom får adressen. Lagre `iss` og `sub` sammen som nøkkel, behold e-posten som en\nvanlig egenskap, og kontroller at `email_verified` er sann før adressen brukes\ntil noe som helst.\n\n**Et tilgangstoken blir tatt som bevis på hvem som logget inn.** Noen\napplikasjoner tar imot et tilgangstoken, kaller et API med det og behandler\nsvaret som en innlogging. Tokenet kan være utstedt til en helt annen\napplikasjon, og da er det nettopp angrepet der noen utgir seg for å være en\nannen, som RFC 6749 advarer mot. Logg folk inn på ID-tokenet, og først når dere\nhar bekreftet at `aud` inneholder deres egen klient-ID.\n\n**ID-tokenet dekodes, men kontrolleres aldri.** Å lese claimene ut av et token\nkrever en base64url-dekoding og ingen nøkkel i det hele tatt, og det er nettopp\ndet som gjør det fristende. Et token der signaturen, `iss`, `aud` eller `exp`\nikke blir kontrollert, kan være forfalsket, høre til en annen applikasjon eller\nha utløpt. Bruk et bibliotek som blir vedlikeholdt, gi det utstederen og\nklient-ID-en, og la det kjøre alle stegene i spesifikasjonens liste, ikke bare\nde lettvinte.\n\n**Nonce mangler, er fast eller blir aldri sammenlignet.** Uten den kan et\nID-token som er snappet opp fra én innlogging, spilles av igjen i en annen.\nRFC 9700 legger til at nonce må høre til én bestemt innlogging og være bundet\ntil nettleseren som startet den. Spesifikasjonen foreslår én måte å gjøre det\npå: Lagre en kryptografisk tilfeldig verdi i en HttpOnly-øktcookie, send hashen\nav den som `nonce`, og sammenlign de to når ID-tokenet kommer tilbake.\n\n**Signeringsnøklene caches for alltid.** Leverandører bytter nøkler, og en\napplikasjon som holder fast ved gårsdagens nøkkelsett, avviser alle tokener som\ner signert med den nye. Spesifikasjonen forventer at leverandøren publiserer\nnøklene på `jwks_uri` og merker hvert token med en `kid`, og at applikasjonen\nhenter nøkkelsettet på nytt når den møter en `kid` den ikke kjenner. Cache gjerne\nnøklene, men la en ukjent `kid` være et signal om å hente dem på nytt og ikke en\ngrunn til å avvise innloggingen.\n\n**To tenanter på samme vert blir behandlet som én utsteder.** En leverandør kan\nkjøre flere utstedere på samme vert, og stien er en del av\nutstederidentifikatoren: Subjektet `1234` hos `https://example.com` og\nsubjektet `1234` hos `https://example.com/sales` er to forskjellige personer.\nLagre hele issuer-strengen, sammenlign den tegn for tegn, og kutt den aldri ned\ntil et vertsnavn.\n\n## Les mer\n\n- [OpenID Connect Core 1.0](https://openid.net/specs/openid-connect-core-1_0.html)\n  — ID-tokenet, de tre flytene, standardclaimene og valideringsstegene, i\n  utgaven med rettelsessett 2 fra desember 2023.\n- [OpenID Connect Discovery 1.0](https://openid.net/specs/openid-connect-discovery-1_0.html)\n  — konfigurasjonsdokumentet på den faste adressen og regelen om at issuer i det\n  må være identisk med issuer-URL-en det ble hentet under.\n- [RFC 6749: The OAuth 2.0 Authorization Framework](https://www.rfc-editor.org/rfc/rfc6749)\n  — rammeverket OpenID Connect bygger på, med advarselen i avsnitt 10.16 mot å\n  bruke tilgangstokener til å identifisere personer.\n- [RFC 7519: JSON Web Token (JWT)](https://www.rfc-editor.org/rfc/rfc7519) —\n  tokenformatet som alle ID-tokener bruker.\n- [RFC 9700: Best Current Practice for OAuth 2.0 Security](https://www.rfc-editor.org/rfc/rfc9700)\n  — gjeldende anbefalinger om PKCE, nonce og omdirigering, som gjelder for\n  OpenID Connect like mye som for OAuth.\n\n\u003chttps://engineer.company/nb/glossary/openid-connect/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Hvordan OpenID Connect logger folk inn oppå OAuth: ID-tokenet og claimene i det, en innlogging fulgt fra discovery til validering og seks vanlige feil.","formats":{"gemtext":"https://engineer.company/nb/glossary/openid-connect/index.gmi","gopher":"https://engineer.company/nb/glossary/openid-connect/gophermap","html":"https://engineer.company/nb/glossary/openid-connect/","json":"https://engineer.company/nb/glossary/openid-connect/index.json","markdown":"https://engineer.company/nb/glossary/openid-connect/index.md","pdf":"https://engineer.company/nb/glossary/openid-connect/index.pdf"},"kind":"page","language":"nb","title":"Hva er OpenID Connect?","url":"https://engineer.company/nb/glossary/openid-connect/","version":1}