{"canonical_url":"https://engineer.company/sv/glossary/openid-connect/","content_markdown":"# OpenID Connect\n\n## Vad det är\n\nOpenID Connect är en standard som låter en applikation få veta vem en person är\nfrån en tjänst som just har loggat in personen. Specifikationen kallar sig själv\nett enkelt identitetslager ovanpå OAuth 2.0, och det är precis så den är byggd:\nsamma omdirigeringar, endpoints och tokens som i OAuth, plus en token till, en\nendpoint till och reglerna för hur de kontrolleras. I vardagligt tal förkortas\nden ofta till OIDC. Kärnspecifikationen blev slutgiltig i februari 2014. Den\naktuella texten, där den andra omgången rättelser har arbetats in, är daterad\nden 15 december 2023 och förvaltas av en arbetsgrupp inom OpenID Foundation.\n\nOAuth på egen hand svarar på frågan ”vad får den här applikationen göra?”.\nApplikationen får en åtkomsttoken som är avsedd för ett API, och det är inte\nmeningen att applikationen själv ska läsa den. OpenID Connect ställer dessutom\nfrågan ”vem loggade in?” och besvarar den med en ID-token: en JSON Web\nToken, adresserad till applikationen själv, som talar om vem personen är, vem\nsom går i god för det, när token utfärdades och vilken applikation den är avsedd\nför. ID-tokens måste vara signerade. Specifikationen tillåter endast `alg: none`\nom svarstypen inte returnerar någon ID-token från auktoriseringsendpointen och\nklienten uttryckligen begärde `none` vid registreringen.\n\nFör den här uppgiften ger specifikationen OAuth-rollerna nya namn. En OpenID\nProvider (OP) är en auktoriseringsserver som autentiserar personer och utfärdar\nID-tokens. En Relying Party (RP) är OAuth-klienten som behöver veta vem personen\när, och personen själv kallas End-User. En begäran blir en OpenID\nConnect-begäran genom att `openid` finns med i scopet, och det värdet är\nobligatoriskt: saknas det är beteendet enligt specifikationens egna ord helt\nospecificerat.\n\nAndra scope-värden ber om profiluppgifter. `profile` täcker namn, smeknamn,\nbild, språkinställning och liknande claims, `email` ger `email` och\n`email_verified`, och `address` och `phone` gör det namnen säger.\nApplikationen kan hämta de här claims från leverantörens UserInfo-endpoint, ett\nhelt vanligt OAuth-skyddat API som den anropar med åtkomsttoken.\n\nDet finns tre sätt att köra det. Authorization code-flödet skickar bara en\nkortlivad kod genom webbläsaren och hämtar själva tokens med en HTTPS-begäran\ntill token-endpointen.\nImplicit-flödet levererar tokens rakt i omdirigeringen, och hybridflödet blandar\nde två. En kompletterande specifikation, OpenID Connect Discovery 1.0, låter\napplikationen slå upp alla endpoints och signeringsnycklar utifrån en enda\nadress.\n\n## Varför det spelar roll\n\nSkälet att införa det är single sign-on. Med en identitetsleverantör framför\nmånga applikationer har människor en uppsättning inloggningsuppgifter,\napplikationerna lagrar inga av dem, och reglerna för hur man loggar in, från\nlösenordskrav till en extra faktor, bestäms på ett ställe, hos leverantören.\nSpärras ett konto hos leverantören kan det inte längre starta en ny session i\nnågon av applikationerna som förlitar sig på den, och därmed blir offboarding\nett enda steg i stället för en checklista.\n\nStandarden täpper också till ett hål som team faller i när de bygger inloggning\npå ren OAuth. RFC 6749 varnar för att en publik klient i implicit-flödet inte\nkan se vilken klient en åtkomsttoken utfärdades till. En klient som utgår från\natt bara resursägaren kan ge den en giltig token går därför att lura: en\nangripare med en token som utfärdats till en annan applikation lämnar fram den\noch tas för personen bakom. En ID-token anger i sitt `aud`-claim vilken\napplikation den är till för, och applikationen kontrollerar det.\n\nEftersom det är en standard går arbetet att återanvända. Specifikationen\nutlovar profiluppgifter på ett interoperabelt sätt, så koden som loggar in\nmänniskor via en leverantör kan logga in dem via en annan också. Med Discovery\nlär sig applikationen leverantörens endpoints och signeringsnycklar utifrån\nissuer-URL:en i stället för från inställningar som någon har skrivit av för\nhand.\n\nTill sist ger OpenID Connect varje person en stabil identifierare.\nSpecifikationen säger uttryckligen att paret `iss` (utfärdaren) och `sub`\n(subjektidentifieraren) är de enda claims som en applikation kan lita på som\nstabil identifierare för en person. Värdet i `sub` är unikt hos utfärdaren,\nåteranvänds aldrig och är högst 255 ASCII-tecken långt. En leverantör kan till\noch med ge varje applikation ett eget `sub`, en så kallad parvis identifierare,\nså att applikationerna inte kan koppla ihop det en person gör utan tillstånd.\n\n## Så ser det ut i praktiken\n\nTa en webbapplikation som är registrerad hos en OpenID Provider på\n`https://server.example.com` med klient-ID:t `s6BhdRkqt3`; värdena nedan är\nhämtade från specifikationens egna exempel. Applikationen börjar med att hämta\nleverantörens konfiguration från den fasta adressen under utfärdaren:\n\n```http\nGET /.well-known/openid-configuration HTTP/1.1\nHost: server.example.com\n```\n\nSvaret är ett JSON-dokument. I förkortad 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 att `issuer` i dokumentet är identiskt med den issuer-URL som\napplikationen satte framför den fasta sökvägen, och applikationen avbryter om de\nskiljer sig åt. Därefter skickar den personens webbläsare till\nauktoriseringsendpointen med code-flödet, scopet `openid` och två slumpmässiga\nvärden som den har sparat tillsammans med webbläsarsessionen: `state` för\nomdirigeringen och `nonce` för ID-token. En publik klient skulle dessutom skicka\nPKCE-parametrarna, som RFC 9700 gör obligatoriska för den; de är utelämnade här\nför att hålla raderna korta.\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\nLeverantören loggar in personen och skickar tillbaka webbläsaren med en kod, som\napplikationen löser in vid token-endpointen precis som i vanlig OAuth.\nSkillnaden ligger i svaret, som nu har en `id_token` bredvid åtkomsttoken\n(förkortat här):\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-token består av tre base64url-delar åtskilda av punkter. Den första avkodas\ntill `{\"alg\":\"RS256\",\"kid\":\"1e9gdk7\"}`: signeringsalgoritmen och ID:t för\nnyckeln i leverantörens publicerade nyckeluppsättning. Den mittersta delen\ninnehåller själva claims, och i specifikationens exempel ser de ut så här:\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\nInnan applikationen litar på ett enda ord av detta validerar den token, och\nspecifikationen räknar upp stegen. `iss` måste stämma exakt med leverantörens\nutfärdare. `aud` måste innehålla applikationens eget klient-ID och inga\nmottagare som den inte litar på. Signaturen måste gå att verifiera med\nleverantörens nycklar från `jwks_uri` och med algoritmen i headern; kom token,\nsom här, direkt från token-endpointen över TLS kan en kontroll av serverns\nTLS-certifikat ersätta signaturkontrollen. Klockan måste vara före `exp`, och\n`nonce` måste vara det värde som applikationen själv skickade. Först då loggar\nden in personen, med `https://server.example.com` plus `24400320` som nyckel,\noch använder åtkomsttoken för att hämta e-post och profiluppgifter från\nUserInfo-endpointen om den behöver dem.\n\nEn leverantör för många system är lika mycket en organisatorisk förändring som\nen teknisk. I ett av projekten här på webbplatsen,\n[behörighetshantering i M365 och SSO](/sv/portfolio/led-access-management-across-m365-and-sso/),\nsamlades identiteterna och åtkomsten i M365, 1Password, Red Hat SSO och OKTA\nSSO. Principen om minsta behörighet upprätthölls, och onboarding och offboarding\nstandardiserades, så att åtkomst återkallades snabbt och konsekvent i stället\nför att ligga kvar efter att någon hade gått vidare.\n\n## Var det går fel\n\n**E-postadressen används som kontonyckel.** Det är det självklara valet och det\nfelaktiga. Specifikationen säger att en utfärdare med tiden kan ge samma\ne-postadress till en annan person, och att `email`, `phone_number`,\n`preferred_username` och `name` inte får användas som unika identifierare. En\napplikation som slår upp människor på e-post kan ge en persons konto till nästa\nperson som får adressen. Spara `iss` och `sub` tillsammans som nyckel, behåll\ne-posten som ett vanligt attribut, och kontrollera att `email_verified` är sant\ninnan adressen används till något alls.\n\n**En åtkomsttoken tas som bevis på vem som loggade in.** Vissa applikationer tar\nemot en åtkomsttoken, anropar ett API med den och behandlar svaret som en\ninloggning. Token kan ha utfärdats till en helt annan applikation, och då är det\njust det angrepp där någon utger sig för att vara någon annan som RFC 6749\nvarnar för. Logga in människor på ID-token, och först när ni har bekräftat att\n`aud` innehåller ert eget klient-ID.\n\n**ID-token avkodas men kontrolleras aldrig.** Att läsa ut claims ur en token\nkräver en base64url-avkodning och ingen nyckel alls, och det är just det som gör\ndet frestande. En token där signaturen, `iss`, `aud` eller `exp` inte\nkontrolleras kan vara förfalskad, tillhöra en annan applikation eller ha gått\nut. Använd ett bibliotek som underhålls, ge det utfärdaren och klient-ID:t, och\nlåt det köra alla steg i specifikationens lista, inte bara de bekväma.\n\n**Nonce saknas, är fast eller jämförs aldrig.** Utan den kan en ID-token som\nsnappats upp från en inloggning spelas upp igen i en annan. RFC 9700 tillägger\natt nonce måste höra till en bestämd inloggning och vara bunden till webbläsaren\nsom startade den. Specifikationen föreslår ett sätt att göra det: spara ett\nkryptografiskt slumpmässigt värde i en HttpOnly-sessionscookie, skicka dess hash\nsom `nonce` och jämför de två när ID-token kommer tillbaka.\n\n**Signeringsnycklarna cachas för evigt.** Leverantörer byter nycklar, och en\napplikation som håller fast vid gårdagens nyckeluppsättning avvisar varje token\nsom är signerad med den nya. Specifikationen förväntar sig att leverantören\npublicerar nycklarna på `jwks_uri` och märker varje token med ett `kid`, och att\napplikationen hämtar nyckeluppsättningen på nytt när den stöter på ett `kid` som\nden inte känner igen. Cacha gärna nycklarna, men låt ett okänt `kid` vara en\nsignal att hämta dem på nytt och inte ett skäl att avvisa inloggningen.\n\n**Två tenants på samma värd behandlas som en utfärdare.** En leverantör kan köra\nflera utfärdare på samma värd, och sökvägen är en del av\nutfärdaridentifieraren: subjektet `1234` hos `https://example.com` och subjektet\n`1234` hos `https://example.com/sales` är två olika personer. Spara hela\nissuer-strängen, jämför den tecken för tecken, och korta aldrig ned den till ett\nvärdnamn.\n\n## Läs mer\n\n- [OpenID Connect Core 1.0](https://openid.net/specs/openid-connect-core-1_0.html)\n  — ID-token, de tre flödena, standardclaims och valideringsstegen, i utgåvan\n  med rättelseomgång 2 från december 2023.\n- [OpenID Connect Discovery 1.0](https://openid.net/specs/openid-connect-discovery-1_0.html)\n  — konfigurationsdokumentet på den fasta adressen och regeln att dess issuer\n  måste vara identisk med den issuer-URL det hämtades under.\n- [RFC 6749: The OAuth 2.0 Authorization Framework](https://www.rfc-editor.org/rfc/rfc6749)\n  — ramverket som OpenID Connect bygger på, med varningen i avsnitt 10.16 mot\n  att använda åtkomsttokens för att identifiera personer.\n- [RFC 7519: JSON Web Token (JWT)](https://www.rfc-editor.org/rfc/rfc7519) —\n  tokenformatet som alla ID-tokens använder.\n- [RFC 9700: Best Current Practice for OAuth 2.0 Security](https://www.rfc-editor.org/rfc/rfc9700)\n  — aktuella rekommendationer om PKCE, nonce och omdirigering, som gäller för\n  OpenID Connect lika mycket som för OAuth.\n\n\u003chttps://engineer.company/sv/glossary/openid-connect/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Hur OpenID Connect loggar in människor ovanpå OAuth: ID-token och dess claims, en inloggning följd från discovery till validering och sex vanliga fel.","formats":{"gemtext":"https://engineer.company/sv/glossary/openid-connect/index.gmi","gopher":"https://engineer.company/sv/glossary/openid-connect/gophermap","html":"https://engineer.company/sv/glossary/openid-connect/","json":"https://engineer.company/sv/glossary/openid-connect/index.json","markdown":"https://engineer.company/sv/glossary/openid-connect/index.md","pdf":"https://engineer.company/sv/glossary/openid-connect/index.pdf"},"kind":"page","language":"sv","title":"Vad är OpenID Connect?","url":"https://engineer.company/sv/glossary/openid-connect/","version":1}