SQL Truncation Attack

SQL-trunkeringsproblemet uppstår när en databas avkortar användarinmatningen på grund av en begränsning av längden. Angripare kan samla information om längden på ett kritiskt fält (t.ex. ett användarnamn) och utnyttja denna information för att få obehörig åtkomst. Angripare kan logga in som någon annan användare, som en admin, med sitt eget registrerade lösenord.

SQL-trunkeringsproblem finns vanligtvis i MySQL-databaser. Denna sårbarhet beskrivs först i CVE-2008-4106, som var relaterad till WordPress CMS.

Hur SQL-avkortningsattacker fungerar

Denna attack fungerar på grund av trunkering av användarinmatning i databaser med funktionerna "urval" och "infogning".

• När inmatning ges i formulärfältet kontrollerar "välj" -funktionen för redundans som motsvarar ingångar i databasen.
• Efter att ha kollat ​​på redundans kontrollerar funktionen 'insättning' längden på inmatningen och användarinmatningen trunkeras om längden överstiger.

Antag att en utvecklare skapar tabellen ”användare” via följande fråga:

skapa tabellanvändare (
user_id INT INTE NULL AUTO_INCREMENT,
användarnamn VARCHAR (20) INTE NULL,
lösenord VARCHAR (40) INTE NULL,
PRIMÄR NYCKEL (user_id)
);

Med hjälp av detta schema, om utvecklaren skapar ett administratörskonto med följande:

user_name = 'admin'
lösenord = “secret_p4ssw0ord”

Uppenbarligen är dessa uppgifter inte offentliga. Det finns bara ett administratörskonto i databasen, och om en angripare försöker registrera ett annat konto med användarnamnet "admin" kommer angriparen att misslyckas på grund av databasens redundanskontroller. Angriparen kan fortfarande kringgå den redundanskontrollen för att lägga till ett annat administratörskonto genom att utnyttja SQL Truncation-sårbarheten. Antag att angriparen registrerar ett annat konto med följande inmatning:

User_name = 'adminxxxxxxxxxxxxxxxrandom'
(x är mellanslag)
&
Lösenord = ”RandomUser”

Databasen tar "användarnamn" (26 tecken) och kontrollerar om det redan finns. Därefter trunkeras användarnamnsingången och 'admin' ('admin' med utrymme) matas in i databasen, vilket resulterar i två dubbla adminanvändare.

Angriparen kan sedan skapa en "admin" -användare med sitt eget lösenord. Nu har databasen två admin 'user_name' poster, men med olika lösenord. Angriparen kan logga in med de nyligen skapade referenserna för att få en adminpanel eftersom både användarnamn "admin" och "admin" är lika för databasnivån. Nu ska vi titta på ett praktiskt exempel.

Provattack

I det här exemplet tar vi ett scenario från webbplatsens overthewire.org. Overthewire-communityn tillhandahåller wargame-CTF: er där vi kan träna våra säkerhetskoncept. Scenariot för SQL-trunkering inträffar i natas-spel Nivå 26-> 27. Vi kan komma åt nivån med följande:

URL: http: // natas27.natas.laboratorier.övertråd.org
Användarnamn: natas27
Lösenord: 55TBjpPZUUJgVP5b3BnbG6ON9uDPVzCJ

Denna nivå finns på: https: // overthewire.org / wargames / natas / natas27.html. Du får en inloggningssida som är sårbar för en SQL-trunkeringsattack.

Vid inspektion av källkoden ser du att användarnamnets längd är 64, som visas nedan.

En användare med namnet 'natas28' finns redan. Vårt mål är att skapa en annan användare med namnet 'natas28' med SQL_truncation-attacken. Så vi kommer att mata in natas28, följt av 57 mellanslag och ett slumpmässigt alfabet (i vårt fall a), användarnamn och valfritt lösenord. Bokstaven 'a' syns inte på skärmdumpen på grund av användarnamnet på 65 tecken. Efter skapandet av användarkontot kan du se 'a.''

Om databasen innehåller sql_truncation-sårbarhet, ska databasen nu ha två 'natas28' användarnamn. Ett användarnamn innehåller vårt lösenord. Låt oss försöka mata in uppgifterna på inloggningssidan.

Nu är vi inloggade som 'natas28' användare.

Mitigation

För att mildra denna attack måste vi ta hänsyn till flera faktorer.

• Vi bör inte tillåta duplicering av kritiska identiteter som användarnamnet. Vi bör göra dessa identiteter till primära nycklar.
• Trunkeringsfunktionen bör implementeras för alla fält i frontend-formulär, såväl som backend-kod, så att databaser får trunkerade ingångar.
• Strikt läge ska vara aktiverat på databasnivå. Utan strikt läge aktiverat, varnar databaser bara varningar i backend, men sparar fortfarande duplicerade data. I strikt läge ger databaser fel i händelse av dubblering och undviker att spara data.

Låt oss till exempel kontrollera efter det strikta läget med följande fråga:

mysql> välj @@ sql_mode

Vi skapar en databas och tabellens användare.''

mysql> CREATE DATABASE test
Fråga OK, 1 rad påverkad (0.02 sek)
mysql> Använd test
Databasen har ändrats
mysql> CREATE TABLE användare (användarnamn VARCHAR (10), lösenord VARCHAR (10));
Fråga OK, 0 rader påverkade (0.05 sek)

Därefter skapar vi en adminanvändare med referenser med INSERT-frågan.

mysql> INSÄTTA I användare VÄRDERINGAR ('admin', 'password1');
Fråga OK, 1 rad påverkad (0.01 sek)

Vi kan se informationen om "användare" i tabellen med alternativet "välj * från användare".

Användarnamnets längd är 10 tecken. Nu kommer vi att prova SQL-trunkeringsattack.

När vi försöker skriva in följande:

Användarnamn = 'adminxxxxxa'
(x är mellanslag)
&
Lösenord = 'pass2'

Vi får ett fel, vilket innebär att strikt läge är helt effektivt.

mysql> INSERT INTO-värden för användare ('admin a', 'pass2')
FEL 1406 (22001): Data är för långa för kolumn 'användarnamn' i rad 1

Utan strikt läge aktiverat skickar databasen varningar, men infogar fortfarande data i tabellen.

Slutsats

Angripare kan få tillgång till konton med hög privilegium om sql_trunction-sårbarheten finns i din applikation. Angriparen kan enkelt få information om ett användarnamn och dess databaslängd med hjälp av de kritiska fälten och sedan skapa samma användarnamn, följt av mellanslag och slumpmässigt alfabet efter minsta längd, vilket resulterar i att flera konton med hög privilegium skapas. Denna sårbarhet är kritisk, men den kan undvikas om du vidtar vissa säkerhetsåtgärder, till exempel att aktivera strikt läge för användaringångar och göra det känsliga fältet till Primärnyckel i databasen.