maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/pentesting-web/hacking-with-cookies/README.md'] to hi

Browse Source
This commit is contained in:
Translator 2025-05-18 03:05:19 +00:00
parent 1b1525b93c
commit b59a11f388
2 changed files with 180 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

102
src/pentesting-web/hacking-with-cookies/README.md
View File

@ -4,23 +4,23 @@
## Cookie Attributes ## Cookie Attributes
कुकीज़ कई विशेषताओं के साथ आती हैं जो उपयोगकर्ता के ब्राउज़र में उनके व्यवहार को नियंत्रित करती हैं। यहाँ इन विशेषताओं का एक संक्षिप्त विवरण दिया गया है: कुकीज़ कई विशेषताओं के साथ आती हैं जो उपयोगकर्ता के ब्राउज़र में उनके व्यवहार को नियंत्रित करती हैं। यहाँ इन विशेषताओं का एक संक्षिप्त विवरण है:
### Expires and Max-Age ### Expires and Max-Age
कुकी की समाप्ति तिथि `Expires` विशेषता द्वारा निर्धारित की जाती है। इसके विपरीत, `Max-age` विशेषता उस समय को सेकंड में परिभाषित करती है जब तक एक कुकी को हटाया नहीं जाता। **`Max-age` का चयन करें क्योंकि यह अधिक आधुनिक प्रथाओं को दर्शाता है।** कुकी की समाप्ति तिथि `Expires` विशेषता द्वारा निर्धारित की जाती है। इसके विपरीत, `Max-age` विशेषता उस समय को सेकंड में परिभाषित करती है जब तक एक कुकी को हटा नहीं दिया जाता। **`Max-age` का चयन करें क्योंकि यह अधिक आधुनिक प्रथाओं को दर्शाता है।**
### Domain ### Domain
कुकी प्राप्त करने वाले होस्ट `Domain` विशेषता द्वारा निर्दिष्ट किए जाते हैं। डिफ़ॉल्ट रूप से, यह उस होस्ट पर सेट होता है जिसने कुकी जारी की, इसके उपडोमेन को शामिल नहीं करता। हालाँकि, जब `Domain` विशेषता स्पष्ट रूप से सेट की जाती है, तो यह उपडोमेन को भी शामिल करती है। यह `Domain` विशेषता के निर्दिष्ट करने को एक कम प्रतिबंधात्मक विकल्प बनाता है, जो उन परिदृश्यों के लिए उपयोगी है जहाँ उपडोमेन के बीच कुकी साझा करना आवश्यक है। उदाहरण के लिए, `Domain=mozilla.org` सेट करने से इसकी उपडोमेन जैसे `developer.mozilla.org` पर कुकीज़ सुलभ हो जाती हैं। कुकी प्राप्त करने वाले होस्ट `Domain` विशेषता द्वारा निर्दिष्ट किए जाते हैं। डिफ़ॉल्ट रूप से, यह उस होस्ट पर सेट होता है जिसने कुकी जारी की, इसके उपडोमेन को शामिल नहीं करता। हालाँकि, जब `Domain` विशेषता को स्पष्ट रूप से सेट किया जाता है, तो यह उपडोमेन को भी शामिल करता है। यह `Domain` विशेषता के निर्दिष्ट करने को एक कम प्रतिबंधात्मक विकल्प बनाता है, जो उन परिदृश्यों के लिए उपयोगी है जहाँ उपडोमेन के बीच कुकी साझा करना आवश्यक है। उदाहरण के लिए, `Domain=mozilla.org` सेट करने से इसकी उपडोमेन जैसे `developer.mozilla.org` पर कुकीज़ सुलभ हो जाती हैं।
### Path ### Path
एक विशिष्ट URL पथ जो अनुरोधित URL में होना चाहिए ताकि `Cookie` हेडर भेजा जा सके, `Path` विशेषता द्वारा इंगित किया जाता है। यह विशेषता `/` वर्ण को एक निर्देशिका विभाजक के रूप में मानती है, जिससे उपनिर्देशिकाओं में मेल खाने की अनुमति मिलती है। `Path` विशेषता द्वारा निर्दिष्ट किया गया एक विशिष्ट URL पथ है जो अनुरोधित URL में होना चाहिए ताकि `Cookie` हेडर भेजा जा सके। यह विशेषता `/` वर्ण को एक निर्देशिका विभाजक के रूप में मानती है, जिससे उपनिर्देशिकाओं में मेल खाने की अनुमति मिलती है।
### Ordering Rules ### Ordering Rules
जब दो कुकीज़ का नाम समान होता है, तो भेजने के लिए चुनी गई कुकी इस आधार पर होती है: जब दो कुकीज़ का नाम समान होता है, तो भेजने के लिए चुनी गई कुकी इस पर आधारित होती है:
- अनुरोधित URL में सबसे लंबे पथ से मेल खाने वाली कुकी। - अनुरोधित URL में सबसे लंबे पथ से मेल खाने वाली कुकी।
- यदि पथ समान हैं, तो सबसे हाल में सेट की गई कुकी। - यदि पथ समान हैं, तो सबसे हाल में सेट की गई कुकी।
@ -28,9 +28,9 @@
### SameSite ### SameSite
- `SameSite` विशेषता यह निर्धारित करती है कि क्या कुकीज़ तीसरे पक्ष के डोमेन से उत्पन्न अनुरोधों पर भेजी जाती हैं। यह तीन सेटिंग्स प्रदान करती है: - `SameSite` विशेषता यह निर्धारित करती है कि क्या कुकीज़ तीसरे पक्ष के डोमेन से उत्पन्न अनुरोधों पर भेजी जाती हैं। यह तीन सेटिंग्स प्रदान करती है:
- **Strict**: तीसरे पक्ष के अनुरोधों पर कुकी को भेजने से रोकता है। - **Strict**: तीसरे पक्ष के अनुरोधों पर कुकी भेजने से रोकता है।
- **Lax**: तीसरे पक्ष की वेबसाइटों द्वारा आरंभ किए गए GET अनुरोधों के साथ कुकी को भेजने की अनुमति देता है। - **Lax**: तीसरे पक्ष की वेबसाइटों द्वारा शुरू किए गए GET अनुरोधों के साथ कुकी भेजने की अनुमति देता है।
- **None**: किसी भी तीसरे पक्ष के डोमेन से कुकी को भेजने की अनुमति देता है। - **None**: किसी भी तीसरे पक्ष के डोमेन से कुकी भेजने की अनुमति देता है।
याद रखें, कुकीज़ को कॉन्फ़िगर करते समय, इन विशेषताओं को समझना यह सुनिश्चित करने में मदद कर सकता है कि वे विभिन्न परिदृश्यों में अपेक्षित रूप से व्यवहार करें। याद रखें, कुकीज़ को कॉन्फ़िगर करते समय, इन विशेषताओं को समझना यह सुनिश्चित करने में मदद कर सकता है कि वे विभिन्न परिदृश्यों में अपेक्षित रूप से व्यवहार करें।
@ -48,7 +48,7 @@ Table from [Invicti](https://www.netsparker.com/blog/web-security/same-site-cook
एक कुकी जिसमें _**SameSite**_ विशेषता होगी **CSRF हमलों को कम करेगी** जहाँ एक लॉग इन सत्र की आवश्यकता होती है। एक कुकी जिसमें _**SameSite**_ विशेषता होगी **CSRF हमलों को कम करेगी** जहाँ एक लॉग इन सत्र की आवश्यकता होती है।
**\*ध्यान दें कि Chrome80 (फरवरी/2019) से बिना कुकी सैमसाइट** **विशेषता वाली कुकी का डिफ़ॉल्ट व्यवहार लक्स होगा** ([https://www.troyhunt.com/promiscuous-cookies-and-their-impending-death-via-the-samesite-policy/](https://www.troyhunt.com/promiscuous-cookies-and-their-impending-death-via-the-samesite-policy/)).\ **\*ध्यान दें कि Chrome80 (फरवरी/2019) से बिना कुकी सैमसाइट** **विशेषता वाली कुकी का डिफ़ॉल्ट व्यवहार लक्स होगा** ([https://www.troyhunt.com/promiscuous-cookies-and-their-impending-death-via-the-samesite-policy/](https://www.troyhunt.com/promiscuous-cookies-and-their-impending-death-via-the-samesite-policy/)).\
ध्यान दें कि अस्थायी रूप से, इस परिवर्तन को लागू करने के बाद, **Chrome में बिना SameSite** **नीति वाली कुकीज़ को **पहले 2 मिनट के लिए None** के रूप में **व्यवहार किया जाएगा और फिर शीर्ष स्तर के क्रॉस-साइट POST अनुरोध के लिए Lax के रूप में।** ध्यान दें कि अस्थायी रूप से, इस परिवर्तन को लागू करने के बाद, Chrome में **बिना SameSite** **नीति वाली कुकीज़ को **पहले 2 मिनट के लिए None** के रूप में **व्यवहार किया जाएगा और फिर शीर्ष स्तर के क्रॉस-साइट POST अनुरोध के लिए Lax के रूप में।**
## Cookies Flags ## Cookies Flags
@ -58,11 +58,11 @@ Table from [Invicti](https://www.netsparker.com/blog/web-security/same-site-cook
#### **Bypasses** #### **Bypasses**
- यदि पृष्ठ **अनुरोधों के उत्तर के रूप में कुकीज़ भेज रहा है** (उदाहरण के लिए एक **PHPinfo** पृष्ठ में), तो XSS का दुरुपयोग करके इस पृष्ठ पर अनुरोध भेजना और **उत्तर से कुकीज़ चुराना** संभव है (एक उदाहरण देखें [https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/](https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/)). - यदि पृष्ठ **अनुरोधों के उत्तर के रूप में कुकीज़ भेज रहा है** (उदाहरण के लिए एक **PHPinfo** पृष्ठ में), तो XSS का दुरुपयोग करके इस पृष्ठ पर अनुरोध भेजना और **उत्तर से कुकीज़ चुराना** संभव है (एक उदाहरण देखें [https://blog.hackcommander.com/posts/2022/11/12/bypass-httponly-via-php-info-page/](https://blog.hackcommander.com/posts/2022/11/12/bypass-httponly-via-php-info-page/)).
- इसे **TRACE** **HTTP** अनुरोधों के साथ बायपास किया जा सकता है क्योंकि सर्वर से उत्तर कुकीज़ को दर्शाएगा। इस तकनीक को **Cross-Site Tracking** कहा जाता है। - इसे **TRACE** **HTTP** अनुरोधों के साथ बायपास किया जा सकता है क्योंकि सर्वर से उत्तर में भेजी गई कुकीज़ को दर्शाया जाएगा (यदि यह HTTP विधि उपलब्ध है)। इस तकनीक को **Cross-Site Tracking** कहा जाता है।
- आधुनिक ब्राउज़रों द्वारा **JS से TRACE** अनुरोध भेजने की अनुमति न देकर इस तकनीक को टाला जाता है। हालाँकि, IE6.0 SP2 के लिए `TRACE` के बजाय `\r\nTRACE` भेजने जैसे कुछ बायपास पाए गए हैं। - इस तकनीक को **आधुनिक ब्राउज़रों द्वारा JS से TRACE** अनुरोध भेजने की अनुमति न देकर टाला जाता है। हालाँकि, IE6.0 SP2 में `TRACE` के बजाय `\r\nTRACE` भेजने जैसे कुछ बायपास पाए गए हैं।
- एक और तरीका ब्राउज़रों की शून्य/दिन की कमजोरियों का शोषण करना है। - एक और तरीका ब्राउज़रों की शून्य/दिन की कमजोरियों का शोषण करना है।
- एक कुकी जार ओवरफ्लो हमले को अंजाम देकर **HttpOnly कुकीज़ को ओवरराइट करना** संभव है: - यह एक कुकी जार ओवरफ्लो हमले को अंजाम देकर **HttpOnly कुकीज़ को ओवरराइट** करना संभव है:
{{#ref}} {{#ref}}
cookie-jar-overflow.md cookie-jar-overflow.md
@ -76,24 +76,24 @@ cookie-jar-overflow.md
## Cookies Prefixes ## Cookies Prefixes
`__Secure-` से प्रारंभ होने वाली कुकीज़ को HTTPS द्वारा सुरक्षित पृष्ठों के साथ `secure` ध्वज के साथ सेट किया जाना आवश्यक है। `__Secure-` से प्रारंभ होने वाली कुकीज़ को HTTPS द्वारा सुरक्षित पृष्ठों से `secure` ध्वज के साथ सेट किया जाना आवश्यक है।
`__Host-` से प्रारंभ होने वाली कुकीज़ के लिए, कई शर्तें पूरी की जानी चाहिए: `__Host-` से प्रारंभ होने वाली कुकीज़ के लिए, कई शर्तें पूरी की जानी चाहिए:
- इन्हें `secure` ध्वज के साथ सेट किया जाना चाहिए। - इन्हें `secure` ध्वज के साथ सेट किया जाना चाहिए।
- इन्हें HTTPS द्वारा सुरक्षित पृष्ठ से उत्पन्न होना चाहिए। - इन्हें HTTPS द्वारा सुरक्षित पृष्ठ से उत्पन्न होना चाहिए।
- इन्हें एक डोमेन निर्दिष्ट करने की अनुमति नहीं है, जिससे इन्हें उपडोमेन में भेजने से रोका जा सके। - इन्हें एक डोमेन निर्दिष्ट करने की अनुमति नहीं है, जिससे उपडोमेन में उनके संचरण को रोका जा सके।
- इन कुकीज़ के लिए पथ को `/` पर सेट किया जाना चाहिए। - इन कुकीज़ के लिए पथ को `/` पर सेट किया जाना चाहिए।
यह ध्यान रखना महत्वपूर्ण है कि `__Host-` से प्रारंभ होने वाली कुकीज़ को सुपरडोमेन या उपडोमेन में भेजने की अनुमति नहीं है। यह प्रतिबंध एप्लिकेशन कुकीज़ को अलग करने में मदद करता है। इसलिए, सभी एप्लिकेशन कुकीज़ के लिए `__Host-` उपसर्ग का उपयोग करना सुरक्षा और अलगाव को बढ़ाने के लिए एक अच्छी प्रथा मानी जा सकती है। यह महत्वपूर्ण है कि `__Host-` से प्रारंभ होने वाली कुकीज़ को सुपरडोमेन या उपडोमेन में भेजने की अनुमति नहीं है। यह प्रतिबंध एप्लिकेशन कुकीज़ को अलग करने में मदद करता है। इसलिए, सभी एप्लिकेशन कुकीज़ के लिए `__Host-` उपसर्ग का उपयोग करना सुरक्षा और अलगाव को बढ़ाने के लिए एक अच्छी प्रथा मानी जा सकती है।
### Overwriting cookies ### Overwriting cookies
तो, `__Host-` उपसर्ग वाली कुकीज़ की एक सुरक्षा यह है कि उन्हें उपडोमेन से ओवरराइट करने से रोका जाता है। उदाहरण के लिए [**Cookie Tossing attacks**](cookie-tossing.md) को रोकना। वार्ता [**Cookie Crumbles: Unveiling Web Session Integrity Vulnerabilities**](https://www.youtube.com/watch?v=F_wAzF4a7Xg) ([**paper**](https://www.usenix.org/system/files/usenixsecurity23-squarcina.pdf)) में प्रस्तुत किया गया है कि उपडोमेन से \_\_HOST- उपसर्ग वाली कुकीज़ सेट करना संभव था, पार्सर को धोखा देकर, उदाहरण के लिए, "=" को शुरुआत या अंत में जोड़कर...: तो, `__Host-` उपसर्ग वाली कुकीज़ की एक सुरक्षा यह है कि उन्हें उपडोमेन से ओवरराइट करने से रोका जा सके। उदाहरण के लिए [**Cookie Tossing attacks**](cookie-tossing.md) को रोकना। वार्ता [**Cookie Crumbles: Unveiling Web Session Integrity Vulnerabilities**](https://www.youtube.com/watch?v=F_wAzF4a7Xg) ([**paper**](https://www.usenix.org/system/files/usenixsecurity23-squarcina.pdf)) में प्रस्तुत किया गया है कि उपडोमेन से \_\_HOST- उपसर्ग वाली कुकीज़ सेट करना संभव था, पार्सर को धोखा देकर, उदाहरण के लिए, "=" को शुरुआत या अंत में जोड़कर...:
<figure><img src="../../images/image (6) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure> <figure><img src="../../images/image (6) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
या PHP में कुकी नाम के प्रारंभ में **अन्य वर्ण जोड़ना** संभव था जो **अंडरस्कोर** वर्णों द्वारा **बदले जाएंगे**, जिससे `__HOST-` कुकीज़ को ओवरराइट करने की अनुमति मिलती है: या PHP में कुकी नाम के प्रारंभ में **अन्य वर्ण जोड़ना** संभव था जो **अंडरस्कोर** वर्णों द्वारा **बदले जाने वाले थे**, जिससे `__HOST-` कुकीज़ को ओवरराइट करने की अनुमति मिलती थी:
<figure><img src="../../images/image (7) (1) (1) (1) (1).png" alt="" width="373"><figcaption></figcaption></figure> <figure><img src="../../images/image (7) (1) (1) (1) (1).png" alt="" width="373"><figcaption></figcaption></figure>
@ -103,7 +103,7 @@ cookie-jar-overflow.md
### Decoding and Manipulating Cookies ### Decoding and Manipulating Cookies
कुकीज़ में एम्बेडेड संवेदनशील डेटा को हमेशा जांचा जाना चाहिए। Base64 या समान प्रारूपों में एन्कोडेड कुकीज़ को अक्सर डिकोड किया जा सकता है। यह कमजोरी हमलावरों को कुकी की सामग्री को बदलने और अन्य उपयोगकर्ताओं का अनुकरण करने की अनुमति देती है, उनके संशोधित डेटा को फिर से कुकी में एन्कोड करके। कुकीज़ में एम्बेडेड संवेदनशील डेटा को हमेशा जांचा जाना चाहिए। Base64 या समान प्रारूपों में एन्कोडेड कुकीज़ को अक्सर डिकोड किया जा सकता है। यह कमजोरी हमलावरों को कुकी की सामग्री को बदलने और अन्य उपयोगकर्ताओं का अनुकरण करने की अनुमति देती है, उनके संशोधित डेटा को कुकी में वापस एन्कोड करके।
### Session Hijacking ### Session Hijacking
@ -111,7 +111,7 @@ cookie-jar-overflow.md
### Session Fixation ### Session Fixation
इस परिदृश्य में, एक हमलावर एक पीड़ित को एक विशिष्ट कुकी का उपयोग करके लॉग इन करने के लिए धोखा देता है। यदि एप्लिकेशन लॉगिन पर एक नई कुकी असाइन नहीं करता है, तो हमलावर, जो मूल कुकी रखता है, पीड़ित का अनुकरण कर सकता है। यह तकनीक इस पर निर्भर करती है कि पीड़ित हमलावर द्वारा प्रदान की गई कुकी के साथ लॉग इन करता है। इस परिदृश्य में, एक हमलावर एक पीड़ित को एक विशिष्ट कुकी का उपयोग करके लॉग इन करने के लिए धोखा देता है। यदि एप्लिकेशन लॉगिन पर एक नई कुकी असाइन नहीं करता है, तो हमलावर, जिसके पास मूल कुकी है, पीड़ित का अनुकरण कर सकता है। यह तकनीक इस पर निर्भर करती है कि पीड़ित हमलावर द्वारा प्रदान की गई कुकी के साथ लॉग इन करता है।
यदि आपने एक **XSS एक उपडोमेन में** पाया है या आप **एक उपडोमेन को नियंत्रित करते हैं**, पढ़ें: यदि आपने एक **XSS एक उपडोमेन में** पाया है या आप **एक उपडोमेन को नियंत्रित करते हैं**, पढ़ें:
@ -131,23 +131,23 @@ cookie-tossing.md
### [JWT Cookies](../hacking-jwt-json-web-tokens.md) ### [JWT Cookies](../hacking-jwt-json-web-tokens.md)
JWT में संभावित दोषों को समझाने वाले पृष्ठ तक पहुँचने के लिए पिछले लिंक पर क्लिक करें। संभावित दोषों को समझाने वाले पृष्ठ तक पहुँचने के लिए पिछले लिंक पर क्लिक करें।
कुकीज़ में उपयोग किए जाने वाले JSON वेब टोकन (JWT) भी कमजोरियाँ प्रस्तुत कर सकते हैं। संभावित दोषों और उन्हें शोषित करने के तरीकों के बारे में गहन जानकारी के लिए, JWT हैकिंग पर लिंक किए गए दस्तावेज़ तक पहुँचने की सिफारिश की जाती है। कुकीज़ में उपयोग किए जाने वाले JSON वेब टोकन (JWT) भी कमजोरियाँ प्रस्तुत कर सकते हैं। संभावित दोषों और उन्हें शोषण करने के तरीकों के बारे में गहन जानकारी के लिए, JWT हैकिंग पर लिंक किए गए दस्तावेज़ तक पहुँचने की सिफारिश की जाती है।
### Cross-Site Request Forgery (CSRF) ### Cross-Site Request Forgery (CSRF)
यह हमला एक लॉग इन उपयोगकर्ता को एक वेब एप्लिकेशन पर अवांछित क्रियाएँ करने के लिए मजबूर करता है जिसमें वे वर्तमान में प्रमाणित हैं। हमलावर उन कुकीज़ का लाभ उठा सकते हैं जो हर अनुरोध के साथ स्वचालित रूप से कमजोर साइट पर भेजी जाती हैं। यह हमला एक लॉग इन उपयोगकर्ता को एक वेब एप्लिकेशन पर अवांछित क्रियाएँ करने के लिए मजबूर करता है जिसमें वे वर्तमान में प्रमाणित हैं। हमलावर उन कुकीज़ का शोषण कर सकते हैं जो कमजोर साइट पर हर अनुरोध के साथ स्वचालित रूप से भेजी जाती हैं।
### Empty Cookies ### Empty Cookies
(अधिक विवरण के लिए [मूल शोध](https://blog.ankursundara.com/cookie-bugs/) देखें) ब्राउज़रों को बिना नाम वाली कुकीज़ बनाने की अनुमति होती है, जिसे JavaScript के माध्यम से इस प्रकार प्रदर्शित किया जा सकता है: (अधिक विवरण के लिए [मूल शोध](https://blog.ankursundara.com/cookie-bugs/) देखें) ब्राउज़र्स बिना नाम वाली कुकीज़ बनाने की अनुमति देते हैं, जिसे JavaScript के माध्यम से इस प्रकार प्रदर्शित किया जा सकता है:
```js ```js
document.cookie = "a=v1" document.cookie = "a=v1"
document.cookie = "=test value;" // Setting an empty named cookie document.cookie = "=test value;" // Setting an empty named cookie
document.cookie = "b=v2" document.cookie = "b=v2"
``` ```
भेजे गए कुकी हेडर में परिणाम है `a=v1; test value; b=v2;`। दिलचस्प बात यह है कि यदि एक खाली नाम की कुकी सेट की जाती है, तो यह कुकीज़ में हेरफेर की अनुमति देती है, संभावित रूप से अन्य कुकीज़ को एक विशिष्ट मान सेट करके नियंत्रित करने की अनुमति देती है: भेजे गए कुकी हेडर में परिणाम है `a=v1; test value; b=v2;`। दिलचस्प बात यह है कि यदि एक खाली नाम की कुकी सेट की जाती है, तो यह कुकीज़ में हेरफेर की अनुमति देती है, संभावित रूप से अन्य कुकीज़ को एक विशिष्ट मान सेट करके नियंत्रित करने की क्षमता प्रदान करती है:
```js ```js
function setCookie(name, value) { function setCookie(name, value) {
document.cookie = `${name}=${value}` document.cookie = `${name}=${value}`
@ -155,11 +155,11 @@ document.cookie = `${name}=${value}`
setCookie("", "a=b") // Setting the empty cookie modifies another cookie's value setCookie("", "a=b") // Setting the empty cookie modifies another cookie's value
``` ```
यह ब्राउज़र को एक कुकी हेडर भेजने की ओर ले जाता है जिसे हर वेब सर्वर द्वारा `a` नाम की कुकी के रूप में और `b` मान के साथ व्याख्यायित किया जाता है। यह ब्राउज़र को एक कुकी हेडर भेजने की ओर ले जाता है जिसे हर वेब सर्वर द्वारा `a` नामक कुकी के रूप में व्याख्यायित किया जाता है जिसका मान `b` है।
#### Chrome बग: यूनिकोड सरोगेट कोडपॉइंट समस्या #### Chrome बग: यूनिकोड सरोगेट कोडपॉइंट समस्या
Chrome में, यदि एक यूनिकोड सरोगेट कोडपॉइंट सेट कुकी का हिस्सा है, तो `document.cookie` भ्रष्ट हो जाता है, और इसके बाद एक खाली स्ट्रिंग लौटाता है: Chrome में, यदि एक यूनिकोड सरोगेट कोडपॉइंट सेट कुकी का हिस्सा है, तो `document.cookie` भ्रष्ट हो जाता है, जिसके परिणामस्वरूप एक खाली स्ट्रिंग लौटती है:
```js ```js
document.cookie = "\ud800=meep" document.cookie = "\ud800=meep"
``` ```
@ -175,27 +175,27 @@ RENDER_TEXT="hello world; JSESSIONID=13371337; ASDF=end";
(Check further details in the[original research](https://blog.ankursundara.com/cookie-bugs/)) सर्वरों द्वारा कुकीज़ का गलत पार्सिंग, विशेष रूप से Undertow, Zope, और जो Python के `http.cookie.SimpleCookie` और `http.cookie.BaseCookie` का उपयोग करते हैं, कुकी इंजेक्शन हमलों के लिए अवसर पैदा करता है। ये सर्वर नए कुकीज़ की शुरुआत को सही तरीके से सीमित नहीं करते, जिससे हमलावरों को कुकीज़ को स्पूफ करने की अनुमति मिलती है: (Check further details in the[original research](https://blog.ankursundara.com/cookie-bugs/)) सर्वरों द्वारा कुकीज़ का गलत पार्सिंग, विशेष रूप से Undertow, Zope, और जो Python के `http.cookie.SimpleCookie` और `http.cookie.BaseCookie` का उपयोग करते हैं, कुकी इंजेक्शन हमलों के लिए अवसर पैदा करता है। ये सर्वर नए कुकीज़ की शुरुआत को सही तरीके से सीमित नहीं करते, जिससे हमलावरों को कुकीज़ को स्पूफ करने की अनुमति मिलती है:
- Undertow एक उद्धृत मान के तुरंत बाद एक नई कुकी की अपेक्षा करता है बिना सेमीकोलन के। - Undertow एक उद्धृत मान के तुरंत बाद एक नए कुकी की अपेक्षा करता है बिना सेमीकोलन के।
- Zope अगली कुकी को पार्स करने के लिए एक अल्पविराम की तलाश करता है। - Zope अगले कुकी को पार्स करने के लिए एक अल्पविराम की तलाश करता है।
- Python की कुकी कक्षाएँ एक स्पेस कैरेक्टर पर पार्सिंग शुरू करती हैं। - Python की कुकी कक्षाएँ एक स्पेस कैरेक्टर पर पार्सिंग शुरू करती हैं।
यह कमजोरी विशेष रूप से उन वेब अनुप्रयोगों में खतरनाक है जो कुकी-आधारित CSRF सुरक्षा पर निर्भर करते हैं, क्योंकि यह हमलावरों को स्पूफ किए गए CSRF-टोकन कुकीज़ इंजेक्ट करने की अनुमति देती है, जो सुरक्षा उपायों को बायपास कर सकती है। समस्या Python के डुप्लिकेट कुकी नामों के प्रबंधन से बढ़ जाती है, जहां अंतिम घटना पहले वाले को ओवरराइड कर देती है। यह `__Secure-` और `__Host-` कुकीज़ के लिए असुरक्षित संदर्भों में चिंताएँ भी उठाती है और जब कुकीज़ को बैक-एंड सर्वरों पर भेजा जाता है जो स्पूफिंग के प्रति संवेदनशील होते हैं, तो यह प्राधिकरण बायपास का कारण बन सकती है। यह कमजोरियाँ विशेष रूप से उन वेब अनुप्रयोगों में खतरनाक हैं जो कुकी-आधारित CSRF सुरक्षा पर निर्भर करते हैं, क्योंकि यह हमलावरों को स्पूफ किए गए CSRF-टोकन कुकीज़ इंजेक्ट करने की अनुमति देती है, जो सुरक्षा उपायों को बायपास कर सकती है। समस्या Python के डुप्लिकेट कुकी नामों के प्रबंधन से बढ़ जाती है, जहां अंतिम घटना पहले वाले को ओवरराइड कर देती है। यह `__Secure-` और `__Host-` कुकीज़ के लिए असुरक्षित संदर्भों में चिंताएँ भी उठाती है और जब कुकीज़ को बैक-एंड सर्वरों पर भेजा जाता है जो स्पूफिंग के प्रति संवेदनशील होते हैं, तो यह प्राधिकरण बायपास का कारण बन सकती है।
### कुकीज़ $version ### कुकीज़ $version
#### WAF बायपास #### WAF बायपास
[**इस ब्लॉगपोस्ट**](https://portswigger.net/research/bypassing-wafs-with-the-phantom-version-cookie) के अनुसार, यह संभव हो सकता है कि कुकी विशेषता **`$Version=1`** का उपयोग करके बैकएंड को कुकी पार्स करने के लिए पुरानी लॉजिक का उपयोग करने के लिए मजबूर किया जा सके, **RFC2109** के कारण। इसके अलावा, अन्य मान जैसे **`$Domain`** और **`$Path`** का उपयोग बैकएंड के व्यवहार को कुकी के साथ संशोधित करने के लिए किया जा सकता है। According to [**this blogpost**](https://portswigger.net/research/bypassing-wafs-with-the-phantom-version-cookie), यह संभव हो सकता है कि कुकी विशेषता **`$Version=1`** का उपयोग करके बैकएंड को कुकी पार्स करने के लिए पुरानी लॉजिक का उपयोग करने के लिए मजबूर किया जा सके, **RFC2109** के कारण। इसके अलावा, अन्य मान जैसे **`$Domain`** और **`$Path`** का उपयोग बैकएंड के व्यवहार को कुकी के साथ संशोधित करने के लिए किया जा सकता है।
#### कुकी सैंडविच हमला #### कुकी सैंडविच हमला
[**इस ब्लॉगपोस्ट**](https://portswigger.net/research/stealing-httponly-cookies-with-the-cookie-sandwich-technique) के अनुसार, HttpOnly कुकीज़ चुराने के लिए कुकी सैंडविच तकनीक का उपयोग करना संभव है। ये आवश्यकताएँ और कदम हैं: According to [**this blogpost**](https://portswigger.net/research/stealing-httponly-cookies-with-the-cookie-sandwich-technique) यह संभव है कि कुकी सैंडविच तकनीक का उपयोग करके HttpOnly कुकीज़ चुराई जा सकें। ये आवश्यकताएँ और कदम हैं:
- एक जगह खोजें जहाँ एक स्पष्ट रूप से बेकार **कुकी प्रतिक्रिया में परिलक्षित होती है** - एक ऐसा स्थान खोजें जहाँ एक स्पष्ट रूप से बेकार **कुकी प्रतिक्रिया में परिलक्षित होती है**
- **`$Version`** नाम की एक कुकी बनाएं जिसका मान `1` हो (आप इसे JS से XSS हमले में कर सकते हैं) एक अधिक विशिष्ट पथ के साथ ताकि यह प्रारंभिक स्थिति प्राप्त कर सके (कुछ फ्रेमवर्क जैसे Python को इस कदम की आवश्यकता नहीं होती) - **एक कुकी बनाएं जिसका नाम `$Version`** हो और जिसका मान `1` हो (आप इसे JS से XSS हमले में कर सकते हैं) एक अधिक विशिष्ट पथ के साथ ताकि यह प्रारंभिक स्थिति प्राप्त कर सके (कुछ फ्रेमवर्क जैसे Python को इस कदम की आवश्यकता नहीं होती)
- **उस कुकी को बनाएं जो परिलक्षित होती है** जिसका मान **खुले डबल कोट्स** को छोड़ता है और एक विशिष्ट पथ के साथ ताकि यह पिछले वाले (`$Version`) के बाद कुकी डेटाबेस में स्थित हो - **उस कुकी को बनाएं जो परिलक्षित होती है** जिसका मान **खुले डबल कोट्स** के साथ हो और एक विशिष्ट पथ के साथ ताकि यह पिछले वाले (`$Version`) के बाद कुकी डेटाबेस में स्थित हो
- फिर, वैध कुकी क्रम में अगली होगी - फिर, वैध कुकी क्रम में अगली होगी
- **एक डमी कुकी बनाएं जो डबल कोट्स को अपने मान के अंदर बंद करती है** - **एक डमी कुकी बनाएं जो डबल कोट्स** को अपने मान के अंदर बंद करती है
इस तरह, पीड़ित कुकी नए कुकी संस्करण 1 के अंदर फंस जाती है और जब भी यह परिलक्षित होती है, यह परिलक्षित हो जाएगी। इस तरह, पीड़ित कुकी नए कुकी संस्करण 1 के अंदर फंस जाती है और जब भी यह परिलक्षित होती है, यह परिलक्षित हो जाएगी।
e.g. from the post: e.g. from the post:
@ -207,24 +207,24 @@ document.cookie = `param2=end";`;
``` ```
### WAF बायपास ### WAF बायपास
#### कुकीज़ $version #### Cookies $version
पिछले अनुभाग की जांच करें। पिछले अनुभाग की जांच करें।
#### उद्धृत-स्ट्रींग एन्कोडिंग के साथ मान विश्लेषण को बायपास करना #### उद्धृत-शृंखला एन्कोडिंग के साथ मान विश्लेषण को बायपास करना
यह पार्सिंग कुकीज़ के अंदर एस्केप किए गए मानों को अनएस्केप करने का संकेत देती है, इसलिए "\a" "a" बन जाता है। यह WAFS को बायपास करने के लिए उपयोगी हो सकता है जैसे: यह पार्सिंग कुकीज़ के अंदर एस्केप किए गए मानों को अनएस्केप करने का संकेत देती है, इसलिए "\a" "a" बन जाता है। यह WAFS को बायपास करने के लिए उपयोगी हो सकता है जैसे:
- `eval('test') => forbidden` - `eval('test') => forbidden`
- `"\e\v\a\l\(\'\t\e\s\t\'\)" => allowed` - `"\e\v\a\l\(\'\t\e\s\t\'\)" => allowed`
#### कुकी-नाम ब्लॉकलिस्ट को बायपास करना #### कुकी-नाम ब्लॉक सूचियों को बायपास करना
RFC2109 में यह संकेत दिया गया है कि **कुकी मानों के बीच में एक कॉमा को सेपरेटर के रूप में उपयोग किया जा सकता है**। और यह भी संभव है कि **बराबर के चिन्ह के पहले और बाद में स्पेस और टैब जोड़े जाएं**। इसलिए एक कुकी जैसे `$Version=1; foo=bar, abc = qux` कुकी `"foo":"bar, admin = qux"` उत्पन्न नहीं करती बल्कि कुकीज़ `foo":"bar"` और `"admin":"qux"` उत्पन्न करती है। ध्यान दें कि 2 कुकीज़ उत्पन्न होती हैं और कैसे admin के बराबर के चिन्ह के पहले और बाद में स्पेस हटा दिया गया है। RFC2109 में यह संकेत दिया गया है कि **कुकी मानों के बीच एक विभाजक के रूप में एक अल्पविराम का उपयोग किया जा सकता है**। और यह भी संभव है कि **बराबर के चिन्ह के पहले और बाद में स्पेस और टैब जोड़े जाएं**। इसलिए एक कुकी जैसे `$Version=1; foo=bar, abc = qux` कुकी `"foo":"bar, admin = qux"` उत्पन्न नहीं करती है बल्कि कुकीज़ `foo":"bar"` और `"admin":"qux"` उत्पन्न करती है। ध्यान दें कि 2 कुकीज़ उत्पन्न होती हैं और कैसे admin के बराबर के चिन्ह के पहले और बाद में स्पेस हटा दिया गया है।
#### कुकी विभाजन के साथ मान विश्लेषण को बायपास करना #### कुकी विभाजन के साथ मान विश्लेषण को बायपास करना
अंत में, विभिन्न बैकडोर विभिन्न कुकी हेडर में पास की गई विभिन्न कुकीज़ को एक स्ट्रिंग में जोड़ेंगे जैसे: अंत में, विभिन्न बैकडोर विभिन्न कुकी हेडर्स में पास की गई विभिन्न कुकीज़ को एक स्ट्रिंग में जोड़ेंगे जैसे:
``` ```
GET / HTTP/1.1 GET / HTTP/1.1
Host: example.com Host: example.com
@ -242,9 +242,9 @@ Resulting cookie: name=eval('test//, comment') => allowed
#### **बुनियादी जांच** #### **बुनियादी जांच**
- **कुकी** हर बार जब आप **लॉगिन** करते हैं, **एक जैसी** होती है। - **कुकी** हर बार जब आप **लॉगिन** करते हैं, तो **एक जैसी** होती है।
- लॉग आउट करें और उसी कुकी का उपयोग करने की कोशिश करें। - लॉग आउट करें और उसी कुकी का उपयोग करने की कोशिश करें।
- एक ही खाते में 2 उपकरणों (या ब्राउज़रों) के साथ उसी कुकी का उपयोग करके लॉगिन करने की कोशिश करें। - एक ही खाते में 2 उपकरणों (या ब्राउज़रों) के साथ उसी कुकी का उपयोग करके लॉग इन करने की कोशिश करें।
- जांचें कि क्या कुकी में कोई जानकारी है और इसे संशोधित करने की कोशिश करें। - जांचें कि क्या कुकी में कोई जानकारी है और इसे संशोधित करने की कोशिश करें।
- लगभग समान उपयोगकर्ता नाम के साथ कई खाते बनाने की कोशिश करें और देखें कि क्या आप समानताएँ देख सकते हैं। - लगभग समान उपयोगकर्ता नाम के साथ कई खाते बनाने की कोशिश करें और देखें कि क्या आप समानताएँ देख सकते हैं।
- यदि "**मुझे याद रखें**" विकल्प मौजूद है, तो देखें कि यह कैसे काम करता है। यदि यह मौजूद है और संवेदनशील हो सकता है, तो हमेशा **मुझे याद रखें** की कुकी का उपयोग करें बिना किसी अन्य कुकी के। - यदि "**मुझे याद रखें**" विकल्प मौजूद है, तो देखें कि यह कैसे काम करता है। यदि यह मौजूद है और संवेदनशील हो सकता है, तो हमेशा **मुझे याद रखें** की कुकी का उपयोग करें बिना किसी अन्य कुकी के।
@ -252,10 +252,10 @@ Resulting cookie: name=eval('test//, comment') => allowed
#### **उन्नत कुकीज हमले** #### **उन्नत कुकीज हमले**
यदि कुकी लॉगिन करते समय समान (या लगभग समान) रहती है, तो इसका मतलब शायद यह है कि कुकी आपके खाते के किसी क्षेत्र से संबंधित है (संभवतः उपयोगकर्ता नाम)। फिर आप कर सकते हैं: यदि कुकी लॉग इन करते समय समान (या लगभग समान) रहती है, तो इसका मतलब शायद यह है कि कुकी आपके खाते के किसी क्षेत्र से संबंधित है (संभवतः उपयोगकर्ता नाम)। फिर आप कर सकते हैं:
- बहुत सारे **खाते** बनाने की कोशिश करें जिनके उपयोगकर्ता नाम बहुत **समान** हैं और अनुमान लगाने की कोशिश करें कि एल्गोरिदम कैसे काम कर रहा है। - बहुत सारे **खाते** बनाने की कोशिश करें जिनके उपयोगकर्ता नाम बहुत **समान** हैं और अनुमान लगाने की कोशिश करें कि एल्गोरिदम कैसे काम कर रहा है।
- **उपयोगकर्ता नाम को ब्रूटफोर्स** करने की कोशिश करें। यदि कुकी केवल आपके उपयोगकर्ता नाम के लिए एक प्रमाणीकरण विधि के रूप में सहेजी जाती है, तो आप "**Bmin**" उपयोगकर्ता नाम के साथ एक खाता बना सकते हैं और अपनी कुकी के हर एक **बिट** को **ब्रूटफोर्स** कर सकते हैं क्योंकि आप जो कुकी आजमाएंगे उनमें से एक "**admin**" की होगी। - **उपयोगकर्ता नाम को ब्रूटफोर्स** करने की कोशिश करें। यदि कुकी केवल आपके उपयोगकर्ता नाम के लिए एक प्रमाणीकरण विधि के रूप में सहेजी जाती है, तो आप "**Bmin**" उपयोगकर्ता नाम के साथ एक खाता बना सकते हैं और अपनी कुकी के हर एक **बिट** को **ब्रूटफोर्स** कर सकते हैं क्योंकि आप जो कुकी आज़माएँगे उनमें से एक "**admin**" की होगी।
- **पैडिंग** **ओरकल** की कोशिश करें (आप कुकी की सामग्री को डिक्रिप्ट कर सकते हैं)। **पैडबस्टर** का उपयोग करें। - **पैडिंग** **ओरकल** की कोशिश करें (आप कुकी की सामग्री को डिक्रिप्ट कर सकते हैं)। **पैडबस्टर** का उपयोग करें।
**पैडिंग ओरकल - पैडबस्टर उदाहरण** **पैडिंग ओरकल - पैडबस्टर उदाहरण**
@ -280,24 +280,24 @@ padbuster http://web.com/index.php 1dMjA5hfXh0jenxJQ0iW6QXKkzAGIWsiDAKV3UwJPT2lB
**CBC-MAC** **CBC-MAC**
शायद एक कुकी में कुछ मान हो सकता है और इसे CBC का उपयोग करके साइन किया जा सकता है। फिर, मान की अखंडता वही हस्ताक्षर है जो उसी मान के साथ CBC का उपयोग करके बनाया गया है। चूंकि IV के रूप में एक शून्य वेक्टर का उपयोग करने की सिफारिश की जाती है, इसलिए इस प्रकार की अखंडता जांच कमजोर हो सकती है। शायद एक कुकी में कुछ मान हो सकता है और इसे CBC का उपयोग करके साइन किया जा सकता है। फिर, मान की अखंडता उस हस्ताक्षर द्वारा होती है जो उसी मान के साथ CBC का उपयोग करके बनाया गया है। चूंकि IV के रूप में एक शून्य वेक्टर का उपयोग करने की सिफारिश की जाती है, यह प्रकार की अखंडता जांच कमजोर हो सकती है।
**हमला** **हमला**
1. उपयोगकर्ता नाम **administ** का हस्ताक्षर प्राप्त करें = **t** 1. उपयोगकर्ता नाम का हस्ताक्षर प्राप्त करें **administ** = **t**
2. उपयोगकर्ता नाम **rator\x00\x00\x00 XOR t** का हस्ताक्षर प्राप्त करें = **t'** 2. उपयोगकर्ता नाम का हस्ताक्षर प्राप्त करें **rator\x00\x00\x00 XOR t** = **t'**
3. कुकी में मान सेट करें **administrator+t'** (**t'** एक मान्य हस्ताक्षर होगा **(rator\x00\x00\x00 XOR t) XOR t** = **rator\x00\x00\x00** 3. कुकी में मान सेट करें **administrator+t'** (**t'** एक मान्य हस्ताक्षर होगा **(rator\x00\x00\x00 XOR t) XOR t** = **rator\x00\x00\x00**
**ECB** **ECB**
यदि कुकी को ECB का उपयोग करके एन्क्रिप्ट किया गया है तो यह कमजोर हो सकता है।\ यदि कुकी को ECB का उपयोग करके एन्क्रिप्ट किया गया है तो यह कमजोर हो सकता है।\
जब आप लॉग इन करते हैं, तो आपको जो कुकी मिलती है वह हमेशा एक समान होनी चाहिए। जब आप लॉग इन करते हैं, तो आपको जो कुकी मिलती है वह हमेशा समान होनी चाहिए।
**कैसे पता करें और हमला करें:** **कैसे पता करें और हमला करें:**
लगभग समान डेटा (उपयोगकर्ता नाम, पासवर्ड, ईमेल, आदि) के साथ 2 उपयोगकर्ता बनाएं और दिए गए कुकी के अंदर कुछ पैटर्न खोजने की कोशिश करें। लगभग समान डेटा (उपयोगकर्ता नाम, पासवर्ड, ईमेल, आदि) के साथ 2 उपयोगकर्ता बनाएं और दी गई कुकी के अंदर कुछ पैटर्न खोजने की कोशिश करें।
उदाहरण के लिए "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" नाम का एक उपयोगकर्ता बनाएं और देखें कि क्या कुकी में कोई पैटर्न है (चूंकि ECB हर ब्लॉक के लिए समान कुंजी के साथ एन्क्रिप्ट करता है, यदि उपयोगकर्ता नाम एन्क्रिप्ट किया गया है तो समान एन्क्रिप्टेड बाइट्स दिखाई दे सकते हैं)। उदाहरण के लिए "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" नाम का एक उपयोगकर्ता बनाएं और देखें कि क्या कुकी में कोई पैटर्न है (चूंकि ECB हर ब्लॉक को समान कुंजी के साथ एन्क्रिप्ट करता है, यदि उपयोगकर्ता नाम एन्क्रिप्ट किया गया है तो समान एन्क्रिप्टेड बाइट्स दिखाई दे सकते हैं)।
एक पैटर्न होना चाहिए (एक उपयोग किए गए ब्लॉक के आकार के साथ)। इसलिए, यह जानकर कि "a" का एक समूह कैसे एन्क्रिप्ट किया गया है, आप एक उपयोगकर्ता नाम बना सकते हैं: "a"\*(ब्लॉक का आकार)+"admin"। फिर, आप कुकी से "a" के एक ब्लॉक के एन्क्रिप्टेड पैटर्न को हटा सकते हैं। और आपके पास उपयोगकर्ता नाम "admin" की कुकी होगी। एक पैटर्न होना चाहिए (एक उपयोग किए गए ब्लॉक के आकार के साथ)। इसलिए, यह जानकर कि "a" का एक समूह कैसे एन्क्रिप्ट किया गया है, आप एक उपयोगकर्ता नाम बना सकते हैं: "a"\*(ब्लॉक का आकार)+"admin"। फिर, आप कुकी से "a" के एक ब्लॉक के एन्क्रिप्टेड पैटर्न को हटा सकते हैं। और आपके पास उपयोगकर्ता नाम "admin" की कुकी होगी।

236
theme/ai.js
View File

@ -1,27 +1,28 @@
/** /**
* HackTricks AI Chat Widget v1.15 – Markdown rendering + sanitised * HackTricks AI Chat Widget v1.16 – resizable sidebar
* ------------------------------------------------------------------------ * ---------------------------------------------------
* • Replaces the static “…” placeholder with a three-dot **bouncing** loader * ❶ Markdown rendering + sanitised (same as before)
* • Renders assistant replies as Markdown while purging any unsafe HTML * ❷ NEW: drag‑to‑resize panel, width persists via localStorage
* (XSS-safe via DOMPurify)
* ------------------------------------------------------------------------
*/ */
(function () { (function () {
const LOG = "[HackTricks-AI]"; const LOG = "[HackTricks‑AI]";
/* ---------------- User‑tunable constants ---------------- */
/* ---------------- User-tunable constants ---------------- */ const MAX_CONTEXT = 3000; // highlighted‑text char limit
const MAX_CONTEXT = 3000; // highlighted-text char limit const MAX_QUESTION = 500; // question char limit
const MAX_QUESTION = 500; // question char limit const MIN_W = 250; // ← resize limits →
const MAX_W = 600;
const DEF_W = 350; // default width (if nothing saved)
const TOOLTIP_TEXT = const TOOLTIP_TEXT =
"💡 Highlight any text on the page,\nthen click to ask HackTricks AI about it"; "💡 Highlight any text on the page,\nthen click to ask HackTricks AI about it";
const API_BASE = "https://www.hacktricks.ai/api/assistants/threads"; const API_BASE = "https://www.hacktricks.ai/api/assistants/threads";
const BRAND_RED = "#b31328"; // HackTricks brand const BRAND_RED = "#b31328";
/* ------------------------------ State ------------------------------ */ /* ------------------------------ State ------------------------------ */
let threadId = null; let threadId = null;
let isRunning = false; let isRunning = false;
/* ---------- helpers ---------- */
const $ = (sel, ctx = document) => ctx.querySelector(sel); const $ = (sel, ctx = document) => ctx.querySelector(sel);
if (document.getElementById("ht-ai-btn")) { if (document.getElementById("ht-ai-btn")) {
console.warn(`${LOG} Widget already injected.`); console.warn(`${LOG} Widget already injected.`);
@ -31,44 +32,37 @@
? document.addEventListener("DOMContentLoaded", init) ? document.addEventListener("DOMContentLoaded", init)
: init()); : init());
/* ==================================================================== */ /* =================================================================== */
/* 🔗 1. 3rd-party libs → Markdown & sanitiser */ /* 🔗 1. 3rd‑party libs → Markdown & sanitiser */
/* ==================================================================== */ /* =================================================================== */
function loadScript(src) { function loadScript(src) {
return new Promise((resolve, reject) => { return new Promise((res, rej) => {
const s = document.createElement("script"); const s = document.createElement("script");
s.src = src; s.src = src;
s.onload = resolve; s.onload = res;
s.onerror = () => reject(new Error(`Failed to load ${src}`)); s.onerror = () => rej(new Error(`Failed to load ${src}`));
document.head.appendChild(s); document.head.appendChild(s);
}); });
} }
async function ensureDeps() { async function ensureDeps() {
const deps = []; const deps = [];
if (typeof marked === "undefined") { if (typeof marked === "undefined")
deps.push(loadScript("https://cdn.jsdelivr.net/npm/marked/marked.min.js")); deps.push(loadScript("https://cdn.jsdelivr.net/npm/marked/marked.min.js"));
} if (typeof DOMPurify === "undefined")
if (typeof DOMPurify === "undefined") {
deps.push( deps.push(
loadScript( loadScript(
"https://cdnjs.cloudflare.com/ajax/libs/dompurify/3.2.5/purify.min.js" "https://cdnjs.cloudflare.com/ajax/libs/dompurify/3.2.5/purify.min.js"
) )
); );
}
if (deps.length) await Promise.all(deps); if (deps.length) await Promise.all(deps);
} }
const mdToSafeHTML = (md) =>
DOMPurify.sanitize(marked.parse(md, { mangle: false, headerIds: false }), {
USE_PROFILES: { html: true }
});
function mdToSafeHTML(md) { /* =================================================================== */
// 1️⃣ Markdown → raw HTML
const raw = marked.parse(md, { mangle: false, headerIds: false });
// 2️⃣ Purify
return DOMPurify.sanitize(raw, { USE_PROFILES: { html: true } });
}
/* ==================================================================== */
async function init() { async function init() {
/* ----- make sure marked & DOMPurify are ready before anything else */
try { try {
await ensureDeps(); await ensureDeps();
} catch (e) { } catch (e) {
@ -76,14 +70,14 @@
return; return;
} }
console.log(`${LOG} Injecting widget… v1.15`); console.log(`${LOG} Injecting widget… v1.16`);
await ensureThreadId(); await ensureThreadId();
injectStyles(); injectStyles();
const btn = createFloatingButton(); const btn = createFloatingButton();
createTooltip(btn); createTooltip(btn);
const panel = createSidebar(); const panel = createSidebar(); // ← panel with resizer
const chatLog = $("#ht-ai-chat"); const chatLog = $("#ht-ai-chat");
const sendBtn = $("#ht-ai-send"); const sendBtn = $("#ht-ai-send");
const inputBox = $("#ht-ai-question"); const inputBox = $("#ht-ai-question");
@ -100,15 +94,8 @@
function addMsg(text, cls) { function addMsg(text, cls) {
const b = document.createElement("div"); const b = document.createElement("div");
b.className = `ht-msg ${cls}`; b.className = `ht-msg ${cls}`;
b[cls === "ht-ai" ? "innerHTML" : "textContent"] =
// ✨ assistant replies rendered as Markdown + sanitised cls === "ht-ai" ? mdToSafeHTML(text) : text;
if (cls === "ht-ai") {
b.innerHTML = mdToSafeHTML(text);
} else {
// user / context bubbles stay plain-text
b.textContent = text;
}
chatLog.appendChild(b); chatLog.appendChild(b);
chatLog.scrollTop = chatLog.scrollHeight; chatLog.scrollTop = chatLog.scrollHeight;
return b; return b;
@ -116,30 +103,28 @@
const LOADER_HTML = const LOADER_HTML =
'<span class="ht-loading"><span></span><span></span><span></span></span>'; '<span class="ht-loading"><span></span><span></span><span></span></span>';
function setInputDisabled(d) { const setInputDisabled = (d) => {
inputBox.disabled = d; inputBox.disabled = d;
sendBtn.disabled = d; sendBtn.disabled = d;
} };
function clearThreadCookie() { const clearThreadCookie = () => {
document.cookie = "threadId=; Path=/; Max-Age=0"; document.cookie = "threadId=; Path=/; Max-Age=0";
threadId = null; threadId = null;
} };
function resetConversation() { const resetConversation = () => {
chatLog.innerHTML = ""; chatLog.innerHTML = "";
clearThreadCookie(); clearThreadCookie();
panel.classList.remove("open"); panel.classList.remove("open");
} };
/* ------------------- Panel open / close ------------------- */ /* ------------------- Panel open / close ------------------- */
btn.addEventListener("click", () => { btn.addEventListener("click", () => {
if (!savedSelection) { if (!savedSelection) {
alert("Please highlight some text first to then ask HackTricks AI about it."); alert("Please highlight some text first.");
return; return;
} }
if (savedSelection.length > MAX_CONTEXT) { if (savedSelection.length > MAX_CONTEXT) {
alert( alert(`Highlighted text is too long. Max ${MAX_CONTEXT} chars.`);
`Highlighted text is too long (${savedSelection.length} chars). Max allowed: ${MAX_CONTEXT}.`
);
return; return;
} }
chatLog.innerHTML = ""; chatLog.innerHTML = "";
@ -157,11 +142,10 @@
addMsg("Please wait until the current operation completes.", "ht-ai"); addMsg("Please wait until the current operation completes.", "ht-ai");
return; return;
} }
isRunning = true; isRunning = true;
setInputDisabled(true); setInputDisabled(true);
const loadingBubble = addMsg("", "ht-ai"); const loading = addMsg("", "ht-ai");
loadingBubble.innerHTML = LOADER_HTML; loading.innerHTML = LOADER_HTML;
const content = context const content = context
? `### Context:\n${context}\n\n### Question to answer:\n${question}` ? `### Context:\n${context}\n\n### Question to answer:\n${question}`
@ -178,43 +162,39 @@
try { try {
const e = await res.json(); const e = await res.json();
if (e.error) err = `Error: ${e.error}`; if (e.error) err = `Error: ${e.error}`;
else if (res.status === 429) else if (res.status === 429) err = "Rate limit exceeded.";
err = "Rate limit exceeded. Please try again later.";
} catch (_) {} } catch (_) {}
loadingBubble.textContent = err; loading.textContent = err;
return; return;
} }
const data = await res.json(); const data = await res.json();
loadingBubble.remove(); loading.remove();
if (Array.isArray(data.response)) if (Array.isArray(data.response))
data.response.forEach((p) => { data.response.forEach((p) =>
addMsg( addMsg(
p.type === "text" && p.text && p.text.value p.type === "text" && p.text && p.text.value
? p.text.value ? p.text.value
: JSON.stringify(p), : JSON.stringify(p),
"ht-ai" "ht-ai"
); )
}); );
else if (typeof data.response === "string") else if (typeof data.response === "string")
addMsg(data.response, "ht-ai"); addMsg(data.response, "ht-ai");
else addMsg(JSON.stringify(data, null, 2), "ht-ai"); else addMsg(JSON.stringify(data, null, 2), "ht-ai");
} catch (e) { } catch (e) {
console.error("Error sending message:", e); console.error("Error sending message:", e);
loadingBubble.textContent = "An unexpected error occurred."; loading.textContent = "An unexpected error occurred.";
} finally { } finally {
isRunning = false; isRunning = false;
setInputDisabled(false); setInputDisabled(false);
chatLog.scrollTop = chatLog.scrollHeight; chatLog.scrollTop = chatLog.scrollHeight;
} }
} }
async function handleSend() { async function handleSend() {
const q = inputBox.value.trim(); const q = inputBox.value.trim();
if (!q) return; if (!q) return;
if (q.length > MAX_QUESTION) { if (q.length > MAX_QUESTION) {
alert( alert(`Question too long (${q.length}). Max ${MAX_QUESTION}.`);
`Your question is too long (${q.length} chars). Max allowed: ${MAX_QUESTION}.`
);
return; return;
} }
inputBox.value = ""; inputBox.value = "";
@ -228,9 +208,9 @@
handleSend(); handleSend();
} }
}); });
} } /* end init */
/* ==================================================================== */ /* =================================================================== */
async function ensureThreadId() { async function ensureThreadId() {
const m = document.cookie.match(/threadId=([^;]+)/); const m = document.cookie.match(/threadId=([^;]+)/);
if (m && m[1]) { if (m && m[1]) {
@ -241,62 +221,67 @@
const r = await fetch(API_BASE, { method: "POST", credentials: "include" }); const r = await fetch(API_BASE, { method: "POST", credentials: "include" });
const d = await r.json(); const d = await r.json();
if (!r.ok || !d.threadId) throw new Error(`${r.status} ${r.statusText}`); if (!r.ok || !d.threadId) throw new Error(`${r.status} ${r.statusText}`);
threadId = d.threadId; threadId = d.threadId;
document.cookie = document.cookie =
`threadId=${threadId}; Path=/; Secure; SameSite=Strict; Max-Age=7200`; `threadId=${threadId}; Path=/; Secure; SameSite=Strict; Max-Age=7200`;
} catch (e) { } catch (e) {
console.error("Error creating threadId:", e); console.error("Error creating threadId:", e);
alert("Failed to initialise the conversation. Please refresh and try again."); alert("Failed to initialise the conversation. Please refresh.");
throw e; throw e;
} }
} }
/* ==================================================================== */ /* =================================================================== */
function injectStyles() { function injectStyles() {
const css = ` const css = `
#ht-ai-btn{position:fixed;bottom:20px;left:50%;transform:translateX(-50%);width:60px;height:60px;border-radius:50%;background:#1e1e1e;color:#fff;font-size:28px;display:flex;align-items:center;justify-content:center;cursor:pointer;z-index:99999;box-shadow:0 2px 8px rgba(0,0,0,.4);transition:opacity .2s} #ht-ai-btn{position:fixed;bottom:20px;left:50%;transform:translateX(-50%);min-width:60px;height:60px;border-radius:30px;background:linear-gradient(45deg, #b31328, #d42d3f, #2d5db4, #3470e4);background-size:300% 300%;animation:gradientShift 8s ease infinite;color:#fff;font-size:18px;display:flex;align-items:center;justify-content:center;cursor:pointer;z-index:99999;box-shadow:0 2px 8px rgba(0,0,0,.4);transition:opacity .2s;padding:0 20px}
#ht-ai-btn:hover{opacity:.85} #ht-ai-btn span{margin-left:8px;font-weight:bold}
@media(max-width:768px){#ht-ai-btn{display:none}} @keyframes gradientShift{0%{background-position:0% 50%}50%{background-position:100% 50%}100%{background-position:0% 50%}}
#ht-ai-tooltip{position:fixed;padding:6px 8px;background:#111;color:#fff;border-radius:4px;font-size:13px;white-space:pre-wrap;pointer-events:none;opacity:0;transform:translate(-50%,-8px);transition:opacity .15s ease,transform .15s ease;z-index:100000} #ht-ai-btn:hover{opacity:.85}
#ht-ai-tooltip.show{opacity:1;transform:translate(-50%,-12px)} @media(max-width:768px){#ht-ai-btn{display:none}}
#ht-ai-panel{position:fixed;top:0;right:0;height:100%;width:350px;max-width:90vw;background:#000;color:#fff;display:flex;flex-direction:column;transform:translateX(100%);transition:transform .3s ease;z-index:100000;font-family:system-ui,-apple-system,Segoe UI,Roboto,"Helvetica Neue",Arial,sans-serif} #ht-ai-tooltip{position:fixed;padding:6px 8px;background:#111;color:#fff;border-radius:4px;font-size:13px;white-space:pre-wrap;pointer-events:none;opacity:0;transform:translate(-50%,-8px);transition:opacity .15s ease,transform .15s ease;z-index:100000}
#ht-ai-panel.open{transform:translateX(0)} #ht-ai-tooltip.show{opacity:1;transform:translate(-50%,-12px)}
@media(max-width:768px){#ht-ai-panel{display:none}} #ht-ai-panel{position:fixed;top:0;right:0;height:100%;max-width:90vw;background:#000;color:#fff;display:flex;flex-direction:column;transform:translateX(100%);transition:transform .3s ease;z-index:100000;font-family:system-ui,-apple-system,Segoe UI,Roboto,"Helvetica Neue",Arial,sans-serif}
#ht-ai-header{display:flex;justify-content:space-between;align-items:center;padding:12px 16px;border-bottom:1px solid #333} #ht-ai-panel.open{transform:translateX(0)}
#ht-ai-header .ht-actions{display:flex;gap:8px;align-items:center} @media(max-width:768px){#ht-ai-panel{display:none}}
#ht-ai-close,#ht-ai-reset{cursor:pointer;font-size:18px;background:none;border:none;color:#fff;padding:0} #ht-ai-header{display:flex;justify-content:space-between;align-items:center;padding:12px 16px;border-bottom:1px solid #333}
#ht-ai-close:hover,#ht-ai-reset:hover{opacity:.7} #ht-ai-header .ht-actions{display:flex;gap:8px;align-items:center}
#ht-ai-chat{flex:1;overflow-y:auto;padding:16px;display:flex;flex-direction:column;gap:12px;font-size:14px} #ht-ai-close,#ht-ai-reset{cursor:pointer;font-size:18px;background:none;border:none;color:#fff;padding:0}
.ht-msg{max-width:90%;line-height:1.4;padding:10px 12px;border-radius:8px;white-space:pre-wrap;word-wrap:break-word} #ht-ai-close:hover,#ht-ai-reset:hover{opacity:.7}
.ht-user{align-self:flex-end;background:${BRAND_RED}} #ht-ai-chat{flex:1;overflow-y:auto;padding:16px;display:flex;flex-direction:column;gap:12px;font-size:14px}
.ht-ai{align-self:flex-start;background:#222} .ht-msg{max-width:90%;line-height:1.4;padding:10px 12px;border-radius:8px;white-space:pre-wrap;word-wrap:break-word}
.ht-context{align-self:flex-start;background:#444;font-style:italic;font-size:13px} .ht-user{align-self:flex-end;background:${BRAND_RED}}
#ht-ai-input{display:flex;gap:8px;padding:12px 16px;border-top:1px solid #333} .ht-ai{align-self:flex-start;background:#222}
#ht-ai-question{flex:1;min-height:40px;max-height:120px;resize:vertical;padding:8px;border-radius:6px;border:none;font-size:14px} .ht-context{align-self:flex-start;background:#444;font-style:italic;font-size:13px}
#ht-ai-send{padding:0 18px;border:none;border-radius:6px;background:${BRAND_RED};color:#fff;font-size:14px;cursor:pointer} #ht-ai-input{display:flex;gap:8px;padding:12px 16px;border-top:1px solid #333}
#ht-ai-send:disabled{opacity:.5;cursor:not-allowed} #ht-ai-question{flex:1;min-height:40px;max-height:120px;resize:vertical;padding:8px;border-radius:6px;border:none;font-size:14px}
/* Loader animation */ #ht-ai-send{padding:0 18px;border:none;border-radius:6px;background:${BRAND_RED};color:#fff;font-size:14px;cursor:pointer}
.ht-loading{display:inline-flex;align-items:center;gap:4px} #ht-ai-send:disabled{opacity:.5;cursor:not-allowed}
.ht-loading span{width:6px;height:6px;border-radius:50%;background:#888;animation:ht-bounce 1.2s infinite ease-in-out} /* Loader */
.ht-loading span:nth-child(2){animation-delay:0.2s} .ht-loading{display:inline-flex;align-items:center;gap:4px}
.ht-loading span:nth-child(3){animation-delay:0.4s} .ht-loading span{width:6px;height:6px;border-radius:50%;background:#888;animation:ht-bounce 1.2s infinite ease-in-out}
@keyframes ht-bounce{0%,80%,100%{transform:scale(0);}40%{transform:scale(1);} } .ht-loading span:nth-child(2){animation-delay:0.2s}
::selection{background:#ffeb3b;color:#000} .ht-loading span:nth-child(3){animation-delay:0.4s}
::-moz-selection{background:#ffeb3b;color:#000}`; @keyframes ht-bounce{0%,80%,100%{transform:scale(0);}40%{transform:scale(1);} }
::selection{background:#ffeb3b;color:#000}
::-moz-selection{background:#ffeb3b;color:#000}
/* NEW: resizer handle */
#ht-ai-resizer{position:absolute;left:0;top:0;width:6px;height:100%;cursor:ew-resize;background:transparent}
#ht-ai-resizer:hover{background:rgba(255,255,255,.05)}`;
const s = document.createElement("style"); const s = document.createElement("style");
s.id = "ht-ai-style"; s.id = "ht-ai-style";
s.textContent = css; s.textContent = css;
document.head.appendChild(s); document.head.appendChild(s);
} }
/* =================================================================== */
function createFloatingButton() { function createFloatingButton() {
const d = document.createElement("div"); const d = document.createElement("div");
d.id = "ht-ai-btn"; d.id = "ht-ai-btn";
d.textContent = "🤖"; d.innerHTML = "🤖<span>HackTricksAI</span>";
document.body.appendChild(d); document.body.appendChild(d);
return d; return d;
} }
function createTooltip(btn) { function createTooltip(btn) {
const t = document.createElement("div"); const t = document.createElement("div");
t.id = "ht-ai-tooltip"; t.id = "ht-ai-tooltip";
@ -311,11 +296,16 @@
btn.addEventListener("mouseleave", () => t.classList.remove("show")); btn.addEventListener("mouseleave", () => t.classList.remove("show"));
} }
/* =================================================================== */
function createSidebar() { function createSidebar() {
const saved = parseInt(localStorage.getItem("htAiWidth") || DEF_W, 10);
const width = Math.min(Math.max(saved, MIN_W), MAX_W);
const p = document.createElement("div"); const p = document.createElement("div");
p.id = "ht-ai-panel"; p.id = "ht-ai-panel";
p.style.width = width + "px"; // ← applied width
p.innerHTML = ` p.innerHTML = `
<div id="ht-ai-header"><strong>HackTricks AI Chat</strong> <div id="ht-ai-header"><strong>HackTricks AI Chat</strong>
<div class="ht-actions"> <div class="ht-actions">
<button id="ht-ai-reset" title="Reset">↺</button> <button id="ht-ai-reset" title="Reset">↺</button>
<span id="ht-ai-close" title="Close">✖</span> <span id="ht-ai-close" title="Close">✖</span>
@ -326,7 +316,39 @@
<textarea id="ht-ai-question" placeholder="Type your question…"></textarea> <textarea id="ht-ai-question" placeholder="Type your question…"></textarea>
<button id="ht-ai-send">Send</button> <button id="ht-ai-send">Send</button>
</div>`; </div>`;
/* NEW: resizer strip */
const resizer = document.createElement("div");
resizer.id = "ht-ai-resizer";
p.appendChild(resizer);
document.body.appendChild(p); document.body.appendChild(p);
addResizeLogic(resizer, p);
return p; return p;
} }
/* ---------------- resize behaviour ---------------- */
function addResizeLogic(handle, panel) {
let startX, startW, dragging = false;
const onMove = (e) => {
if (!dragging) return;
const dx = startX - e.clientX; // dragging leftwards ⇒ +dx
let newW = startW + dx;
newW = Math.min(Math.max(newW, MIN_W), MAX_W);
panel.style.width = newW + "px";
};
const onUp = () => {
if (!dragging) return;
dragging = false;
localStorage.setItem("htAiWidth", parseInt(panel.style.width, 10));
document.removeEventListener("mousemove", onMove);
document.removeEventListener("mouseup", onUp);
};
handle.addEventListener("mousedown", (e) => {
dragging = true;
startX = e.clientX;
startW = parseInt(window.getComputedStyle(panel).width, 10);
document.addEventListener("mousemove", onMove);
document.addEventListener("mouseup", onUp);
});
}
})(); })();