{"canonical_url":"https://engineer.company/da/glossary/cors/","content_markdown":"# CORS\n\n## Hvad det er\n\nCORS, skrevet helt ud Cross-Origin Resource Sharing, er de regler, en server\nbruger til at fortælle browseren, at sider fra andre websites må læse det, den\nsender tilbage. Browsere holder oprindelser adskilt. En oprindelse er skema,\nvært og port taget under ét, så `https://app.example.com`,\n`https://api.example.com` og `http://app.example.com` er tre forskellige\noprindelser, og et script på den ene må ikke læse et svar fra en anden, medmindre\nden anden siger god for det. CORS er måden, den siger god for det på: en lille\nfamilie af HTTP-headere, som næsten alle begynder med `Access-Control-`, og som\nserveren sætter på sine svar, mens browseren tjekker dem, før noget som helst\nnår frem til det kaldende script.\n\nProtokollen står i WHATWG's Fetch-standard, den levende specifikation af, hvordan\nbrowsere henter ressourcer. Begrundelsen står der også, og den er enkel. En side\nskal kunne bruge data fra en anden oprindelse og sende mere avancerede requests,\nend en HTML-formular kan, men kun når modparten selv har sagt ja. Uden det ja\nkunne en tilfældig side på nettet læse servere, der står bag en virksomheds\nfirewall, eller læse en brugers private data på et andet site med brugerens\ncookies hængt på.\n\nSelve udvekslingen er kort. Når et script beder om en ressource fra en anden\noprindelse, tilføjer browseren en `Origin`-header med sidens egen oprindelse.\nServeren svarer med `Access-Control-Allow-Origin`, og værdien er enten den\nsamme oprindelse, skrevet nøjagtigt, eller `*` for alle. Passer den, får\nscriptet svaret. Passer den ikke, får scriptet en netværksfejl og intet af\nindholdet.\n\nNogle requests kræver lov, før de overhovedet bliver sendt. En `GET`, `HEAD`\neller `POST` med nogle få almindelige headere og en krop af typen\n`application/x-www-form-urlencoded`, `multipart/form-data` eller `text/plain`\ngår direkte afsted, for den slags har en HTML-formular altid kunnet sende fra et\nhvilket som helst site. Alt ud over det, fx en `PUT`, en `DELETE`, en JSON-krop\neller en `Authorization`-header, får en preflight foran sig: en\n`OPTIONS`-request, der nævner metoden i `Access-Control-Request-Method` og de\nekstra headere i `Access-Control-Request-Headers`. Den rigtige request kommer\nførst, når svaret har en ok-status som 200 eller 204 og tillader begge dele.\n\n## Hvorfor det betyder noget\n\nNæsten alle webapplikationer med et separat API støder på CORS den første dag.\nFrontenden serveres fra én oprindelse og API'et fra en anden, og det første\n`fetch` fra den ene til den anden fejler i browserens konsol, indtil API'et\nsender de rigtige headere. Teams, der møder CORS på den måde, husker det typisk\nsom en forhindring og konfigurerer det som en, ved at tillade hvad som helst der\nfår fejlen til at gå væk. Det er dér, risikoen ligger.\n\nHeaderne afgør, hvem der kan læse dine brugeres data gennem deres egne browsere.\nEn bruger, der er logget ind i din applikation, har en sessionscookie med. Hvis\nAPI'et lader en hvilken som helst oprindelse sende requests med cookies og læse\nsvarene, kan enhver side, brugeren besøger, kalde API'et i brugerens navn og\nlæse resultatet. Fetch-standarden siger det ligeud: at dele svar, der er hentet\nmed brugerens loginoplysninger, kræver den yderste omhu for at undgå det, den\nkalder confused deputy-problemet. Browseren, som bærer brugerens cookies, er den\nstedfortræder, der bliver narret, og en sjusket CORS-opsætning lader en\nfremmed side styre den.\n\nDet er lige så vigtigt at vide, hvad CORS ikke gør. Det beskytter ikke serveren.\nEn simpel request når frem til serveren og bliver udført, uanset om svaret\nbagefter må deles, så en `POST`, der ændrer data, har ændret dem, før browseren\nhar kigget på en eneste CORS-header. Uden for en browser er `Origin`-headeren\nhvad end kalderen skriver, og OWASP's testvejledning advarer om, at den kan\nforfalskes. Hvem der må kalde et endepunkt, og hvad de må gøre der, afgøres af\nautentificering og autorisation på serveren, hver gang. CORS afgør kun, hvilke\nwebsider der må læse svaret inde i en browser.\n\n## Sådan ser det ud i praksis\n\nForestil dig en single-page-applikation på `https://app.example.com`, der gemmer\nen note gennem et API på `https://api.example.com` og bruger den\nsessionscookie, API'et satte ved login:\n\n```js\nawait fetch(\"https://api.example.com/v1/notes/42\", {\n  method: \"PUT\",\n  credentials: \"include\",\n  headers: { \"Content-Type\": \"application/json\" },\n  body: JSON.stringify({ text: \"Udgiv på fredag\" }),\n});\n```\n\nEn `PUT` med en JSON-krop er mere, end en formular kan sende, så browseren\nspørger først. Preflighten har ingen cookies med; den nævner bare, hvad den\nrigtige request vil bruge:\n\n```http\nOPTIONS /v1/notes/42 HTTP/1.1\nHost: api.example.com\nOrigin: https://app.example.com\nAccept: */*\nAccess-Control-Request-Method: PUT\nAccess-Control-Request-Headers: content-type\n```\n\nAPI'et holder oprindelsen op mod sin egen liste og svarer:\n\n```http\nHTTP/1.1 204 No Content\nAccess-Control-Allow-Origin: https://app.example.com\nAccess-Control-Allow-Credentials: true\nAccess-Control-Allow-Methods: PUT\nAccess-Control-Allow-Headers: content-type\nAccess-Control-Max-Age: 600\nVary: Origin\n```\n\nNu sender browseren selve `PUT`-requesten med cookie og `Origin`-header, og\nAPI'ets svar gentager `Access-Control-Allow-Origin` og\n`Access-Control-Allow-Credentials: true`. Mangler en af dem, er noten gemt på\nserveren, men scriptet får aldrig svaret at se. `Access-Control-Max-Age` lader\nbrowseren genbruge preflight-svaret i op til 600 sekunder i stedet for at spørge\nfør hvert kald; uden headeren gemmer standarden det i fem sekunder.\n`Vary: Origin` er med, fordi svaret afhænger af, hvem der spørger, og en cache,\nder overså det, kunne give én oprindelses svar videre til en anden.\n\nPå en platform med professionelle og organisatoriske data\n[har API'et rate limiting, CORS, grænser for request-størrelse og inputvalidering, før noget når databasen](/da/portfolio/hardened-the-application-with-nonce-based-csp/).\nDen samme side forklarer, hvorfor CORS kun er ét punkt på den liste og ikke hele\nforsvaret: platformen går ud fra, at klienten er fjendtlig, og serveren\nkontrollerer rettighederne igen ved hver request, uanset hvad browseren har\ntilladt.\n\n## Hvor det går galt\n\n**Serveren kopierer en hvilken som helst `Origin` tilbage i\n`Access-Control-Allow-Origin`.** Det er den hurtigste vej til at få fejlen i\nkonsollen til at forsvinde, og sammen med `Access-Control-Allow-Credentials: true`\ngiver det hvert eneste website på nettet brugerens udsyn til API'et. Hav en\neksplicit liste over de oprindelser, der skal have adgang, sammenlign den\nindkommende `Origin` nøjagtigt med den, og send kun headerne ved et match.\n\n**Listen tjekkes med et præfiks eller en delstreng.** En regel, der godtager\nenhver oprindelse, som begynder med `https://app.example.com`, godtager også\n`https://app.example.com.attacker.example`, og et delstrengsmatch er endnu\nværre. Sammenlign hele serialiserede oprindelser. En serialiseret oprindelse har\nhverken sti eller afsluttende skråstreg, så `https://app.example.com/` på listen\nkommer aldrig til at matche noget.\n\n**`*` forventes at virke sammen med cookies.** Når en request har\nloginoplysninger med, afviser browseren `*` i `Access-Control-Allow-Origin`,\n`Access-Control-Allow-Methods`, `Access-Control-Allow-Headers` og\n`Access-Control-Expose-Headers`, og `Access-Control-Allow-Credentials` skal være\npræcis `true` med små bogstaver. Et offentligt API, der kun læses og ikke bruger\ncookies, kan trygt svare `*`; et API, der hviler på en session, skal nævne\noprindelsen.\n\n**`null` står på listen over tilladte.** Sider, der er indlæst fra en\n`data:`-URL, får en uigennemsigtig oprindelse, og en request, der er blevet\nomdirigeret på tværs af oprindelser, melder også `Origin: null`, så mange\nvidt forskellige dokumenter viser den samme værdi. At tillade `null` er at\ntillade dem alle. Lad den blive ude.\n\n**`Vary: Origin` mangler.** Sender API'et kun `Access-Control-Allow-Origin`, når\nen request har en `Origin`, der passer, kan en cache gemme et svar uden headeren\nog servere det for en senere CORS-request, eller gemme én oprindelses svar og\ngive det til en anden. Fetch-standarden beder om `Vary: Origin`, når svaret\nafhænger af oprindelsen. Er værdien `*` eller én fast oprindelse, så send den på\nhvert eneste svar og lad `Vary` være.\n\n**`Access-Control-Allow-Headers: *` regnes for at dække alt.** Jokertegnet dækker\naldrig `Authorization`, som skal nævnes ved navn, og det dækker slet ingenting\nfor requests med loginoplysninger. Nævn de headere, klienten faktisk sender.\n\n**CORS bliver brugt som adgangskontrol.** En server, der afviser requests, fordi\n`Origin` ser forkert ud, og ellers lukker dem ind, har skrevet et tjek, som\nethvert script uden for en browser går lige forbi. Autentificér kalderen,\nautorisér handlingen på serveren, og lad CORS passe sit ene job: at afgøre, hvad\nen browser viser en side.\n\n## Læs mere\n\n- [Fetch Standard: the CORS protocol](https://fetch.spec.whatwg.org/#http-cors-protocol)\n  — definitionen: request- og svarheaderne, preflighten, tabellen over\n  loginoplysninger og rådet om `Vary`.\n- [RFC 6454: The Web Origin Concept](https://www.rfc-editor.org/rfc/rfc6454) —\n  hvad en oprindelse er, hvordan skema, vært og port afgør den, og hvordan den\n  skrives i `Origin`-headeren.\n- [OWASP Web Security Testing Guide: Testing Cross Origin Resource Sharing](https://wstg.owasp.org/v4.2/4-Web_Application_Security_Testing/11-Client-side_Testing/07-Testing_Cross_Origin_Resource_Sharing/)\n  — hvordan testere leder efter en jokertegns-oprindelse eller en oprindelse,\n  der sendes tilbage uden kontrol.\n\n\u003chttps://engineer.company/da/glossary/cors/\u003e\n","date_modified":"2026-10-29T11:17:41Z","description":"Sådan afgør CORS, hvilke andre sites der må læse en servers svar, hvad en preflight spørger om, og de header-fejl, der lækker brugernes data.","formats":{"gemtext":"https://engineer.company/da/glossary/cors/index.gmi","gopher":"https://engineer.company/da/glossary/cors/gophermap","html":"https://engineer.company/da/glossary/cors/","json":"https://engineer.company/da/glossary/cors/index.json","markdown":"https://engineer.company/da/glossary/cors/index.md","pdf":"https://engineer.company/da/glossary/cors/index.pdf"},"kind":"page","language":"da","title":"Hvad er CORS?","url":"https://engineer.company/da/glossary/cors/","version":1}