<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong><ahref="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* 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).
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`.
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.
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.
`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:
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()`:
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`.
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:
Podemos agora visitar a URL do exploit: `http://localhost:8000/_fragment?_path=_controller%3Dsystem%26command%3Did%26return_value%3Dnull&_hash=GFhQ4Hr1LIA8mO1M%2FqSfwQaSM8xQj35vPhyrF3hvQyI%3D`.
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.
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()`.
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.
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`.
[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.
Como no esqueleto do Symfony, você será solicitado a inserir um segredo durante a instalação. O valor padrão é `ThisEzPlatformTokenIsNotSoSecret_PleaseChangeIt`.
[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:
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.
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`.
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.
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:
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).
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()`.
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.
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).
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.
* 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.
* 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.
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`.
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:
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)!
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.
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).
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.
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong><ahref="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* 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).
