mirror of
https://github.com/carlospolop/hacktricks
synced 2024-12-11 22:03:10 +00:00
546 lines
30 KiB
Markdown
546 lines
30 KiB
Markdown
# विविध जेएस ट्रिक्स और संबंधित जानकारी
|
|
|
|
<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 को पीडीएफ में डाउनलोड करने का उपयोग** करने की आवश्यकता है? [**सदस्यता योजनाएं**](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>
|
|
|
|
## जावास्क्रिप्ट फजिंग
|
|
|
|
### मान्य जेएस टिप्पणी वर्ण
|
|
```javascript
|
|
//This is a 1 line comment
|
|
/* This is a multiline comment*/
|
|
#!This is a 1 line comment, but "#!" must to be at the beggining of the line
|
|
-->This is a 1 line comment, but "-->" must to be at the beggining of the line
|
|
|
|
|
|
for (let j = 0; j < 128; j++) {
|
|
for (let k = 0; k < 128; k++) {
|
|
for (let l = 0; l < 128; l++) {
|
|
if (j == 34 || k ==34 || l ==34)
|
|
continue;
|
|
if (j == 0x0a || k ==0x0a || l ==0x0a)
|
|
continue;
|
|
if (j == 0x0d || k ==0x0d || l ==0x0d)
|
|
continue;
|
|
if (j == 0x3c || k ==0x3c || l ==0x3c)
|
|
continue;
|
|
if (
|
|
(j == 47 && k == 47)
|
|
||(k == 47 && l == 47)
|
|
)
|
|
continue;
|
|
try {
|
|
var cmd = String.fromCharCode(j) + String.fromCharCode(k) + String.fromCharCode(l) + 'a.orange.ctf"';
|
|
eval(cmd);
|
|
} catch(e) {
|
|
var err = e.toString().split('\n')[0].split(':')[0];
|
|
if (err === 'SyntaxError' || err === "ReferenceError")
|
|
continue
|
|
err = e.toString().split('\n')[0]
|
|
}
|
|
console.log(err,cmd);
|
|
}
|
|
}
|
|
}
|
|
//From: https://balsn.tw/ctf_writeup/20191012-hitconctfquals/#bounty-pl33z
|
|
|
|
// From: Heyes, Gareth. JavaScript for hackers: Learn to think like a hacker (p. 43). Kindle Edition.
|
|
log=[];
|
|
for(let i=0;i<=0xff;i++){
|
|
for(let j=0;j<=0xfff;j++){
|
|
try {
|
|
eval(`${String.fromCodePoint(i,j)}%$£234$`)
|
|
log.push([i,j])
|
|
}catch(e){}
|
|
}
|
|
}
|
|
console.log(log)//[35,33],[47,47]
|
|
```
|
|
### मान्य जेएस नए लाइन वर्ण
|
|
|
|
जेएस कोड में नई पंक्तियों को दर्शाने के लिए निम्नलिखित वर्ण प्रयोग किए जा सकते हैं:
|
|
|
|
- `\n` - नई पंक्ति वर्ण
|
|
- `\r` - कैरिज रिटर्न वर्ण
|
|
- `\u2028` - लाइन सेपरेटर वर्ण
|
|
- `\u2029` - पैराग्राफ सेपरेटर वर्ण
|
|
|
|
इन वर्णों का उपयोग करके, आप जेएस कोड में नई पंक्तियों को शामिल कर सकते हैं और इसे अधिक पठनीय बना सकते हैं।
|
|
```javascript
|
|
//Javascript interpret as new line these chars:
|
|
String.fromCharCode(10) //0x0a
|
|
String.fromCharCode(13) //0x0d
|
|
String.fromCharCode(8232) //0xe2 0x80 0xa8
|
|
String.fromCharCode(8233) //0xe2 0x80 0xa8
|
|
|
|
for (let j = 0; j < 65536; j++) {
|
|
try {
|
|
var cmd = '"aaaaa";'+String.fromCharCode(j) + '-->a.orange.ctf"';
|
|
eval(cmd);
|
|
} catch(e) {
|
|
var err = e.toString().split('\n')[0].split(':')[0];
|
|
if (err === 'SyntaxError' || err === "ReferenceError")
|
|
continue;
|
|
err = e.toString().split('\n')[0]
|
|
}
|
|
console.log(`[${err}]`,j,cmd);
|
|
}
|
|
//From: https://balsn.tw/ctf_writeup/20191012-hitconctfquals/#bounty-pl33z
|
|
```
|
|
### फंक्शन कॉल में मान्य जेएस स्थान
|
|
|
|
In JavaScript, function calls can be made using various techniques. One such technique is using valid JS spaces within the function call. This can be done by inserting spaces between the function name and the opening parenthesis, as well as between the closing parenthesis and the semicolon.
|
|
|
|
For example:
|
|
```javascript
|
|
alert ('Hello, world!');
|
|
```
|
|
|
|
In the above code, the function `alert` is called with a space between the function name and the opening parenthesis. This is a valid JS space and the function will be executed without any errors.
|
|
|
|
This technique can be useful in certain scenarios where the application filters out specific characters or keywords but allows spaces. By using valid JS spaces, an attacker can bypass such filters and inject malicious code into the application.
|
|
|
|
It is important to note that this technique should only be used for educational purposes and with proper authorization. Unauthorized use of this technique can lead to legal consequences.
|
|
```javascript
|
|
// Heyes, Gareth. JavaScript for hackers: Learn to think like a hacker (pp. 40-41). Kindle Edition.
|
|
|
|
// Check chars that can be put in between in func name and the ()
|
|
function x(){}
|
|
|
|
log=[];
|
|
for(let i=0;i<=0x10ffff;i++){
|
|
try {
|
|
eval(`x${String.fromCodePoint(i)}()`)
|
|
log.push(i)
|
|
}catch(e){}
|
|
}
|
|
|
|
console.log(log)v//9,10,11,12,13,32,160,5760,8192,8193,8194,8195,8196,8197,8198,8199,8200,8201,8202,813 232,8233,8239,8287,12288,65279
|
|
```
|
|
### **स्ट्रिंग उत्पन्न करने के लिए मान्य वर्ण**
|
|
```javascript
|
|
// Heyes, Gareth. JavaScript for hackers: Learn to think like a hacker (pp. 41-42). Kindle Edition.
|
|
|
|
// Check which pairs of chars can make something be a valid string
|
|
log=[];
|
|
for(let i=0;i<=0x10ffff;i++){
|
|
try {
|
|
eval(`${String.fromCodePoint(i)}%$£234${String.fromCodePoint(i)}`)
|
|
log.push(i)
|
|
}catch(e){}
|
|
}
|
|
console.log(log) //34,39,47,96
|
|
//single quote, quotes, backticks & // (regex)
|
|
```
|
|
### **सरोगेट पेयर्स बीएफ**
|
|
|
|
यह तकनीक XSS के लिए बहुत उपयोगी नहीं होगी, लेकिन यह WAF संरक्षण को दुर्गम करने के लिए उपयोगी हो सकती है। इस पायथन कोड को दो बाइट के रूप में इनपुट मिलता है और यह उच्च सरोगेट पेयर के अंतिम बाइट के रूप में पहले बाइट और निम्न सरोगेट पेयर के अंतिम बाइट के रूप में अंतिम बाइट रखता है।
|
|
```python
|
|
def unicode(findHex):
|
|
for i in range(0,0xFFFFF):
|
|
H = hex(int(((i - 0x10000) / 0x400) + 0xD800))
|
|
h = chr(int(H[-2:],16))
|
|
L = hex(int(((i - 0x10000) % 0x400 + 0xDC00)))
|
|
l = chr(int(L[-2:],16))
|
|
if(h == findHex[0]) and (l == findHex[1]):
|
|
print(H.replace("0x","\\u")+L.replace("0x","\\u"))
|
|
```
|
|
अधिक जानकारी:
|
|
|
|
* [https://github.com/dreadlocked/ctf-writeups/blob/master/nn8ed/README.md](https://github.com/dreadlocked/ctf-writeups/blob/master/nn8ed/README.md)
|
|
* [https://mathiasbynens.be/notes/javascript-unicode](https://mathiasbynens.be/notes/javascript-unicode) [https://mathiasbynens.be/notes/javascript-encoding](https://mathiasbynens.be/notes/javascript-encoding)
|
|
|
|
### `javascript{}:` प्रोटोकॉल फजिंग
|
|
```javascript
|
|
// Heyes, Gareth. JavaScript for hackers: Learn to think like a hacker (p. 34). Kindle Edition.
|
|
log=[];
|
|
let anchor = document.createElement('a');
|
|
for(let i=0;i<=0x10ffff;i++){
|
|
anchor.href = `javascript${String.fromCodePoint(i)}:`;
|
|
if(anchor.protocol === 'javascript:') {
|
|
log.push(i);
|
|
}
|
|
}
|
|
console.log(log)//9,10,13,58
|
|
// Note that you could BF also other possitions of the use of multiple chars
|
|
|
|
// Test one option
|
|
let anchor = document.createElement('a');
|
|
anchor.href = `javascript${String.fromCodePoint(58)}:alert(1337)`;
|
|
anchor.append('Click me')
|
|
document.body.append(anchor)
|
|
|
|
// Another way to test
|
|
<a href="javascript:alert(1337)">Test</a>
|
|
```
|
|
### URL फज़िलता
|
|
|
|
URL फज़िलता एक वेब अनुप्रयोग को परीक्षण करने का एक तकनीक है जिसमें विभिन्न URL पैरामीटरों को अनुमानित मानों के साथ प्रयोग किया जाता है। इसका उपयोग वेब अनुप्रयोगों में संभावित सुरक्षा दुरुपयोगों की खोज करने के लिए किया जाता है। यह तकनीक एक अनुप्रयोग के विभिन्न भागों को परीक्षण करने के लिए उपयोगी हो सकती है, जैसे कि पैरामीटर, पथ, हेडर, कुकीज़, यूआरएल शीर्षक आदि।
|
|
|
|
यह तकनीक एक अनुप्रयोग के विभिन्न भागों को परीक्षण करने के लिए उपयोगी हो सकती है, जैसे कि पैरामीटर, पथ, हेडर, कुकीज़, यूआरएल शीर्षक आदि। यह तकनीक एक अनुप्रयोग के विभिन्न भागों को परीक्षण करने के लिए उपयोगी हो सकती है, जैसे कि पैरामीटर, पथ, हेडर, कुकीज़, यूआरएल शीर्षक आदि।
|
|
```javascript
|
|
// Heyes, Gareth. JavaScript for hackers: Learn to think like a hacker (pp. 36-37). Kindle Edition.
|
|
|
|
// Before the protocol
|
|
a=document.createElement('a');
|
|
log=[];
|
|
for(let i=0;i<=0x10ffff;i++){
|
|
a.href = `${String.fromCodePoint(i)}https://hacktricks.xyz`;
|
|
if(a.hostname === 'hacktricks.xyz'){
|
|
log.push(i);
|
|
}
|
|
}
|
|
console.log(log) //0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32
|
|
|
|
// Between the slashes
|
|
a=document.createElement('a');
|
|
log=[];
|
|
for(let i=0;i<=0x10ffff;i++){
|
|
a.href = `/${String.fromCodePoint(i)}/hacktricks.xyz`;
|
|
if(a.hostname === 'hacktricks.xyz'){
|
|
log.push(i);
|
|
}
|
|
}
|
|
console.log(log) //9,10,13,47,92
|
|
```
|
|
### HTML फज़िलता
|
|
|
|
HTML फज़िलता एक टेक्निक है जिसका उपयोग क्रॉस-साइट स्क्रिप्टिंग (XSS) अटैक के लिए किया जाता है। इस तकनीक में, हम विभिन्न HTML टैग और उनके विशेषताओं को अनुकरण करके वेब ऐप्लिकेशन को टेस्ट करते हैं। यह हमें उन टैगों और विशेषताओं की पहचान करने में मदद करता है जिनका उपयोग XSS अटैक के लिए किया जा सकता है।
|
|
|
|
इस तकनीक का उपयोग करने के लिए, हम विभिन्न HTML टैगों को वेब ऐप्लिकेशन में इंजेक्ट करते हैं और उनका उत्पादन देखते हैं। यदि ऐप्लिकेशन ने इंजेक्टेड टैग को सही ढंग से प्रोसेस किया है, तो उसका उत्पादन ठीक होगा। लेकिन, यदि ऐप्लिकेशन ने इंजेक्टेड टैग को गलत ढंग से प्रोसेस किया है, तो वह XSS अटैक के लिए उपयोगी हो सकता है।
|
|
|
|
इस तकनीक का उपयोग करने के लिए, हम विभिन्न HTML टैगों को इंजेक्ट करने के लिए विभिन्न तरीकों का उपयोग कर सकते हैं, जैसे कि टैगों को इंजेक्ट करने के लिए इनपुट फ़ील्ड, URL पैरामीटर, या कुकीज़ का उपयोग करना। इसके अलावा, हम विभिन्न विशेषताओं को भी इंजेक्ट कर सकते हैं, जैसे कि इवेंट हैंडलर, स्टाइल आवेदन, या अन्य एट्रिब्यूट्स।
|
|
|
|
इस तकनीक का उपयोग करके, हम XSS अटैक के लिए उपयोगी टैग और विशेषताओं की पहचान कर सकते हैं और उन्हें एक्सप्लोइट करने के लिए उपयोग कर सकते हैं।
|
|
```javascript
|
|
// Heyes, Gareth. JavaScript for hackers: Learn to think like a hacker (p. 38). Kindle Edition.
|
|
|
|
// Fuzzing chars that can close an HTML comment
|
|
|
|
let log=[];
|
|
let div = document.createElement('div');
|
|
for(let i=0;i<=0x10ffff;i++){
|
|
div.innerHTML=`<!----${String.fromCodePoint(i)}><span></span>-->`;
|
|
if(div.querySelector('span')){
|
|
log.push(i);
|
|
}
|
|
}
|
|
console.log(log)//33,45,62
|
|
```
|
|
## **विश्लेषण गुणों का विश्लेषण**
|
|
|
|
पोर्टस्विगर के टूल **हैकबिलिटी इंस्पेक्टर** जावास्क्रिप्ट ऑब्जेक्ट के **गुणों का विश्लेषण करने** में मदद करता है। जांचें: [https://portswigger-labs.net/hackability/inspector/?input=x.contentWindow\&html=%3Ciframe%20src=//subdomain1.portswigger-labs.net%20id=x%3E](https://portswigger-labs.net/hackability/inspector/?input=x.contentWindow\&html=%3Ciframe%20src=//subdomain1.portswigger-labs.net%20id=x%3E)
|
|
|
|
## **.map js फ़ाइलें**
|
|
|
|
* .map js फ़ाइलें डाउनलोड करने के लिए ट्रिक: [https://medium.com/@bitthebyte/javascript-for-bug-bounty-hunters-part-2-f82164917e7](https://medium.com/@bitthebyte/javascript-for-bug-bounty-hunters-part-2-f82164917e7)
|
|
* आप इन फ़ाइलों का विश्लेषण करने के लिए इस टूल का उपयोग कर सकते हैं [https://github.com/paazmaya/shuji](https://github.com/paazmaya/shuji)
|
|
|
|
## "--" असाइनमेंट
|
|
|
|
डिक्रीमेंट ऑपरेटर `--` भी एक असाइनमेंट है। यह ऑपरेटर एक मान लेता है और उसे एक के रूप में कम कर देता है। यदि वह मान एक नंबर नहीं है, तो यह `NaN` पर सेट किया जाएगा। इसका उपयोग करके **पर्यावरण से चरों की सामग्री को हटाने** के लिए किया जा सकता है।
|
|
|
|
.png>)
|
|
|
|
.png>)
|
|
|
|
## फ़ंक्शन ट्रिक्स
|
|
|
|
### .call और .apply
|
|
|
|
एक फ़ंक्शन का **`.call`** मेथड फ़ंक्शन को **चलाने** के लिए उपयोग किया जाता है।\
|
|
यह **पहला तर्क** डिफ़ॉल्ट रूप से **`this` के मान** की उम्मीद करता है और अगर **कुछ नहीं** प्रदान किया गया है, तो **`window`** उस मान की होगी (यहां तक कि **`strict mode`** का उपयोग नहीं हो रहा है)।
|
|
```javascript
|
|
function test_call(){
|
|
console.log(this.value); //baz
|
|
}
|
|
new_this={value:"hey!"}
|
|
test_call.call(new_this);
|
|
|
|
// To pass more arguments, just pass then inside .call()
|
|
function test_call() {
|
|
console.log(arguments[0]); //"arg1"
|
|
console.log(arguments[1]); //"arg2"
|
|
console.log(this); //[object Window]
|
|
}
|
|
test_call.call(null, "arg1", "arg2")
|
|
|
|
// If you use the "use strict" directive "this" will be null instead of window:
|
|
function test_call() {
|
|
"use strict";
|
|
console.log(this); //null
|
|
}
|
|
test_call.call(null)
|
|
|
|
//The apply function is pretty much exactly the same as the call function with one important difference, you can supply an array of arguments in the second argument:
|
|
function test_apply() {
|
|
console.log(arguments[0]); //"arg1"
|
|
console.log(arguments[1]); //"arg2"
|
|
console.log(this); //[object Window]
|
|
}
|
|
test_apply.apply(null, ["arg1", "arg2"])
|
|
```
|
|
### एरो फंक्शन्स
|
|
|
|
एरो फंक्शन्स आपको एक ही लाइन में आसानी से फंक्शन बनाने की अनुमति देते हैं (यदि आप उन्हें समझते हैं)।
|
|
```javascript
|
|
// Traditional
|
|
function (a){ return a + 1; }
|
|
// Arrow forms
|
|
a => a + 100;
|
|
a => {a + 100};
|
|
|
|
// Traditional
|
|
function (a, b){ return a + b + 1; }
|
|
// Arrow
|
|
(a, b) => a + b + 100;
|
|
|
|
// Tradictional no args
|
|
let a = 4;
|
|
let b = 2;
|
|
function (){ return a + b + 1; }
|
|
|
|
// Arrow
|
|
let a = 4;
|
|
let b = 2;
|
|
() => a + b + 1;
|
|
```
|
|
तो, पिछले अधिकांश फ़ंक्शन वास्तव में अनर्थक हैं क्योंकि हम उन्हें कहीं नहीं सहेज रहे हैं ताकि हम उन्हें सहेजें और उन्हें कॉल करें। उदाहरण के रूप में `plusone` फ़ंक्शन बनाना:
|
|
```javascript
|
|
// Traductional
|
|
function plusone (a){ return a + 1; }
|
|
|
|
//Arrow
|
|
plusone = a => a + 100;
|
|
```
|
|
### बाइंड फंक्शन
|
|
|
|
बाइंड फंक्शन का उपयोग करके हम एक **कॉपी** बना सकते हैं एक **फंक्शन को संशोधित करके** **`this`** ऑब्जेक्ट और दिए गए **पैरामीटर** को।
|
|
```javascript
|
|
//This will use the this object and print "Hello World"
|
|
var fn = function ( param1, param2 ) {
|
|
console.info( this, param1, param2 );
|
|
}
|
|
fn('Hello', 'World')
|
|
|
|
//This will still use the this object and print "Hello World"
|
|
var copyFn = fn.bind();
|
|
copyFn('Hello', 'World')
|
|
|
|
//This will use the "console" object as "this" object inside the function and print "fixingparam1 Hello"
|
|
var bindFn_change = fn.bind(console, "fixingparam1");
|
|
bindFn_change('Hello', 'World')
|
|
|
|
//This will still use the this object and print "fixingparam1 Hello"
|
|
var bindFn_thisnull = fn.bind(null, "fixingparam1");
|
|
bindFn_change('Hello', 'World')
|
|
|
|
//This will still use the this object and print "fixingparam1 Hello"
|
|
var bindFn_this = fn.bind(this, "fixingparam1");
|
|
bindFn_change('Hello', 'World')
|
|
```
|
|
{% hint style="info" %}
|
|
ध्यान दें कि **`bind`** का उपयोग करके आप उस वस्तु को बदल सकते हैं जो कि फ़ंक्शन को कॉल करते समय उपयोग होगी।
|
|
{% endhint %}
|
|
|
|
### फ़ंक्शन कोड लीक
|
|
|
|
यदि आप एक फ़ंक्शन के ऑब्जेक्ट तक पहुंच सकते हैं तो आप उस फ़ंक्शन के कोड को प्राप्त कर सकते हैं।
|
|
```javascript
|
|
function afunc(){
|
|
return 1+1;
|
|
}
|
|
console.log(afunc.toString()); //This will print the code of the function
|
|
console.log(String(afunc)); //This will print the code of the function
|
|
console.log(this.afunc.toString()); //This will print the code of the function
|
|
console.log(global.afunc.toString()); //This will print the code of the function
|
|
```
|
|
ऐसे मामलों में जहां **फ़ंक्शन का कोई नाम नहीं होता है**, आप अभी भी **फ़ंक्शन कोड** को अंदर से प्रिंट कर सकते हैं:
|
|
```javascript
|
|
(function (){ return arguments.callee.toString(); })()
|
|
(function (){ return arguments[0]; })("arg0")
|
|
```
|
|
किसी अन्य फ़ंक्शन से एक फ़ंक्शन के कोड (हमेशा की तरह टिप्पणियाँ सहित) को निकालने के लिए कुछ **यादृच्छिक** तरीके:
|
|
```javascript
|
|
(function (){ return retFunc => String(arguments[0]) })(a=>{/* Hidden commment */})()
|
|
(function (){ return retFunc => Array(arguments[0].toString()) })(a=>{/* Hidden commment */})()
|
|
(function (){ return String(this)}).bind(()=>{ /* Hidden commment */ })()
|
|
(u=>(String(u)))(_=>{ /* Hidden commment */ })
|
|
(u=>_=>(String(u)))(_=>{ /* Hidden commment */ })()
|
|
```
|
|
## सैंडबॉक्स छूट - विंडो ऑब्जेक्ट की पुनर्प्राप्ति
|
|
|
|
विंडो ऑब्जेक्ट को अलर्ट या इवैल जैसे वैश्विक रूप से परिभाषित फंक्शन तक पहुंचने की अनुमति देता है।
|
|
|
|
{% code overflow="wrap" %}
|
|
```javascript
|
|
// Some ways to access window
|
|
window.eval("alert(1)")
|
|
frames
|
|
globalThis
|
|
parent
|
|
self
|
|
top //If inside a frame, this is top most window
|
|
|
|
// Access window from document
|
|
document.defaultView.alert(1)
|
|
// Access document from a node object
|
|
node = document.createElement('div')
|
|
node.ownerDocument.defaultView.alert(1)
|
|
|
|
// There is a path property on each error event whose last element is the window
|
|
<img src onerror=event.path.pop().alert(1337)>
|
|
// In other browsers the method is
|
|
<img src onerror=event.composedPath().pop().alert(1337)>
|
|
// In case of svg, the "event" object is called "evt"
|
|
<svg><image href=1 onerror=evt.composedPath().pop().alert(1337)>
|
|
|
|
// Abusing Error.prepareStackTrace to get Window back
|
|
Error.prepareStackTrace=function(error, callSites){
|
|
2 callSites.shift().getThis().alert(1337);
|
|
3 };
|
|
4 new Error().stack
|
|
|
|
// From an HTML event
|
|
// Events from HTML are executed in this context
|
|
with(document) {
|
|
with(element) {
|
|
//executed event
|
|
}
|
|
}
|
|
// Because of that with(document) it's possible to access properties of document like:
|
|
<img src onerror=defaultView.alert(1337)>
|
|
<img src onerror=s=createElement('script');s.append('alert(1337)');appendChild(s)>
|
|
```
|
|
{% endcode %}
|
|
|
|
## मान तक पहुंच पर ब्रेकपॉइंट
|
|
```javascript
|
|
// Stop when a property in sessionStorage or localStorage is set/get
|
|
// via getItem or setItem functions
|
|
sessionStorage.getItem = localStorage.getItem = function(prop) {
|
|
debugger;
|
|
return sessionStorage[prop];
|
|
}
|
|
|
|
localStorage.setItem = function(prop, val) {
|
|
debugger;
|
|
localStorage[prop] = val;
|
|
}
|
|
```
|
|
|
|
```javascript
|
|
// Stop when anyone sets or gets the property "ppmap" in any object
|
|
// For example sessionStorage.ppmap
|
|
// "123".ppmap
|
|
// Useful to find where weird properties are being set or accessed
|
|
// or to find where prototype pollutions are occurring
|
|
|
|
function debugAccess(obj, prop, debugGet=true){
|
|
|
|
var origValue = obj[prop];
|
|
|
|
Object.defineProperty(obj, prop, {
|
|
get: function () {
|
|
if ( debugGet )
|
|
debugger;
|
|
return origValue;
|
|
},
|
|
set: function(val) {
|
|
debugger;
|
|
origValue = val;
|
|
}
|
|
});
|
|
};
|
|
|
|
debugAccess(Object.prototype, 'ppmap')
|
|
```
|
|
## परीक्षण पेलोड के लिए स्वचालित ब्राउज़र एक्सेस
|
|
|
|
यह तकनीक आपको अपने परीक्षण पेलोड को स्वचालित रूप से ब्राउज़र में एक्सेस करने में मदद करेगी। इसके लिए आपको निम्नलिखित कदमों का पालन करना होगा:
|
|
|
|
1. एक नया HTML फ़ाइल बनाएं और उसे अपने वेब सर्वर पर होस्ट करें।
|
|
2. फ़ाइल में निम्नलिखित कोड जोड़ें:
|
|
|
|
```html
|
|
<script>
|
|
// यहां अपना परीक्षण पेलोड डालें
|
|
var payload = "<script>alert('XSS');</script>";
|
|
|
|
// ब्राउज़र एक्सेस के लिए नया विंडो खोलें
|
|
var win = window.open("", "_blank");
|
|
|
|
// विंडो के अंदर HTML डॉक्यूमेंट बनाएं
|
|
var doc = win.document.open();
|
|
|
|
// डॉक्यूमेंट में पेलोड लोड करें
|
|
doc.write(payload);
|
|
|
|
// डॉक्यूमेंट को बंद करें
|
|
doc.close();
|
|
</script>
|
|
```
|
|
|
|
3. अपने ब्राउज़र में नया टैब खोलें और नया URL दर्ज करें: `http://आपका_वेब_सर्वर/आपकी_फ़ाइल.html`
|
|
4. जब आप यह URL खोलेंगे, तो एक नया विंडो खुलेगा और आपका परीक्षण पेलोड उसमें लोड होगा। यदि आपका पेलोड कार्यान्वित होता है, तो एक अलर्ट दिखाई देगा।
|
|
|
|
इस तकनीक का उपयोग करके आप अपने परीक्षण पेलोड को स्वचालित रूप से ब्राउज़र में एक्सेस कर सकते हैं और XSS के लिए सुरक्षा जांच सकते हैं।
|
|
```javascript
|
|
//Taken from https://github.com/svennergr/writeups/blob/master/inti/0621/README.md
|
|
const puppeteer = require("puppeteer");
|
|
|
|
const realPasswordLength = 3000;
|
|
async function sleep(ms) {
|
|
return new Promise((resolve) => setTimeout(resolve, ms));
|
|
}
|
|
|
|
(async () => {
|
|
const browser = await puppeteer.launch();
|
|
const page = await browser.newPage();
|
|
//Loop to iterate through different values
|
|
for (let i = 0; i < 10000; i += 100) {
|
|
console.log(`Run number ${i}`);
|
|
const input = `${"0".repeat(i)}${realPasswordLength}`;
|
|
console.log(` https://challenge-0621.intigriti.io/passgen.php?passwordLength=${input}&allowNumbers=true&allowSymbols=true×tamp=1624556811000`);
|
|
//Go to the page
|
|
await page.goto(
|
|
`https://challenge-0621.intigriti.io/passgen.php?passwordLength=${input}&allowNumbers=true&allowSymbols=true×tamp=1624556811000`
|
|
);
|
|
//Call function "generate()" inside the page
|
|
await page.evaluate("generate()");
|
|
//Get node inner text from an HTML element
|
|
const passwordContent = await page.$$eval(
|
|
".alert .page-content",
|
|
(node) => node[0].innerText
|
|
);
|
|
//Transform the content and print it in console
|
|
const plainPassword = passwordContent.replace("Your password is: ", "");
|
|
if (plainPassword.length != realPasswordLength) {
|
|
console.log(i, plainPassword.length, plainPassword);
|
|
}
|
|
|
|
await sleep(1000);
|
|
}
|
|
await browser.close();
|
|
})();
|
|
```
|
|
<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)**.**
|
|
* **अपने हैकिंग ट्रिक्स को** [**hacktricks रेपो**](https://github.com/carlospolop/hacktricks) **और** [**hacktricks-cloud रेपो**](https://github.com/carlospolop/hacktricks-cloud) **में PR जमा करके साझा करें।**
|
|
|
|
</details>
|