{"canonical_url":"https://engineer.company/nb/glossary/cors/","content_markdown":"# CORS\n\n## Hva det er\n\nCORS, skrevet ut Cross-Origin Resource Sharing, er reglene en server bruker for å fortelle\nnettleseren at sider fra andre nettsteder får lese det den sender tilbake. Nettlesere holder opphav\n(_origins_) adskilt. Et opphav er skjema, vert og port til sammen, så `https://app.example.com`,\n`https://api.example.com` og `http://app.example.com` er tre forskjellige opphav, og et skript på\ndet ene får ikke lese et svar fra et annet uten at det andre går med på det. CORS er måten det går\nmed på det: en liten familie HTTP-headere, nesten alle med navn som begynner på `Access-Control-`,\nsom serveren legger på svarene sine, og som nettleseren sjekker før noe som helst slippes videre\ntil skriptet som spurte.\n\nProtokollen står i Fetch-standarden fra WHATWG, den levende spesifikasjonen av hvordan nettlesere\nhenter ressurser. Begrunnelsen står der også, og den er enkel. En side skal kunne bruke data fra et\nannet opphav og sende rikere forespørsler enn et HTML-skjema kan, men bare når motparten selv har\nsagt ja. Uten det ja-et kunne en hvilken som helst side på nettet lese servere som står bak en\nbedrifts brannmur, eller lese en brukers private data på et annet nettsted med brukerens\ninformasjonskapsler (_cookies_) på slep.\n\nSelve utvekslingen er kort. Når et skript ber om en ressurs fra et annet opphav, legger nettleseren\ntil en `Origin`-header med sidens eget opphav. Serveren svarer med `Access-Control-Allow-Origin`,\nog verdien er enten det samme opphavet, skrevet nøyaktig, eller `*` for alle. Stemmer den, får\nskriptet svaret. Stemmer den ikke, får skriptet en nettverksfeil og ingenting av innholdet.\n\nNoen forespørsler trenger lov før de i det hele tatt sendes. En `GET`, `HEAD` eller `POST` med noen\nfå vanlige headere og en kropp av typen `application/x-www-form-urlencoded`, `multipart/form-data`\neller `text/plain` går rett ut, for det har et HTML-skjema alltid kunnet sende fra et hvilket som\nhelst nettsted. Alt utover det, for eksempel en `PUT`, en `DELETE`, en JSON-kropp eller en\n`Authorization`-header, får en forhåndsforespørsel (_preflight_) foran seg: en `OPTIONS`-forespørsel\nsom navngir metoden i `Access-Control-Request-Method` og de ekstra headerne i\n`Access-Control-Request-Headers`. Den egentlige forespørselen følger bare når svaret har en\nvellykket status som 200 eller 204 og tillater begge deler.\n\n## Hvorfor det er viktig\n\nNesten alle nettapplikasjoner med et eget API møter CORS den første dagen. Frontenden serveres fra\nett opphav og API-et fra et annet, og det første `fetch`-kallet fra det ene til det andre feiler i\nnettleserens konsoll til API-et sender de riktige headerne. Team som blir kjent med CORS på den\nmåten, husker det gjerne som et hinder og konfigurerer det deretter, ved å tillate det som får\nfeilen til å forsvinne. Det er der risikoen ligger.\n\nHeaderne avgjør hvem som kan lese brukernes data gjennom deres egne nettlesere. En bruker som er\nlogget inn i applikasjonen din, har med seg en øktkapsel. Hvis API-et lar et hvilket som helst\nopphav sende forespørsler med informasjonskapsler og lese svarene, kan hver side brukeren besøker,\nkalle API-et i brukerens navn og lese resultatet. Fetch-standarden sier det rett ut: å dele svar som\ner hentet med brukerens påloggingsdata, krever den største forsiktighet for å unngå det den kaller\n_confused deputy_-problemet. Nettleseren, som bærer brukerens informasjonskapsler, er\nstedfortrederen som blir lurt, og et slurvete CORS-oppsett lar en fremmed side styre den.\n\nDet er like viktig å vite hva CORS ikke gjør. Det beskytter ikke serveren. En enkel forespørsel når\nfram til serveren og blir utført uansett om svaret senere får deles, så en `POST` som endrer data,\nhar endret dem før nettleseren har sett på en eneste CORS-header. Utenfor en nettleser er\n`Origin`-headeren det kalleren skriver inn, og testveiledningen fra OWASP advarer om at den kan\nforfalskes. Hvem som får kalle et endepunkt, og hva de får gjøre der, avgjøres av autentisering og\nautorisasjon på serveren, hver gang. CORS avgjør bare hvilke nettsider som får lese svaret inne i en\nnettleser.\n\n## Slik ser det ut i praksis\n\nTenk deg en enkeltsideapplikasjon på `https://app.example.com` som lagrer et notat gjennom et API\npå `https://api.example.com` og bruker øktkapselen API-et satte ved innlogging:\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: \"Lanser på fredag\" }),\n});\n```\n\nEn `PUT` med JSON-kropp er mer enn et skjema kan sende, så nettleseren spør først.\nForhåndsforespørselen har ingen informasjonskapsler med; den navngir bare det den egentlige\nforespørselen vil bruke:\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 opphavet opp mot 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\nNå sender nettleseren selve `PUT`-forespørselen med kapselen og en `Origin`-header, og svaret fra\nAPI-et gjentar `Access-Control-Allow-Origin` og `Access-Control-Allow-Credentials: true`. Mangler\nen av dem, er notatet lagret på serveren, men skriptet får aldri se svaret.\n`Access-Control-Max-Age` lar nettleseren gjenbruke svaret på forhåndsforespørselen i opptil 600\nsekunder i stedet for å spørre før hvert kall; uten headeren holder standarden på det i fem\nsekunder. `Vary: Origin` er med fordi svaret avhenger av hvem som spør, og en hurtigbuffer\n(_cache_) som overså det, kunne gi ett opphavs svar videre til et annet.\n\nPå en plattform med profesjonelle og organisatoriske data har API-et\n[hastighetsbegrensning, CORS, grenser for forespørselsstørrelse og inndatavalidering](/nb/portfolio/hardened-the-application-with-nonce-based-csp/)\nfør noe rører databasen.\nDen samme siden forklarer hvorfor CORS er ett punkt på den lista og ikke hele forsvaret: plattformen\ngår ut fra at klienten er fiendtlig, og serveren kontrollerer rettighetene på nytt ved hver\nforespørsel, uansett hva nettleseren har tillatt.\n\n## Hvor det går galt\n\n**Serveren kopierer en hvilken som helst `Origin` tilbake i `Access-Control-Allow-Origin`.** Det er\nden raskeste veien til å få feilen i konsollen til å forsvinne, og sammen med\n`Access-Control-Allow-Credentials: true` gir det hvert eneste nettsted på internett brukerens utsyn\ni API-et. Ha en eksplisitt liste over opphavene som skal ha tilgang, sammenlign den innkommende\n`Origin` nøyaktig med den, og send headerne bare ved treff.\n\n**Lista sjekkes med et prefiks eller en delstreng.** En regel som godtar ethvert opphav som begynner\nmed `https://app.example.com`, godtar også `https://app.example.com.attacker.example`, og et\ndelstrengtreff er verre. Sammenlign hele serialiserte opphav. Et serialisert opphav har verken sti\neller avsluttende skråstrek, så `https://app.example.com/` på lista kommer aldri til å treffe noe.\n\n**`*` forventes å virke sammen med informasjonskapsler.** Når en forespørsel har påloggingsdata med,\navviser nettleseren `*` i `Access-Control-Allow-Origin`, `Access-Control-Allow-Methods`,\n`Access-Control-Allow-Headers` og `Access-Control-Expose-Headers`, og\n`Access-Control-Allow-Credentials` må være nøyaktig `true`, med små bokstaver. Et offentlig API som\nbare leses og ikke bruker informasjonskapsler, kan trygt svare `*`; et API som hviler på en økt, må\nnavngi opphavet.\n\n**`null` står på lista over tillatte.** Sider som er lastet fra en `data:`-URL, får et\nugjennomsiktig opphav, og en forespørsel som er blitt omdirigert på tvers av opphav, melder også\n`Origin: null`, så mange helt ulike dokumenter viser den samme verdien. Å tillate `null` er å\ntillate alle sammen. La den være ute.\n\n**`Vary: Origin` mangler.** Sender API-et `Access-Control-Allow-Origin` bare når en forespørsel har\nen `Origin` som stemmer, kan en hurtigbuffer lagre et svar uten headeren og servere det for en\nsenere CORS-forespørsel, eller lagre ett opphavs svar og gi det til et annet. Fetch-standarden ber\nom `Vary: Origin` når svaret avhenger av opphavet. Er verdien `*` eller ett fast opphav, send den på\nhvert eneste svar og la `Vary` være.\n\n**`Access-Control-Allow-Headers: *` antas å dekke alt.** Jokertegnet dekker aldri `Authorization`,\nsom må navngis, og det dekker ingenting i det hele tatt for forespørsler med påloggingsdata. Navngi\nheaderne klienten faktisk sender.\n\n**CORS brukes som tilgangskontroll.** En server som avviser forespørsler fordi `Origin` ser feil ut,\nog ellers slipper dem inn, har skrevet en sjekk som ethvert skript utenfor en nettleser går rett\nforbi. Autentiser kalleren, autoriser handlingen på serveren, og la CORS gjøre sin ene jobb: å\navgjøre hva en nettleser viser en side.\n\n## Les mer\n\n- [Fetch Standard: the CORS protocol](https://fetch.spec.whatwg.org/#http-cors-protocol) —\n  definisjonen: forespørsels- og svarheaderne, forhåndsforespørselen, tabellen over påloggingsdata\n  og rådet om `Vary`.\n- [RFC 6454: The Web Origin Concept](https://www.rfc-editor.org/rfc/rfc6454) — hva et opphav er,\n  hvordan skjema, vert og port avgjør det, og hvordan det 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 ser etter et jokertegnopphav eller et opphav som sendes tilbake uten kontroll.\n\n\u003chttps://engineer.company/nb/glossary/cors/\u003e\n","date_modified":"2026-10-29T11:17:41Z","description":"Hvordan CORS avgjør hvilke andre nettsteder som får lese svarene fra en server, hva en preflight spør om, og headerfeilene som lekker data.","formats":{"gemtext":"https://engineer.company/nb/glossary/cors/index.gmi","gopher":"https://engineer.company/nb/glossary/cors/gophermap","html":"https://engineer.company/nb/glossary/cors/","json":"https://engineer.company/nb/glossary/cors/index.json","markdown":"https://engineer.company/nb/glossary/cors/index.md","pdf":"https://engineer.company/nb/glossary/cors/index.pdf"},"kind":"page","language":"nb","title":"Hva er CORS?","url":"https://engineer.company/nb/glossary/cors/","version":1}