{"canonical_url":"https://engineer.company/sv/glossary/oauth/","content_markdown":"# OAuth\n\n## Vad det är\n\nOAuth är ett protokoll som låter en applikation använda data som en person har\nhos en annan tjänst, med personens medgivande och inom gränser som personen\nsjälv kan se, utan att applikationen någonsin får veta lösenordet. Den version\nsom används i dag är OAuth 2.0, som IETF publicerade i oktober 2012 som\nRFC 6749, och den skrivs lika ofta OAuth 2.0 eller OAuth2 som bara OAuth. Den\nersatte OAuth 1.0, och de två versionerna är inte kompatibla.\n\nSpecifikationen har fyra roller. Resursägaren är den som kan ge åtkomst, oftast\nen person. Resursservern har de skyddade uppgifterna och svarar på varje begäran\nsom bär en token. Klienten är applikationen som vill ha åtkomst: en webbapp, en\nmobilapp, ett skript, en AI-agent. Auktoriseringsservern loggar in ägaren, ber om\nmedgivande och utfärdar tokens. En liten produkt kan köra resursservern och auktoriseringsservern som ett\noch samma system; i ett företag står det oftare en identitetsleverantör framför\nmånga API:er.\n\nDet klienten får är en åtkomsttoken (access token): en teckensträng som står för\nen viss omfattning av åtkomst under en viss tid. Klienten skickar den med varje\nbegäran till resursservern. RFC:n beskriver strängen som i regel ogenomskinlig\nför klienten, som bär den utan att vara tänkt att läsa den.\nAuktoriseringsservern kan också lämna ut en refresh-token, som klienten byter\nmot en ny åtkomsttoken när den gamla går ut, utan att fråga personen igen.\n\nSin första token får klienten genom en grant, en typ av beviljande. RFC 6749\ndefinierar fyra: authorization code, implicit, resource owner password\ncredentials och client credentials. Client credentials är till för ett program\nsom agerar för egen räkning, utan någon person inblandad. Authorization code är\nden som gäller för allt annat, eftersom dagens säkerhetsrekommendationer har\npensionerat implicit och password. Hos IETF förs rekommendationerna, tillsammans\nmed Proof Key for Code Exchange (PKCE) och reglerna för bearer-tokens, samman i\nett enda OAuth 2.1-dokument. I det sextonde utkastet, daterat den 3 september\n2026, är det fortfarande ett Internet-Draft, alltså ett pågående arbete och inte\nen standard.\n\nOAuth handlar om auktorisering, inte om autentisering. En token talar om för\nAPI:et vad klienten får göra; den säger inget tillförlitligt till klienten om\nvem personen är. Att logga in människor ovanpå OAuth är uppgiften för OpenID\nConnect, som lägger till en token som just är avsedd att läsas av klienten.\n\n## Varför det spelar roll\n\nRFC 6749 inleds med problemet den skrevs för att göra slut på. Skulle en\ntredjepartsapplikation komma åt dina uppgifter, gav du den ditt lösenord.\nApplikationen måste då lagra lösenordet, ofta i klartext. Den nådde allt som\nlösenordet nådde, så länge den ville. Ville du stänga ute en enda applikation\nfick du byta lösenord, och då stängde du samtidigt ute alla andra. Och blev en\nav dem komprometterad följde lösenordet och allt bakom det med. OAuth tar bort\nvart och ett av de problemen: applikationen har aldrig lösenordet, token har en\nomfattning och ett utgångsdatum, och åtkomsten kan dras tillbaka från en klient\nutan att resten påverkas.\n\nEtt team möter OAuth från båda hållen. Äger ni ett API låter OAuth partner,\nintegrationer och kundernas egna verktyg anropa det för en användares räkning,\nutan att någon lagrar någon annans lösenord. Använder ni ett är OAuth vad\nkalendrar, e-postlådor, ekonomisystem och fillagringstjänster erbjuder, så\nklienthalvan är kod som ert team skriver och håller vid liv. AI-agenter som\nagerar åt en person sitter på samma plats som vilken annan klient som helst: de\nska ha en token som är begränsad till det personen har godkänt, aldrig personens\ninloggningsuppgifter.\n\nScopes gör principen om minsta behörighet till något en server kan upprätthålla.\nEn token som låter en utskriftstjänst läsa bilder ska inte låta den radera dem,\noch en token som utfärdats för ett API ska avvisas av ett annat. IETF:s\nsäkerhetsvägledning från 2025, RFC 9700, kräver just det: en åtkomsttokens\nrättigheter hållna till det minimum användningsfallet behöver, och tokens\nbegränsade till den resursserver de utfärdades för.\n\n## Så ser det ut i praktiken\n\nRFC:ns eget exempel är en utskriftstjänst som vill hämta bilder från en\nbilddelningstjänst. Här är det utbytet som authorization code-flödet med PKCE,\nden form dagens rekommendationer ber alla klienter använda. Allra först skapar\nklienten en slumpmässig code verifier på 43 till 128 tecken och behåller den för\nsig själv. Den hashar verifieraren med SHA-256, kodar resultatet med base64url\noch skickar det som code challenge när den leder personens webbläsare vidare\ntill auktoriseringsservern:\n\n```http\nGET /authorize?response_type=code\u0026client_id=s6BhdRkqt3\u0026state=xyz\n    \u0026redirect_uri=https%3A%2F%2Fclient%2Eexample%2Ecom%2Fcb\n    \u0026code_challenge=E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM\n    \u0026code_challenge_method=S256 HTTP/1.1\nHost: server.example.com\n```\n\nAuktoriseringsservern loggar in personen, visar vad utskriftstjänsten ber om\noch skickar, när personen har godkänt, tillbaka webbläsaren med en kortlivad\nauktoriseringskod. Klienten kontrollerar att `state` är det värde den själv\nskickade:\n\n```http\nHTTP/1.1 302 Found\nLocation: https://client.example.com/cb?code=SplxlOBeZQQYbYS6WxSbIA\n          \u0026state=xyz\n```\n\nKoden är värdelös i sig. Klienten löser in den med en HTTPS-begäran till\nauktoriseringsserverns token-endpoint och skickar den här gången själva verifieraren:\n\n```http\nPOST /token HTTP/1.1\nHost: server.example.com\nContent-Type: application/x-www-form-urlencoded\n\ngrant_type=authorization_code\u0026code=SplxlOBeZQQYbYS6WxSbIA\n\u0026redirect_uri=https%3A%2F%2Fclient%2Eexample%2Ecom%2Fcb\n\u0026client_id=s6BhdRkqt3\n\u0026code_verifier=dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk\n```\n\nServern hashar verifieraren, jämför med den challenge den sparade tillsammans\nmed koden, och först när de stämmer överens returnerar den tokens, märkta så att\ningen cache behåller dem:\n\n```http\nHTTP/1.1 200 OK\nContent-Type: application/json;charset=UTF-8\nCache-Control: no-store\nPragma: no-cache\n\n{\n  \"access_token\":\"2YotnFZFEjr1zCsicMWpAA\",\n  \"token_type\":\"Bearer\",\n  \"expires_in\":3600,\n  \"refresh_token\":\"tGzv3JOkF0XG5Qx2TlKWIA\"\n}\n```\n\nHärifrån skickar klienten `Authorization: Bearer 2YotnFZFEjr1zCsicMWpAA` med\nvarje anrop till bild-API:et. En timme senare har token gått ut, API:et svarar\n`401 Unauthorized` med `error=\"invalid_token\"` i sitt `WWW-Authenticate`-huvud,\noch klienten använder sin refresh-token för att hämta en ny. Ber klienten om\nnågot utanför det beviljade scopet blir svaret i stället `403 Forbidden` med\n`insufficient_scope`. Verifieraren skyddar mot missbruk av en uppsnappad kod: en kod\nsom kopieras från enheten under överföringen — den attack PKCE ursprungligen\nskrevs mot — kan inte lösas in av någon som saknar verifieraren. Själva\nverifieraren skickades varken i auktoriseringsbegäran eller i webbläsarens\nomdirigering.\n\nSamma delegering är det som låter programvara delta i agenters arbete. På\nwebbplatsens sida om att göra\n[befintlig programvara till verktyg som AI-agenter kan anropa](/sv/ai-tools/)\nger OAuth den delegerade åtkomsten, så att en agent agerar åt en användare utan att\nett lösenord lämnas vidare, och bara inom den användarens rättigheter.\n\n## Var det går fel\n\n**En slapp kontroll av redirect-URI:n skickar koden till någon annan.** En\nauktoriseringsserver som godtar varje redirect-URI som börjar med ett\nregistrerat prefix eller matchar ett jokertecken kan luras att lämna en kod till\nen sida som angriparen styr. RFC 9700 kräver att auktoriseringsservrar jämför\nredirect-URI:er med de registrerade genom exakt strängjämförelse, med ett\nundantag för portnummer på localhost för native-appar, och förbjuder både\nklienter och servrar att exponera öppna omdirigerare som skickar webbläsaren\nvidare till en godtycklig URL ur en frågeparameter.\n\n**Klienten tar emot ett svar den aldrig bad om.** Tar klienten emot vilken kod\nsom helst som hamnar på dess redirect-URI kan en angripare trycka in sin egen\nkod genom ett offers webbläsare, och offret slutar med att arbeta i angriparens\nkonto. Det är cross-site request forgery riktad mot omdirigeringen. En klient\nkan låta PKCE skydda den när den har försäkrat sig om att servern stöder PKCE;\nannars skickar den ett engångsvärde i `state`, bundet till personens\nwebbläsarsession, och avvisar ett svar som kommer tillbaka utan det.\n\n**Tokens färdas i URL:er.** Implicit-flödet lägger åtkomsttoken direkt i\nomdirigeringen, där webbläsarhistorik och `Referer`-huvuden kan bära den dit\nden aldrig borde komma, och ingenting binder den till klienten som bad om den.\nRFC 9700 säger att klienter inte bör använda det, och OAuth 2.1-utkastet tar\ninte med det alls. Detsamma gäller ett API som tar emot en token som\nfrågeparameter: enligt RFC 6750 bör bearer-tokens inte skickas i sidans URL:er.\nAnvänd authorization code-flödet och skicka tokens i `Authorization`-huvudet.\n\n**Appen ber om lösenordet ändå.** Password-flödet, resource owner password\ncredentials, låter en klient samla in en persons användarnamn och lösenord och\nbyta dem mot en token, vilket undergräver själva skälet till att OAuth finns.\nRFC 9700 slår fast att det inte får användas: det exponerar\ninloggningsuppgifterna för klienten, vänjer människor vid att skriva sitt\nlösenord på andra ställen än hos auktoriseringsservern, och det utformades\naldrig för tvåfaktorsautentisering eller inloggningar i flera steg. Skicka\nmänniskor till auktoriseringsservern med authorization code-flödet, och använd\nclient credentials när ingen person alls är inblandad.\n\n**En stulen token fungerar för den som har den.** RFC 6750 definierar en\nbearer-token som en token som vem som helst som har den i sin besittning kan\nanvända, utan ytterligare bevis. Håll åtkomsttokens kortlivade, begränsa var\noch en till det API den utfärdades för, och bind dem till klienten med ömsesidig\nTLS (RFC 8705) eller DPoP (RFC 9449) där mycket står på spel. Refresh-tokens för\npublika klienter, som mobil- och webbläsarappar, måste antingen vara bundna till\nklienten eller roteras: varje förnyelse ger en ny token och ogiltigförklarar den\ngamla. Används en stulen kopia också slutar den ena parten med att visa upp en\nogiltigförklarad token, servern återkallar den aktiva, och attacken stoppas, till\npriset av att den riktiga klienten måste be personen om ett nytt medgivande.\n\n## Läs mer\n\n- [RFC 6749: The OAuth 2.0 Authorization Framework](https://www.rfc-editor.org/rfc/rfc6749)\n  — de fyra rollerna, de fyra grant-typerna och slutpunkterna så som de\n  publicerades i oktober 2012.\n- [RFC 7636: Proof Key for Code Exchange by OAuth Public Clients](https://www.rfc-editor.org/rfc/rfc7636)\n  — code verifier och code challenge, med S256-exemplet som används ovan.\n- [RFC 9700: Best Current Practice for OAuth 2.0 Security](https://www.rfc-editor.org/rfc/rfc9700)\n  — vägledningen från januari 2025: exakt jämförelse av redirect-URI:er, PKCE\n  för alla klienter och inget implicit- eller password-flöde.\n- [RFC 6750: Bearer Token Usage](https://www.rfc-editor.org/rfc/rfc6750) — hur\n  en klient visar upp en åtkomsttoken och hur ett API säger att den saknas, har\n  gått ut eller ger för snäv åtkomst.\n- [The OAuth 2.1 Authorization Framework](https://datatracker.ietf.org/doc/draft-ietf-oauth-v2-1/)\n  — arbetsgruppens utkast som för samman dessa dokument till ett, fortfarande ett\n  Internet-Draft i oktober 2026.\n\n\u003chttps://engineer.company/sv/glossary/oauth/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hur OAuth låter en applikation agera åt en användare utan lösenordet: de fyra rollerna, ett kodutbyte med PKCE steg för steg och fem sätt det läcker på.","formats":{"gemtext":"https://engineer.company/sv/glossary/oauth/index.gmi","gopher":"https://engineer.company/sv/glossary/oauth/gophermap","html":"https://engineer.company/sv/glossary/oauth/","json":"https://engineer.company/sv/glossary/oauth/index.json","markdown":"https://engineer.company/sv/glossary/oauth/index.md","pdf":"https://engineer.company/sv/glossary/oauth/index.pdf"},"kind":"page","language":"sv","title":"Vad är OAuth?","url":"https://engineer.company/sv/glossary/oauth/","version":1}