{"canonical_url":"https://engineer.company/sv/glossary/sql-injection/","content_markdown":"# SQL-injektion\n\n## Vad det är\n\nSQL-injektion, på engelska SQL injection och ofta förkortat SQLi, är angreppet\ndär en applikation bygger ett SQL-kommando av text som någon annan har lämnat,\noch databasen till slut läser en del av texten som SQL i stället för som ett\nvärde. Common Weakness Enumeration för upp svagheten som CWE-89 och beskriver\nden som ett kommando som helt eller delvis byggs av indata utifrån, utan att de\ntecken som har särskild betydelse i SQL först har oskadliggjorts. OWASP:s\nfusklapp för förebyggande (cheat sheet) säger samma sak enklare: angreppet\nfungerar när data som inte går att lita på blir en del av syntaxen i en\ndatabasfråga.\n\nRoten till problemet är att SQL inte drar någon fast gräns mellan\ninstruktionerna i ett kommando och datan inuti det. Ett enkelt citattecken\navslutar en strängliteral, och allt som angriparen skriver efter det tolkas som\nmer SQL. Två bindestreck inleder en kommentar, vilket låter angriparen kasta\nbort resten av utvecklarens sats. Ett semikolon avslutar, där databasen och\ndrivrutinen tillåter det, en sats och inleder nästa. Inget av tecknen är\nexotiskt: samma tecken dyker upp i efternamn och fritext.\n\nOWASP:s Web Security Testing Guide delar in angreppen i tre klasser efter hur\nresultaten når angriparen. Angrepp i samma kanal (in-band) läser svaret genom\nsamma kanal som användes för att skicka det, oftast på applikationens egen sida.\nAngrepp utanför kanalen (out-of-band) får databasen att leverera resultaten\nnågon annanstans, till exempel över en separat HTTP-anslutning. Slutledande\neller blinda angrepp (inferential eller blind) får inga data alls, utan bygger\nupp dem en fråga i taget utifrån hur applikationen beter sig. Guiden nämner fem\nvanliga tekniker i de här klasserna: en `UNION`-operator som hänger på en andra\n`SELECT` efter den första, booleska villkor, fel som framkallas med flit, anrop\nutanför kanalen och avsiktliga fördröjningar.\n\nSQL-injektion hör till en större familj. I CWE står den under den allmänna\ninjektionssvagheten, CWE-74, tillsammans med cross-site scripting, och OWASP Top\nTen för 2025 placerar båda i kategorin A05 Injection. Den gemensamma nämnaren är\ndata som korsar en gräns och hamnar på ett ställe där den läses som\ninstruktioner. Här är tolken databasens SQL-parser, och botemedlet är att hålla\nvarje värde helt utanför SQL-texten.\n\n## Varför det spelar roll\n\nSkadan beror på vad applikationens databaskonto får göra, och det är ofta\nmycket. CWE-89 räknar upp att läsa data som angriparen aldrig skulle ha sett,\natt ta sig förbi autentiseringen utan att känna till ett lösenord, att ändra de\ndata som avgör vem som får göra vad, att ändra eller radera poster och, i vissa\nuppsättningar, att köra kommandon i operativsystemet. OWASP:s sida om angreppet\nlägger till administrativa åtgärder som att stänga av databasen, läsa innehåll\nfrån databasserverns disk och ta över databasservern som administratör.\n\nBåda källorna bedömer svagheten som allvarlig. CWE anger sannolikheten för\nutnyttjande som hög, och OWASP:s sida om angreppet beskriver felet som både lätt\natt hitta och lätt att utnyttja. Svagheten finns med i varje utgåva av CWE Top\n25 Most Dangerous Software Weaknesses från 2019 till 2025. CWE-posten nämner\nockså en våg 2008, då en och samma angreppssträng, som fungerade mot många olika\nprogram, komprometterade ett stort antal webbservrar och fick dem att sprida\nskadlig kod.\n\nFörsvaret är däremot välkänt och billigt. OWASP:s fusklapp gör förberedda satser\n(prepared statements) med bundna parametrar till det första försvaret, och CWE\nrekommenderar dem också: SQL-koden och värdena färdas var för sig, så databasen\nkan inte förväxla det ena med det andra. Allt annat, från minsta möjliga\nbehörighet till noggrann felhantering, är ett extra lager som begränsar skadan\nnär ett misstag slinker igenom.\n\n## Så ser det ut i praktiken\n\nTa en webbutik vars sida med orderhistorik slår upp beställningar efter den\ne-postadress som skrivs in i ett formulär. Utvecklaren bygger SQL-koden med en\nf-sträng i Python:\n\n```python\ncur.execute(f\"SELECT id, total FROM orders WHERE email = '{email}'\")\n```\n\nEn besökare skriver `x' OR '1'='1` i fältet. Programmet klistrar in det som det\när, och databasen tar emot det här:\n\n```sql\nSELECT id, total FROM orders WHERE email = 'x' OR '1'='1'\n```\n\nCitattecknet efter `x` stänger strängen som utvecklaren öppnade, och\n`OR`-villkoret efter det är alltid sant, så databasen returnerar varenda\nbeställning i tabellen. CWE-89 och testguiden använder samma alltid sanna trick,\nsom också kan få ett inloggningsformulär att släppa in en besökare som varken\nkänner till användarnamnet eller lösenordet.\n\nVärre indata avslutar satsen och inleder en ny. Exemplet i CWE-posten matar in\n`name'; DELETE FROM items; --` som artikelnamn, så att en andra sats följer på\nden första och bindestrecken gör resten till en kommentar. Om det körs beror på\ndatabasen och drivrutinen, och flera av dagens gränssnitt vägrar. PostgreSQL:s\n`PQexecParams` tar högst ett SQL-kommando per sträng, vilket dokumentationen\nräknar som ett visst skydd mot SQL-injektion. Python-modulen `sqlite3` ger ett\nfel så snart `execute()` får mer än en sats, och psycopg vägrar köra flera\nsatser i ett anrop när parametrar skickas med. Inget av det stoppar det alltid\nsanna villkoret ovan, som bara behöver en sats.\n\nLösningen är att skicka värdet separat. PEP 249, standarden för\ndatabasgränssnitt i Python, låter varje drivrutin ange sin platshållarstil i en\nmodulkonstant som heter `paramstyle`, och räknar upp fem stilar: `qmark` (`?`),\n`numeric` (`:1`), `named` (`:name`), `format` (`%s`) och `pyformat`\n(`%(name)s`). Modulen `sqlite3` är låst till `qmark` och godtar även `named`.\nPsycopg, drivrutinen för PostgreSQL, tar `%s` och `%(name)s`:\n\n```python\ncur.execute(\n    \"SELECT id, total FROM orders WHERE email = %s\",\n    (email,),\n)\n```\n\n`%s` ser ut som strängformatering i Python, men ingenting formateras: SQL-koden\noch tupeln med värden når drivrutinen som två separata argument. Psycopg 3\nhåller isär dem hela vägen och skickar kommandot och dess parametrar till\nservern var för sig, i stället för att foga ihop dem hos klienten. OWASP:s\nfusklapp visar poängen med sitt eget exempel på indata, `tom' or '1'='1`: bundet\nsom parameter är det ett märkligt användarnamn som slås upp bokstavligt, och det\nmatchar ingen.\n\nPostgreSQL erbjuder samma uppdelning i ren SQL. `PREPARE` låser satsen med\nnumrerade parametrar, och `EXECUTE` levererar värdena senare:\n\n```sql\nPREPARE order_lookup (text) AS\n    SELECT id, total FROM orders WHERE email = $1;\nEXECUTE order_lookup('x'' OR ''1''=''1');\n```\n\nDen fientliga indatan, här skriven som en SQL-literal, hamnar i `$1` som en enda\nunderlig e-postadress och hittar inga beställningar.\n\nPå en plattform med yrkes- och organisationsdata valideras indata innan något\nnår databasen, och sedan\n[ansluter API:et till databasen som en roll med minsta möjliga behörighet](/sv/portfolio/hardened-the-application-with-nonce-based-csp/),\nsom bara får anropa appens funktioner, och allt är parametriserat. Bindningen\nhindrar data från att bli SQL, och den smala rollen begränsar vad ett misstag\nkan nå.\n\n## Var det går fel\n\n**Strängen byggs ändå.** En f-sträng, `%`-operatorn, `+` eller `.format()` fogar\nin värdet i SQL-koden innan drivrutinen ser det, och det gör även en\nplatshållare som skrivs inom citattecken, som `'%s'`. OWASP påpekar att den som\nsätter ihop värden som inte går att lita på innan satsen förbereds, gör hela\nskyddet verkningslöst, och dokumentationen för psycopg säger att utvecklare\naldrig ska använda `%` eller `+` för att foga in värden i databasfrågor. Skicka\nvarje värde som det andra argumentet till `execute()`, med platshållaren utan\ncitattecken.\n\n**Tecken som maskeras för hand.** Att dubblera citattecken eller lägga till\nomvända snedstreck (escaping) ser likvärdigt ut, men reglerna beror på\nSQL-dialekten och dess inställningar. OWASP:s exempel är MySQL-läget\n`NO_BACKSLASH_ESCAPES`, som stänger av maskering med omvänt snedstreck, och\nfusklappen avråder starkt från sådan maskering. Ersätt strängar som maskerats\nför hand med bundna parametrar.\n\n**Validering eller en WAF som lösningen.** Validering fångar misstag, men\nfritext måste tillåta de tecken som en angripare behöver: exemplet i CWE-posten\när efternamnet O'Reilly, som sannolikt skulle klara valideringen och ändå\ninnehåller ett citattecken. Listor över farliga ord (denylists) har kryphål, och\nCWE bedömer effekten av en brandvägg för applikationer som bara måttlig. OWASP\nsäger det rakt ut: att ett värde är validerat gör det inte säkert att foga in i\nSQL. Fortsätt validera för korrekthetens skull, och bind för säkerhetens.\n\n**Tabellnamn, kolumnnamn eller sorteringsordning från indata.** Platshållare\nstår bara för värden, så en utvecklare som behöver låta en användare välja en\nkolumn eller riktningen för `ORDER BY` frestas att klistra in texten. OWASP:s\nsvar är att koppla varje val till en liten uppsättning namn som applikationen\nsjälv äger och avvisa allt annat, till exempel genom att göra om en begärd\nriktning till literalen `ASC` eller `DESC`. När ett namn verkligen måste vara\ndynamiskt kan modulen `psycopg.sql` sätta ihop identifierare, men OWASP påpekar\natt ett namn inom citattecken inte begränsar vilka tabeller applikationen kan\nstyras mot.\n\n**Lagrade procedurer som antas vara säkra.** Att anropa en procedur med bundna\nargument skyddar anropet, inte den SQL-kod som proceduren bygger inuti sig\nsjälv. CWE påpekar att lagrade procedurer förhindrar vissa typer av\nSQL-injektion men inte många andra. Använd statisk SQL inne i databasen, eller\nbind värdena även i dynamisk SQL; i PostgreSQL innebär det `EXECUTE ... USING`\nför värden och `format('%I', ...)` för identifierare.\n\n**En ORM med strängar insydda.** En objektrelationell mappare (object-relational\nmapper, ORM) binder värden när den används som det är tänkt, och CWE tillskriver\npersistenslager som Hibernate ett betydande skydd när de används rätt. OWASP\ntillägger att databasfrågor i Hibernate fortfarande kan angripas när utvecklare\nsätter ihop indata med frågetexten. Använd ORM:ens parametrar, inte strängbygge.\n\n**Ett applikationskonto med administratörsrättigheter.** Om kontot kan göra allt\nkan angriparen det också. OWASP vill se skrivskyddade konton där det bara behövs\nläsning, en egen databasanvändare för varje webbapplikation, vyer (views) som\nbara visar de kolumner ett konto behöver, och inga administratörsrättigheter för\napplikationskonton. När en applikation bara arbetar genom lagrade procedurer ska\nden få köra dem och ingenting annat. Minsta möjliga behörighet begränsar skadan,\nmen förhindrar inte själva injektionen.\n\n**Detaljerade databasfel som visas för användarna.** Ett felmeddelande som\navslöjar satsens struktur hjälper en angripare att skräddarsy nästa försök, och\nden felbaserade tekniken i testguiden bygger just på det. CWE rekommenderar\nminimala felmeddelanden. Visa användaren ett allmänt felmeddelande och behåll\ndetaljerna på servern för teamet.\n\n**Tillit till data som redan finns i databasen.** Ett värde som sparades säkert\nkan ändå bli farligt när en senare kodbit klistrar in det i SQL. OWASP säger att\ndess åtgärder gäller oavsett om data kommer från ett HTTP-anrop, en annan tjänst\neller sparades tidigare, och CWE varnar för att senare processer kan glömma att\nmaskera det som sparades. Bind värden som läses från dina egna tabeller precis\nsom du binder det en besökare skriver in.\n\n## Läs mer\n\n- [CWE-89 in the Common Weakness Enumeration](https://cwe.mitre.org/data/definitions/89.html)\n  — själva posten om svagheten: konsekvenser, exempel och åtgärderna med deras\n  begränsningar.\n- [OWASP SQL Injection Prevention Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/SQL_Injection_Prevention_Cheat_Sheet.html)\n  — parametriserade databasfrågor, lagrade procedurer, dynamiska identifierare\n  och minsta möjliga behörighet.\n- [OWASP Web Security Testing Guide: Testing for SQL Injection](https://wstg.owasp.org/v4.2/4-Web_Application_Security_Testing/07-Input_Validation_Testing/05-Testing_for_SQL_Injection/)\n  — angreppsklasserna och teknikerna så som en testare möter dem.\n- [PEP 249: Python Database API Specification v2.0](https://peps.python.org/pep-0249/)\n  — gränssnittet som Pythons drivrutiner delar, med de fem platshållarstilarna.\n- [Psycopg 3: Passing parameters to SQL queries](https://www.psycopg.org/psycopg3/docs/basic/params.html)\n  — reglerna för platshållare och rätt sätt att bygga dynamisk SQL.\n- [PostgreSQL: Command Execution Functions](https://www.postgresql.org/docs/current/libpq-exec.html)\n  — hur libpq skickar parametrar åtskilda från kommandosträngen.\n\n\u003chttps://engineer.company/sv/glossary/sql-injection/\u003e\n","date_modified":"2026-10-29T11:17:41Z","description":"Hur SQL-injektion låter inskriven text skriva om de kommandon en databas kör, vad en angripare vinner och varför bundna parametrar stoppar det.","formats":{"gemtext":"https://engineer.company/sv/glossary/sql-injection/index.gmi","gopher":"https://engineer.company/sv/glossary/sql-injection/gophermap","html":"https://engineer.company/sv/glossary/sql-injection/","json":"https://engineer.company/sv/glossary/sql-injection/index.json","markdown":"https://engineer.company/sv/glossary/sql-injection/index.md","pdf":"https://engineer.company/sv/glossary/sql-injection/index.pdf"},"kind":"page","language":"sv","title":"Vad är SQL-injektion?","url":"https://engineer.company/sv/glossary/sql-injection/","version":1}