{"canonical_url":"https://engineer.company/da/glossary/openid-connect/","content_markdown":"# OpenID Connect\n\n## Hvad det er\n\nOpenID Connect er en standard, der lader et program få at vide, hvem en person\ner, fra en tjeneste, der lige har logget personen ind. Specifikationen kalder\nsig selv et enkelt identitetslag oven på OAuth 2.0, og sådan er den også bygget:\nde samme omdirigeringer, endpoints og tokens som i OAuth, plus ét token mere, ét\nendpoint mere og reglerne for, hvordan de kontrolleres. I daglig tale hedder den\nofte bare OIDC. Kernespecifikationen blev endelig i februar 2014. Den gældende\ntekst, hvor anden runde rettelser er indarbejdet, er dateret 15. december 2023\nog vedligeholdes af en arbejdsgruppe under OpenID Foundation.\n\nOAuth alene svarer på spørgsmålet »hvad må dette program?«. Programmet får et\nadgangstoken, der er beregnet til et API, og det er ikke meningen, at programmet\nselv læser det. OpenID Connect stiller også spørgsmålet »hvem loggede ind?« og\nbesvarer det med et ID-token: et JSON Web Token, stilet til programmet\nselv, som fortæller, hvem personen er, hvem der står inde for det, hvornår\ntokenet blev udstedt, og hvilket program det er tiltænkt. ID-tokens skal signeres. Specifikationen tillader kun `alg: none`, hvis svartypen ikke\nreturnerer noget ID-token fra autorisationsendpointet, og klienten udtrykkeligt\nbad om `none` ved registreringen.\n\nTil den opgave giver specifikationen OAuth-rollerne nye navne. En OpenID\nProvider (OP) er en autorisationsserver, der autentificerer personer og udsteder\nID-tokens. En Relying Party (RP) er den OAuth-klient, der har brug for at vide,\nhvem personen er, og personen selv hedder End-User. En forespørgsel bliver til\nen OpenID Connect-forespørgsel ved at have `openid` med i sit scope, og den værdi\ner obligatorisk: mangler den, er adfærden efter specifikationens egne ord\nfuldstændig uspecificeret.\n\nAndre scope-værdier beder om profildata. `profile` dækker navn, kaldenavn,\nbillede, sprogindstilling og lignende claims, `email` giver `email` og\n`email_verified`, og `address` og `phone` gør, hvad navnene siger. Programmet\nkan hente de claims fra udbyderens UserInfo-endpoint, et helt almindeligt\nOAuth-beskyttet API, som det kalder med adgangstokenet.\n\nDer er tre måder at køre det på. Authorization code-flowet sender kun en\nkortlivet kode gennem browseren og henter selve tokens med en HTTPS-forespørgsel\ntil token-endpointet.\nImplicit-flowet leverer tokens lige i omdirigeringen, og hybrid-flowet blander\nde to. En ledsagende specifikation, OpenID Connect Discovery 1.0, lader\nprogrammet slå alle endpoints og signeringsnøgler op ud fra én adresse.\n\n## Hvorfor det betyder noget\n\nGrunden til at tage det i brug er single sign-on. Med én identitetsudbyder foran\nmange programmer har folk ét sæt loginoplysninger, programmerne gemmer ingen, og\nreglerne for, hvordan man logger ind, fra krav til adgangskoder til en ekstra\nfaktor, fastlægges ét sted, hos udbyderen. Spærrer man en konto hos udbyderen,\nkan den ikke starte en ny session i nogen af de programmer, der læner sig op ad\nden, og så er offboarding ét trin og ikke en tjekliste.\n\nStandarden lukker også et hul, som teams falder i, når de bygger login på ren\nOAuth. RFC 6749 advarer om, at en offentlig klient i implicit-flowet ikke kan\nse, hvilken klient et adgangstoken blev udstedt til. En klient, der går ud fra,\nat kun ressourceejeren kan give den et gyldigt token, kan derfor narres: En\nangriber med et token, der er udstedt til et andet program, afleverer det og\nbliver taget for personen bag. Et ID-token angiver i sit `aud`-claim, hvilket\nprogram det er til, og programmet kontrollerer det.\n\nFordi det er en standard, kan arbejdet genbruges. Specifikationen lover\nprofiloplysninger på en interoperabel måde, så den kode, der logger folk ind via\nén udbyder, også kan logge dem ind via en anden. Med Discovery lærer programmet\nudbyderens endpoints og signeringsnøgler at kende ud fra dens issuer-URL i\nstedet for fra indstillinger, som nogen har skrevet af i hånden.\n\nEndelig giver OpenID Connect hver person en stabil identifikator.\nSpecifikationen siger klart, at parret `iss` (udstederen) og `sub` (subjektets\nidentifikator) er de eneste claims, et program kan regne med som stabil\nidentifikator for en person. `sub` er entydig hos udstederen, bliver aldrig\ngenbrugt og er højst 255 ASCII-tegn lang. En udbyder kan endda give hvert\nprogram sin egen `sub`, en såkaldt parvis identifikator, så programmerne ikke\nkan koble en persons aktiviteter sammen uden lov.\n\n## Sådan ser det ud i praksis\n\nTag en webapplikation, der er registreret hos en OpenID Provider på\n`https://server.example.com` med klient-ID'et `s6BhdRkqt3`; værdierne nedenfor\nstammer fra specifikationens egne eksempler. Programmet begynder med at hente\nudbyderens konfiguration fra den faste adresse under udstederen:\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 kræver, at `issuer` i dokumentet er identisk med den issuer-URL,\nprogrammet satte foran den faste sti, og programmet stopper, hvis de to afviger.\nDerefter sender det personens browser til autorisationsendpointet med\ncode-flowet, scopet `openid` og to tilfældige værdier, som det har gemt sammen\nmed browsersessionen: `state` til omdirigeringen og `nonce` til ID-tokenet. En\noffentlig klient ville også sende PKCE-parametrene, som RFC 9700 gør\nobligatoriske for den; de er udeladt her for at holde linjerne 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\nUdbyderen logger personen ind og sender browseren tilbage med en kode, som\nprogrammet indløser ved token-endpointet nøjagtig som i almindelig OAuth.\nForskellen ligger i svaret, der nu har et `id_token` ved siden af adgangstokenet\n(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 af tre base64url-dele, adskilt af punktummer. Den første\nafkodes til `{\"alg\":\"RS256\",\"kid\":\"1e9gdk7\"}`: signeringsalgoritmen og ID'et på\nnøglen i udbyderens offentliggjorte nøglesæt. Den midterste del rummer selve\nclaims, og i specifikationens eksempel ser de sådan ud:\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 programmet stoler på et eneste ord af det, validerer det tokenet, og\nspecifikationen opregner trinnene. `iss` skal stemme nøjagtigt overens med\nudbyderens issuer. `aud` skal indeholde programmets eget klient-ID og ingen\nmålgruppe, programmet ikke stoler på. Signaturen skal kunne verificeres med\nudbyderens nøgler fra `jwks_uri` og med algoritmen i headeren; kom tokenet, som\nher, direkte fra token-endpointet over TLS, må en kontrol af serverens\nTLS-certifikat træde i stedet for signaturkontrollen. Klokken skal være før\n`exp`, og `nonce` skal være den værdi, programmet selv sendte. Først da logger\ndet personen ind, med `https://server.example.com` plus `24400320` som nøgle,\nog bruger adgangstokenet til at hente e-mail og profiloplysninger fra\nUserInfo-endpointet, hvis det har brug for dem.\n\nÉn udbyder til mange systemer er lige så meget en organisatorisk ændring som en\nteknisk. I et af projekterne her på sitet,\n[adgangsstyring med M365 og SSO](/da/portfolio/led-access-management-across-m365-and-sso/),\nblev identiteter og adgange samlet i M365, 1Password, Red Hat SSO og OKTA SSO.\nLeast privilege blev håndhævet, og on- og offboarding blev standardiseret, så\nadgangen blev frataget hurtigt og ensartet i stedet for at blive hængende, efter\nat nogen var gået videre.\n\n## Hvor det går galt\n\n**E-mailadressen bruges som kontonøgle.** Det er det oplagte valg og det\nforkerte. Specifikationen siger, at en udsteder med tiden må give den samme\ne-mailadresse til en anden person, og at `email`, `phone_number`,\n`preferred_username` og `name` ikke må bruges som entydige identifikatorer. Et\nprogram, der slår folk op på e-mail, kan give én persons konto til den næste,\nder får adressen. Gem `iss` og `sub` sammen som nøgle, behold e-mailen som en\nalmindelig egenskab, og kontrollér, at `email_verified` er sand, før adressen\nbruges til noget som helst.\n\n**Et adgangstoken tages som bevis på, hvem der loggede ind.** Nogle programmer\nmodtager et adgangstoken, kalder et API med det og behandler svaret som et\nlogin. Tokenet kan være udstedt til et helt andet program, og så er det netop\ndet angreb, hvor nogen udgiver sig for en anden, som RFC 6749 advarer imod. Log\nfolk ind på ID-tokenet, og først når I har bekræftet, at dets `aud` indeholder\njeres eget klient-ID.\n\n**ID-tokenet afkodes, men kontrolleres aldrig.** At læse claims ud af et token\nkræver en base64url-afkodning og ingen nøgle overhovedet, og netop det gør det\nså fristende. Et token, hvis signatur, `iss`, `aud` eller `exp` ikke bliver\nkontrolleret, kan være forfalsket, høre til et andet program eller være udløbet.\nBrug et vedligeholdt bibliotek, giv det udstederen og klient-ID'et, og lad det\nkøre alle trinnene i specifikationens liste, ikke kun de bekvemme.\n\n**Nonce mangler, er fast eller sammenlignes aldrig.** Uden den kan et ID-token,\nder er opsnappet fra ét login, genbruges i et andet. RFC 9700 tilføjer, at nonce\nskal høre til ét bestemt login og være bundet til den browser, der startede det.\nSpecifikationen foreslår én måde at gøre det på: Gem en kryptografisk tilfældig\nværdi i en HttpOnly-sessionscookie, send dens hash som `nonce`, og sammenlign de\nto, når ID-tokenet kommer tilbage.\n\n**Signeringsnøglerne caches for evigt.** Udbydere skifter nøgler, og et program,\nder holder fast i gårsdagens nøglesæt, afviser alle tokens, som er signeret med\nden nye. Specifikationen forventer, at udbyderen offentliggør nøglerne på\n`jwks_uri` og mærker hvert token med et `kid`, og at programmet henter\nnøglesættet igen, når det møder et `kid`, det ikke kender. Cache gerne\nnøglerne, men lad et ukendt `kid` være et signal til at hente dem på ny og ikke\nen grund til at afvise login.\n\n**To tenants på samme vært behandles som én udsteder.** En udbyder kan køre\nflere udstedere på samme vært, og stien er en del af udstederens identifikator:\nSubjektet `1234` hos `https://example.com` og subjektet `1234` hos\n`https://example.com/sales` er to forskellige personer. Gem hele\nissuer-strengen, sammenlign den tegn for tegn, og skær den aldrig ned til et\nværtsnavn.\n\n## Læs mere\n\n- [OpenID Connect Core 1.0](https://openid.net/specs/openid-connect-core-1_0.html)\n  — ID-tokenet, de tre flows, standardclaims og valideringstrinnene, i udgaven\n  med rettelsessæt 2 fra december 2023.\n- [OpenID Connect Discovery 1.0](https://openid.net/specs/openid-connect-discovery-1_0.html)\n  — konfigurationsdokumentet på den faste adresse og reglen om, at dets issuer\n  skal være identisk med den issuer-URL, det blev hentet under.\n- [RFC 6749: The OAuth 2.0 Authorization Framework](https://www.rfc-editor.org/rfc/rfc6749)\n  — rammen, som OpenID Connect bygger på, med advarslen i afsnit 10.16 mod at\n  bruge adgangstokens til at identificere personer.\n- [RFC 7519: JSON Web Token (JWT)](https://www.rfc-editor.org/rfc/rfc7519) —\n  tokenformatet, som alle ID-tokens bruger.\n- [RFC 9700: Best Current Practice for OAuth 2.0 Security](https://www.rfc-editor.org/rfc/rfc9700)\n  — de gældende anbefalinger om PKCE, nonce og omdirigeringen, som gælder for\n  OpenID Connect lige så vel som for OAuth.\n\n\u003chttps://engineer.company/da/glossary/openid-connect/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Hvordan OpenID Connect logger folk ind oven på OAuth: ID-tokenet og dets claims, et login fulgt fra discovery til validering og seks typiske fejl.","formats":{"gemtext":"https://engineer.company/da/glossary/openid-connect/index.gmi","gopher":"https://engineer.company/da/glossary/openid-connect/gophermap","html":"https://engineer.company/da/glossary/openid-connect/","json":"https://engineer.company/da/glossary/openid-connect/index.json","markdown":"https://engineer.company/da/glossary/openid-connect/index.md","pdf":"https://engineer.company/da/glossary/openid-connect/index.pdf"},"kind":"page","language":"da","title":"Hvad er OpenID Connect?","url":"https://engineer.company/da/glossary/openid-connect/","version":1}