{"canonical_url":"https://engineer.company/nb/glossary/csrf/","content_markdown":"# CSRF\n\n## Hva det er\n\nCSRF, kort for cross-site request forgery, er angrepet der en side offeret tilfeldigvis åpner, får\nofferets egen nettleser til å sende en forespørsel til et annet nettsted, et der offeret er logget\ninn. Nettleseren legger ved nettstedets informasjonskapsler slik den alltid gjør, så forespørselen\nkommer fram med offerets økt og ser ut som noe offeret selv valgte å gjøre. Common Weakness\nEnumeration fører det som CWE-352 og beskriver feilen fra serverens side: applikasjonen kontrollerer\nikke, eller kan ikke kontrollere, godt nok om en forespørsel bevisst ble sendt av den brukeren den\nser ut til å komme fra.\n\nOWASPs jukselapp om forebygging av CSRF (cheat sheet) lister opp hvor angrepet kan starte, fra et\nondsinnet nettsted til en e-post, et blogginnlegg, en direktemelding eller et program, og hva det\nkan oppnå: en pengeoverføring, et endret passord, et kjøp, tildelte privilegier. Hver av dem er en\nhandling på nettstedet, en endring av tilstand, og det er der jukselappen setter forsvaret: et token\npå hver forespørsel som endrer tilstand. CWE legger til at omfanget bare begrenses av offerets\nprivilegier, fordi angriperen låner offerets identitet. Rettet mot en administrator kan resultatet\nbli full kontroll over webapplikasjonen.\n\nCWE behandler CSRF som en sammensatt svakhet, en svakhet som bare finnes der flere andre møtes.\nBlant dem er en feil i validering av opprinnelse, CWE-346, og den utilsiktede proxyen eller\n«confused deputy», CWE-441: nettleseren har offerets påloggingsinformasjon og bruker den på vegne av\nen side som ikke har noen. Det skiller CSRF fra krysskripting, som CWE fører opp som en likestilt\nsvakhet. Ved XSS kjører angriperens kode inne i målnettstedet; ved CSRF blir den værende på\nangriperens side og sender bare forespørsler. Det skiller det også fra CORS, som styrer hva en side\nkan lese fra en annen opprinnelse. OWASP påpeker at et vanlig HTML-skjema sender en enkel\nforespørsel, en som ikke trenger noen forhåndsforespørsel (preflight), og at nettlesere tillater\nslike forespørsler til enhver opprinnelse. CWE staver selv termen Cross-Site Request Forgery i\ntittelen, og oppføringen nevner andre navn på det samme, blant dem XSRF og Session Riding.\n\n## Hvorfor det er viktig\n\nCSRF har holdt seg på begge de mest kjente listene over svakheter. CWE-352 var med på CWE Top 25 i\n2009, 2010 og 2011, og i hver utgave fra 2019 til 2025. OWASP ga det en egen kategori på Top 10 i\n2007 og 2010, som A5, og i 2013, som A8. Siden 2021 har det vært en del av A01, Broken Access\nControl, som står øverst i 2025-utgaven. OWASP melder at hver eneste av de testede applikasjonene\nhadde en eller annen form for brutt tilgangskontroll, og nevner CWE-352 blant de mest merkbare\nsvakhetene i kategorien.\n\nAngrepet er vanskelig å utrydde fordi det er nettleseren som gjør jobben. W3C-utkastet om Fetch\nMetadata tar utgangspunkt i nettopp det: nettlesere lar seg lett overtale til å sende forespørsler\ntil et nettsteds endepunkter og ta med påloggingsinformasjonen brukeren allerede har, for eksempel\ninformasjonskapsler eller en privilegert plass på et intranett, så applikasjoner må være svært nøye\nmed hvordan disse endepunktene oppfører seg, og det viser seg å være vanskelig. CWE påpeker at\nangrepet kan settes i gang fra så å si hvilken som helst tagg eller HTML-konstruksjon, også\nbildetagger og lenker. De observerte eksemplene i oppføringen leses som en liste over administrative\nhandlinger utført fra en annens side: brukerkontoer lagt til gjennom en URL i en `img`-tagg\n(CVE-2004-1703), administratorrettigheter skaffet på samme måte (CVE-2004-1842), og et\nwebgrensesnitt der en forfalsket forespørsel kunne endre passord eller stoppe en virtuell maskin\n(CVE-2009-3759).\n\nSkannere hjelper lite. CWE skriver at CSRF i dag er vanskelig å oppdage pålitelig med automatiske\nteknikker, fordi hver applikasjon har sin egen underforståtte policy for hvilke forespørsler en\nutenforstående kan utløse, og hvilke som krever sterk visshet om at brukeren mente dem. Et verktøy\nkan ikke vite at ett skjema er harmløst og det neste flytter penger. Det gjør CSRF til et\ndesignspørsmål: avgjør, forespørsel for forespørsel, hva som beviser at brukeren mente det.\n\nNettleserne har flyttet seg i forsvarerens favør. OWASPs jukselapp sier at dagens utbredte\nnettlesere som standard håndhever SameSite=Lax på informasjonskapsler, noe som holder dem unna de\nfleste `POST`-forespørsler på tvers av nettsteder, og at alle de store nettleserne har sendt Fetch\nMetadata-headerne siden mars 2023. Begge deler hjelper, og ingen av dem avgjør saken. Utkastet om\ninformasjonskapsler som definerer SameSite, kaller Lax et rimelig ekstra forsvarslag mot angrep som\nbygger på usikre metoder som `POST`, men ikke et robust forsvar mot CSRF som kategori, og råder til\nat ikke engang Strict-modus skal være hele forsvaret til et nettsted. Brukere av eldre eller\ninnebygde nettlesere, legger OWASP til, kan få informasjonskapsler som oppfører seg som om det ikke\nvar satt noen SameSite-verdi i det hele tatt.\n\n## Slik ser det ut i praksis\n\nTa en webapplikasjon på `app.example.com` der en innlogget bruker endrer e-postadressen på kontoen\nsin med et skjema som sendes med `POST` til `/account/email`. Øktens informasjonskapsel er satt med\n`SameSite=None; Secure`, fordi det samme dashbordet også er innebygd i en partners portal, og None\ner verdien som lar en nettleser sende en informasjonskapsel i en kontekst på tvers av nettsteder. En\nangriper publiserer en side på `prizes.example.net` og får offeret til å åpne den:\n\n```html\n\u003cform action=\"https://app.example.com/account/email\" method=\"post\"\u003e\n  \u003cinput type=\"hidden\" name=\"email\" value=\"mallory@example.net\"\u003e\n\u003c/form\u003e\n\u003cscript\u003edocument.forms[0].submit();\u003c/script\u003e\n```\n\nNettleseren sender skjemaet så snart siden er lastet, og siden informasjonskapselen tillater det,\nfølger økten med:\n\n```http\nPOST /account/email HTTP/1.1\nHost: app.example.com\nOrigin: https://prizes.example.net\nSec-Fetch-Site: cross-site\nContent-Type: application/x-www-form-urlencoded\nCookie: session=...\n\nemail=mallory%40example.net\n```\n\nFor serveren er dette en innlogget bruker som endrer adressen sin. Blir ingenting annet kontrollert,\nendres adressen, og en tilbakestilling av passordet som sendes til den nye adressen, gir kontoen til\nangriperen.\n\nTo av headerne i denne forespørselen tilhører nettleseren, ikke angriperen. Fetch-standarden regner\n`Origin` blant de forbudte forespørselsheaderne, sammen med alle headere der navnet begynner med\n`Sec-`, så et skript på siden kan verken sette eller endre dem. `Origin` oppgir opprinnelsen som\nsendte forespørselen, og Fetch Metadata-utkastet definerer fire verdier for `Sec-Fetch-Site`:\n`cross-site`, `same-site`, `same-origin` og `none` for en navigasjon brukeren selv startet ved å\nskrive inn en adresse eller velge et bokmerke. En kontroll kan lene seg på begge og likevel falle\ntilbake på et token for nettlesere som ikke sender noen av dem. En skisse i Python:\n\n```python\nimport hmac\nimport secrets\n\nSAFE_METHODS = {\"GET\", \"HEAD\", \"OPTIONS\", \"TRACE\"}\nOUR_ORIGIN = \"https://app.example.com\"\n\n\ndef new_csrf_token(session: dict) -\u003e str:\n    session[\"csrf_token\"] = secrets.token_urlsafe(32)\n    return session[\"csrf_token\"]\n\n\ndef csrf_ok(method: str, headers: dict, form: dict, session: dict) -\u003e bool:\n    if method in SAFE_METHODS:\n        return True\n    if headers.get(\"Sec-Fetch-Site\") == \"cross-site\":\n        return False\n    origin = headers.get(\"Origin\")\n    if origin is not None and origin != OUR_ORIGIN:\n        return False\n    expected = session.get(\"csrf_token\", \"\").encode()\n    sent = form.get(\"csrf_token\", \"\").encode()\n    return bool(expected) and hmac.compare_digest(sent, expected)\n```\n\nTokenet kommer fra `secrets.token_urlsafe(32)`. Python-dokumentasjonen sier at modulen `secrets`\nhenter fra den sikreste kilden til tilfeldighet operativsystemet tilbyr, og at 32 byte, altså 256\nbit, regnes som nok. Serveren legger tokenet i et skjult felt i hvert skjema den lager, og tar vare\npå en kopi i økten. Tokenet havner aldri i en informasjonskapsel, en URL eller en logg, som er\nstedene OWASPs jukselapp utelukker for et synkroniseringstoken (synchronizer token).\n`hmac.compare_digest` er laget for ikke å stoppe ved den første byten som er ulik, så tiden en\nsammenligning tar, avslører ingenting om hvor mye av en gjetning som var riktig. Begge sider kodes\ntil bytes først, fordi funksjonen bare tar imot tekststrenger når de er rene ASCII. En forespørsel\nuten `Origin`-header faller gjennom til tokenet, og `Origin: null` stoppes, siden bare den eksakte\nopprinnelsen slipper gjennom.\n\nI en ekte applikasjon bør du ta i bruk rammeverkets beskyttelse før du skriver din egen; det er det\nførste punktet på OWASPs liste. Mellomvaren i Django krever for eksempel både sin\nCSRF-informasjonskapsel og et `csrfmiddlewaretoken`-felt for alle metoder unntatt `GET`, `HEAD`,\n`OPTIONS` og `TRACE`, svarer med 403 når et av dem mangler eller er feil, og kontrollerer `Origin`\nmot verten og innstillingen `CSRF_TRUSTED_ORIGINS`. Der ingenting trenger å bygge inn applikasjonen,\nkan øktens informasjonskapsel også sendes som `__Host-session=...; Path=/; Secure; SameSite=Lax`.\nOWASP påpeker at en informasjonskapsel med prefikset `__Host-` ikke kan overskrives fra et annet\nunderdomene.\n\nInnstillingene i nettleseren er et lag, ikke selve forsvaret. Beskrivelsen vår av hvordan vi\n[herdet applikasjonen med nonce-basert CSP](/nb/portfolio/hardened-the-application-with-nonce-based-csp/)\nforteller at proxy-mellomvaren i frontenden setter HSTS og SameSite-cookies i tillegg til\nContent-Security-Policy, og at rettighetene kontrolleres på nytt på serveren ved hver forespørsel,\nmens sperrene i frontenden bare behandles som UX.\n\n## Hvor det går galt\n\n**Tilstandsendringer bak GET.** SameSite=Lax sender fortsatt informasjonskapselen ved en navigasjon\npå toppnivå på tvers av nettsteder med en sikker metode, så en lenke offeret klikker på, eller en\nside som sender hele vinduet til `https://app.example.com/account/delete?confirm=yes`, kommer fram\ninnlogget. OWASP kaller dette den vanligste måten forsvar basert på SameSite svikter på i praksis,\nog Django bygger beskyttelsen sin på samme premiss: `GET` og de andre sikre metodene skal ikke ha\nbivirkninger. Hold `GET`, `HEAD`, `OPTIONS` og `TRACE` fri for bivirkninger, og legg hver endring\nbak en metode kontrollene dine dekker.\n\n**SameSite som hele forsvaret.** Utkastet om informasjonskapsler forklarer hvorfor Lax ikke er nok\nalene: en angriper kan fortsatt åpne et nytt vindu eller utløse en navigasjon på toppnivå for å få\nen forespørsel til å telle som same-site, og forhåndsrendering (prerendering) kan gjøre det samme\nuten at brukeren merker det. OWASP legger til at SameSite gjelder det registrerbare domenet, ikke\nopprinnelsen. En forespørsel fra en hvilken som helst vert under example.com regnes som same-site\nfor `app.example.com`, så et glemt underdomene som noen tar over, er allerede innenfor gjerdet.\nBehandle SameSite som et ekstra lag, og avgjør på serveren med et token eller en kontroll av\nopprinnelsen.\n\n**Et token angriperen kan plante.** I det naive double-submit-mønsteret kontrollerer serveren bare\nat en informasjonskapsel og et skjemafelt har den samme tilfeldige verdien. OWASP fraråder nå det\nmønsteret, fordi alle som kan skrive informasjonskapsler på domenet, gjennom et sårbart underdomene\nved siden av, en DNS-overtakelse eller en informasjonskapsel injisert over vanlig HTTP, kan sette\nbegge halvdelene. CWE-oppføringen nevner fortsatt den enkle dobbelt innsendte informasjonskapselen\nblant tiltakene sine, så de to kildene er uenige her, og det er OWASPs advarsel man bør følge. Hold\ntokenet i økten på serversiden, eller bruk OWASPs signerte double-submit-informasjonskapsel, bundet\ntil økten med en HMAC.\n\n**Krysskripting på samme nettsted.** Et skript som kjører i dine egne sider, kan lese tokenet fra\nskjemaet og sende en forespørsel som er same-origin etter alle mål. OWASPs jukselapp sier det rett\nut: XSS kan sette alle teknikker mot CSRF ut av spill. CWE og Django sier det samme, og CWEs mest\nkjente eksempel viser de to i samspill. Samy-ormen brukte XSS til å plante seg selv i en\nMySpace-profil og legge til angriperen som venn, og venner som så på profilen, fikk sine egne\nprofiler endret på samme måte; siden ingen av ofrene valgte å gjøre den endringen, regner CWE CSRF\nsom en av de grunnleggende årsakene. Behandle hvert XSS-funn som et CSRF-funn også, og rett det\nførst.\n\n**En kontroll av opprinnelse som slipper gjennom for mye.** En test som\n`origin.startswith(\"https://app.example.com\")` godtar også\n`https://app.example.com.attacker.example`, fellen OWASPs jukselapp advarer mot. Verdien `null` er\nen annen. Etter Fetch-standarden kommer et skjema sendt fra en side med referrer-policyen\n`no-referrer` fram med `Origin: null`, og OWASP legger til at omdirigeringer på tvers av\nopprinnelser og rammer i sandkasse også kan gi den. Sammenlign hele opprinnelsen med en fast liste\nover eksakte strenger, og behandle en manglende header eller `null` som ukjent, aldri som din egen\nopprinnelse.\n\n**For stor tillit til forhåndsforespørselen.** En egendefinert forespørselsheader er et solid\nforsvar for et API, fordi nettlesere sender en forhåndsforespørsel (preflight) før enhver\nforespørsel på tvers av opprinnelser som har en slik header. Det holder bare hvis API-et avviser alt\nannet. OWASP advarer om at et JSON-API som også godtar `text/plain`, kan nås fra et skjema, siden\ndet er en av de tre innholdstypene en enkel forespørsel kan bruke, og at en CORS-policy som tillater\npåloggingsinformasjon fra alle underdomener gjennom et regulært uttrykk, lar alle som tar over et\nunderdomene, sende den egendefinerte headeren. Avvis innholdstyper endepunktet ikke forventer, og\nlist opp de eksakte opprinnelsene som får sende forespørsler med påloggingsinformasjon.\n\n**Det glemte innloggingsskjemaet.** Login-CSRF går motsatt vei: angriperen logger offeret inn på\nangriperens egen konto. På en nettbutikk, slik OWASPs eksempel lyder, legger offeret deretter inn\nkortopplysningene sine, og angriperen kan senere handle med dem. Django-dokumentasjonen nevner\nlogin-CSRF blant angrepene beskyttelsen dekker. Beskytt innloggingsskjemaet med et token knyttet til\nen forhåndsøkt (pre-session), og ødelegg den økten og start en ny når brukeren har logget inn, slik\nOWASP anbefaler.\n\n**Forespørsler bygd av angriperens input.** CSRF på klientsiden (client-side CSRF) oppstår når\napplikasjonens egen JavaScript bygger en forespørsel av input angriperen kontrollerer, for eksempel\nURL-en, vindusnavnet eller en `postMessage`. Skriptet legger selv ved tokenet, og forespørselen er\nsame-site, så verken tokener eller SameSite stopper den; OWASP beskriver det som at confused\ndeputy-problemet kommer tilbake. Hold mål og parametere for forespørsler utenfor rekkevidden til\ninput angriperen kontrollerer, eller velg dem fra en fast liste i koden.\n\n## Les mer\n\n- [CWE-352: Cross-Site Request Forgery (CSRF)](https://cwe.mitre.org/data/definitions/352.html)\n  — svakhetsoppføringen: den sammensatte strukturen, konsekvensene, tiltakene og de observerte\n  CVE-ene.\n- [OWASP Cheat Sheet Series: Cross-Site Request Forgery Prevention](https://cheatsheetseries.owasp.org/cheatsheets/Cross-Site_Request_Forgery_Prevention_Cheat_Sheet.html)\n  — tokener, Fetch Metadata, kontroll av opprinnelse, grensene for SameSite og login-CSRF.\n- [W3C: Fetch Metadata Request Headers](https://www.w3.org/TR/fetch-metadata/)\n  — headeren `Sec-Fetch-Site` og de fire verdiene en nettleser kan sende.\n- [IETF draft: Cookies: HTTP State Management Mechanism (draft-ietf-httpbis-rfc6265bis)](https://datatracker.ietf.org/doc/draft-ietf-httpbis-rfc6265bis/)\n  — attributtet SameSite og hvorfor Lax er et ekstra forsvarslag og ikke en kur; fortsatt et\n  Internet-Draft.\n- [Django documentation: Cross Site Request Forgery protection](https://docs.djangoproject.com/en/6.1/ref/csrf/)\n  — et rammeverks innebygde beskyttelse, hva den forutsetter, og hvor underdomener kommer rundt den.\n- [OWASP Top 10:2025: A01 Broken Access Control](https://owasp.org/Top10/2025/A01_2025-Broken_Access_Control/)\n  — hvor CWE-352 står i 2025-utgaven.\n\n\u003chttps://engineer.company/nb/glossary/csrf/\u003e\n","date_modified":"2026-10-29T11:17:41Z","description":"Slik vender cross-site request forgery en innlogget nettleser mot nettstedet som stoler på den, hvorfor SameSite ikke er nok, og hvilke kontroller som holder.","formats":{"gemtext":"https://engineer.company/nb/glossary/csrf/index.gmi","gopher":"https://engineer.company/nb/glossary/csrf/gophermap","html":"https://engineer.company/nb/glossary/csrf/","json":"https://engineer.company/nb/glossary/csrf/index.json","markdown":"https://engineer.company/nb/glossary/csrf/index.md","pdf":"https://engineer.company/nb/glossary/csrf/index.pdf"},"kind":"page","language":"nb","title":"Hva er CSRF?","url":"https://engineer.company/nb/glossary/csrf/","version":1}