
Det är den skillnaden du ska granska: vad API:t tog emot och vad webbläsaren lämnade vidare till anropande kod. Att felet försvinner ur konsolen är ett för svagt godkännandekriterium. Spara serverloggen bredvid utfallet från fetch().
Bestäm origin innan du ber om en fix
En origin består av schema, värdnamn och port. https://app.example.com och http://app.example.com är därför olika origins. CORS styr vilka svar webbläsaren låter en sida läsa från en annan origin; det ger inte användaren någon behörighet på servern. MDN beskriver mekanismen och preflight.
Skriv ner de webbklienter som faktiskt behöver läsa svaren. Lägg till utvecklingsmiljön som en separat post när den behövs, och låt inte en tillfällig localhost-post följa med till produktion av bekvämlighet. Be granskaren pröva varje post mot en känd användning.
I provet är http://127.0.0.1:18110 tillåten, http://127.0.0.1:18111 nekad och API:t ligger på port 18112. Portskillnaden räcker för att få två olika origins på samma dator.
Granska jämförelsen, inte bara headernamnet
Be AI:n visa raden där inkommande origin jämförs med listan. Här är den avgörande skillnaden mellan provets två policyer, med samma omslutning och namn:
// Före: varje origin som skickas med godtas, även strängen 'null'.
function originAllowed(origin) {
return Boolean(origin);
}
// Efter: bara den uttryckligen listade klienten godtas.
function originAllowed(origin) {
return new Set(['http://127.0.0.1:18110']).has(origin);
}
Provserverns strikta variant gör samma medlemskontroll innan den sätter Access-Control-Allow-Origin till inkommande origin. Den reflekterande varianten saknar kontrollen och speglar varje origin tillsammans med Access-Control-Allow-Credentials: true. Därför blev svaret läsbart även från den nekade porten, med credentials: 'include'. Inga cookies var satta i provet.
Testa också din tänkta produktionslista med snarlika strängar. I ett separat prov av strängjämförelsen godtog listan https://app.example.com men avvisade https://app.example.com.attacker.test, https://evilapp.example.com, annat schema, annan port och strängen null. Det är sex strängkontroller, inte sex webbläsarfall.
Ersätt inte medlemskontrollen med includes('example.com') eller ett ogenomtänkt suffixvillkor. Be AI:n förklara vilka av dina negativa testvärden villkoret skulle släppa igenom. Behöver du flera subdomäner listar du först vilka, och granskar sedan en uttrycklig policy för just dem.
Kör enkel begäran och preflight var för sig
En enkel begäran kan skickas utan preflight. En POST med Content-Type: application/json är ingen enkel begäran, så i vårt exempel skickade webbläsaren först OPTIONS med önskad metod och headers. Fetch-standarden definierar kontrollen.
Provsidan kör båda anropen från var och en av de två origins, mot samma API-adress och med en frågeparameter för spårbarhet:
// Enkel POST i provet:
await fetch('http://127.0.0.1:18112/strict?case=simple', {
method: 'POST',
headers: { 'Content-Type': 'text/plain' },
body: 'demo'
});
// POST med preflight i provet:
await fetch('http://127.0.0.1:18112/strict?case=json', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: '{"demo":true}'
});
Sidan kör också GET-anrop mot den strikta varianten, wildcard-varianten och den reflekterande varianten. Vi körde provet i headless Chrome 157.0.8103.78 med Node.js 24.13.0 i november 2026, två gånger med samma utfall i alla 12 webbläsarfall. Tabellen återger observationerna i loopbackmiljön, inte ett utlovat beteende i varje driftsmiljö.
| Origin och variant | Vad servern fick | Vad JavaScript kunde läsa |
|---|---|---|
| Tillåten, enkel POST, strikt lista | POST | JSON-svaret, HTTP 200 |
| Nekad, enkel POST, strikt lista | POST | Inget svar; fetch avvisades |
| Tillåten, JSON-POST, strikt lista | OPTIONS och POST | JSON-svaret, HTTP 200 |
| Nekad, JSON-POST, strikt lista | OPTIONS, ingen POST | Inget svar; fetch avvisades |
| Tillåten, GET med include, strikt lista | GET | JSON-svaret, HTTP 200 |
| Nekad, GET med include, strikt lista | GET | Inget svar; fetch avvisades |
| Båda, wildcard och omit | GET från respektive origin | JSON-svaret i båda fallen |
| Båda, wildcard och include | GET från respektive origin | Inget svar i båda fallen |
| Båda, okontrollerad reflektion och include | GET från respektive origin | JSON-svaret i båda fallen |
Ta med den nekade enkla POST-begäran i din granskning. Den visar att ett CORS-fel inte bevisar att servern slapp ta emot anropet. CORS ersätter inte serverns autentisering, objektbehörighet eller CSRF-skydd. Den granskningen gör du separat, med stöd av säkerhetsguiden och artikeln om objektnivåkontrollen som AI-koden hoppar över.
Lägg till credentials med en uttrycklig anledning
Med credentials: 'include' måste ett läsbart CORS-svar ange den konkreta tillåtna originen och Access-Control-Allow-Credentials: true. Wildcard räcker inte. Kravet gäller credentials-läget, även när anropet inte har några cookies att skicka, vilket wildcard-fallet i provet också visade. Se standardens tabell för credentials.
Beställ därför inte include slentrianmässigt. Ange vilken inloggningsmekanism klienten använder och vilka svar den behöver läsa. Prova sedan den verkliga inloggningen i målmiljön med ett testkonto; provservern här saknar inloggning.
Cookies har egna villkor. SameSite och webbläsarens regler för tredjepartscookies kan hindra att en cookie skickas, även när CORS-policyn tillåter läsning. SameSite=None kräver Secure. MDN:s Set-Cookie-referens beskriver attributen. Loopbackprovet säger därför inget om inloggning mellan olika webbplatser eller om dina produktionscookies faktiskt skickas.
Kontrollera cache och beställ ett tydligt facit
Sätter servern CORS-headrarna utifrån inkommande Origin säger standarden att Vary ska användas, alltså Vary: Origin. Läs standardens cacheavsnitt. Be AI:n lägga till Origin i ramverkets befintliga Vary-värden i stället för att skriva över dem. Vary styr cachevariation och är ingen behörighetskontroll, så cachning av personliga svar granskar du för sig.
Provservern skickar Cache-Control: no-store och provar därför inte en delad cache i ett CDN. Använder ditt API en sådan lägger du till ett driftprov: begär samma resurs från tillåten och nekad origin, i båda ordningarna, och kontrollera svarens faktiska headers.
Du kan använda följande beställning till assistenten: ”Tillåt bara den angivna originlistan. Visa medlemskontrollen. Redovisa enkel POST, JSON-POST och credentials från tillåten och nekad origin. För varje fall: spara vad servern fick och vad JavaScript kunde läsa. Beskriv vad provet inte täcker.”
Godkänn ändringen när koden och provmatrisen stämmer överens, och behåll de negativa fallen i testerna. Då har du ett facit nästa gång assistenten ändrar API-konfigurationen.
FAQ
Är CORS samma sak som autentisering?
Nej. CORS styr vilka svar webbläsaren låter en sida läsa från en annan origin. Servern behöver egna kontroller för autentisering och behörighet.
Stoppar ett CORS-fel begäran innan API:t nås?
Inte i alla fall. I vårt prov nådde en enkel POST servern från nekad origin, men JavaScript fick inte läsa svaret. Den nekade JSON-begäran stannade efter OPTIONS.
Kan jag använda wildcard med credentials include?
Inte för att göra svaret läsbart. Med credentials include krävs en konkret tillåten origin och Access-Control-Allow-Credentials med värdet true.
Bevisar provet att mina inloggningscookies fungerar?
Nej. Provet använder olika portar på loopback utan satta cookies. Cookieattribut och webbläsarens cookieregler behöver provas i den verkliga målmiljön.
Källor
- WHATWG Fetch: CORS-protokollet, credentials och HTTP-cache.
- MDN: Cross-Origin Resource Sharing.
- MDN: Set-Cookie.
- Eget lokalt prov i november 2026: provserver i Node.js och 12 webbläsarfall i headless Chrome. Miljö och begränsningar anges ovan.