{"canonical_url":"https://engineer.company/sv/glossary/cors/","content_markdown":"# CORS\n\n## Vad det är\n\nCORS, utskrivet Cross-Origin Resource Sharing, är de regler som en server\nanvänder för att tala om för webbläsaren att sidor från andra webbplatser får\nläsa det den skickar tillbaka. Webbläsare håller isär ursprung. Ett ursprung är\nschema, värd och port tillsammans, så `https://app.example.com`,\n`https://api.example.com` och `http://app.example.com` är tre olika ursprung,\noch ett skript på det ena får inte läsa ett svar från ett annat om inte det\nandra går med på det. CORS är sättet att gå med på det: en liten familj\nHTTP-headrar, nästan alla med namn som börjar på `Access-Control-`, som servern\nsätter på sina svar och som webbläsaren kontrollerar innan något alls lämnas\nvidare till skriptet som frågade.\n\nProtokollet beskrivs i Fetch-standarden från WHATWG, den levande\nspecifikationen av hur webbläsare hämtar resurser. Där står också skälet, och\ndet är enkelt. En sida ska kunna använda data från ett annat ursprung och\nskicka rikare anrop än ett HTML-formulär klarar, men bara när motparten själv\nhar sagt ja. Utan det jaet skulle vilken sida som helst på nätet kunna läsa\nservrar som står bakom ett företags brandvägg, eller läsa en användares privata\ndata på en annan webbplats med användarens kakor på köpet.\n\nSjälva utbytet är kort. När ett skript ber om en resurs från ett annat ursprung\nlägger webbläsaren till en `Origin`-header med sidans eget ursprung. Servern\nsvarar med `Access-Control-Allow-Origin`, och värdet är antingen samma\nursprung, exakt skrivet, eller `*` för alla. Stämmer det får skriptet svaret.\nStämmer det inte får skriptet ett nätverksfel och ingenting av innehållet.\n\nVissa anrop behöver lov innan de ens skickas. En `GET`, `HEAD` eller `POST`\nmed några få vanliga headrar och en kropp av typen\n`application/x-www-form-urlencoded`, `multipart/form-data` eller `text/plain`\ngår direkt iväg, eftersom ett HTML-formulär alltid har kunnat skicka sådant\nfrån vilken webbplats som helst. Allt utöver det, till exempel en `PUT`, en\n`DELETE`, en JSON-kropp eller en `Authorization`-header, föregås av ett\nförhandsanrop, som alla kallar preflight: ett `OPTIONS`-anrop som namnger\nmetoden i `Access-Control-Request-Method` och de extra headrarna i\n`Access-Control-Request-Headers`. Det riktiga anropet följer bara om svaret har\nen lyckad status som 200 eller 204 och tillåter båda delarna.\n\n## Varför det spelar roll\n\nNästan varje webbapplikation med ett separat API stöter på CORS första dagen.\nFrontenden serveras från ett ursprung och API:et från ett annat, och det första\n`fetch`-anropet från det ena till det andra misslyckas i webbläsarens konsol\ntills API:et skickar rätt headrar. Team som lär känna CORS på det sättet minns\ndet gärna som ett hinder och konfigurerar det därefter, genom att tillåta det\nsom får felet att försvinna. Det är där risken finns.\n\nHeadrarna avgör vem som kan läsa dina användares data genom deras egna\nwebbläsare. En användare som är inloggad i din applikation bär på en\nsessionskaka. Om API:et låter vilket ursprung som helst skicka anrop med kakor\noch läsa svaren kan varje sida som användaren besöker anropa API:et i\nanvändarens namn och läsa resultatet. Fetch-standarden säger det rakt ut: att\ndela svar som hämtats med användarens inloggningsuppgifter kräver största\nförsiktighet för att undvika det den kallar confused deputy-problemet.\nWebbläsaren, som bär användarens kakor, är ställföreträdaren som blir lurad,\noch en slarvig CORS-inställning låter en främmande sida styra den.\n\nDet är lika viktigt att veta vad CORS inte gör. Det skyddar inte servern. Ett\nenkelt anrop når fram till servern och körs oavsett om svaret sedan får delas,\nså en `POST` som ändrar data har ändrat dem innan webbläsaren har tittat på en\nenda CORS-header. Utanför en webbläsare innehåller `Origin`-headern vad\nanroparen än skriver, och OWASP:s testguide varnar för att den kan förfalskas.\nVem som får anropa en slutpunkt, och vad de får göra där, avgörs av\nautentisering och auktorisering på servern, varje gång. CORS avgör bara vilka\nwebbsidor som får läsa svaret inne i en webbläsare.\n\n## Så ser det ut i praktiken\n\nTänk dig en ensidesapplikation på `https://app.example.com` som sparar en\nanteckning via ett API på `https://api.example.com` och använder den\nsessionskaka som API:et satte vid inloggningen:\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: \"Släpp på fredag\" }),\n});\n```\n\nEn `PUT` med en JSON-kropp är mer än ett formulär kan skicka, så webbläsaren\nfrågar först. Förhandsanropet har inga kakor med sig; det namnger bara vad det\nriktiga anropet kommer att använda:\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 jämför ursprunget med sin egen lista och svarar:\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 skickar webbläsaren själva `PUT`-anropet med kakan och en `Origin`-header,\noch API:ets svar upprepar `Access-Control-Allow-Origin` och\n`Access-Control-Allow-Credentials: true`. Saknas någon av dem är anteckningen\nsparad på servern, men skriptet får aldrig se svaret. `Access-Control-Max-Age`\nlåter webbläsaren återanvända svaret på förhandsanropet i upp till 600 sekunder\ni stället för att fråga före varje anrop; utan headern behåller standarden det\ni fem sekunder. `Vary: Origin` är med eftersom svaret beror på vem som frågar,\noch en cache som bortsåg från det skulle kunna lämna ett ursprungs svar vidare\ntill ett annat.\n\nPå en plattform med professionella och organisatoriska data har API:et\n[hastighetsbegränsning, CORS, storleksgränser för anrop och validering av indata](/sv/portfolio/hardened-the-application-with-nonce-based-csp/)\ninnan något når databasen.\nSamma sida förklarar varför CORS är en punkt på den listan och inte hela\nförsvaret: plattformen utgår från att klienten är fientlig, och servern\nkontrollerar behörigheterna på nytt vid varje anrop, oavsett vad webbläsaren\nhar tillåtit.\n\n## Var det går fel\n\n**Servern kopierar vilken `Origin` som helst tillbaka till\n`Access-Control-Allow-Origin`.** Det är den snabbaste vägen till att få felet i\nkonsolen att försvinna, och tillsammans med\n`Access-Control-Allow-Credentials: true` ger det varenda webbplats på internet\nanvändarens vy av API:et. Ha en uttrycklig lista över de ursprung som ska ha\nåtkomst, jämför inkommande `Origin` exakt med den och skicka headrarna bara vid\nträff.\n\n**Listan kontrolleras med ett prefix eller en delsträng.** En regel som godtar\nvarje ursprung som börjar med `https://app.example.com` godtar också\n`https://app.example.com.attacker.example`, och en delsträngsmatchning är ännu\nsämre. Jämför hela serialiserade ursprung. Ett serialiserat ursprung har varken\nsökväg eller avslutande snedstreck, så `https://app.example.com/` på listan\nkommer aldrig att matcha någonting.\n\n**`*` förväntas fungera tillsammans med kakor.** När ett anrop har\ninloggningsuppgifter med sig avvisar webbläsaren `*` i\n`Access-Control-Allow-Origin`, `Access-Control-Allow-Methods`,\n`Access-Control-Allow-Headers` och `Access-Control-Expose-Headers`, och\n`Access-Control-Allow-Credentials` måste vara exakt `true`, med små bokstäver.\nEtt publikt API som bara läses och inte använder kakor kan tryggt svara `*`;\nett API som vilar på en session måste namnge ursprunget.\n\n**`null` står på listan över tillåtna.** Sidor som laddats från en\n`data:`-URL får ett ogenomskinligt ursprung, och ett anrop som har\nomdirigerats mellan ursprung rapporterar också `Origin: null`, så många helt\nolika dokument visar samma värde. Att tillåta `null` är att tillåta alla. Låt\ndet vara ute.\n\n**`Vary: Origin` saknas.** Skickar API:et `Access-Control-Allow-Origin` bara\nnär ett anrop har en `Origin` som stämmer kan en cache spara ett svar utan\nheadern och servera det för ett senare CORS-anrop, eller spara ett ursprungs\nsvar och ge det till ett annat. Fetch-standarden ber om `Vary: Origin` när\nsvaret beror på ursprunget. Är värdet `*` eller ett fast ursprung, skicka det i\nvarje svar och låt bli `Vary`.\n\n**`Access-Control-Allow-Headers: *` antas täcka allt.** Jokertecknet täcker\naldrig `Authorization`, som måste namnges, och det täcker ingenting alls för\nanrop med inloggningsuppgifter. Namnge de headrar som klienten faktiskt\nskickar.\n\n**CORS används som åtkomstkontroll.** En server som avvisar anrop för att\n`Origin` ser fel ut, och annars släpper in dem, har skrivit en kontroll som\nvarje skript utanför en webbläsare går rakt förbi. Autentisera anroparen,\nauktorisera handlingen på servern och låt CORS sköta sitt enda jobb: att avgöra\nvad en webbläsare visar för en sida.\n\n## Läs mer\n\n- [Fetch Standard: the CORS protocol](https://fetch.spec.whatwg.org/#http-cors-protocol)\n  — definitionen: anrops- och svarsheadrarna, förhandsanropet, tabellen över\n  inloggningsuppgifter och rådet om `Vary`.\n- [RFC 6454: The Web Origin Concept](https://www.rfc-editor.org/rfc/rfc6454) —\n  vad ett ursprung är, hur schema, värd och port avgör det och hur det skrivs i\n  `Origin`-headern.\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  — hur testare letar efter ett jokerteckensursprung eller ett ursprung som\n  skickas tillbaka utan kontroll.\n\n\u003chttps://engineer.company/sv/glossary/cors/\u003e\n","date_modified":"2026-10-29T11:17:41Z","description":"Hur CORS avgör vilka andra webbplatser som får läsa en servers svar, vad en preflight frågar efter och de headerfel som läcker användarnas data.","formats":{"gemtext":"https://engineer.company/sv/glossary/cors/index.gmi","gopher":"https://engineer.company/sv/glossary/cors/gophermap","html":"https://engineer.company/sv/glossary/cors/","json":"https://engineer.company/sv/glossary/cors/index.json","markdown":"https://engineer.company/sv/glossary/cors/index.md","pdf":"https://engineer.company/sv/glossary/cors/index.pdf"},"kind":"page","language":"sv","title":"Vad är CORS?","url":"https://engineer.company/sv/glossary/cors/","version":1}