Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-27 07:01:09 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/pentesting-web/xss-cross-site-scripting/other-js-tricks.md
Translator workflow 5e0daf0e23 Translated to Polish
2024-02-11 01:46:25 +00:00

24 KiB
Raw Blame History

Różne sztuczki JS i istotne informacje

Naucz się hakować AWS od zera do bohatera z htARTE (HackTricks AWS Red Team Expert)!

Fuzzowanie JavaScript

Poprawne znaki komentarza JS

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

Poprawne znaki nowej linii w JS

W języku JavaScript istnieje kilka poprawnych znaków nowej linii, które można używać w skryptach. Oto kilka z nich:

  • \n - znak nowej linii
  • \r - znak powrotu karetki
  • \u2028 - separator linii Unicode
  • \u2029 - separator akapitu Unicode

Te znaki nowej linii mogą być używane w skryptach JavaScript do tworzenia nowych linii lub oddzielania bloków kodu.

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

Poprawne spacje w wywołaniu funkcji JS

W niektórych przypadkach, podczas wywoływania funkcji w JavaScript, można użyć spacji jako separatorów między argumentami. Przykładem jest:

functionName argument1 argument2 argument3

W powyższym przykładzie, spacje są używane jako separator między argumentami argument1, argument2 i argument3. Ta technika może być wykorzystana do ukrycia kodu złośliwego w wywołaniu funkcji, co może prowadzić do ataków typu Cross-Site Scripting (XSS).

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

Poprawne znaki do generowania ciągów znaków

Below is a list of valid characters that can be used to generate strings:

Poniżej znajduje się lista poprawnych znaków, które można użyć do generowania ciągów znaków:

< > " ' % ; ( ) & + - * / = \ ! [ ] { } | ^ ~ ` @ $ # , . ? _ :

These characters can be used in various scenarios, such as crafting payloads for XSS attacks or manipulating input fields.

Te znaki mogą być używane w różnych scenariuszach, takich jak tworzenie ładunków dla ataków XSS lub manipulowanie polami wejściowymi.

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

Surrogate Pairs BF

Ta technika nie będzie bardzo przydatna do XSS, ale może być przydatna do omijania ochrony WAF. Ten kod Pythona przyjmuje jako wejście 2 bajty i wyszukuje pary zastępcze, które mają pierwszy bajt jako ostatnie bajty pary zastępczej wysokiej i ostatni bajt jako ostatni bajt pary zastępczej niskiej.

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

Więcej informacji:

Fuzzowanie protokołu 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="&#12;javascript:alert(1337)">Test</a>

Fuzzowanie adresu URL

URL Fuzzing jest techniką polegającą na wysyłaniu różnych, nieprawidłowych lub losowych danych do adresu URL w celu znalezienia podatności. Może to obejmować zmianę parametrów, dodawanie znaków specjalnych lub manipulację ścieżką URL. Celem jest znalezienie luk w zabezpieczeniach, które mogą prowadzić do ataków XSS (Cross-Site Scripting) lub innych podobnych zagrożeń.

Przykłady technik fuzzowania URL:

  1. Zmiana parametrów: Można zmieniać wartości parametrów w adresie URL, aby sprawdzić, czy aplikacja jest odporna na nieprawidłowe dane. Na przykład, jeśli adres URL zawiera parametr "id", można spróbować wprowadzić różne wartości, takie jak liczby, znaki specjalne lub ciągi znaków.

  2. Dodawanie znaków specjalnych: Dodawanie znaków specjalnych, takich jak znaki specjalne HTML lub znaki kontrolne, może pomóc w identyfikacji podatności XSS. Można spróbować wstrzyknąć znaki specjalne w różne części adresu URL, takie jak parametry, ścieżka lub fragment.

  3. Manipulacja ścieżką URL: Zmiana ścieżki URL może pomóc w odkryciu podatności związanych z nieprawidłowym przetwarzaniem ścieżki. Można spróbować zmieniać nazwy katalogów, dodawać lub usuwać segmenty ścieżki, aby sprawdzić, czy aplikacja reaguje w nieoczekiwany sposób.

Narzędzia do fuzzowania URL:

  • wfuzz: Narzędzie do fuzzowania URL, które umożliwia automatyczne testowanie wielu kombinacji danych wejściowych.
  • Burp Suite: Popularne narzędzie do testowania penetracyjnego, które zawiera moduł do fuzzowania URL.
  • ZAP (Zed Attack Proxy): Inne popularne narzędzie do testowania penetracyjnego, które oferuje funkcje fuzzowania URL.

Fuzzowanie adresu URL jest ważnym krokiem w procesie testowania penetracyjnego aplikacji internetowych. Pozwala ono na identyfikację podatności i zabezpieczenie aplikacji przed atakami XSS i innymi zagrożeniami.

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

Fuzzowanie HTML

Fuzzowanie HTML jest techniką polegającą na wprowadzaniu nieprawidłowych lub nieoczekiwanych danych do kodu HTML w celu znalezienia potencjalnych podatności. Jest to często stosowane podczas testowania bezpieczeństwa aplikacji internetowych w celu wykrycia podatności na ataki XSS (Cross-Site Scripting).

Podczas fuzzowania HTML, atakujący może wprowadzać różne kombinacje znaków, tagów HTML, atrybutów i innych elementów, aby sprawdzić, czy aplikacja internetowa nieprawidłowo interpretuje te dane i umożliwia wykonanie złośliwego kodu JavaScript na stronie.

Przykłady nieprawidłowych danych, które mogą być używane podczas fuzzowania HTML, to:

  • Wstrzykiwanie znaków specjalnych, takich jak znaki "<" i ">", które mogą prowadzić do nieprawidłowego zamknięcia tagów HTML i otwarcia nowych tagów.
  • Wstrzykiwanie atrybutów HTML, takich jak "onmouseover" lub "onclick", które mogą umożliwić wykonanie złośliwego kodu JavaScript w momencie, gdy użytkownik najedzie myszką na dany element lub kliknie na niego.
  • Wstrzykiwanie kodu JavaScript wewnątrz tagów HTML, takich jak "