{"canonical_url":"https://engineer.company/sv/glossary/jwt/","content_markdown":"# JWT\n\n## Vad det är\n\nEn JWT är en kort teckensträng som bär en uppsättning påståenden från en part\ntill en annan i en form som mottagaren kan kontrollera. Bokstäverna står för\nJSON Web Token. RFC 7519 definierade formatet i maj 2015 som ett kompakt sätt\natt representera claims som kan skickas oförändrat i en URL, och föreslår att\nnamnet uttalas som det engelska ordet ”jot”. Ett claim är ett namn och ett\nvärde som påstås om ett subjekt: `\"sub\": \"24400320\"` säger vem den handlar om,\noch `\"exp\": 1300819380` när den slutar gälla.\n\nNär den skickas är en JWT en rad base64url-strängar åtskilda av punkter. En\nsignerad JWT har tre: en header som anger algoritmen, en payload med claims och\nen signatur beräknad över de två första. En krypterad JWT har fem, och dess\nclaims går inte att läsa utan nyckeln. RFC 7519 sköter inte själv\nkryptografin. Den överlåter tokens som signeras eller skyddas med en MAC\n(message authentication code) åt JSON Web Signature (RFC 7515), och tokens som\nkrypteras åt JSON Web Encryption (RFC 7516). Algoritmerna listas i RFC 7518,\noch nycklarna kan publiceras i formatet JSON Web Key från RFC 7517.\n\n`HS256` är en HMAC med SHA-256: en och samma delade hemlighet både skapar och\nkontrollerar token, så varje tjänst som kan verifiera den också kan utfärda en\negen. `RS256` och `ES256` använder ett nyckelpar: utfärdaren signerar med en\nprivat nyckel, och alla andra verifierar med den publika, som kan delas ut\nfritt. RFC 7519 kräver bara att `HS256` och den osignerade `none` implementeras,\noch rekommenderar dessutom `RS256` och `ES256`.\n\nAvsnitt 4.1 registrerar sju claimnamn: `iss` (utfärdare), `sub` (subjekt),\n`aud` (mottagare, på engelska audience), `exp` (utgångstid), `nbf` (giltig\nfrån), `iat` (utfärdad) och `jti` (ett unikt ID som kan användas för att hindra\natt token spelas upp igen). Namnen har tre bokstäver eftersom formatet ska vara\nkompakt, och alla är valfria. Vilka claims en token måste innehålla bestämmer\nden applikation som använder den. Utöver de registrerade kan vem som helst\ndefiniera publika claims, antingen registrerade hos IANA eller med ett namn som\ninte kan krocka med någon annans, till exempel en URL, och privata claims som\ntvå parter kommer överens om sinsemellan.\n\n## Varför det spelar roll\n\nPoängen med en JWT är att mottagaren kan kontrollera den på egen hand. Med\nutfärdarens nyckel och en klocka kan en tjänst avgöra om token är äkta, vem den\när avsedd för och om den fortfarande gäller, utan att slå upp något i en\ndatabas och utan att fråga utfärdaren. RFC 9068 från oktober 2021 konstaterar\natt många kommersiella OAuth-implementationer utfärdar åtkomsttokens som\nresursservrar själva tolkar och validerar, att mönstret är särskilt vanligt där\nservern som utfärdar tokens och den som tar emot dem skiljs åt av någon form av\ngräns, och att många av dem använder JWT. Därefter standardiserade RFC:n\nuppbyggnaden, så att sådana tokens fungerar mellan olika leverantörer.\n\nJWT är också formatet bakom OpenID Connect: varje ID-token är en JWT adresserad\ntill den applikation som bad om den. Identitetsleverantören måste signera den om\ninte båda villkoren för att använda `alg` med värdet `none` är uppfyllda:\nsvarstypen returnerar ingen ID-token från Authorization Endpoint, som i\nAuthorization Code Flow, och klienten begärde uttryckligen `none` vid\nregistreringen. När medietypen `application/jwt` registrerades 2015 nämnde\nregistreringen redan OpenID Connect, Salesforce, Google, Android, Windows Azure\noch Amazon Web Services bland användarna.\n\nRFC 7519 riktar in formatet på ställen med begränsat utrymme, som HTTP-headern\nAuthorization och parametrar i en URI. Därför är claimnamnen korta, och därför\nanvänder kodningen bara tecken som kan stå i en URL utan att behöva kodas om.\n\nSamma egenskap som gör en JWT billig att kontrollera gör den svår att dra\ntillbaka. En mottagare som kontrollerar signaturen och klockan godtar token\nfram till `exp`, oavsett vad som har hänt med kontot under tiden.\n\n## Så ser det ut i praktiken\n\nRFC 7519 går igenom ett komplett exempel. Headern deklarerar att objektet är en\nJWT och att det är skyddat med HMAC SHA-256:\n\n```text\n{\"typ\":\"JWT\",\n \"alg\":\"HS256\"}\n```\n\nClaims anger en utfärdare, en utgångstid och ett publikt claim vars namn är en\nURL, så att det inte kan krocka med ett claim som någon annan definierar:\n\n```text\n{\"iss\":\"joe\",\n \"exp\":1300819380,\n \"http://example.com/is_root\":true}\n```\n\nVarje del kodas med base64url, HMAC:en beräknas över header och payload\nsammanfogade med en punkt, och de tre resultaten fogas ihop till en enda\nsträng. RFC:n visar den med radbrytningar som bara finns där för läsbarhetens\nskull:\n\n```text\neyJ0eXAiOiJKV1QiLA0KICJhbGciOiJIUzI1NiJ9\n.\neyJpc3MiOiJqb2UiLA0KICJleHAiOjEzMDA4MTkzODAsDQogImh0dHA6Ly9leGFt\ncGxlLmNvbS9pc19yb290Ijp0cnVlfQ\n.\ndBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk\n```\n\nTre saker följer av exemplet. För det första kan alla som har token läsa dess\nclaims: base64url är en kodning, så den mittersta delen blir JSON igen utan\nnågon nyckel. För det andra täcker signaturen de kodade strängarna exakt som de\nskickades. Headern i RFC:n innehåller en CRLF-radbrytning och ett inledande\nmellanslag, och RFC:n anger exakt vilka byte det rör sig om för att undanröja\ntvetydigheter. Formaterar man JSON-texten snyggare och kodar den igen blir\nsträngen en annan, och signaturen stämmer inte längre. Nyckeln till exemplet\nstår i bilaga A.1 i RFC 7515, och med den går signaturen att verifiera. För det\ntredje har token för länge sedan gått ut: `1300819380` sekunder efter den\n1 januari 1970 är den 22 mars 2011 kl. 18.43 UTC, så en korrekt validerare\navvisar den i dag.\n\nEn mottagare som får en sådan token går igenom en fast rad kontroller innan den\nläser ett enda claim. Den delar strängen vid punkterna, avkodar headern och\nförsäkrar sig om att den är giltig JSON med enbart parametrar och värden vars\nsyntax och innebörd den förstår och stöder, eller som enligt specifikationen\nuttryckligen ska ignoreras om de är okända. Den jämför `alg` med de algoritmer\nden har bestämt sig för att godta för just den här utfärdaren och nyckeln. RFC\n7519 säger uttryckligen att det är applikationens beslut, och att en token bör\navvisas om algoritmen inte är godtagbar, även när signaturen är giltig. Den\nverifierar signaturen med en nyckel som tillhör utfärdaren. Sedan kontrollerar\nden claims: `iss` måste vara en utfärdare den litar på, `aud` måste ange\nmottagaren själv, och aktuell tid måste ligga före `exp` (med högst några\nminuters marginal för avvikande klockor) och efter `nbf` om det claimet finns.\nFörst då agerar den på innehållet.\n\nEn JWT-åtkomsttoken enligt RFC 9068 visar vad en konkret profil lägger till.\nHeadern i den RFC:n lyder `{\"typ\":\"at+JWT\",\"alg\":\"RS256\",\"kid\":\"RjEwOwOA\"}`: en\nuttrycklig typ, en asymmetrisk algoritm och ID:t för nyckeln i utfärdarens\npublicerade nyckeluppsättning. Profilen gör `iss`, `exp`, `aud`, `sub`,\n`client_id`, `iat` och `jti` obligatoriska, och en resursserver ska kontrollera\natt `typ` är `at+jwt` eller `application/at+jwt` och avvisa andra typer. Dessa\nnamn på medietyper och undertyper är skiftlägesokänsliga; `at+JWT` i exemplet är\ndärför ett likvärdigt skrivsätt.\n\nClaims i en token är en ögonblicksbild från när den signerades, så allt som kan\nändras före `exp` avgörs bäst på servern. I ett av projekten här på\nwebbplatsen,\n[härdning av en applikation i varje lager](/sv/portfolio/hardened-the-application-with-nonce-based-csp/),\nkontrolleras rättigheterna (nivå, roll, organisation och avgränsning per\nfartyg) på nytt på servern vid varje anrop, medan spärrarna i frontenden\nenbart behandlas som UX.\n\n## Var det går fel\n\n**Token väljer sin egen algoritm.** Headern `alg` finns där för\nflexibilitetens skull, och RFC 8725 beskriver hur vissa bibliotek litade för\nmycket på den. En angripare kunde ändra den till `none`, och biblioteket\ngodtog token helt utan signatur. Eller så ändrade angriparen `RS256` till\n`HS256`, och biblioteket kontrollerade en HMAC med utfärdarens publika\nRSA-nyckel som delad hemlighet, en nyckel som angriparen helt enkelt kan ladda\nner. Konfigurera biblioteket med de algoritmer ni godtar, använd varje nyckel\nmed exakt en algoritm, och avvisa `none` utan undantag.\n\n**HMAC-hemligheten är ett lösenord.** En token som signerats med `HS256` under\nen kort hemlighet som är lätt att komma ihåg kan angripas offline: den som har\nen enda token kan pröva gissningar mot den i sin egen takt utan att röra er\nserver. RFC 8725 förbjuder att ett lösenord som en människa kan komma ihåg\nanvänds direkt som HMAC-nyckel, och RFC 7518 kräver en nyckel på minst 256\nbitar för `HS256`. Generera nyckeln med en kryptografisk slumpkälla, förvara den\ni ett hemlighetslager, och välj ett nyckelpar när många tjänster bara behöver\nverifiera.\n\n**Signaturen stämmer, så allt annat godtas.** En giltig signatur visar vem som\nutfärdade token, inte vem den var avsedd för. Om en utfärdare betjänar flera\ntjänster och mottagaren hoppar över `aud`, kan en token som legitimt skickats\ntill en tjänst återanvändas mot en annan. RFC 8725 kallar det substitution och\nkräver att mottagare av sådana tokens validerar audience och avvisar en token\nsom saknar det. Kontrollera `aud` mot er egen identifierare, och kontrollera\natt signeringsnyckeln tillhör den utfärdare som anges i `iss`.\n\n**En sorts token tas för en annan.** En ID-token, en åtkomsttoken och en\nsecurity event token från samma utfärdare kan likna varandra mycket, och en\nmottagare som bara kontrollerar signatur och utfärdare kan godta fel sort.\nRFC 8725 kallar det cross-JWT confusion och rekommenderar en uttrycklig typ i\nheadern `typ`. RFC 9068 tillämpar just det med `at+jwt`. Ge varje sorts token\nen egen typ eller audience, och skriv valideringsreglerna så att varje sort\nfastnar i de andras kontroller.\n\n**Headern väljer nyckeln.** Headern `kid` anger vilken nyckel som ska\nanvändas, och `jku` och `x5u` kan peka på en URL som nyckeln ska hämtas från.\nAlla kommer från avsändaren. Ett `kid`-värde som skickas okontrollerat vidare\ntill en databasfråga eller en uppslagning i en katalogtjänst blir en väg in i\ndet systemet, och en server som följer vilken URL som helst i `jku` eller\n`x5u` kan avsändaren få att skicka anrop vart som helst. Slå bara upp `kid`\nbland nycklar ni redan har, och hämta bara nycklar från en godkänd lista med\nadresser, till exempel utfärdarens publicerade `jwks_uri`.\n\n**Vem som helst kan läsa payloaden.** En signerad JWT skyddar sina claims mot\nändringar, inte mot att läsas, och den passerar ofta webbläsare, loggar och\nproxyservrar. RFC 7519 påpekar att en JWT kan innehålla integritetskänslig\ninformation och att det enklaste skyddet är att utelämna den. Annars bör token\nkrypteras eller åtminstone bara skickas över TLS. RFC 9068 lägger till att en\nklient inte alls får titta in i en åtkomsttoken, eftersom utfärdaren när som\nhelst kan byta format. Lägg identifierare i token, inte personuppgifter, och\nkryptera när själva innehållet måste hållas privat.\n\n## Läs mer\n\n- [RFC 7519: JSON Web Token (JWT)](https://www.rfc-editor.org/rfc/rfc7519) —\n  själva formatet med de registrerade claimnamnen, det genomgångna exemplet och\n  valideringsstegen.\n- [RFC 7515: JSON Web Signature (JWS)](https://www.rfc-editor.org/rfc/rfc7515) —\n  hur header, payload och signatur kodas och fogas ihop, och nyckeln till\n  exemplet ovan.\n- [RFC 8725: JSON Web Token Best Current Practices](https://www.rfc-editor.org/rfc/rfc8725)\n  — de kända attackerna mot JWT och reglerna för bibliotek och applikationer\n  som förhindrar dem.\n- [RFC 7518: JSON Web Algorithms (JWA)](https://www.rfc-editor.org/rfc/rfc7518)\n  — algoritmnamnen i `alg` med minsta nyckelstorlek för varje HMAC.\n- [RFC 9068: JWT Profile for OAuth 2.0 Access Tokens](https://www.rfc-editor.org/rfc/rfc9068)\n  — standardupplägget för åtkomsttokens i JWT-format och de kontroller en\n  resursserver ska göra.\n\n\u003chttps://engineer.company/sv/glossary/jwt/\u003e\n","date_modified":"2026-11-08T11:12:58Z","description":"Hur en JWT bär signerade claims i tre delar åtskilda av punkter, kontrollerna en server måste göra innan den litar på den, och sex vanliga fel.","formats":{"gemtext":"https://engineer.company/sv/glossary/jwt/index.gmi","gopher":"https://engineer.company/sv/glossary/jwt/gophermap","html":"https://engineer.company/sv/glossary/jwt/","json":"https://engineer.company/sv/glossary/jwt/index.json","markdown":"https://engineer.company/sv/glossary/jwt/index.md","pdf":"https://engineer.company/sv/glossary/jwt/index.pdf"},"kind":"page","language":"sv","title":"Vad är JWT?","url":"https://engineer.company/sv/glossary/jwt/","version":1}