{"canonical_url":"https://engineer.company/da/glossary/jwt/","content_markdown":"# JWT\n\n## Hvad det er\n\nEt JWT er en kort tekststreng, der bærer en række udsagn fra én part til en\nanden i en form, modtageren kan kontrollere. Bogstaverne står for JSON Web\nToken. RFC 7519 definerede formatet i maj 2015 som en kompakt måde at\nrepræsentere claims på, der kan sendes uændret i en URL, og foreslår, at navnet\nudtales som det engelske ord »jot«. Et claim er et navn og en værdi, der siges\nom et subjekt: `\"sub\": \"24400320\"` fortæller, hvem tokenet handler om, og\n`\"exp\": 1300819380` fortæller, hvornår det holder op med at gælde.\n\nNår det sendes, er et JWT en række base64url-strenge adskilt af punktummer. Et\nsigneret JWT har tre: en header, der angiver algoritmen, en payload med claims\nog en signatur beregnet over de to første. Et krypteret JWT har fem, og dets\nclaims kan ikke læses uden nøglen. RFC 7519 står ikke selv for kryptografien.\nDen lader JSON Web Signature (RFC 7515) tage sig af tokens, der signeres eller\nbeskyttes med en MAC (message authentication code), og JSON Web Encryption (RFC\n7516) af dem, der krypteres. Algoritmerne er listet i RFC 7518, og nøglerne kan\noffentliggøres i formatet JSON Web Key fra RFC 7517.\n\n`HS256` er en HMAC med SHA-256: én delt hemmelighed både laver og kontrollerer\ntokenet, så enhver tjeneste, der kan verificere det, også kan udstede det.\n`RS256` og `ES256` bruger et nøglepar: udstederen signerer med en privat nøgle,\nog alle andre verificerer med den offentlige, som frit kan deles ud. RFC 7519\nkræver kun, at `HS256` og den usignerede `none` er implementeret, og anbefaler\ndesuden `RS256` og `ES256`.\n\nAfsnit 4.1 registrerer syv claimnavne: `iss` (udsteder), `sub` (subjekt), `aud`\n(modtager, på engelsk audience), `exp` (udløbstidspunkt), `nbf` (gyldig fra),\n`iat` (udstedt) og `jti` (et entydigt ID, der kan bruges til at forhindre, at\ntokenet afspilles igen). Navnene er på tre bogstaver, fordi formatet skal være\nkompakt, og de er alle valgfrie. Hvilke claims et token skal indeholde, afgør\nden applikation, der bruger det. Ud over de registrerede kan enhver definere\noffentlige claims, enten registreret hos IANA eller med et navn, der ikke kan\nkollidere med andres, for eksempel en URL, og private claims, som to parter\naftaler indbyrdes.\n\n## Hvorfor det betyder noget\n\nPointen med et JWT er, at modtageren kan kontrollere det på egen hånd. Med\nudstederens nøgle og et ur kan en tjeneste afgøre, om tokenet er ægte, hvem det\ner til, og om det stadig gælder, uden at slå op i en database og uden at spørge\nudstederen. RFC 9068 fra oktober 2021 konstaterer, at mange kommercielle\nOAuth-implementeringer udsteder adgangstokens, som ressourceservere selv parser\nog validerer, at mønstret er særlig udbredt, hvor den server, der udsteder\ntokens, og den, der modtager dem, er adskilt af en eller anden grænse, og at\nmange af dem bruger JWT. Derefter standardiserede RFC'en opbygningen, så den\nslags tokens fungerer på tværs af leverandører.\n\nJWT er også formatet bag OpenID Connect: hvert ID-token er et JWT stilet til den\napplikation, der bad om det. Identitetsudbyderen skal signere det, medmindre\nbegge betingelser for at sætte `alg` til `none` er opfyldt: svartypen returnerer\nikke noget ID-token fra Authorization Endpoint, som i Authorization Code Flow,\nog klienten bad udtrykkeligt om `none` ved registreringen. Da medietypen\n`application/jwt` blev registreret i 2015, nævnte registreringen allerede OpenID\nConnect, Salesforce, Google, Android, Windows Azure og Amazon Web Services\nblandt brugerne.\n\nRFC 7519 sigter mod steder med begrænset plads, som HTTP-headeren Authorization\nog parametre i en URI. Derfor er claimnavnene korte, og derfor bruger kodningen\nkun tegn, der kan stå i en URL uden at blive escapet.\n\nDen egenskab, der gør et JWT billigt at kontrollere, gør det også svært at\ntrække tilbage. En modtager, der kontrollerer signaturen og uret, accepterer\ntokenet indtil `exp`, uanset hvad der er sket med kontoen i mellemtiden.\n\n## Sådan ser det ud i praksis\n\nRFC 7519 gennemgår et komplet eksempel. Headeren erklærer, at objektet er et JWT,\nog at det er beskyttet med HMAC SHA-256:\n\n```text\n{\"typ\":\"JWT\",\n \"alg\":\"HS256\"}\n```\n\nClaims angiver en udsteder, et udløbstidspunkt og ét offentligt claim, hvis navn\ner en URL, så det ikke kan støde sammen med et claim, som andre definerer:\n\n```text\n{\"iss\":\"joe\",\n \"exp\":1300819380,\n \"http://example.com/is_root\":true}\n```\n\nHver del kodes med base64url, HMAC'en beregnes over header og payload sat\nsammen med et punktum, og de tre resultater sættes sammen til én streng. RFC'en\nviser den med linjeskift, der kun er der af hensyn til læsbarheden:\n\n```text\neyJ0eXAiOiJKV1QiLA0KICJhbGciOiJIUzI1NiJ9\n.\neyJpc3MiOiJqb2UiLA0KICJleHAiOjEzMDA4MTkzODAsDQogImh0dHA6Ly9leGFt\ncGxlLmNvbS9pc19yb290Ijp0cnVlfQ\n.\ndBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk\n```\n\nTre ting følger af eksemplet. For det første kan alle, der har tokenet, læse\ndets claims: base64url er en kodning, så den midterste del bliver til JSON igen\nuden nogen nøgle. For det andet dækker signaturen de kodede strenge præcis, som\nde blev sendt. Headeren i RFC'en indeholder et CRLF-linjeskift og et indledende\nmellemrum, og RFC'en angiver de nøjagtige bytes for at undgå tvivl. Formaterer\nman JSON'en pænere og koder den igen, får man en anden streng, og signaturen\npasser ikke længere. Nøglen til eksemplet står i appendiks A.1 i RFC 7515, og\nmed den kan signaturen verificeres. For det tredje er tokenet for længst udløbet:\n`1300819380` sekunder efter 1. januar 1970 er 22. marts 2011 kl. 18.43 UTC, så\nen korrekt validator afviser det i dag.\n\nEn modtager, der får sådan et token, kører en fast række kontroller, før den\nlæser et eneste claim. Den deler strengen ved punktummerne, afkoder headeren og\nsikrer sig, at den er gyldig JSON med kun parametre og værdier, hvis syntaks og\nbetydning den forstår og understøtter, eller som ifølge specifikationen\nudtrykkeligt skal ignoreres, hvis de er ukendte. Den sammenligner `alg` med de\nalgoritmer, den har besluttet at acceptere for netop denne udsteder og nøgle.\nRFC 7519 er udtrykkelig om, at det er applikationens beslutning, og at et token\nbør afvises, hvis algoritmen ikke er acceptabel, også selvom signaturen er\ngyldig. Den verificerer signaturen med en nøgle, der hører til udstederen.\nDerefter kontrollerer den claims: `iss` skal være en udsteder, den stoler på,\n`aud` skal nævne modtageren selv, tidspunktet skal ligge før `exp`, med højst få\nminutters margin for forskelle mellem urene, og efter `nbf`, hvis det claim er\nmed. Først da handler den på indholdet.\n\nEt JWT-adgangstoken efter RFC 9068 viser, hvad en konkret profil lægger til.\nHeaderen i den RFC lyder `{\"typ\":\"at+JWT\",\"alg\":\"RS256\",\"kid\":\"RjEwOwOA\"}`: en\nudtrykkelig type, en asymmetrisk algoritme og ID'et på nøglen i udstederens\noffentliggjorte nøglesæt. Profilen gør `iss`, `exp`, `aud`, `sub`, `client_id`,\n`iat` og `jti` obligatoriske, og en ressourceserver skal kontrollere, at `typ`\ner `at+jwt` eller `application/at+jwt`, og afvise andre typer. Der skelnes ikke\nmellem store og små bogstaver i disse medietype- og undertypenavne; `at+JWT` i\neksemplet er derfor en ækvivalent skrivemåde.\n\nClaims i et token er et øjebliksbillede fra det tidspunkt, det blev signeret, så\nalt, hvad der kan ændre sig før `exp`, er bedre afgjort på serveren. I et af\nsitets projekter,\n[hærdning af en applikation i hvert lag](/da/portfolio/hardened-the-application-with-nonce-based-csp/),\nkontrolleres rettighederne (tier, rolle, organisation og afgrænsning til skibe)\nigen på serveren ved hver request, mens kontrollerne i frontenden kun betragtes\nsom UX.\n\n## Hvor det går galt\n\n**Tokenet vælger selv sin algoritme.** Headeren `alg` er der for fleksibilitetens\nskyld, og RFC 8725 beskriver, hvordan nogle biblioteker stolede for meget på\nden. En angriber kunne ændre den til `none`, og biblioteket accepterede tokenet\nhelt uden signatur. Eller angriberen ændrede `RS256` til `HS256`, og biblioteket\nkontrollerede en HMAC med udstederens offentlige RSA-nøgle som delt hemmelighed,\nen nøgle, angriberen bare kan hente. Konfigurér biblioteket med de algoritmer,\nI accepterer, brug hver nøgle med præcis én algoritme, og afvis `none` helt.\n\n**HMAC-hemmeligheden er en adgangskode.** Et token signeret med `HS256` under en\nkort hemmelighed, der er til at huske, kan angribes offline: den, der har ét\neneste token, kan prøve gæt mod det i sit eget tempo uden at røre jeres server.\nRFC 8725 forbyder at bruge en adgangskode, et menneske kan huske, direkte som\nHMAC-nøgle, og RFC 7518 kræver en nøgle på mindst 256 bit til `HS256`. Generér\nnøglen med en kryptografisk tilfældighedskilde, opbevar den i et\nhemmelighedslager, og vælg et nøglepar, når mange tjenester kun skal verificere.\n\n**Signaturen holder, så alt andet bliver troet.** En gyldig signatur viser, hvem\nder udstedte tokenet, ikke hvem det var til. Hvis én udsteder betjener flere\ntjenester, og modtageren springer `aud` over, kan et token, der lovligt blev sendt\ntil én tjeneste, genbruges mod en anden. RFC 8725 kalder det substitution og\nkræver, at modtagere af den slags tokens validerer audience og afviser et token\nuden. Kontrollér `aud` mod jeres egen identifikator, og kontrollér, at\nsigneringsnøglen hører til den udsteder, der står i `iss`.\n\n**Én slags token går for en anden.** Et ID-token, et adgangstoken og et security\nevent token fra samme udsteder kan ligne hinanden meget, og en modtager, der kun\nkontrollerer signatur og udsteder, kan acceptere den forkerte slags. RFC 8725\nkalder det cross-JWT confusion og anbefaler en udtrykkelig type i headeren\n`typ`. RFC 9068 bruger netop det med `at+jwt`. Giv hver slags token sin egen type\neller audience, og skriv valideringsreglerne, så hver slags falder igennem i de\nandres kontroller.\n\n**Headeren vælger nøglen.** Headeren `kid` angiver, hvilken nøgle der skal\nbruges, og `jku` og `x5u` kan pege på en URL, nøglen skal hentes fra. De kommer\nalle fra afsenderen. Et `kid`, der sendes ukontrolleret videre til en\ndatabaseforespørgsel eller et opslag i en katalogtjeneste, bliver en vej ind i\ndet system, og en server, der følger enhver URL i `jku` eller `x5u`, kan\nafsenderen få til at sende forespørgsler hvorhen som helst. Slå kun `kid` op\nblandt nøgler, I allerede har, og hent kun nøgler fra en godkendt liste af\nadresser, for eksempel udstederens offentliggjorte `jwks_uri`.\n\n**Alle kan læse payloaden.** Et signeret JWT beskytter sine claims mod\nændringer, ikke mod at blive læst, og det kommer ofte forbi browsere, logfiler\nog proxyer. RFC 7519 bemærker, at et JWT kan indeholde personfølsomme\noplysninger, og at den enkleste beskyttelse er at lade dem blive ude. Ellers bør\ntokenet krypteres eller i det mindste kun sendes over TLS. RFC 9068 tilføjer, at\nen klient slet ikke må se ind i et adgangstoken, fordi udstederen kan skifte\nformat når som helst. Læg identifikatorer i tokenet, ikke personoplysninger, og\nkryptér, når selve indholdet skal holdes privat.\n\n## Læs mere\n\n- [RFC 7519: JSON Web Token (JWT)](https://www.rfc-editor.org/rfc/rfc7519) —\n  selve formatet med de registrerede claims, det gennemgåede eksempel og\n  valideringstrinnene.\n- [RFC 7515: JSON Web Signature (JWS)](https://www.rfc-editor.org/rfc/rfc7515) —\n  hvordan header, payload og signatur kodes og sættes sammen, og nøglen til\n  eksemplet ovenfor.\n- [RFC 8725: JSON Web Token Best Current Practices](https://www.rfc-editor.org/rfc/rfc8725)\n  — de kendte angreb på JWT og reglerne for biblioteker og applikationer, der\n  forhindrer dem.\n- [RFC 7518: JSON Web Algorithms (JWA)](https://www.rfc-editor.org/rfc/rfc7518)\n  — algoritmenavnene i `alg` med mindste nøglestørrelse for hver HMAC.\n- [RFC 9068: JWT Profile for OAuth 2.0 Access Tokens](https://www.rfc-editor.org/rfc/rfc9068)\n  — standardopbygningen af JWT-adgangstokens og de kontroller, en\n  ressourceserver skal køre.\n\n\u003chttps://engineer.company/da/glossary/jwt/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hvordan et JWT bærer signerede claims i tre dele adskilt af punktummer, de kontroller en server skal køre, før den tror på det, og seks typiske fejl.","formats":{"gemtext":"https://engineer.company/da/glossary/jwt/index.gmi","gopher":"https://engineer.company/da/glossary/jwt/gophermap","html":"https://engineer.company/da/glossary/jwt/","json":"https://engineer.company/da/glossary/jwt/index.json","markdown":"https://engineer.company/da/glossary/jwt/index.md","pdf":"https://engineer.company/da/glossary/jwt/index.pdf"},"kind":"page","language":"da","title":"Hvad er JWT?","url":"https://engineer.company/da/glossary/jwt/","version":1}